@ai-devkit/agent-manager 0.33.1 → 0.34.0

package/src/__tests__/providers/opencode/OpenCodeSessionParser.test.ts

@@ -0,0 +1,148 @@
+import Database from "better-sqlite3";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { OpenCodeSessionParser } from "../../../providers/opencode/OpenCodeSessionParser.js";
+
+describe("OpenCodeSessionParser", () => {
+  let db: Database.Database;
+  let parser: OpenCodeSessionParser;
+
+  beforeEach(() => {
+    db = new Database(":memory:");
+    db.exec(`
+      CREATE TABLE message (id TEXT, session_id TEXT, data TEXT, time_created INTEGER, time_updated INTEGER);
+      CREATE TABLE part (message_id TEXT, session_id TEXT, data TEXT, time_created INTEGER);
+    `);
+    parser = new OpenCodeSessionParser();
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  it("extracts session stats from OpenCode messages and parts", () => {
+    insertMessage(db, {
+      id: "msg-user",
+      sessionId: "sess-1",
+      role: "user",
+      timeCreated: 1000,
+      timeUpdated: 1000,
+    });
+    insertMessage(db, {
+      id: "msg-assistant",
+      sessionId: "sess-1",
+      role: "assistant",
+      timeCreated: 2000,
+      timeUpdated: 2500,
+      completed: 2400,
+    });
+    insertPart(db, {
+      messageId: "msg-user",
+      sessionId: "sess-1",
+      data: { type: "text", text: "Plan the migration" },
+      timeCreated: 1000,
+    });
+
+    expect(parser.getSessionStats(db, "sess-1")).toEqual({
+      lastRole: "assistant",
+      lastTimeUpdated: 2500,
+      lastAssistantCompleted: true,
+      lastAssistantErrored: false,
+      summary: "Plan the migration",
+    });
+  });
+
+  it("orders stats by message creation time, not metadata update time", () => {
+    insertMessage(db, {
+      id: "msg-user",
+      sessionId: "sess-1",
+      role: "user",
+      timeCreated: 1000,
+      timeUpdated: 3000,
+    });
+    insertMessage(db, {
+      id: "msg-assistant",
+      sessionId: "sess-1",
+      role: "assistant",
+      timeCreated: 2000,
+      timeUpdated: 2100,
+      completed: 2200,
+    });
+
+    expect(parser.getSessionStats(db, "sess-1").lastRole).toBe("assistant");
+  });
+
+  it("reads visible conversation text and hides verbose-only parts by default", () => {
+    insertMessage(db, {
+      id: "msg-user",
+      sessionId: "sess-1",
+      role: "user",
+      timeCreated: 1000,
+      timeUpdated: 1000,
+    });
+    insertMessage(db, {
+      id: "msg-assistant",
+      sessionId: "sess-1",
+      role: "assistant",
+      timeCreated: 2000,
+      timeUpdated: 2000,
+    });
+    insertPart(db, {
+      messageId: "msg-user",
+      sessionId: "sess-1",
+      data: { type: "text", text: "Hello" },
+      timeCreated: 1000,
+    });
+    insertPart(db, {
+      messageId: "msg-assistant",
+      sessionId: "sess-1",
+      data: { type: "reasoning", reasoning: "private thought" },
+      timeCreated: 2000,
+    });
+    insertPart(db, {
+      messageId: "msg-assistant",
+      sessionId: "sess-1",
+      data: { type: "tool", tool: "read_file" },
+      timeCreated: 3000,
+    });
+
+    expect(parser.getConversation(db, "sess-1")).toEqual([{ role: "user", content: "Hello" }]);
+    expect(parser.getConversation(db, "sess-1", { verbose: true })).toEqual([
+      { role: "user", content: "Hello" },
+      { role: "assistant", content: "[thinking] private thought" },
+      { role: "assistant", content: "[tool: read_file]" },
+    ]);
+  });
+});
+
+function insertMessage(
+  db: Database.Database,
+  input: {
+    id: string;
+    sessionId: string;
+    role: string;
+    timeCreated: number;
+    timeUpdated: number;
+    completed?: number;
+  },
+): void {
+  db.prepare(
+    "INSERT INTO message (id, session_id, data, time_created, time_updated) VALUES (?, ?, ?, ?, ?)",
+  ).run(
+    input.id,
+    input.sessionId,
+    JSON.stringify({
+      role: input.role,
+      time: input.completed === undefined ? {} : { completed: input.completed },
+    }),
+    input.timeCreated,
+    input.timeUpdated,
+  );
+}
+
+function insertPart(
+  db: Database.Database,
+  input: { messageId: string; sessionId: string; data: unknown; timeCreated: number },
+): void {
+  db.prepare("INSERT INTO part (message_id, session_id, data, time_created) VALUES (?, ?, ?, ?)")
+    .run(input.messageId, input.sessionId, JSON.stringify(input.data), input.timeCreated);
+}

package/src/adapters/index.ts

@@ -3,7 +3,7 @@ export { CodexAdapter } from "../providers/codex/CodexAdapter.js";
 export { CopilotAdapter } from "../providers/copilot/CopilotAdapter.js";
 export { GeminiCliAdapter } from "../providers/gemini/GeminiCliAdapter.js";
 export { GrokCliAdapter } from "./GrokCliAdapter.js";
-export { OpenCodeAdapter } from "./OpenCodeAdapter.js";
+export { OpenCodeAdapter } from "../providers/opencode/OpenCodeAdapter.js";
 export { PiAdapter } from "../providers/pi/PiAdapter.js";
 export { AgentStatus } from "./AgentAdapter.js";
 export type {

package/src/capacity/codex.ts

@@ -15,7 +15,13 @@ type RpcMessage = { id?: number; method: string; params?: UnknownRecord };
 type CliResponses = { rateLimits: unknown; account: unknown };
 type CodexRpc = (messages: RpcMessage[]) => Promise<CliResponses>;
 
-export const CODEX_APP_SERVER_ARGS = ["-s", "read-only", "-a", "untrusted", "app-server"] as const;
+export const CODEX_APP_SERVER_ARGS = [
+  "-s",
+  "read-only",
+  "-a",
+  "untrusted",
+  "app-server",
+] as const;
 
 type CodexProbeOptions = {
   installed: boolean;
@@ -57,12 +63,18 @@ function safeIdentifier(value: unknown): string | null {
   return candidate;
 }
 
-export function resolveCodexAuthPath(env: NodeJS.ProcessEnv = process.env): string {
+export function resolveCodexAuthPath(
+  env: NodeJS.ProcessEnv = process.env,
+): string {
   const root = env.CODEX_HOME || join(env.HOME || "", ".codex");
   return join(root, "auth.json");
 }
 
-export function toRateWindow(value: unknown, id: string, label: string): CapacityWindow | null {
+export function toRateWindow(
+  value: unknown,
+  id: string,
+  label: string,
+): CapacityWindow | null {
   const input = record(value);
   if (!input) return null;
   const used = finiteNumber(input.used_percent);
@@ -84,13 +96,24 @@ function extraWindows(value: unknown): CapacityWindow[] {
     const scope = safeIdentifier(limit.limit_name) ?? `extra-${index + 1}`;
     const windows = record(limit.rate_limit) ?? limit;
     return [
-      toRateWindow(windows.primary_window, `${scope}:primary`, `${scope} primary`),
-      toRateWindow(windows.secondary_window, `${scope}:secondary`, `${scope} secondary`),
+      toRateWindow(
+        windows.primary_window,
+        `${scope}:primary`,
+        `${scope} primary`,
+      ),
+      toRateWindow(
+        windows.secondary_window,
+        `${scope}:secondary`,
+        `${scope} secondary`,
+      ),
     ].filter((window): window is CapacityWindow => window !== null);
   });
 }
 
-export function parseUsage(raw: unknown, source: "pat" | "oauth"): UsageSnapshot {
+export function parseUsage(
+  raw: unknown,
+  source: "pat" | "oauth",
+): UsageSnapshot {
   const response = record(raw) ?? {};
   const limits = record(response.rate_limit) ?? {};
   const credits = record(response.credits) ?? {};
@@ -105,7 +128,11 @@ export function parseUsage(raw: unknown, source: "pat" | "oauth"): UsageSnapshot
   };
 }
 
-function cliWindow(value: unknown, id: string, label: string): CapacityWindow | null {
+function cliWindow(
+  value: unknown,
+  id: string,
+  label: string,
+): CapacityWindow | null {
   const input = record(value);
   if (!input) return null;
   return {
@@ -117,10 +144,14 @@ function cliWindow(value: unknown, id: string, label: string): CapacityWindow |
   };
 }
 
-function cliSnapshotWindows(value: unknown, fallbackId: string): CapacityWindow[] {
+function cliSnapshotWindows(
+  value: unknown,
+  fallbackId: string,
+): CapacityWindow[] {
   const snapshot = record(value);
   if (!snapshot) return [];
-  const scope = safeIdentifier(snapshot.limitId) ?? safeIdentifier(fallbackId) ?? "codex";
+  const scope =
+    safeIdentifier(snapshot.limitId) ?? safeIdentifier(fallbackId) ?? "codex";
   return [
     cliWindow(snapshot.primary, `${scope}:primary`, `${scope} primary`),
     cliWindow(snapshot.secondary, `${scope}:secondary`, `${scope} secondary`),
@@ -136,7 +167,9 @@ export function parseCliUsage(raw: unknown): UsageSnapshot {
     for (const [id, snapshot] of Object.entries(buckets))
       windows.push(...cliSnapshotWindows(snapshot, id));
   }
-  const unique = [...new Map(windows.map((window) => [window.id, window])).values()];
+  const unique = [
+    ...new Map(windows.map((window) => [window.id, window])).values(),
+  ];
   return { windows: unique, creditsRemaining: null, source: "cli" };
 }
 
@@ -145,18 +178,23 @@ function capacityFromSnapshot(
   context: CodexProbeOptions,
   raw?: unknown,
 ): CapacityReport {
-  const hasUsage = snapshot.windows.some((window) => window.usedPercent !== null);
+  const hasUsage = snapshot.windows.some(
+    (window) => window.usedPercent !== null,
+  );
   const rateLimits = record(record(raw)?.rateLimits);
   const reached = nonEmptyText(rateLimits?.rateLimitReachedType);
   const resetCredits =
-    record(record(raw)?.rateLimitResetCredits) ?? record(record(raw)?.usageLimitResetCredits);
+    record(record(raw)?.rateLimitResetCredits) ??
+    record(record(raw)?.usageLimitResetCredits);
   return {
-    provider: "codex",
+    harness: "codex",
+    provider: "openai",
     generatedAt: context.checkedAt,
     authenticated: true,
     available: reached ? "no" : hasUsage ? "yes" : "unknown",
     windows: snapshot.windows,
-    creditsRemaining: snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount),
+    creditsRemaining:
+      snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount),
   };
 }
 
@@ -164,7 +202,9 @@ function jwtExpiry(token: string): number | null {
   const part = token.split(".")[1];
   if (!part) return null;
   try {
-    return finiteNumber(record(JSON.parse(Buffer.from(part, "base64url").toString("utf8")))?.exp);
+    return finiteNumber(
+      record(JSON.parse(Buffer.from(part, "base64url").toString("utf8")))?.exp,
+    );
   } catch {
     return null;
   }
@@ -191,7 +231,10 @@ async function fetchJson(
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const response = await fetcher(url, { ...init, signal: controller.signal });
-    if (!response.ok) throw new Error(response.status === 401 ? "unauthorized" : "request failed");
+    if (!response.ok)
+      throw new Error(
+        response.status === 401 ? "unauthorized" : "request failed",
+      );
     return await response.json();
   } finally {
     clearTimeout(timer);
@@ -209,14 +252,20 @@ async function apiSnapshot(
     fetcher,
     "https://chatgpt.com/backend-api/wham/usage",
     {
-      headers: { Authorization: `Bearer ${token}`, "ChatGPT-Account-Id": accountId },
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "ChatGPT-Account-Id": accountId,
+      },
     },
     options.timeoutMs ?? 5000,
   );
   return parseUsage(raw, source);
 }
 
-function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResponses> {
+function appServerRpc(
+  messages: RpcMessage[],
+  timeoutMs = 5000,
+): Promise<CliResponses> {
   return new Promise((resolve, reject) => {
     const child = spawn("codex", CODEX_APP_SERVER_ARGS, {
       stdio: ["pipe", "pipe", "ignore"],
@@ -232,8 +281,13 @@ function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResp
       if (error) reject(error);
       else resolve(results as CliResponses);
     };
-    const timer = setTimeout(() => finish(new Error("codex probe timed out")), timeoutMs);
-    child.once("error", () => finish(new Error("codex app-server unavailable")));
+    const timer = setTimeout(
+      () => finish(new Error("codex probe timed out")),
+      timeoutMs,
+    );
+    child.once("error", () =>
+      finish(new Error("codex app-server unavailable")),
+    );
     child.once("exit", () => {
       if (!settled) finish(new Error("codex app-server exited"));
     });
@@ -256,7 +310,8 @@ function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResp
           for (const request of messages.slice(1))
             child.stdin.write(`${JSON.stringify(request)}\n`);
         } else if (message.id === 2) {
-          if (message.error) finish(new Error("codex rate-limit method failed"));
+          if (message.error)
+            finish(new Error("codex rate-limit method failed"));
           else results.rateLimits = message.result;
         } else if (message.id === 3) {
           if (message.error) finish(new Error("codex account method failed"));
@@ -269,10 +324,11 @@ function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResp
   });
 }
 
-function unavailable(options: CodexProbeOptions): CapacityReport {
+export function codexUnavailableReport(checkedAt: string): CapacityReport {
   return {
-    provider: "codex",
-    generatedAt: options.checkedAt,
+    harness: "codex",
+    provider: "openai",
+    generatedAt: checkedAt,
     authenticated: null,
     available: "unknown",
     windows: [],
@@ -280,7 +336,13 @@ function unavailable(options: CodexProbeOptions): CapacityReport {
   };
 }
 
-async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport> {
+function unavailable(options: CodexProbeOptions): CapacityReport {
+  return codexUnavailableReport(options.checkedAt);
+}
+
+async function cliFallback(
+  options: CodexProbeOptions,
+): Promise<CapacityReport> {
   if (!options.installed) return unavailable(options);
   const messages: RpcMessage[] = [
     {
@@ -296,7 +358,8 @@ async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport>
     { id: 3, method: "account/read" },
   ];
   try {
-    const rpc = options.rpc ?? ((requests) => appServerRpc(requests, options.timeoutMs));
+    const rpc =
+      options.rpc ?? ((requests) => appServerRpc(requests, options.timeoutMs));
     const response = await rpc(messages);
     const result = capacityFromSnapshot(
       parseCliUsage(response.rateLimits),
@@ -318,7 +381,9 @@ async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport>
   }
 }
 
-export async function probeCodexCapacity(options: CodexProbeOptions): Promise<CapacityReport> {
+export async function probeCodexCapacity(
+  options: CodexProbeOptions,
+): Promise<CapacityReport> {
   let parsed: UnknownRecord | null = null;
   try {
     const contents = await (options.readFile ?? readFile)(
@@ -345,7 +410,10 @@ export async function probeCodexCapacity(options: CodexProbeOptions): Promise<Ca
       );
       const accountId = nonEmptyText(whoami?.chatgpt_account_id);
       if (!accountId) throw new Error("account unavailable");
-      return capacityFromSnapshot(await apiSnapshot(pat, accountId, "pat", options), options);
+      return capacityFromSnapshot(
+        await apiSnapshot(pat, accountId, "pat", options),
+        options,
+      );
     } catch {
       // Continue to a separately available OAuth credential before using the CLI.
     }

package/src/capacity/index.ts

@@ -1,7 +1,8 @@
 import { constants } from "node:fs";
 import { access as fsAccess } from "node:fs/promises";
 import path from "node:path";
-import { probeCodexCapacity } from "./codex.js";
+import { codexUnavailableReport, probeCodexCapacity } from "./codex.js";
+import { probeZaiCapacity } from "./zai.js";
 import type { CapacityReport } from "./types.js";
 
 export type { CapacityReport, CapacityWindow } from "./types.js";
@@ -13,6 +14,14 @@ export type CapacityProbeOptions = {
   probe?: typeof probeCodexCapacity;
 };
 
+export type ZaiCapacityOptions = {
+  now?: () => Date;
+  env?: NodeJS.ProcessEnv;
+  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+};
+
 async function canAccess(target: string, mode: number): Promise<boolean> {
   try {
     await fsAccess(target, mode);
@@ -46,17 +55,26 @@ export async function getCodexCapacityReport(
   options: CapacityProbeOptions = {},
 ): Promise<CapacityReport> {
   const generatedAt = (options.now?.() ?? new Date()).toISOString();
-  const installed = await isCodexInstalled(options.path ?? process.env.PATH ?? "", options.access);
+  const installed = await isCodexInstalled(
+    options.path ?? process.env.PATH ?? "",
+    options.access,
+  );
   try {
-    return await (options.probe ?? probeCodexCapacity)({ installed, checkedAt: generatedAt });
+    return await (options.probe ?? probeCodexCapacity)({
+      installed,
+      checkedAt: generatedAt,
+    });
   } catch {
-    return {
-      provider: "codex",
-      generatedAt,
-      authenticated: null,
-      available: "unknown",
-      windows: [],
-      creditsRemaining: null,
-    };
+    return codexUnavailableReport(generatedAt);
   }
 }
+
+export async function getZaiCapacityReport(
+  options: ZaiCapacityOptions = {},
+): Promise<CapacityReport> {
+  const { now, ...probeOptions } = options;
+  return probeZaiCapacity({
+    ...probeOptions,
+    checkedAt: (now?.() ?? new Date()).toISOString(),
+  });
+}

package/src/capacity/types.ts

@@ -1,4 +1,5 @@
 export type Availability = "yes" | "no" | "unknown";
+export type CapacityLimitType = "TOKENS_LIMIT" | "CREDIT_LIMIT" | "TIME_LIMIT";
 
 export interface CapacityWindow {
   id: string;
@@ -6,9 +7,16 @@ export interface CapacityWindow {
   durationMinutes: number | null;
   usedPercent: number | null;
   resetsAt: string | null;
+  limitType?: CapacityLimitType;
+  total?: number | null;
+  current?: number | null;
+  remaining?: number | null;
 }
 
 export interface CapacityReport {
+  /** Harness whose quota pool is measured, e.g. "pi" or "codex". */
+  harness: string;
+  /** Model provider backing the harness, e.g. "zai" or "openai". */
   provider: string;
   generatedAt: string;
   authenticated: boolean | null;