@ai-devkit/agent-manager 0.36.0 → 0.38.0

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

@@ -1,104 +0,0 @@
-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,
-  CodexPrintAgentService,
-  DurableAgentRepository,
-  type ProcessInspector,
-} from "../../index.js";
-
-const SESSION = "22222222-2222-4222-8222-222222222222";
-const roots: string[] = [];
-
-afterEach(() => {
-  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
-});
-
-describe("Codex print-agent fake-provider journey", () => {
-  it("creates unbound, then binds and explicitly resumes the provider-minted session", async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-print-integration-"));
-    roots.push(root);
-    const cwd = path.join(root, "project");
-    fs.mkdirSync(cwd);
-    const processInspector: ProcessInspector = {
-      getIdentity: (pid) => ({ pid, startedAt: `process-${pid}` }),
-    };
-    const repository = new DurableAgentRepository({
-      dbPath: path.join(root, "agents.db"),
-      processInspector,
-    });
-    const runner = {
-      run: vi.fn().mockImplementation(async (request) => {
-        await request.onSpawn({ pid: 42, startedAt: "process-42" });
-        await request.onSession(SESSION);
-        return {
-          sessionId: SESSION,
-          result: `answer:${request.prompt}`,
-          messages: [`answer:${request.prompt}`],
-          exitCode: 0,
-        };
-      }),
-    };
-    const service = new CodexPrintAgentService({
-      repository,
-      probe: { validate: vi.fn() },
-      runner,
-    });
-
-    const created = await service.create({ name: "reviewer", cwd });
-    expect(created).toMatchObject({
-      provider: "codex",
-      providerSessionId: null,
-      sessionHealth: "uninitialized",
-    });
-
-    const first = await service.send(created.id, "first secret");
-    expect(first).toMatchObject({ result: "answer:first secret" });
-    const bound = await repository.getById(created.id);
-    expect(bound?.providerSessionId).toBe(first.sessionId);
-    await expect(service.send(created.id, "follow up")).resolves.toMatchObject({
-      result: "answer:follow up",
-    });
-
-    expect(runner.run.mock.calls[0][0].agent).toMatchObject({ providerSessionId: null });
-    expect(runner.run.mock.calls[1][0].agent).toMatchObject({ providerSessionId: SESSION });
-  });
-
-  it("retains a first-run binding when the provider fails after thread start", async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-print-bind-failure-"));
-    roots.push(root);
-    const cwd = path.join(root, "project");
-    fs.mkdirSync(cwd);
-    const processInspector: ProcessInspector = {
-      getIdentity: (pid) => ({ pid, startedAt: `process-${pid}` }),
-    };
-    const repository = new DurableAgentRepository({
-      dbPath: path.join(root, "agents.db"),
-      processInspector,
-    });
-    const runner = {
-      run: vi.fn().mockImplementation(async (request) => {
-        await request.onSpawn({ pid: 42, startedAt: "process-42" });
-        await request.onSession(SESSION);
-        throw new CodexPrintError("Codex print run failed.", "CODEX_PROCESS");
-      }),
-    };
-    const service = new CodexPrintAgentService({
-      repository,
-      probe: { validate: vi.fn() },
-      runner,
-    });
-    const created = await service.create({ name: "reviewer", cwd });
-
-    await expect(service.send(created.id, "secret")).rejects.toMatchObject({
-      code: "CODEX_PROCESS",
-    });
-    expect(await repository.getById(created.id)).toMatchObject({
-      providerSessionId: SESSION,
-      state: "degraded",
-      sessionHealth: "unknown",
-    });
-  });
-});

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

@@ -1,217 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-const SESSION = "22222222-2222-4222-8222-222222222222";
-const base = {
-  id: "id",
-  name: "reviewer",
-  provider: "codex",
-  providerSessionId: null,
-  sessionHealth: "uninitialized",
-};
-
-describe("CodexPrintAgentService", () => {
-  it("constructs default non-billable dependencies without invoking them", async () => {
-    const api = (await import("../../index.js")) as Record<string, unknown>;
-    const Service = api.CodexPrintAgentService as new () => any;
-    expect(new Service().repository).toBeDefined();
-  });
-
-  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), list: vi.fn() };
-    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" });
-    expect(repository.create).toHaveBeenCalledWith({
-      name: "reviewer",
-      cwd: "/project",
-      provider: "codex",
-    });
-    expect(runner.run).not.toHaveBeenCalled();
-  });
-
-  it("binds during first send and explicitly resumes later 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, providerSessionId: SESSION, sessionHealth: "healthy" },
-          token: "two",
-        }),
-      recordProviderProcess: vi.fn(),
-      bindProviderSession: vi.fn(),
-      completeRun: vi.fn(),
-    };
-    const runner = {
-      run: vi.fn().mockImplementation(async (request) => {
-        await request.onSpawn({ pid: 42, startedAt: "start" });
-        await request.onSession(SESSION);
-        return { sessionId: SESSION, result: "answer", messages: ["answer"], exitCode: 0 };
-      }),
-    };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-    const service = new Service({
-      repository,
-      probe: { validate: vi.fn() },
-      runner,
-      executable: "fake-codex",
-    });
-
-    await service.send("reviewer", "first");
-    await service.send("reviewer", "later");
-
-    expect(repository.bindProviderSession).toHaveBeenNthCalledWith(1, "id", "one", SESSION);
-    expect(repository.bindProviderSession).toHaveBeenNthCalledWith(2, "id", "two", SESSION);
-    expect(repository.completeRun).toHaveBeenCalledWith(
-      "id",
-      "one",
-      expect.objectContaining({
-        status: "succeeded",
-        sessionHealth: "healthy",
-      }),
-    );
-  });
-
-  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 = {
-      list: vi.fn(),
-      resolve: vi.fn().mockResolvedValue(base),
-      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
-      recordProviderProcess: vi.fn(),
-      bindProviderSession: vi.fn(),
-      completeRun,
-    };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-    const service = new Service({
-      repository,
-      probe: { validate: vi.fn() },
-      runner: {
-        run: vi.fn().mockRejectedValue(new ErrorType("mismatch", "CODEX_SESSION_MISMATCH")),
-      },
-    });
-    await expect(service.send("reviewer", "x")).rejects.toMatchObject({
-      code: "CODEX_SESSION_MISMATCH",
-    });
-    expect(completeRun).toHaveBeenCalledWith(
-      "id",
-      "one",
-      expect.objectContaining({ sessionHealth: "mismatch" }),
-    );
-  });
-
-  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(),
-      recordProviderProcess: vi.fn(),
-      bindProviderSession: vi.fn(),
-      completeRun: vi.fn(),
-    };
-
-    await expect(
-      new Service({ 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),
-      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
-      recordProviderProcess: vi.fn(),
-      bindProviderSession: 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();
-  });
-
-  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 = {
-      list: vi.fn(),
-      resolve: vi.fn().mockResolvedValue(base),
-      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
-      recordProviderProcess: vi.fn(),
-      bindProviderSession: vi
-        .fn()
-        .mockRejectedValue(new BindingError("binding mismatch", "CODEX_SESSION_MISMATCH")),
-      completeRun,
-    };
-    const runner = {
-      run: vi.fn().mockImplementation(async (request) => {
-        await request.onSession(SESSION);
-        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"),
-    ).rejects.toMatchObject({ code: "CODEX_SESSION_MISMATCH" });
-    expect(completeRun).toHaveBeenCalledWith(
-      "id",
-      "one",
-      expect.objectContaining({ sessionHealth: "mismatch" }),
-    );
-  });
-
-  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 = {
-      list: vi.fn(),
-      create: vi.fn(),
-      resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]),
-      acquireRun: vi.fn(),
-      recordProviderProcess: vi.fn(),
-      bindProviderSession: vi.fn(),
-      completeRun: vi.fn(),
-    };
-    const service = new Service({
-      repository,
-      probe: { validate: vi.fn() },
-      runner: { run: vi.fn() },
-    });
-    await expect(service.send("missing", "x")).rejects.toMatchObject({
-      code: "DURABLE_AGENT_NOT_FOUND",
-    });
-    await expect(service.send("ambiguous", "x")).rejects.toMatchObject({
-      code: "CODEX_UNSUPPORTED",
-    });
-    expect(repository.acquireRun).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,309 +0,0 @@
-import { EventEmitter } from "node:events";
-import { PassThrough, Writable } from "node:stream";
-import { describe, expect, it, vi } from "vitest";
-import type { CodexDurableAgent } from "../../index.js";
-
-const SESSION = "22222222-2222-4222-8222-222222222222";
-
-function agent(providerSessionId: string | null = null): CodexDurableAgent {
-  return {
-    id: "11111111-1111-4111-8111-111111111111",
-    name: "reviewer",
-    provider: "codex",
-    mode: "durable",
-    cwd: "/project",
-    providerSessionId,
-    state: "running",
-    sessionHealth: "uninitialized",
-    createdAt: "",
-    updatedAt: "",
-    lastActiveAt: null,
-    lastResult: null,
-    activeRun: null,
-  };
-}
-
-function fakeSpawn(lines: string[], exitCode = 0, chunks = false) {
-  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) {
-      const output = lines.join("\n");
-      if (chunks) {
-        const bytes = Buffer.from(output);
-        child.stdout.write(bytes.subarray(0, 7));
-        child.stdout.write(bytes.subarray(7));
-      } else child.stdout.write(output);
-      child.stdout.end();
-      queueMicrotask(() => child.emit("close", exitCode, null));
-      callback();
-    },
-  });
-  const spawn = vi.fn(() => child);
-  return { child, spawn, promptChunks };
-}
-
-function events(session = SESSION): string[] {
-  return [
-    JSON.stringify({ type: "thread.started", thread_id: session }),
-    JSON.stringify({ type: "turn.started" }),
-    JSON.stringify({ type: "future.event", anything: true }),
-    JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "first" } }),
-    JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "final" } }),
-    JSON.stringify({ type: "turn.completed" }),
-    "",
-  ];
-}
-
-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({
-    spawn: fixture.spawn,
-    maxLineBytes,
-    processInspector: {
-      getIdentity: () => ({ pid: 4242, startedAt: "provider-start" }),
-    },
-  });
-}
-
-describe("CodexPrintRunner", () => {
-  it("constructs default process dependencies without spawning", async () => {
-    const api = (await import("../../index.js")) as Record<string, unknown>;
-    const Runner = api.CodexPrintRunner as new () => any;
-    expect(new Runner()).toBeDefined();
-  });
-
-  it("binds an initial thread before returning ordered assistant output", async () => {
-    const fixture = fakeSpawn(events(), 0, true);
-    const instance = await runner(fixture);
-    const order: string[] = [];
-    const result = await instance.run({
-      agent: agent(),
-      prompt: "secret prompt",
-      executable: "fake-codex",
-      onSpawn: async () => {
-        expect(fixture.promptChunks).toHaveLength(0);
-        order.push("spawn");
-      },
-      onSession: async (id: string) => {
-        expect(id).toBe(SESSION);
-        order.push("session");
-      },
-    });
-
-    expect(order).toEqual(["spawn", "session"]);
-    expect(fixture.spawn).toHaveBeenCalledWith(
-      "fake-codex",
-      ["exec", "--json", "-"],
-      expect.objectContaining({
-        cwd: "/project",
-        shell: false,
-        stdio: ["pipe", "pipe", "pipe"],
-      }),
-    );
-    expect(JSON.stringify(fixture.spawn.mock.calls)).not.toContain("secret prompt");
-    expect(Buffer.concat(fixture.promptChunks).toString()).toBe("secret prompt");
-    expect(result).toEqual({
-      sessionId: SESSION,
-      result: "final",
-      messages: ["first", "final"],
-      exitCode: 0,
-    });
-  });
-
-  it("resumes the exact stored UUID and rejects a mismatch", async () => {
-    const mismatch = "33333333-3333-4333-8333-333333333333";
-    const fixture = fakeSpawn(events(mismatch));
-    const instance = await runner(fixture);
-    await expect(
-      instance.run({
-        agent: agent(SESSION),
-        prompt: "later",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "CODEX_SESSION_MISMATCH" });
-    expect(fixture.spawn.mock.calls[0]![1]).toEqual(["exec", "resume", "--json", SESSION, "-"]);
-  });
-
-  it.each([
-    ["malformed JSON", ["{bad\n"], "CODEX_PROTOCOL"],
-    ["non-object JSON", ["[]\n"], "CODEX_PROTOCOL"],
-    ["truncated JSON", ["{}"], "CODEX_PROTOCOL"],
-    [
-      "missing thread",
-      [
-        JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "x" } }),
-        JSON.stringify({ type: "turn.completed" }),
-        "",
-      ],
-      "CODEX_PROTOCOL",
-    ],
-    [
-      "missing assistant",
-      [
-        JSON.stringify({ type: "thread.started", thread_id: SESSION }),
-        JSON.stringify({ type: "turn.completed" }),
-        "",
-      ],
-      "CODEX_RESULT_MISSING",
-    ],
-    [
-      "missing completion",
-      [
-        JSON.stringify({ type: "thread.started", thread_id: SESSION }),
-        JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "x" } }),
-        "",
-      ],
-      "CODEX_PROTOCOL",
-    ],
-  ])("rejects %s", async (_name, lines, code) => {
-    const fixture = fakeSpawn(lines as string[]);
-    await expect(
-      (await runner(fixture)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code });
-  });
-
-  it("rejects oversized output, non-zero exit, and missing process identity without leaking stderr", async () => {
-    const oversized = fakeSpawn([`${"x".repeat(20)}\n`]);
-    await expect(
-      (await runner(oversized, 10)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "CODEX_PROTOCOL" });
-    const oversizedWithoutNewline = fakeSpawn(["x".repeat(20)]);
-    await expect(
-      (await runner(oversizedWithoutNewline, 10)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "CODEX_PROTOCOL" });
-
-    const failed = fakeSpawn(events(), 1);
-    failed.child.stderr.end("secret-looking provider diagnostic");
-    await expect(
-      (await runner(failed)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "CODEX_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: "CODEX_PROCESS" });
-  });
-
-  it("rejects invalid or duplicate thread identities", async () => {
-    for (const lines of [
-      [JSON.stringify({ type: "thread.started", thread_id: "bad" }), ""],
-      [
-        JSON.stringify({ type: "thread.started", thread_id: SESSION }),
-        JSON.stringify({ type: "thread.started", thread_id: SESSION }),
-        "",
-      ],
-    ]) {
-      const fixture = fakeSpawn(lines);
-      await expect(
-        (await runner(fixture)).run({
-          agent: agent(),
-          prompt: "x",
-          onSpawn: vi.fn(),
-          onSession: vi.fn(),
-        }),
-      ).rejects.toMatchObject({ code: "CODEX_PROTOCOL" });
-    }
-  });
-
-  it("classifies callback processing failure and kills when spawn persistence fails", async () => {
-    const callbackFailure = fakeSpawn(events());
-    await expect(
-      (await runner(callbackFailure)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn().mockRejectedValue(new Error("storage unavailable")),
-      }),
-    ).rejects.toMatchObject({ code: "CODEX_PROTOCOL" });
-
-    const spawnFailure = fakeSpawn([]);
-    const failure = new Error("cannot persist process");
-    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("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({
-      spawn: fixture.spawn,
-      processInspector: { getIdentity: () => null },
-    });
-    await expect(
-      instance.run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "CODEX_PROCESS" });
-    expect(fixture.child.kill).toHaveBeenCalledOnce();
-  });
-
-  it("classifies a child spawn error as a process failure", async () => {
-    const fixture = fakeSpawn([]);
-    fixture.child.stdin = new Writable({
-      write(_chunk, _encoding, callback) {
-        callback();
-      },
-      final(callback) {
-        queueMicrotask(() => fixture.child.emit("error", new Error("spawn failed")));
-        callback();
-      },
-    });
-    await expect(
-      (await runner(fixture)).run({
-        agent: agent(),
-        prompt: "x",
-        onSpawn: vi.fn(),
-        onSession: vi.fn(),
-      }),
-    ).rejects.toMatchObject({ code: "CODEX_PROCESS" });
-  });
-});

package/src/__tests__/fixtures/fake-claude.cjs

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-const fs = require("node:fs");
-
-const args = process.argv.slice(2);
-if (args[0] === "--version") {
-  process.stdout.write("fake-claude 2.1.220\n");
-  process.exit(0);
-}
-if (args[0] === "--help") {
-  process.stdout.write("--print -p --session-id --resume --output-format stream-json --verbose\n");
-  process.exit(0);
-}
-
-let prompt = "";
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", (chunk) => {
-  prompt += chunk;
-});
-process.stdin.on("end", () => {
-  const flag = args.includes("--session-id") ? "--session-id" : "--resume";
-  const sessionId = args[args.indexOf(flag) + 1];
-  const capture = process.env.AI_DEVKIT_FAKE_CLAUDE_CAPTURE;
-  if (capture)
-    fs.appendFileSync(capture, `${JSON.stringify({ args, prompt, cwd: process.cwd() })}\n`);
-  process.stdout.write(
-    `${JSON.stringify({ type: "system", subtype: "init", session_id: sessionId })}\n`,
-  );
-  process.stdout.write(
-    `${JSON.stringify({ type: "result", session_id: sessionId, result: `answer:${prompt}` })}\n`,
-  );
-});