feat: final v0

Author: riturajFi

diff.txt

@@ -4059,12 +4059,23 @@ export class Agent {
       return;
     }
 
-    const refillPerSecond = updateResult.normalized.refillPerMs * 1000;
+    const now = Date.now();
+    const effectiveRemaining = Math.max(
+      0,
+      updateResult.state.remaining - updateResult.state.reserved,
+    );
+    const resetInMs = Math.max(0, updateResult.state.resetAt - now);
+    const nextAllowedInMs = Math.max(0, updateResult.state.nextAllowedAt - now);
     logger?.info?.("[Traffic] Applied rate limit from response headers", {
       rateLimitKey: updateResult.key,
-      capacity: updateResult.normalized.capacity,
-      refillPerSecond,
-      appliedTokens: updateResult.appliedTokens,
+      limit: updateResult.state.limit,
+      remaining: updateResult.state.remaining,
+      reserved: updateResult.state.reserved,
+      effectiveRemaining,
+      resetAt: updateResult.state.resetAt,
+      resetInMs,
+      nextAllowedAt: updateResult.state.nextAllowedAt,
+      nextAllowedInMs,
       headers: {
         limitRequests: updateResult.headerSnapshot.limitRequests,
         remainingRequests: updateResult.headerSnapshot.remainingRequests,

packages/core/src/agent/agent.ts

@@ -40,22 +40,16 @@ describe("TrafficController priority scheduling", () => {
     vi.useFakeTimers();
 
     try {
-      const controller = new TrafficController({
-        maxConcurrent: 1,
-        rateLimits: {
-          "p0::m0": { capacity: 1, refillPerSecond: 1 },
+      vi.setSystemTime(new Date(0));
+      const controller = new TrafficController({ maxConcurrent: 1 });
+      controller.updateRateLimitFromHeaders(
+        { provider: "p0", model: "m0" },
+        {
+          "x-ratelimit-limit-requests": "1",
+          "x-ratelimit-remaining-requests": "0",
+          "x-ratelimit-reset-requests": "1s",
         },
-      });
-
-      // Exhaust the bucket for the P0 key so it initially waits
-      const buckets = (controller as unknown as { rateLimitBuckets: Map<string, any> })
-        .rateLimitBuckets;
-      buckets.set("p0::m0", {
-        tokens: 0,
-        capacity: 1,
-        refillPerMs: 1 / 1000,
-        lastRefill: Date.now(),
-      });
+      );
 
       const order: string[] = [];
 
@@ -85,3 +79,119 @@ describe("TrafficController priority scheduling", () => {
     }
   });
 });
+
+describe("TrafficController rate limit headers", () => {
+  it("parses OpenAI-style compound reset durations (e.g. 1m30.951s)", () => {
+    vi.useFakeTimers();
+
+    try {
+      vi.setSystemTime(new Date(1_000_000));
+      const controller = new TrafficController({ maxConcurrent: 1 });
+      const now = Date.now();
+
+      const result = controller.updateRateLimitFromHeaders(
+        { provider: "openai.responses", model: "gpt-4o-mini" },
+        {
+          "x-ratelimit-limit-requests": "10000",
+          "x-ratelimit-remaining-requests": "9989",
+          "x-ratelimit-reset-requests": "1m30.951s",
+        },
+      );
+
+      expect(result).toBeTruthy();
+      expect(result?.headerSnapshot.resetRequestsMs).toBeCloseTo(90_951, 6);
+      expect(result?.state.limit).toBe(10000);
+      expect(result?.state.remaining).toBe(9989);
+      expect(result?.state.resetAt).toBe(now + 90_951);
+      expect(result?.state.reserved).toBe(0);
+      expect(result?.state.nextAllowedAt).toBe(now);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("keeps resetAt monotonic when headers shorten the reset duration", () => {
+    vi.useFakeTimers();
+
+    try {
+      vi.setSystemTime(new Date(0));
+      const controller = new TrafficController({ maxConcurrent: 1 });
+
+      const first = controller.updateRateLimitFromHeaders(
+        { provider: "openai.responses", model: "gpt-4o-mini" },
+        {
+          "x-ratelimit-limit-requests": "10000",
+          "x-ratelimit-remaining-requests": "9999",
+          "x-ratelimit-reset-requests": "60s",
+        },
+      );
+
+      expect(first).toBeTruthy();
+      expect(first?.state.resetAt).toBe(60_000);
+
+      vi.setSystemTime(new Date(10_000));
+      const second = controller.updateRateLimitFromHeaders(
+        { provider: "openai.responses", model: "gpt-4o-mini" },
+        {
+          "x-ratelimit-limit-requests": "10000",
+          "x-ratelimit-remaining-requests": "9998",
+          "x-ratelimit-reset-requests": "5s",
+        },
+      );
+
+      expect(second).toBeTruthy();
+      expect(second?.state.resetAt).toBe(60_000);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("never increases remaining within the same window", () => {
+    vi.useFakeTimers();
+
+    try {
+      vi.setSystemTime(new Date(0));
+      const controller = new TrafficController({ maxConcurrent: 1 });
+
+      const first = controller.updateRateLimitFromHeaders(
+        { provider: "openai.responses", model: "gpt-4o-mini" },
+        {
+          "x-ratelimit-limit-requests": "10",
+          "x-ratelimit-remaining-requests": "9",
+          "x-ratelimit-reset-requests": "60s",
+        },
+      );
+
+      expect(first?.state.remaining).toBe(9);
+      expect(first?.state.resetAt).toBe(60_000);
+
+      vi.setSystemTime(new Date(10_000));
+      const second = controller.updateRateLimitFromHeaders(
+        { provider: "openai.responses", model: "gpt-4o-mini" },
+        {
+          "x-ratelimit-limit-requests": "10",
+          "x-ratelimit-remaining-requests": "8",
+          "x-ratelimit-reset-requests": "50s",
+        },
+      );
+
+      expect(second?.state.remaining).toBe(8);
+      expect(second?.state.resetAt).toBe(60_000);
+
+      vi.setSystemTime(new Date(20_000));
+      const third = controller.updateRateLimitFromHeaders(
+        { provider: "openai.responses", model: "gpt-4o-mini" },
+        {
+          "x-ratelimit-limit-requests": "10",
+          "x-ratelimit-remaining-requests": "9",
+          "x-ratelimit-reset-requests": "40s",
+        },
+      );
+
+      expect(third?.state.remaining).toBe(8);
+      expect(third?.state.resetAt).toBe(60_000);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});