@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/__tests__/providers/pi/durable/PiDurableAgentRepository.test.ts

@@ -1,32 +1,33 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { DurableAgentRepository } from '../../../../durable/DurableAgentRepository.js';
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { DurableAgentRepository } from "../../../../durable/DurableAgentRepository.js";
 
 const roots: string[] = [];
 
 afterEach(() => {
-    for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
 });
 
-describe('Pi durable-agent repository sessions', () => {
-    it('assigns a non-null session at creation and rejects deferred binding', async () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-durable-repository-'));
-        roots.push(root);
-        const cwd = path.join(root, 'project');
-        fs.mkdirSync(cwd);
-        const repository = new DurableAgentRepository({
-            dbPath: path.join(root, 'agents.db'),
-            processInspector: { getIdentity: (pid) => ({ pid, startedAt: 'owner-start' }) },
-        });
+describe("Pi durable-agent repository sessions", () => {
+  it("assigns a non-null session at creation and rejects deferred binding", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-durable-repository-"));
+    roots.push(root);
+    const cwd = path.join(root, "project");
+    fs.mkdirSync(cwd);
+    const repository = new DurableAgentRepository({
+      dbPath: path.join(root, "agents.db"),
+      processInspector: { getIdentity: (pid) => ({ pid, startedAt: "owner-start" }) },
+    });
 
-        const agent = await repository.create({ name: 'reviewer', cwd, provider: 'pi' });
-        expect(agent).toMatchObject({ provider: 'pi', sessionHealth: 'uninitialized' });
-        expect(agent.providerSessionId).toMatch(/^[0-9a-f-]{36}$/);
+    const agent = await repository.create({ name: "reviewer", cwd, provider: "pi" });
+    expect(agent).toMatchObject({ provider: "pi", sessionHealth: "uninitialized" });
+    expect(agent.providerSessionId).toMatch(/^[0-9a-f-]{36}$/);
 
-        const run = await repository.acquireRun(agent.id);
-        await expect(repository.bindProviderSession(agent.id, run.token, crypto.randomUUID()))
-            .rejects.toThrow('Only Codex durable sessions can be bound after creation.');
-    });
+    const run = await repository.acquireRun(agent.id);
+    await expect(
+      repository.bindProviderSession(agent.id, run.token, crypto.randomUUID()),
+    ).rejects.toThrow("Only Codex durable sessions can be bound after creation.");
+  });
 });

package/src/__tests__/providers/pi/durable/PiPrintAgentService.test.ts

@@ -1,69 +1,141 @@
-import { describe, expect, it, vi } from 'vitest';
-const SESSION = '22222222-2222-4222-8222-222222222222';
-const base = { id: 'id', name: 'reviewer', provider: 'pi', providerSessionId: SESSION, sessionHealth: 'uninitialized' };
+import { describe, expect, it, vi } from "vitest";
+const SESSION = "22222222-2222-4222-8222-222222222222";
+const base = {
+  id: "id",
+  name: "reviewer",
+  provider: "pi",
+  providerSessionId: SESSION,
+  sessionHealth: "uninitialized",
+};
 
-describe('PiPrintAgentService', () => {
-    it('probes before provider-aware create', async () => {
-        const api = await import('../../../../index.js') as Record<string, unknown>; expect(api).toHaveProperty('PiPrintAgentService');
-        const probe = { validate: vi.fn() }; const repository = { create: vi.fn().mockResolvedValue(base), list: vi.fn() }; const runner = { run: vi.fn() };
-        const Service = api.PiPrintAgentService as new (options: unknown) => any;
-        await new Service({ repository, probe, runner }).create({ name: 'reviewer', cwd: '/project' });
-        expect(probe.validate).toHaveBeenCalledOnce(); expect(repository.create).toHaveBeenCalledWith({ name: 'reviewer', cwd: '/project', provider: 'pi' });
+describe("PiPrintAgentService", () => {
+  it("probes before provider-aware create", async () => {
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
+    expect(api).toHaveProperty("PiPrintAgentService");
+    const probe = { validate: vi.fn() };
+    const repository = { create: vi.fn().mockResolvedValue(base), list: vi.fn() };
+    const runner = { run: vi.fn() };
+    const Service = api.PiPrintAgentService as new (options: unknown) => any;
+    await new Service({ repository, probe, runner }).create({ name: "reviewer", cwd: "/project" });
+    expect(probe.validate).toHaveBeenCalledOnce();
+    expect(repository.create).toHaveBeenCalledWith({
+      name: "reviewer",
+      cwd: "/project",
+      provider: "pi",
     });
+  });
 
-    it('records successful first and resumed sends', async () => {
-        const api = await import('../../../../index.js') as Record<string, unknown>;
-        const repository = { list: vi.fn(), resolve: vi.fn().mockResolvedValue(base), acquireRun: vi.fn()
-            .mockResolvedValueOnce({ agent: base, token: 'one' }).mockResolvedValueOnce({ agent: { ...base, sessionHealth: 'healthy' }, token: 'two' }),
-            recordProviderProcess: vi.fn(), completeRun: vi.fn() };
-        const runner = { run: vi.fn(async (request) => { await request.onSpawn({ pid: 42, startedAt: 'start' }); return { sessionId: SESSION, result: 'answer', messages: ['answer'], exitCode: 0 }; }) };
-        const Service = api.PiPrintAgentService as new (options: unknown) => any; const service = new Service({ repository, probe: { validate: vi.fn() }, runner });
-        await service.send('reviewer', 'first'); await service.send('reviewer', 'later');
-        expect(repository.completeRun).toHaveBeenCalledWith('id', 'one', expect.objectContaining({ status: 'succeeded', sessionHealth: 'healthy' }));
-    });
+  it("records successful first and resumed sends", async () => {
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
+    const repository = {
+      list: vi.fn(),
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi
+        .fn()
+        .mockResolvedValueOnce({ agent: base, token: "one" })
+        .mockResolvedValueOnce({ agent: { ...base, sessionHealth: "healthy" }, token: "two" }),
+      recordProviderProcess: vi.fn(),
+      completeRun: vi.fn(),
+    };
+    const runner = {
+      run: vi.fn(async (request) => {
+        await request.onSpawn({ pid: 42, startedAt: "start" });
+        return { sessionId: SESSION, result: "answer", messages: ["answer"], exitCode: 0 };
+      }),
+    };
+    const Service = api.PiPrintAgentService as new (options: unknown) => any;
+    const service = new Service({ repository, probe: { validate: vi.fn() }, runner });
+    await service.send("reviewer", "first");
+    await service.send("reviewer", "later");
+    expect(repository.completeRun).toHaveBeenCalledWith(
+      "id",
+      "one",
+      expect.objectContaining({ status: "succeeded", sessionHealth: "healthy" }),
+    );
+  });
 
-    it('records mismatches and rejects missing and ambiguous records', async () => {
-        const api = await import('../../../../index.js') as Record<string, unknown>; const ErrorType = api.PiPrintError as new (message: string, code: string) => Error;
-        const completeRun = vi.fn(); const repository = { list: vi.fn(), resolve: vi.fn().mockResolvedValue(base), acquireRun: vi.fn().mockResolvedValue({ agent: base, token: 'one' }), recordProviderProcess: vi.fn(), completeRun };
-        const Service = api.PiPrintAgentService as new (options: unknown) => any;
-        await expect(new Service({ repository, probe: { validate: vi.fn() }, runner: { run: vi.fn().mockRejectedValue(new ErrorType('bad', 'PI_SESSION_MISMATCH')) } }).send('reviewer', 'x'))
-            .rejects.toMatchObject({ code: 'PI_SESSION_MISMATCH' });
-        expect(completeRun).toHaveBeenCalledWith('id', 'one', expect.objectContaining({ sessionHealth: 'mismatch' }));
-        const earlyRepository = { ...repository, resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]), acquireRun: vi.fn() };
-        const early = new Service({ repository: earlyRepository, probe: { validate: vi.fn() }, runner: { run: vi.fn() } });
-        await expect(early.send('missing', 'x')).rejects.toMatchObject({ code: 'DURABLE_AGENT_NOT_FOUND' });
-        await expect(early.send('many', 'x')).rejects.toMatchObject({ code: 'PI_UNSUPPORTED' });
+  it("records mismatches and rejects missing and ambiguous records", async () => {
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
+    const ErrorType = api.PiPrintError as new (message: string, code: string) => Error;
+    const completeRun = vi.fn();
+    const repository = {
+      list: vi.fn(),
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
+      recordProviderProcess: vi.fn(),
+      completeRun,
+    };
+    const Service = api.PiPrintAgentService as new (options: unknown) => any;
+    await expect(
+      new Service({
+        repository,
+        probe: { validate: vi.fn() },
+        runner: { run: vi.fn().mockRejectedValue(new ErrorType("bad", "PI_SESSION_MISMATCH")) },
+      }).send("reviewer", "x"),
+    ).rejects.toMatchObject({ code: "PI_SESSION_MISMATCH" });
+    expect(completeRun).toHaveBeenCalledWith(
+      "id",
+      "one",
+      expect.objectContaining({ sessionHealth: "mismatch" }),
+    );
+    const earlyRepository = {
+      ...repository,
+      resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]),
+      acquireRun: vi.fn(),
+    };
+    const early = new Service({
+      repository: earlyRepository,
+      probe: { validate: vi.fn() },
+      runner: { run: vi.fn() },
+    });
+    await expect(early.send("missing", "x")).rejects.toMatchObject({
+      code: "DURABLE_AGENT_NOT_FOUND",
     });
+    await expect(early.send("many", "x")).rejects.toMatchObject({ code: "PI_UNSUPPORTED" });
+  });
 
-    it('rejects a non-Pi target without acquiring or mutating it', async () => {
-        const api = await import('../../../../index.js') as Record<string, unknown>;
-        const Service = api.PiPrintAgentService as new (options: unknown) => any;
-        const repository = {
-            resolve: vi.fn().mockResolvedValue({ ...base, provider: 'claude' }),
-            acquireRun: vi.fn(), recordProviderProcess: vi.fn(), completeRun: vi.fn(),
-        };
+  it("rejects a non-Pi target without acquiring or mutating it", async () => {
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
+    const Service = api.PiPrintAgentService as new (options: unknown) => any;
+    const repository = {
+      resolve: vi.fn().mockResolvedValue({ ...base, provider: "claude" }),
+      acquireRun: vi.fn(),
+      recordProviderProcess: vi.fn(),
+      completeRun: vi.fn(),
+    };
 
-        await expect(new Service({ repository, probe: { validate: vi.fn() }, runner: { run: vi.fn() } })
-            .send('reviewer', 'x')).rejects.toMatchObject({ code: 'PI_UNSUPPORTED' });
-        expect(repository.acquireRun).not.toHaveBeenCalled();
-        expect(repository.completeRun).not.toHaveBeenCalled();
-    });
+    await expect(
+      new Service({ repository, probe: { validate: vi.fn() }, runner: { run: vi.fn() } }).send(
+        "reviewer",
+        "x",
+      ),
+    ).rejects.toMatchObject({ code: "PI_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.PiPrintAgentService as new (options: unknown) => any;
-        const completionFailure = new Error('completion failed');
-        const repository = {
-            resolve: vi.fn().mockResolvedValue(base),
-            acquireRun: vi.fn().mockResolvedValue({ agent: base, token: 'one' }),
-            recordProviderProcess: vi.fn(), completeRun: vi.fn().mockRejectedValue(completionFailure),
-        };
-        const runner = { run: vi.fn().mockResolvedValue({
-            sessionId: SESSION, result: 'answer', messages: ['answer'], exitCode: 0,
-        }) };
+  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.PiPrintAgentService as new (options: unknown) => any;
+    const completionFailure = new Error("completion failed");
+    const repository = {
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
+      recordProviderProcess: vi.fn(),
+      completeRun: vi.fn().mockRejectedValue(completionFailure),
+    };
+    const runner = {
+      run: vi.fn().mockResolvedValue({
+        sessionId: SESSION,
+        result: "answer",
+        messages: ["answer"],
+        exitCode: 0,
+      }),
+    };
 
-        await expect(new Service({ repository, probe: { validate: vi.fn() }, runner })
-            .send('reviewer', 'x')).rejects.toBe(completionFailure);
-        expect(repository.completeRun).toHaveBeenCalledOnce();
-    });
+    await expect(
+      new Service({ repository, probe: { validate: vi.fn() }, runner }).send("reviewer", "x"),
+    ).rejects.toBe(completionFailure);
+    expect(repository.completeRun).toHaveBeenCalledOnce();
+  });
 });

package/src/__tests__/providers/pi/durable/PiPrintProtocol.test.ts

@@ -1,33 +1,71 @@
-import { describe, expect, it } from 'vitest';
-import { buildPiPrintArgs, readPiAssistantText, readPiSessionId } from '../../../../providers/pi/durable/PiPrintProtocol.js';
+import { describe, expect, it } from "vitest";
+import {
+  buildPiPrintArgs,
+  readPiAssistantText,
+  readPiSessionId,
+} from "../../../../providers/pi/durable/PiPrintProtocol.js";
 
-const SESSION = '22222222-2222-4222-8222-222222222222';
+const SESSION = "22222222-2222-4222-8222-222222222222";
 
-describe('Pi print pure protocol mapping', () => {
-    it('maps first and resumed runs to exact documented arguments', () => {
-        expect(buildPiPrintArgs(SESSION, true)).toEqual(['--mode', 'json', '--session-id', SESSION]);
-        expect(buildPiPrintArgs(SESSION, false)).toEqual(['--mode', 'json', '--session', SESSION]);
-    });
+describe("Pi print pure protocol mapping", () => {
+  it("maps first and resumed runs to exact documented arguments", () => {
+    expect(buildPiPrintArgs(SESSION, true)).toEqual(["--mode", "json", "--session-id", SESSION]);
+    expect(buildPiPrintArgs(SESSION, false)).toEqual(["--mode", "json", "--session", SESSION]);
+  });
 
-    it('accepts one expected UUID and rejects invalid, duplicate, and mismatched identities', () => {
-        expect(readPiSessionId({ id: SESSION }, null, SESSION)).toBe(SESSION);
-        expect(() => readPiSessionId({}, null, SESSION)).toThrowError(expect.objectContaining({ code: 'PI_PROTOCOL' }));
-        expect(() => readPiSessionId({ id: [SESSION] }, null, SESSION))
-            .toThrowError(expect.objectContaining({ code: 'PI_PROTOCOL' }));
-        expect(() => readPiSessionId({ id: SESSION }, SESSION, SESSION)).toThrowError(expect.objectContaining({ code: 'PI_PROTOCOL' }));
-        expect(() => readPiSessionId({ id: '33333333-3333-4333-8333-333333333333' }, null, SESSION))
-            .toThrowError(expect.objectContaining({ code: 'PI_SESSION_MISMATCH' }));
-    });
+  it("accepts one expected UUID and rejects invalid, duplicate, and mismatched identities", () => {
+    expect(readPiSessionId({ id: SESSION }, null, SESSION)).toBe(SESSION);
+    expect(() => readPiSessionId({}, null, SESSION)).toThrowError(
+      expect.objectContaining({ code: "PI_PROTOCOL" }),
+    );
+    expect(() => readPiSessionId({ id: [SESSION] }, null, SESSION)).toThrowError(
+      expect.objectContaining({ code: "PI_PROTOCOL" }),
+    );
+    expect(() => readPiSessionId({ id: SESSION }, SESSION, SESSION)).toThrowError(
+      expect.objectContaining({ code: "PI_PROTOCOL" }),
+    );
+    expect(() =>
+      readPiSessionId({ id: "33333333-3333-4333-8333-333333333333" }, null, SESSION),
+    ).toThrowError(expect.objectContaining({ code: "PI_SESSION_MISMATCH" }));
+  });
 
-    it('extracts only non-empty completed assistant text', () => {
-        expect(readPiAssistantText({ type: 'future' })).toBeNull();
-        expect(readPiAssistantText({ type: 'message_end' })).toBeNull();
-        expect(readPiAssistantText({ type: 'message_end', message: [] })).toBeNull();
-        expect(readPiAssistantText({ type: 'message_end', message: { role: 'user', content: 'no' } })).toBeNull();
-        expect(readPiAssistantText({ type: 'message_end', message: { role: 'assistant', content: ' ' } })).toBeNull();
-        expect(readPiAssistantText({ type: 'message_end', message: { role: 'assistant', content: 'answer' } })).toBe('answer');
-        expect(readPiAssistantText({ type: 'message_end', message: { role: 'assistant', content: null } })).toBeNull();
-        expect(readPiAssistantText({ type: 'message_end', message: { role: 'assistant', content: [null, [], { type: 'thinking' }] } })).toBeNull();
-        expect(readPiAssistantText({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: 'a' }, { type: 'text', text: 1 }, { type: 'text', text: 'b' }] } })).toBe('ab');
-    });
+  it("extracts only non-empty completed assistant text", () => {
+    expect(readPiAssistantText({ type: "future" })).toBeNull();
+    expect(readPiAssistantText({ type: "message_end" })).toBeNull();
+    expect(readPiAssistantText({ type: "message_end", message: [] })).toBeNull();
+    expect(
+      readPiAssistantText({ type: "message_end", message: { role: "user", content: "no" } }),
+    ).toBeNull();
+    expect(
+      readPiAssistantText({ type: "message_end", message: { role: "assistant", content: " " } }),
+    ).toBeNull();
+    expect(
+      readPiAssistantText({
+        type: "message_end",
+        message: { role: "assistant", content: "answer" },
+      }),
+    ).toBe("answer");
+    expect(
+      readPiAssistantText({ type: "message_end", message: { role: "assistant", content: null } }),
+    ).toBeNull();
+    expect(
+      readPiAssistantText({
+        type: "message_end",
+        message: { role: "assistant", content: [null, [], { type: "thinking" }] },
+      }),
+    ).toBeNull();
+    expect(
+      readPiAssistantText({
+        type: "message_end",
+        message: {
+          role: "assistant",
+          content: [
+            { type: "text", text: "a" },
+            { type: "text", text: 1 },
+            { type: "text", text: "b" },
+          ],
+        },
+      }),
+    ).toBe("ab");
+  });
 });