@ai-devkit/agent-manager 0.37.0 → 0.39.0

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

@@ -1,18 +1,13 @@
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it, vi } from "vitest";
-import {
-  parseZaiQuota,
-  probeZaiCapacity,
-  resolveZaiApiKey,
-} from "../../capacity/zai.js";
+import { parseZaiCapacity } from "../../capacity/providers/zai.js";
+import { probeZaiCapacity } from "../../capacity/sources/pi.js";
+import { resolvePiZaiApiKey as resolveZaiApiKey } from "../../harnesses/pi/credentials.js";
 
 const checkedAt = "2026-08-20T10:00:00.000Z";
 const fixture = (name: string) =>
-  readFile(
-    fileURLToPath(new URL(`./fixtures/${name}`, import.meta.url)),
-    "utf8",
-  );
+  readFile(fileURLToPath(new URL(`./fixtures/${name}`, import.meta.url)), "utf8");
 
 describe("z.ai credential resolution", () => {
   it("prefers Z_AI_API_KEY without reading Pi auth", async () => {
@@ -31,44 +26,28 @@ describe("z.ai credential resolution", () => {
     await expect(
       resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
     ).resolves.toBe("pi-zai-test-key");
-    expect(readAuth).toHaveBeenCalledWith(
-      "/users/test/.pi/agent/auth.json",
-      "utf8",
-    );
+    expect(readAuth).toHaveBeenCalledWith("/users/test/.pi/agent/auth.json", "utf8");
   });
 
   it.each([
     [
       "missing",
-      async () =>
-        Promise.reject(Object.assign(new Error("missing"), { code: "ENOENT" })),
+      async () => Promise.reject(Object.assign(new Error("missing"), { code: "ENOENT" })),
     ],
     ["invalid JSON", async () => "{"],
-    [
-      "wrong credential type",
-      async () => JSON.stringify({ zai: { type: "oauth", key: "x" } }),
-    ],
+    ["wrong credential type", async () => JSON.stringify({ zai: { type: "oauth", key: "x" } })],
     ["missing key", async () => JSON.stringify({ zai: { type: "api_key" } })],
-  ])(
-    "fails clearly for %s credentials without exposing file content",
-    async (_name, readAuth) => {
-      await expect(
-        resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
-      ).rejects.toThrow(/z\.ai API key|z\.ai Pi auth file/);
-    },
-  );
+  ])("fails clearly for %s credentials without exposing file content", async (_name, readAuth) => {
+    await expect(
+      resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
+    ).rejects.toThrow(/z\.ai API key|z\.ai Pi auth file/);
+  });
 });
 
 describe("z.ai quota mapping", () => {
   it("maps token, credit, and monthly MCP windows with recomputed usage", async () => {
-    const report = parseZaiQuota(
-      JSON.parse(await fixture("zai-quota.json")),
-      checkedAt,
-    );
+    const report = parseZaiCapacity(JSON.parse(await fixture("zai-quota.json")));
     expect(report).toMatchObject({
-      harness: "pi",
-      provider: "zai",
-      generatedAt: checkedAt,
       authenticated: true,
       available: "yes",
       creditsRemaining: null,
@@ -111,40 +90,26 @@ describe("z.ai quota mapping", () => {
   });
 
   it("uses and clamps the server percentage when quota amounts are unavailable", () => {
-    const report = parseZaiQuota(
-      {
-        success: true,
-        code: 200,
-        data: {
-          limits: [
-            { type: "TOKENS_LIMIT", unit: 1, number: 1, percentage: 120 },
-            { type: "CREDIT_LIMIT", unit: 5, number: 30, percentage: -5 },
-          ],
-        },
+    const report = parseZaiCapacity({
+      success: true,
+      code: 200,
+      data: {
+        limits: [
+          { type: "TOKENS_LIMIT", unit: 1, number: 1, percentage: 120 },
+          { type: "CREDIT_LIMIT", unit: 5, number: 30, percentage: -5 },
+        ],
       },
-      checkedAt,
-    );
-    expect(report.windows.map((window) => window.usedPercent)).toEqual([
-      100, 0,
-    ]);
+    });
+    expect(report.windows.map((window) => window.usedPercent)).toEqual([100, 0]);
   });
 
   it.each([
-    [
-      "invalid fixture",
-      async () => JSON.parse(await fixture("zai-quota-invalid.json")),
-    ],
-    [
-      "unsuccessful envelope",
-      async () => ({ success: false, code: 401, data: { limits: [] } }),
-    ],
-    [
-      "invalid entry",
-      async () => ({ success: true, code: 200, data: { limits: [{}] } }),
-    ],
+    ["invalid fixture", async () => JSON.parse(await fixture("zai-quota-invalid.json"))],
+    ["unsuccessful envelope", async () => ({ success: false, code: 401, data: { limits: [] } })],
+    ["invalid entry", async () => ({ success: true, code: 200, data: { limits: [{}] } })],
   ])("rejects %s", async (_name, input) => {
     const value = await input();
-    expect(() => parseZaiQuota(value, checkedAt)).toThrow(/z\.ai quota/);
+    expect(() => parseZaiCapacity(value)).toThrow(/z\.ai quota/);
   });
 });
 

package/src/__tests__/harnesses/claude/durable/ClaudePrintAgent.integration.test.ts

@@ -3,10 +3,10 @@ import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
-  ClaudePrintAgentService,
   DurableAgentRepository,
   type ProcessInspector,
-} from "../../../../index.js";
+} from "../../../../durable/DurableAgentRepository.js";
+import { ClaudePrintAgentService } from "../../../../harnesses/claude/durable/ClaudePrintAgentService.js";
 
 const roots: string[] = [];
 

package/src/__tests__/harnesses/claude/durable/ClaudePrintRunner.test.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
 import { describe, expect, it, vi } from "vitest";
-import type { DurableAgent } from "../../../../index.js";
+import type { DurableAgent } from "../../../../durable/DurableAgent.js";
 import { ClaudePrintRunner } from "../../../../harnesses/claude/durable/ClaudePrintRunner.js";
 
 function agent(): DurableAgent {

package/src/__tests__/harnesses/codex/durable/CodexCliProbe.test.ts

@@ -1,9 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
+import { CodexCliProbe } from "../../../../harnesses/codex/durable/CodexCliProbe.js";
 
 describe("CodexCliProbe", () => {
   it("validates version, exec JSON/stdin, and resume capabilities without a model call", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    expect(api).toHaveProperty("CodexCliProbe");
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: "codex-cli 0.147.0", stderr: "" })
@@ -15,12 +14,12 @@ describe("CodexCliProbe", () => {
         stdout: "Usage: codex exec resume [SESSION_ID] [PROMPT]\n--json\n- stdin",
         stderr: "",
       });
-    const Probe = api.CodexCliProbe as new (options: unknown) => any;
-
-    await expect(new Probe({ executable: "fake-codex", exec }).validate()).resolves.toEqual({
-      executable: "fake-codex",
-      version: "codex-cli 0.147.0",
-    });
+    await expect(new CodexCliProbe({ executable: "fake-codex", exec }).validate()).resolves.toEqual(
+      {
+        executable: "fake-codex",
+        version: "codex-cli 0.147.0",
+      },
+    );
     expect(exec.mock.calls).toEqual([
       ["fake-codex", ["--version"]],
       ["fake-codex", ["exec", "--help"]],
@@ -29,9 +28,7 @@ describe("CodexCliProbe", () => {
   });
 
   it("rejects unsupported and unavailable CLIs with bounded sanitized errors", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.CodexCliProbe as new (options: unknown) => any;
-    const unsupported = new Probe({
+    const unsupported = new CodexCliProbe({
       exec: vi
         .fn()
         .mockResolvedValueOnce({ stdout: "version", stderr: "" })
@@ -39,7 +36,7 @@ describe("CodexCliProbe", () => {
         .mockResolvedValueOnce({ stdout: "resume", stderr: "" }),
     });
     await expect(unsupported.validate()).rejects.toMatchObject({ code: "CODEX_CLI_UNSUPPORTED" });
-    const missingCommands = new Probe({
+    const missingCommands = new CodexCliProbe({
       exec: vi
         .fn()
         .mockResolvedValueOnce({ stdout: "version", stderr: "" })
@@ -50,7 +47,7 @@ describe("CodexCliProbe", () => {
       code: "CODEX_CLI_UNSUPPORTED",
     });
 
-    const unavailable = new Probe({
+    const unavailable = new CodexCliProbe({
       exec: vi.fn().mockRejectedValue(new Error(`bad\0${"x".repeat(1000)}`)),
     });
     const error = await unavailable.validate().catch((value: Error & { code: string }) => value);
@@ -60,25 +57,23 @@ describe("CodexCliProbe", () => {
   });
 
   it("reports an empty version response as unknown", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.CodexCliProbe as new (options: unknown) => any;
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: " \n", stderr: "" })
       .mockResolvedValueOnce({ stdout: "exec --json -", stderr: "" })
       .mockResolvedValueOnce({ stdout: "resume --json -", stderr: "" });
-    await expect(new Probe({ exec }).validate()).resolves.toMatchObject({ version: "unknown" });
+    await expect(new CodexCliProbe({ exec }).validate()).resolves.toMatchObject({
+      version: "unknown",
+    });
   });
 
   it("requires a standalone stdin dash rather than accepting flag hyphens", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.CodexCliProbe as new (options: unknown) => any;
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: "version", stderr: "" })
       .mockResolvedValueOnce({ stdout: "exec --json", stderr: "" })
       .mockResolvedValueOnce({ stdout: "resume --json", stderr: "" });
-    await expect(new Probe({ exec }).validate()).rejects.toMatchObject({
+    await expect(new CodexCliProbe({ exec }).validate()).rejects.toMatchObject({
       code: "CODEX_CLI_UNSUPPORTED",
     });
   });

package/src/__tests__/harnesses/codex/durable/CodexPrintAgent.integration.test.ts

@@ -2,12 +2,12 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { CodexPrintError } from "../../../../durable/DurableAgent.js";
 import {
-  CodexPrintError,
-  CodexPrintAgentService,
   DurableAgentRepository,
   type ProcessInspector,
-} from "../../../../index.js";
+} from "../../../../durable/DurableAgentRepository.js";
+import { CodexPrintAgentService } from "../../../../harnesses/codex/durable/CodexPrintAgentService.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 const roots: string[] = [];

package/src/__tests__/harnesses/codex/durable/CodexPrintAgentService.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
+import { CodexPrintError } from "../../../../durable/DurableAgent.js";
+import { CodexPrintAgentService } from "../../../../harnesses/codex/durable/CodexPrintAgentService.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 const base = {
@@ -11,15 +13,15 @@ const base = {
 
 describe("CodexPrintAgentService", () => {
   it("validates before provider-aware create and never runs Codex", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    expect(api).toHaveProperty("CodexPrintAgentService");
     const probe = {
       validate: vi.fn().mockResolvedValue({ executable: "codex", version: "0.147.0" }),
     };
     const repository = { create: vi.fn().mockResolvedValue(base) };
     const runner = { run: vi.fn() };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-    await new Service({ repository, probe, runner }).create({ name: "reviewer", cwd: "/project" });
+    await new CodexPrintAgentService({ repository, probe, runner }).create({
+      name: "reviewer",
+      cwd: "/project",
+    });
     expect(repository.create).toHaveBeenCalledWith({
       name: "reviewer",
       cwd: "/project",
@@ -29,7 +31,6 @@ describe("CodexPrintAgentService", () => {
   });
 
   it("binds during first send and explicitly resumes later sends", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
       acquireRun: vi
@@ -50,8 +51,7 @@ describe("CodexPrintAgentService", () => {
         return { sessionId: SESSION, result: "answer", messages: ["answer"], exitCode: 0 };
       }),
     };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-    const service = new Service({
+    const service = new CodexPrintAgentService({
       repository,
       probe: { validate: vi.fn() },
       runner,
@@ -74,8 +74,6 @@ describe("CodexPrintAgentService", () => {
   });
 
   it("records mismatch separately from unknown failures", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const ErrorType = api.CodexPrintError as new (message: string, code: string) => Error;
     const completeRun = vi.fn();
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
@@ -84,12 +82,11 @@ describe("CodexPrintAgentService", () => {
       bindProviderSession: vi.fn(),
       completeRun,
     };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-    const service = new Service({
+    const service = new CodexPrintAgentService({
       repository,
       probe: { validate: vi.fn() },
       runner: {
-        run: vi.fn().mockRejectedValue(new ErrorType("mismatch", "CODEX_SESSION_MISMATCH")),
+        run: vi.fn().mockRejectedValue(new CodexPrintError("mismatch", "CODEX_SESSION_MISMATCH")),
       },
     });
     await expect(service.send("reviewer", "x")).rejects.toMatchObject({
@@ -103,8 +100,6 @@ describe("CodexPrintAgentService", () => {
   });
 
   it("rejects a non-Codex target without acquiring or mutating it", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
     const repository = {
       resolve: vi.fn().mockResolvedValue({ ...base, provider: "claude" }),
       acquireRun: vi.fn(),
@@ -114,18 +109,17 @@ describe("CodexPrintAgentService", () => {
     };
 
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner: { run: vi.fn() } }).send(
-        "reviewer",
-        "x",
-      ),
+      new CodexPrintAgentService({
+        repository,
+        probe: { validate: vi.fn() },
+        runner: { run: vi.fn() },
+      }).send("reviewer", "x"),
     ).rejects.toMatchObject({ code: "CODEX_UNSUPPORTED" });
     expect(repository.acquireRun).not.toHaveBeenCalled();
     expect(repository.completeRun).not.toHaveBeenCalled();
   });
 
   it("does not turn a successful completion write failure into a second completion", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
     const completionFailure = new Error("completion failed");
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
@@ -144,14 +138,15 @@ describe("CodexPrintAgentService", () => {
     };
 
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner }).send("reviewer", "x"),
+      new CodexPrintAgentService({ repository, probe: { validate: vi.fn() }, runner }).send(
+        "reviewer",
+        "x",
+      ),
     ).rejects.toBe(completionFailure);
     expect(repository.completeRun).toHaveBeenCalledOnce();
   });
 
   it("records a repository binding conflict as a session mismatch", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const BindingError = api.CodexPrintError as new (message: string, code: string) => Error;
     const completeRun = vi.fn();
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
@@ -159,7 +154,7 @@ describe("CodexPrintAgentService", () => {
       recordProviderProcess: vi.fn(),
       bindProviderSession: vi
         .fn()
-        .mockRejectedValue(new BindingError("binding mismatch", "CODEX_SESSION_MISMATCH")),
+        .mockRejectedValue(new CodexPrintError("binding mismatch", "CODEX_SESSION_MISMATCH")),
       completeRun,
     };
     const runner = {
@@ -168,10 +163,11 @@ describe("CodexPrintAgentService", () => {
         return { sessionId: SESSION, result: "x", messages: ["x"], exitCode: 0 };
       }),
     };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner }).send("reviewer", "x"),
+      new CodexPrintAgentService({ repository, probe: { validate: vi.fn() }, runner }).send(
+        "reviewer",
+        "x",
+      ),
     ).rejects.toMatchObject({ code: "CODEX_SESSION_MISMATCH" });
     expect(completeRun).toHaveBeenCalledWith(
       "id",
@@ -181,8 +177,6 @@ describe("CodexPrintAgentService", () => {
   });
 
   it("rejects missing and ambiguous records before acquiring a run", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
     const repository = {
       create: vi.fn(),
       resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]),
@@ -191,7 +185,7 @@ describe("CodexPrintAgentService", () => {
       bindProviderSession: vi.fn(),
       completeRun: vi.fn(),
     };
-    const service = new Service({
+    const service = new CodexPrintAgentService({
       repository,
       probe: { validate: vi.fn() },
       runner: { run: vi.fn() },

package/src/__tests__/harnesses/codex/durable/CodexPrintRunner.test.ts

@@ -1,7 +1,8 @@
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
 import { describe, expect, it, vi } from "vitest";
-import type { CodexDurableAgent } from "../../../../index.js";
+import type { CodexDurableAgent } from "../../../../durable/DurableAgent.js";
+import { CodexPrintRunner } from "../../../../harnesses/codex/durable/CodexPrintRunner.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 
@@ -64,10 +65,7 @@ function events(session = SESSION): string[] {
 }
 
 async function runner(fixture: ReturnType<typeof fakeSpawn>, maxLineBytes?: number) {
-  const api = (await import("../../../../index.js")) as Record<string, unknown>;
-  expect(api).toHaveProperty("CodexPrintRunner");
-  const Runner = api.CodexPrintRunner as new (options: unknown) => any;
-  return new Runner({
+  return new CodexPrintRunner({
     spawn: fixture.spawn,
     maxLineBytes,
     processInspector: {
@@ -262,10 +260,8 @@ describe("CodexPrintRunner", () => {
   });
 
   it("rejects an unverifiable positive PID", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     const fixture = fakeSpawn([]);
-    const Runner = api.CodexPrintRunner as new (options: unknown) => any;
-    const instance = new Runner({
+    const instance = new CodexPrintRunner({
       spawn: fixture.spawn,
       processInspector: { getIdentity: () => null },
     });