@ai-devkit/agent-manager 0.36.0 → 0.38.0

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

@@ -1,141 +0,0 @@
-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",
-    });
-  });
-
-  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("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();
-  });
-
-  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();
-  });
-});

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

@@ -1,71 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildPiPrintArgs,
-  readPiAssistantText,
-  readPiSessionId,
-} from "../../../../providers/pi/durable/PiPrintProtocol.js";
-
-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]);
-  });
-
-  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");
-  });
-});

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

@@ -1,253 +0,0 @@
-import { EventEmitter } from "node:events";
-import { PassThrough, Writable } from "node:stream";
-import { describe, expect, it, vi } from "vitest";
-import type { PiDurableAgent } from "../../../../index.js";
-
-const SESSION = "22222222-2222-4222-8222-222222222222";
-function agent(sessionHealth: PiDurableAgent["sessionHealth"] = "uninitialized"): PiDurableAgent {
-  return {
-    id: "11111111-1111-4111-8111-111111111111",
-    name: "reviewer",
-    provider: "pi",
-    mode: "durable",
-    cwd: "/project",
-    providerSessionId: SESSION,
-    state: "running",
-    sessionHealth,
-    createdAt: "",
-    updatedAt: "",
-    lastActiveAt: null,
-    lastResult: null,
-    activeRun: null,
-  };
-}
-function fakeSpawn(lines: string[], exitCode = 0) {
-  const promptChunks: Buffer[] = [];
-  const child = new EventEmitter() as any;
-  child.pid = 4242;
-  child.stdout = new PassThrough();
-  child.stderr = new PassThrough();
-  child.kill = vi.fn();
-  child.stdin = new Writable({
-    write(chunk, _encoding, callback) {
-      promptChunks.push(Buffer.from(chunk));
-      callback();
-    },
-    final(callback) {
-      child.stdout.end(lines.join("\n"));
-      queueMicrotask(() => child.emit("close", exitCode, null));
-      callback();
-    },
-  });
-  return { child, spawn: vi.fn(() => child), promptChunks };
-}
-function events(session = SESSION): string[] {
-  return [
-    JSON.stringify({ type: "session", version: 3, id: session, cwd: "/project" }),
-    JSON.stringify({
-      type: "message_end",
-      message: { role: "assistant", content: [{ type: "text", text: "first" }] },
-    }),
-    JSON.stringify({
-      type: "message_end",
-      message: {
-        role: "assistant",
-        content: [
-          { type: "thinking", thinking: "hidden" },
-          { type: "text", text: "final" },
-        ],
-      },
-    }),
-    JSON.stringify({ type: "agent_end", messages: [] }),
-    "",
-  ];
-}
-async function runner(fixture: ReturnType<typeof fakeSpawn>, maxLineBytes?: number) {
-  const api = (await import("../../../../index.js")) as Record<string, unknown>;
-  expect(api).toHaveProperty("PiPrintRunner");
-  const Runner = api.PiPrintRunner as new (options: unknown) => any;
-  return new Runner({
-    spawn: fixture.spawn,
-    maxLineBytes,
-    processInspector: { getIdentity: () => ({ pid: 4242, startedAt: "start" }) },
-  });
-}
-
-describe("PiPrintRunner", () => {
-  it("binds a first session and returns the last completed assistant text", async () => {
-    const fixture = fakeSpawn(events());
-    const instance = await runner(fixture);
-    const order: string[] = [];
-    const result = await instance.run({
-      agent: agent(),
-      prompt: "secret",
-      executable: "fake-pi",
-      onSpawn: async () => {
-        expect(fixture.promptChunks).toHaveLength(0);
-        order.push("spawn");
-      },
-    });
-    expect(order).toEqual(["spawn"]);
-    expect(fixture.spawn).toHaveBeenCalledWith(
-      "fake-pi",
-      ["--mode", "json", "--session-id", SESSION],
-      expect.objectContaining({ cwd: "/project", shell: false }),
-    );
-    expect(Buffer.concat(fixture.promptChunks).toString()).toBe("secret");
-    expect(result).toEqual({
-      sessionId: SESSION,
-      result: "final",
-      messages: ["first", "final"],
-      exitCode: 0,
-    });
-  });
-
-  it("resumes the exact stored session and rejects mismatch", async () => {
-    const fixture = fakeSpawn(events("33333333-3333-4333-8333-333333333333"));
-    await expect(
-      (await runner(fixture)).run({ agent: agent("healthy"), prompt: "later", onSpawn: vi.fn() }),
-    ).rejects.toMatchObject({ code: "PI_SESSION_MISMATCH" });
-    expect(fixture.spawn.mock.calls[0]![1]).toEqual(["--mode", "json", "--session", SESSION]);
-  });
-
-  it.each([
-    ["malformed", ["{bad\n"], "PI_PROTOCOL"],
-    ["non-object", ["[]\n"], "PI_PROTOCOL"],
-    ["truncated", ["{}"], "PI_PROTOCOL"],
-    ["missing session", [JSON.stringify({ type: "agent_end" }), ""], "PI_PROTOCOL"],
-    [
-      "missing result",
-      [JSON.stringify({ type: "session", id: SESSION }), JSON.stringify({ type: "agent_end" }), ""],
-      "PI_RESULT_MISSING",
-    ],
-    [
-      "missing end",
-      [
-        JSON.stringify({ type: "session", id: SESSION }),
-        JSON.stringify({
-          type: "message_end",
-          message: { role: "assistant", content: [{ type: "text", text: "x" }] },
-        }),
-        "",
-      ],
-      "PI_PROTOCOL",
-    ],
-  ])("rejects %s output", async (_name, lines, code) => {
-    await expect(
-      (await runner(fakeSpawn(lines as string[]))).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code });
-  });
-
-  it("rejects oversized output, failed processes, and unverifiable identities", async () => {
-    await expect(
-      (await runner(fakeSpawn(["x".repeat(20)]), 10)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "PI_PROTOCOL" });
-    await expect(
-      (await runner(fakeSpawn(events(), 1))).run({ agent: agent(), prompt: "x", onSpawn: vi.fn() }),
-    ).rejects.toMatchObject({ code: "PI_PROCESS" });
-    const fixture = fakeSpawn([]);
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Runner = api.PiPrintRunner as new (options: unknown) => any;
-    await expect(
-      new Runner({ spawn: fixture.spawn, processInspector: { getIdentity: () => null } }).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "PI_PROCESS" });
-    expect(fixture.child.kill).toHaveBeenCalledOnce();
-  });
-
-  it("rejects invalid and duplicate session identities", async () => {
-    for (const lines of [
-      [JSON.stringify({ type: "session", id: "bad" }), ""],
-      [
-        JSON.stringify({ type: "session", id: SESSION }),
-        JSON.stringify({ type: "session", id: SESSION }),
-        "",
-      ],
-    ])
-      await expect(
-        (await runner(fakeSpawn(lines))).run({
-          agent: agent(),
-          prompt: "x",
-          onSpawn: vi.fn(),
-          onSession: vi.fn(),
-        }),
-      ).rejects.toMatchObject({ code: "PI_PROTOCOL" });
-  });
-
-  it("kills on spawn persistence failure", async () => {
-    const spawnFailure = fakeSpawn([]);
-    const failure = new Error("cannot persist");
-    await expect(
-      (await runner(spawnFailure)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn().mockRejectedValue(failure),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toBe(failure);
-    expect(spawnFailure.child.kill).toHaveBeenCalledOnce();
-  });
-
-  it("classifies spawn errors and a missing PID as process failures", async () => {
-    const errored = fakeSpawn([]);
-    errored.child.stdin = new Writable({
-      write(_chunk, _encoding, callback) {
-        callback();
-      },
-      final(callback) {
-        queueMicrotask(() => errored.child.emit("error", new Error("spawn")));
-        callback();
-      },
-    });
-    await expect(
-      (await runner(errored)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "PI_PROCESS" });
-    const missing = fakeSpawn([]);
-    missing.child.pid = undefined;
-    await expect(
-      (await runner(missing)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "PI_PROCESS" });
-    expect(missing.child.kill).toHaveBeenCalledOnce();
-  });
-
-  it("accepts string assistant content and ignores empty or unrelated messages", async () => {
-    const lines = [
-      JSON.stringify({ type: "session", id: SESSION }),
-      JSON.stringify({ type: "future" }),
-      JSON.stringify({ type: "message_end", message: { role: "user", content: "ignored" } }),
-      JSON.stringify({ type: "message_end", message: { role: "assistant", content: " " } }),
-      JSON.stringify({ type: "message_end", message: { role: "assistant", content: "answer" } }),
-      JSON.stringify({ type: "agent_end" }),
-      "",
-    ];
-    await expect(
-      (await runner(fakeSpawn(lines))).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).resolves.toMatchObject({ result: "answer" });
-  });
-});

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

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { PiStreamParser } from "../../../../providers/pi/durable/PiStreamParser.js";
-
-const SESSION = "22222222-2222-4222-8222-222222222222";
-
-describe("PiStreamParser", () => {
-  it("ignores blank lines and normalizes unexpected parser failures", () => {
-    const parser = new PiStreamParser(SESSION, 1024);
-    parser.accept("\n");
-    parser.fail(new Error("unexpected"));
-
-    expect(parser.hasFailed()).toBe(true);
-    expect(() => parser.result({ code: 0, signal: null })).toThrowError(
-      expect.objectContaining({ code: "PI_PROTOCOL", message: "Pi stream processing failed." }),
-    );
-  });
-
-  it("includes the terminating signal in process failures", () => {
-    const parser = new PiStreamParser(SESSION, 1024);
-    parser.accept(`${JSON.stringify({ type: "session", id: SESSION })}\n`);
-
-    expect(() => parser.result({ code: null, signal: "SIGTERM" })).toThrowError(
-      expect.objectContaining({ code: "PI_PROCESS", message: "Pi print run failed (SIGTERM)" }),
-    );
-  });
-});