@ai-devkit/agent-manager 0.33.0 → 0.34.0

package/src/AgentManager.ts

@@ -13,8 +13,19 @@ import type {
   ProcessInfo,
 } from "./adapters/AgentAdapter.js";
 import { sortAgents, type AgentSortKey } from "./utils/sortAgents.js";
-import { AgentRegistry, type RegistryEntry } from "./utils/AgentRegistry.js";
+import {
+  AgentRegistry,
+  parseTmuxRuntimeRef,
+  type AgentRuntimeProvider,
+  type RegistryEntry,
+} from "./utils/AgentRegistry.js";
 import { captureProcessSnapshot, filterByProcessNames } from "./utils/process.js";
+import {
+  findMatchingHerdrPane,
+  fetchHerdrAgentPanes,
+  herdrPaneToRuntimeRef,
+  type HerdrAgentPane,
+} from "./runtime/herdr/HerdrAgentDiscovery.js";
 
 type ProcessSnapshotCapture = (namePatterns: readonly string[]) => Promise<ProcessInfo[]>;
 
@@ -26,6 +37,14 @@ export interface ListAgentsOptions {
   sortBy?: AgentSortKey;
 }
 
+export interface AgentManagerOptions {
+  runtimeProvider?:
+    | AgentRuntimeProvider
+    | (() => AgentRuntimeProvider | Promise<AgentRuntimeProvider>);
+  fetchHerdrAgentPanes?: () => Promise<readonly HerdrAgentPane[]>;
+  onRuntimeDiscoveryError?: (error: unknown) => void;
+}
+
 export class AgentNotRunningError extends Error {
   constructor(public agentName: string) {
     super(`Agent "${agentName}" is no longer running.`);
@@ -55,6 +74,7 @@ export class AgentManager {
   constructor(
     registry: AgentRegistry = AgentRegistry.default(),
     private readonly captureSnapshot: ProcessSnapshotCapture = captureProcessSnapshot,
+    private readonly options: AgentManagerOptions = {},
   ) {
     this.registry = registry;
   }
@@ -193,8 +213,13 @@ export class AgentManager {
     const preExistingByIdentity = new Map(
       this.registry.list().map((entry) => [identityKey(entry.type, entry.pid), entry]),
     );
+    const herdrPanes = allAgents.length > 0 ? await this.resolveHerdrPanes() : [];
     const entries = allAgents.map((agent) =>
-      this.toRegistryEntry(agent, preExistingByIdentity.get(identityKey(agent.type, agent.pid))),
+      this.toRegistryEntry(
+        agent,
+        preExistingByIdentity.get(identityKey(agent.type, agent.pid)),
+        herdrPanes,
+      ),
     );
     if (entries.length > 0) this.registry.registerBatch(entries);
     this.registry.pruneIfDue();
@@ -212,9 +237,33 @@ export class AgentManager {
     return sortAgents(allAgents, sortKey);
   }
 
-  private toRegistryEntry(agent: AgentInfo, existing?: RegistryEntry): RegistryEntry {
-    return {
-      name: existing?.name ?? agent.name,
+  private async resolveHerdrPanes(): Promise<readonly HerdrAgentPane[]> {
+    const runtimeProvider = await this.resolveRuntimeProvider();
+    if (runtimeProvider !== "herdr") return [];
+
+    try {
+      return await (this.options.fetchHerdrAgentPanes ?? fetchHerdrAgentPanes)();
+    } catch (error) {
+      this.options.onRuntimeDiscoveryError?.(error);
+      return [];
+    }
+  }
+
+  private async resolveRuntimeProvider(): Promise<AgentRuntimeProvider | undefined> {
+    const runtimeProvider = this.options.runtimeProvider;
+    return typeof runtimeProvider === "function" ? await runtimeProvider() : runtimeProvider;
+  }
+
+  private toRegistryEntry(
+    agent: AgentInfo,
+    existing?: RegistryEntry,
+    herdrPanes: readonly HerdrAgentPane[] = [],
+  ): RegistryEntry {
+    const name = existing?.name ?? agent.name;
+    const existingHasAuthoritativeRuntimeRef =
+      existing?.runtime === "herdr" || Boolean(parseTmuxRuntimeRef(existing?.runtimeRef));
+    const baseEntry: RegistryEntry = {
+      name,
       type: agent.type,
       pid: agent.pid,
       runtime: existing?.runtime ?? "tmux",
@@ -225,6 +274,19 @@ export class AgentManager {
       sessionFilePath: agent.sessionFilePath ?? "",
       pinned: existing?.pinned ?? agent.pinned ?? false,
     };
+
+    if (!existingHasAuthoritativeRuntimeRef) {
+      const herdrPane = findMatchingHerdrPane(agent, herdrPanes);
+      if (herdrPane) {
+        return {
+          ...baseEntry,
+          runtime: "herdr",
+          runtimeRef: herdrPaneToRuntimeRef(herdrPane, name),
+        };
+      }
+    }
+
+    return baseEntry;
   }
 
   togglePin(agentName: string): boolean {

package/src/__tests__/AgentManager.test.ts

@@ -16,6 +16,7 @@ import type {
 } from "../adapters/AgentAdapter.js";
 import { AgentStatus } from "../adapters/AgentAdapter.js";
 import { AgentRegistry, type RegistryEntry } from "../utils/AgentRegistry.js";
+import type { HerdrAgentPane } from "../runtime/herdr/HerdrAgentDiscovery.js";
 
 // Mock adapter for testing
 class MockAdapter implements AgentAdapter {
@@ -360,6 +361,15 @@ describe("AgentManager", () => {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     });
 
+    function useHerdrPanes(panes: readonly HerdrAgentPane[]): ReturnType<typeof vi.fn> {
+      const fetchHerdrPanes = vi.fn().mockResolvedValue(panes);
+      scopedManager = new AgentManager(registry, undefined, {
+        runtimeProvider: "herdr",
+        fetchHerdrAgentPanes: fetchHerdrPanes,
+      });
+      return fetchHerdrPanes;
+    }
+
     it("persists every detected agent to the registry", async () => {
       scopedManager.registerAdapter(
         new MockAdapter("claude", [
@@ -390,6 +400,223 @@ describe("AgentManager", () => {
       expect(entries[0].startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
     });
 
+    it("persists a Herdr runtime ref for manually discovered agents matched by session id", async () => {
+      useHerdrPanes([
+        {
+          agent: "codex",
+          agentSessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w31:p1",
+          workspaceId: "w31",
+          tabId: "w31:t1",
+        },
+      ]);
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-44290",
+            type: "codex",
+            pid: process.pid,
+            sessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+            sessionFilePath: "/path/codex.jsonl",
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(registry.list()[0]).toMatchObject({
+        name: "ai-devkit-44290",
+        type: "codex",
+        pid: process.pid,
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w31:p1",
+          workspaceId: "w31",
+          tabId: "w31:t1",
+          agentName: "ai-devkit-44290",
+        },
+      });
+    });
+
+    it("upgrades an existing tmux fallback row when Herdr later matches by session id", async () => {
+      useHerdrPanes([
+        {
+          agent: "codex",
+          agentSessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w31:p1",
+        },
+      ]);
+      registry.register({
+        name: "ai-devkit-44290",
+        type: "codex",
+        pid: process.pid,
+        runtime: "tmux",
+        runtimeRef: null,
+        cwd: "/cwd/ai-devkit",
+        startedAt: "2026-09-14T00:00:00.000Z",
+        sessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+        sessionFilePath: "/path/codex.jsonl",
+      });
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-44290",
+            type: "codex",
+            pid: process.pid,
+            sessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+            sessionFilePath: "/path/codex.jsonl",
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(registry.lookup("ai-devkit-44290")).toMatchObject({
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w31:p1",
+          agentName: "ai-devkit-44290",
+        },
+      });
+    });
+
+    it("upgrades an existing tmux fallback row when Herdr matches by foreground pid", async () => {
+      useHerdrPanes([
+        {
+          agent: "codex",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w31:p1",
+          foregroundPids: [44290],
+        },
+        {
+          agent: "codex",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w32:p1",
+          foregroundPids: [process.pid],
+        },
+      ]);
+      registry.register({
+        name: "ai-devkit-64904",
+        type: "codex",
+        pid: process.pid,
+        runtime: "tmux",
+        runtimeRef: null,
+        cwd: "/cwd/ai-devkit",
+        startedAt: "2026-09-14T00:00:00.000Z",
+        sessionId: `pid-${process.pid}`,
+        sessionFilePath: "",
+      });
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-64904",
+            type: "codex",
+            pid: process.pid,
+            sessionId: `pid-${process.pid}`,
+            sessionFilePath: undefined,
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(registry.lookup("ai-devkit-64904")).toMatchObject({
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w32:p1",
+          agentName: "ai-devkit-64904",
+        },
+      });
+    });
+
+    it("fetches Herdr panes automatically when the configured runtime is Herdr", async () => {
+      const fetchHerdrPanes = useHerdrPanes([
+        {
+          agent: "codex",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w32:p1",
+          foregroundPids: [process.pid],
+        },
+      ]);
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-64904",
+            type: "codex",
+            pid: process.pid,
+            sessionId: `pid-${process.pid}`,
+            sessionFilePath: undefined,
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(fetchHerdrPanes).toHaveBeenCalledOnce();
+      expect(registry.lookup("ai-devkit-64904")).toMatchObject({
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w32:p1",
+          agentName: "ai-devkit-64904",
+        },
+      });
+    });
+
+    it("upgrades an existing tmux row with a malformed runtime ref when Herdr matches", async () => {
+      useHerdrPanes([
+        {
+          agent: "codex",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w32:p1",
+          foregroundPids: [process.pid],
+        },
+      ]);
+      registry.register({
+        name: "ai-devkit-64904",
+        type: "codex",
+        pid: process.pid,
+        runtime: "tmux",
+        runtimeRef: {},
+        cwd: "/cwd/ai-devkit",
+        startedAt: "2026-09-14T00:00:00.000Z",
+        sessionId: `pid-${process.pid}`,
+        sessionFilePath: "",
+      });
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-64904",
+            type: "codex",
+            pid: process.pid,
+            sessionId: `pid-${process.pid}`,
+            sessionFilePath: undefined,
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(registry.lookup("ai-devkit-64904")).toMatchObject({
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w32:p1",
+          agentName: "ai-devkit-64904",
+        },
+      });
+    });
+
     it("prunes entries for dead pids", async () => {
       registry.register({
         name: "dead",
@@ -620,7 +847,7 @@ describe("AgentManager", () => {
       expect(agents[0].lastActive.toISOString()).toBe("2026-01-01T00:00:00.000Z");
     });
 
-    it("persists changed fields once in one write transaction", async () => {
+    it("does not persist passive cwd changes when an existing cwd is present", async () => {
       const adapter = new MockAdapter("claude", [
         createMockAgent({ name: "changing", pid: process.pid, projectPath: "/cwd/before" }),
       ]);
@@ -636,10 +863,9 @@ describe("AgentManager", () => {
 
       const upserts = databaseOperations.filter((sql) => /^\s*INSERT INTO agents/i.test(sql));
       const transactions = databaseOperations.filter((sql) => /^\s*(BEGIN|COMMIT)/i.test(sql));
-      expect(upserts).toHaveLength(1);
-      expect(upserts[0]).toContain("'2026-08-14T10:00:01.000Z'");
-      expect(transactions).toHaveLength(2);
-      expect(registry.lookup("changing")?.cwd).toBe("/cwd/after");
+      expect(upserts).toHaveLength(0);
+      expect(transactions).toHaveLength(0);
+      expect(registry.lookup("changing")?.cwd).toBe("/cwd/before");
     });
 
     it("prunes newly dead entries only when the passive cadence is due", async () => {

package/src/__tests__/capacity/codex.test.ts

@@ -13,7 +13,11 @@ const context = { installed: true, checkedAt };
 function apiUsage(overrides: Record<string, unknown> = {}) {
   return {
     rate_limit: {
-      primary_window: { used_percent: 20, limit_window_seconds: 18_000, reset_at: 1_787_220_000 },
+      primary_window: {
+        used_percent: 20,
+        limit_window_seconds: 18_000,
+        reset_at: 1_787_220_000,
+      },
       secondary_window: {
         used_percent: 60,
         limit_window_seconds: 604_800,
@@ -39,13 +43,18 @@ function apiUsage(overrides: Record<string, unknown> = {}) {
 
 describe("Codex auth resolution", () => {
   it("uses CODEX_HOME before HOME", () => {
-    expect(resolveCodexAuthPath({ CODEX_HOME: "/custom/codex", HOME: "/users/test" })).toBe(
-      "/custom/codex/auth.json",
-    );
+    expect(
+      resolveCodexAuthPath({
+        CODEX_HOME: "/custom/codex",
+        HOME: "/users/test",
+      }),
+    ).toBe("/custom/codex/auth.json");
   });
 
   it("falls back to ~/.codex/auth.json", () => {
-    expect(resolveCodexAuthPath({ HOME: "/users/test" })).toBe("/users/test/.codex/auth.json");
+    expect(resolveCodexAuthPath({ HOME: "/users/test" })).toBe(
+      "/users/test/.codex/auth.json",
+    );
   });
 });
 
@@ -53,7 +62,11 @@ describe("Codex API usage mapping", () => {
   it("converts an API window without treating missing data as zero", () => {
     expect(
       toRateWindow(
-        { used_percent: 25, limit_window_seconds: 18_000, reset_at: 1_787_220_000 },
+        {
+          used_percent: 25,
+          limit_window_seconds: 18_000,
+          reset_at: 1_787_220_000,
+        },
         "session",
         "Session",
       ),
@@ -64,7 +77,9 @@ describe("Codex API usage mapping", () => {
       usedPercent: 25,
       resetsAt: "2026-08-20T10:00:00.000Z",
     });
-    expect(toRateWindow({}, "session", "Session")).toMatchObject({ usedPercent: null });
+    expect(toRateWindow({}, "session", "Session")).toMatchObject({
+      usedPercent: null,
+    });
   });
 
   it("maps session, weekly, credits, and extra limits", () => {
@@ -89,16 +104,23 @@ describe("tiered Codex probing", () => {
     const fetch = vi
       .fn()
       .mockResolvedValueOnce(
-        new Response(JSON.stringify({ chatgpt_account_id: "acct-1" }), { status: 200 }),
+        new Response(JSON.stringify({ chatgpt_account_id: "acct-1" }), {
+          status: 200,
+        }),
       )
-      .mockResolvedValueOnce(new Response(JSON.stringify(apiUsage()), { status: 200 }));
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify(apiUsage()), { status: 200 }),
+      );
     const rpc = vi.fn();
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>
         JSON.stringify({
           personal_access_token: "pat-secret",
-          tokens: { access_token: "ignored-oauth", account_id: "ignored-account" },
+          tokens: {
+            access_token: "ignored-oauth",
+            account_id: "ignored-account",
+          },
         }),
       fetch,
       rpc,
@@ -107,14 +129,17 @@ describe("tiered Codex probing", () => {
     expect(fetch.mock.calls[0][0]).toBe(
       "https://auth.openai.com/api/accounts/v1/user-auth-credential/whoami",
     );
-    expect(fetch.mock.calls[1][0]).toBe("https://chatgpt.com/backend-api/wham/usage");
+    expect(fetch.mock.calls[1][0]).toBe(
+      "https://chatgpt.com/backend-api/wham/usage",
+    );
     expect(fetch.mock.calls[1][1].headers).toMatchObject({
       Authorization: "Bearer pat-secret",
       "ChatGPT-Account-Id": "acct-1",
     });
     expect(rpc).not.toHaveBeenCalled();
     expect(result).toMatchObject({
-      provider: "codex",
+      harness: "codex",
+      provider: "openai",
       available: "yes",
       creditsRemaining: 12.5,
       authenticated: true,
@@ -129,12 +154,18 @@ describe("tiered Codex probing", () => {
   it("selects a fresh OAuth token without calling whoami", async () => {
     const fetch = vi
       .fn()
-      .mockResolvedValue(new Response(JSON.stringify(apiUsage()), { status: 200 }));
+      .mockResolvedValue(
+        new Response(JSON.stringify(apiUsage()), { status: 200 }),
+      );
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>
         JSON.stringify({
-          tokens: { access_token: "oauth-secret", account_id: "acct-2", expires_at: 1_800_000_000 },
+          tokens: {
+            access_token: "oauth-secret",
+            account_id: "acct-2",
+            expires_at: 1_800_000_000,
+          },
         }),
       fetch,
       now: () => new Date("2026-08-20T10:00:00.000Z"),
@@ -158,23 +189,35 @@ describe("tiered Codex probing", () => {
       "stale OAuth token",
       async () =>
         JSON.stringify({
-          tokens: { access_token: "stale-secret", account_id: "acct", expires_at: 1 },
+          tokens: {
+            access_token: "stale-secret",
+            account_id: "acct",
+            expires_at: 1,
+          },
         }),
     ],
     [
       "OAuth 401",
       async () =>
         JSON.stringify({
-          tokens: { access_token: "oauth-secret", account_id: "acct", expires_at: 1_800_000_000 },
+          tokens: {
+            access_token: "oauth-secret",
+            account_id: "acct",
+            expires_at: 1_800_000_000,
+          },
         }),
     ],
   ])("falls back to the CLI for %s", async (name, readFile) => {
     const fetch = vi
       .fn()
-      .mockResolvedValue(new Response("", { status: name === "OAuth 401" ? 401 : 200 }));
+      .mockResolvedValue(
+        new Response("", { status: name === "OAuth 401" ? 401 : 200 }),
+      );
     const rpc = vi.fn(async () => ({
       rateLimits: {
-        rateLimits: { primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null } },
+        rateLimits: {
+          primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null },
+        },
       },
       account: { account: { type: "chatgpt" } },
     }));
@@ -190,10 +233,14 @@ describe("tiered Codex probing", () => {
   });
 
   it("falls back to CLI if PAT requests fail", async () => {
-    const rpc = vi.fn(async () => ({ rateLimits: {}, account: { account: null } }));
+    const rpc = vi.fn(async () => ({
+      rateLimits: {},
+      account: { account: null },
+    }));
     const result = await probeCodexCapacity({
       ...context,
-      readFile: async () => JSON.stringify({ personal_access_token: "pat-secret" }),
+      readFile: async () =>
+        JSON.stringify({ personal_access_token: "pat-secret" }),
       fetch: vi.fn().mockRejectedValue(new Error("network failure pat-secret")),
       rpc,
     });
@@ -205,14 +252,20 @@ describe("tiered Codex probing", () => {
     const fetch = vi
       .fn()
       .mockRejectedValueOnce(new Error("PAT failed"))
-      .mockResolvedValueOnce(new Response(JSON.stringify(apiUsage()), { status: 200 }));
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify(apiUsage()), { status: 200 }),
+      );
     const rpc = vi.fn();
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>
         JSON.stringify({
           personal_access_token: "pat-secret",
-          tokens: { access_token: "oauth-secret", account_id: "acct", expires_at: 1_800_000_000 },
+          tokens: {
+            access_token: "oauth-secret",
+            account_id: "acct",
+            expires_at: 1_800_000_000,
+          },
         }),
       fetch,
       rpc,
@@ -226,7 +279,9 @@ describe("tiered Codex probing", () => {
   it("uses hardened read-only app-server arguments and both account methods", async () => {
     const rpc = vi.fn(async () => ({
       rateLimits: {
-        rateLimits: { primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null } },
+        rateLimits: {
+          primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null },
+        },
       },
       account: { account: { type: "chatgpt" } },
     }));
@@ -239,7 +294,13 @@ describe("tiered Codex probing", () => {
       "account/read",
     ]);
     expect(JSON.stringify(messages)).not.toMatch(/prompt|turn\/start/);
-    expect(CODEX_APP_SERVER_ARGS).toEqual(["-s", "read-only", "-a", "untrusted", "app-server"]);
+    expect(CODEX_APP_SERVER_ARGS).toEqual([
+      "-s",
+      "read-only",
+      "-a",
+      "untrusted",
+      "app-server",
+    ]);
   });
 
   it("uses account/read to distinguish logged-out CLI state", async () => {
@@ -248,11 +309,18 @@ describe("tiered Codex probing", () => {
       readFile: async () => "{}",
       rpc: async () => ({ rateLimits: {}, account: { account: null } }),
     });
-    expect(result).toMatchObject({ authenticated: false, available: "unknown" });
+    expect(result).toMatchObject({
+      authenticated: false,
+      available: "unknown",
+    });
   });
 
   it("never exposes tokens or raw auth content through failures", async () => {
-    const secrets = ["pat-secret-value", "oauth-secret-value", "refresh-secret-value"];
+    const secrets = [
+      "pat-secret-value",
+      "oauth-secret-value",
+      "refresh-secret-value",
+    ];
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>

package/src/__tests__/capacity/fixtures/zai-auth.json

@@ -0,0 +1,6 @@
+{
+  "zai": {
+    "type": "api_key",
+    "key": "pi-zai-test-key"
+  }
+}

package/src/__tests__/capacity/fixtures/zai-quota-invalid.json

@@ -0,0 +1,7 @@
+{
+  "success": true,
+  "code": 200,
+  "data": {
+    "limits": {}
+  }
+}

package/src/__tests__/capacity/fixtures/zai-quota.json

@@ -0,0 +1,38 @@
+{
+  "success": true,
+  "code": 200,
+  "data": {
+    "limits": [
+      {
+        "type": "TOKENS_LIMIT",
+        "unit": 3,
+        "number": 5,
+        "percentage": 99,
+        "usage": 1000,
+        "currentValue": 200,
+        "remaining": 700,
+        "nextResetTime": 1787220000000
+      },
+      {
+        "type": "CREDIT_LIMIT",
+        "unit": 6,
+        "number": 1,
+        "percentage": 5,
+        "usage": 200,
+        "currentValue": 80,
+        "remaining": 150,
+        "nextResetTime": 1787824800000
+      },
+      {
+        "type": "TIME_LIMIT",
+        "unit": 5,
+        "number": 1,
+        "percentage": 25,
+        "usage": 100,
+        "currentValue": 20,
+        "remaining": 90,
+        "nextResetTime": 1789812000000
+      }
+    ]
+  }
+}