fix(ollama): map free-plan monthly window and derive reset from signup date

tests/unit/ollama-usage.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 
 vi.mock("../../open-sse/utils/proxyFetch.js", () => ({
   proxyAwareFetch: vi.fn(),
@@ -44,6 +44,27 @@ const SAMPLE_USAGE = {
   },
 };
 
+const SAMPLE_FREE_USAGE = {
+  activity: {
+    cost: "0.00000",
+    period: {
+      type: "last_4_weeks",
+      starting_at: "2026-08-24T00:00:00Z",
+      ending_at: "2026-09-18T15:03:00Z",
+    },
+    models: [],
+  },
+  limits: {
+    monthly: {
+      usage: 0.021,
+      models: [
+        { name: "gpt-oss:120b", request_count: 6 },
+        { name: "gemma4:31b", request_count: 6 },
+      ],
+    },
+  },
+};
+
 const SAMPLE_ME = {
   Plan: "max",
 };
@@ -103,6 +124,98 @@ describe("getUsageForProvider(ollama)", () => {
     expect(meOpts.headers["Content-Length"]).toBe("0");
   });
 
+  it("maps the free plan's monthly window", async () => {
+    proxyAwareFetch
+      .mockResolvedValueOnce(jsonResponse(SAMPLE_FREE_USAGE))
+      .mockResolvedValueOnce(jsonResponse({ Plan: "free" }));
+
+    const usage = await getUsageForProvider({
+      provider: "ollama",
+      apiKey: "k",
+      providerSpecificData: {},
+    });
+
+    expect(usage.message).toBeUndefined();
+    expect(usage.plan).toBe("Free");
+    expect(Object.keys(usage.quotas)).toEqual(["Monthly"]);
+    expect(usage.quotas["Monthly"]).toMatchObject({
+      used: 2,
+      total: 100,
+      remainingPercentage: 98,
+      unlimited: false,
+    });
+    expect(usage.quotas["Monthly"].remaining).toBeUndefined();
+    expect(usage.quotas["Monthly"].resetAt).toBeNull();
+  });
+
+  describe("free plan monthly reset from signup date", () => {
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    async function monthlyResetAt(createdAt, now) {
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date(now));
+      proxyAwareFetch
+        .mockResolvedValueOnce(jsonResponse(SAMPLE_FREE_USAGE))
+        .mockResolvedValueOnce(jsonResponse({ Plan: "free", CreatedAt: createdAt }));
+
+      const usage = await getUsageForProvider({
+        provider: "ollama",
+        apiKey: "k",
+        providerSpecificData: {},
+      });
+      return usage.quotas["Monthly"].resetAt;
+    }
+
+    it("uses the signup day of the next month", async () => {
+      expect(await monthlyResetAt("2025-09-06T22:15:39.871687Z", "2026-09-18T15:03:00Z"))
+        .toBe("2026-10-06T22:15:39.000Z");
+    });
+
+    it("stays in the current month when the signup day is still ahead", async () => {
+      expect(await monthlyResetAt("2026-09-18T09:50:49.514335Z", "2026-09-18T15:33:33Z"))
+        .toBe("2026-10-18T09:50:49.000Z");
+      expect(await monthlyResetAt("2025-09-25T10:00:00Z", "2026-09-18T15:33:33Z"))
+        .toBe("2026-09-25T10:00:00.000Z");
+    });
+
+    it("clamps the signup day to shorter months", async () => {
+      expect(await monthlyResetAt("2026-01-31T12:00:00Z", "2026-02-10T00:00:00Z"))
+        .toBe("2026-02-28T12:00:00.000Z");
+    });
+
+    it("skips the reset when the plan is not free", async () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date("2026-09-18T15:03:00Z"));
+      proxyAwareFetch
+        .mockResolvedValueOnce(jsonResponse(SAMPLE_FREE_USAGE))
+        .mockResolvedValueOnce(jsonResponse({ Plan: "pro", CreatedAt: "2025-09-06T22:15:39Z" }));
+
+      const usage = await getUsageForProvider({
+        provider: "ollama",
+        apiKey: "k",
+        providerSpecificData: {},
+      });
+      expect(usage.quotas["Monthly"].resetAt).toBeNull();
+    });
+  });
+
+  it("reports no limits when no known window is present", async () => {
+    proxyAwareFetch
+      .mockResolvedValueOnce(jsonResponse({ activity: {}, limits: {} }))
+      .mockResolvedValueOnce(jsonResponse({ Plan: "free" }));
+
+    const usage = await getUsageForProvider({
+      provider: "ollama",
+      apiKey: "k",
+      providerSpecificData: {},
+    });
+
+    expect(usage.message).toMatch(/no usage limits/i);
+    expect(usage.quotas).toEqual({});
+  });
+
   it("surfaces invalid key message on 401", async () => {
     proxyAwareFetch.mockResolvedValueOnce(
       jsonResponse({ error: "unauthorized" }, 401),