@openclaw/acpx 2026.5.2-beta.1 → 2026.5.3-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/acpx",
-  "version": "2026.5.2-beta.1",
+  "version": "2026.5.3-beta.1",
   "description": "OpenClaw ACP runtime backend",
   "repository": {
     "type": "git",
@@ -25,14 +25,44 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.5.2-beta.1"
+      "pluginApi": ">=2026.5.3-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.2-beta.1"
+      "openclawVersion": "2026.5.3-beta.1",
+      "staticAssets": [
+        {
+          "source": "./src/runtime-internals/mcp-proxy.mjs",
+          "output": "mcp-proxy.mjs"
+        },
+        {
+          "source": "./src/runtime-internals/error-format.mjs",
+          "output": "error-format.mjs"
+        },
+        {
+          "source": "./src/runtime-internals/mcp-command-line.mjs",
+          "output": "mcp-command-line.mjs"
+        }
+      ]
     },
     "release": {
       "publishToClawHub": true,
       "publishToNpm": true
+    },
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ]
+  },
+  "files": [
+    "dist/**",
+    "openclaw.plugin.json",
+    "skills/**"
+  ],
+  "peerDependencies": {
+    "openclaw": ">=2026.5.3-beta.1"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
     }
   }
 }

package/AGENTS.md

@@ -1,54 +0,0 @@
-# ACPX Extension Notes
-
-This file applies to work under `extensions/acpx/`.
-
-## Purpose
-
-The ACPX extension is a thin OpenClaw wrapper around the published `acpx` package. Keep reusable ACP runtime logic in `openclaw/acpx`, not in this extension.
-
-## Default Version Policy
-
-- `extensions/acpx/package.json` should point at a published npm release by default.
-- Do not leave the extension pinned to a temporary GitHub commit or local checkout once the ACPX release exists.
-- Do not leave temporary pnpm build-script allowlist exceptions behind after switching back to a published ACPX package.
-
-## Unreleased ACPX Development Flow
-
-Use this flow when OpenClaw needs unreleased ACPX changes before the ACPX version is published.
-
-1. Make the ACPX code change in the `openclaw/acpx` repo first.
-2. In OpenClaw, temporarily point `extensions/acpx/package.json` at the ACPX GitHub commit you need.
-3. If pnpm blocks ACPX lifecycle/build scripts for that temporary GitHub-sourced package, temporarily add `acpx` to `onlyBuiltDependencies` in both `package.json` and `pnpm-workspace.yaml`.
-4. Refresh the root workspace lock:
-   - `pnpm install --lockfile-only --filter ./extensions/acpx`
-5. Refresh the extension-local npm lock for install metadata:
-   - `cd extensions/acpx && npm install --package-lock-only --ignore-scripts`
-6. Rebuild OpenClaw and restart the gateway before doing live ACP validation.
-7. Once ACPX is released, switch `extensions/acpx/package.json` back to the published npm version and refresh the same lockfiles again.
-8. Remove any temporary `acpx` build-script allowlist entries that were only needed for the GitHub-sourced development pin.
-
-## Lockfile Notes
-
-- `pnpm-lock.yaml` is the tracked workspace lockfile and must match the ACPX version referenced by `extensions/acpx/package.json`.
-- `extensions/acpx/package-lock.json` is useful local install metadata for the plugin package.
-- If `extensions/acpx/package-lock.json` is gitignored in this repo state, regenerating it is still useful for local verification, but it will not appear in `git status`.
-
-## Local Runtime Validation
-
-When ACPX integration changes here, prefer this sequence:
-
-1. `pnpm install --filter ./extensions/acpx`
-2. `pnpm test:extension acpx`
-3. `pnpm build`
-4. Restart the local gateway if ACP runtime behavior or bundled plugin wiring changed.
-5. If the change affects direct ACP behavior in chat, run a real ACP smoke after restart.
-
-## Direct ACPX Binary Policy
-
-- Prefer the plugin-local ACPX binary under `extensions/acpx/node_modules/.bin/acpx`.
-- Do not rely on a globally installed `acpx` binary for OpenClaw ACP validation.
-- If the plugin-local ACPX binary is missing or on the wrong version, reinstall it from the version pinned in `extensions/acpx/package.json`.
-
-## Boundary Rule
-
-If a change feels like shared ACP runtime behavior instead of OpenClaw-specific glue, move it to `openclaw/acpx` and consume it from here instead of re-implementing it inside `extensions/acpx`.

package/index.test.ts

@@ -1,119 +0,0 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
-import { createTestPluginApi } from "openclaw/plugin-sdk/plugin-test-api";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import setupPlugin from "./setup-api.js";
-
-const { createAcpxRuntimeServiceMock, tryDispatchAcpReplyHookMock } = vi.hoisted(() => ({
-  createAcpxRuntimeServiceMock: vi.fn(),
-  tryDispatchAcpReplyHookMock: vi.fn(),
-}));
-
-vi.mock("./register.runtime.js", () => ({
-  createAcpxRuntimeService: createAcpxRuntimeServiceMock,
-}));
-
-vi.mock("openclaw/plugin-sdk/acp-runtime-backend", () => ({
-  tryDispatchAcpReplyHook: tryDispatchAcpReplyHookMock,
-}));
-
-import plugin from "./index.js";
-
-type AcpxAutoEnableProbe = Parameters<OpenClawPluginApi["registerAutoEnableProbe"]>[0];
-
-function registerAcpxAutoEnableProbe(): AcpxAutoEnableProbe {
-  const probes: AcpxAutoEnableProbe[] = [];
-  setupPlugin.register(
-    createTestPluginApi({
-      registerAutoEnableProbe(probe) {
-        probes.push(probe);
-      },
-    }),
-  );
-  const probe = probes[0];
-  if (!probe) {
-    throw new Error("expected ACPX setup plugin to register an auto-enable probe");
-  }
-  return probe;
-}
-
-describe("acpx plugin", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("registers the runtime service and reply_dispatch hook", () => {
-    const service = { id: "acpx-service", start: vi.fn() };
-    createAcpxRuntimeServiceMock.mockReturnValue(service);
-
-    const api = {
-      pluginConfig: { stateDir: "/tmp/acpx" },
-      registerService: vi.fn(),
-      on: vi.fn(),
-    };
-
-    plugin.register(api as never);
-
-    expect(createAcpxRuntimeServiceMock).toHaveBeenCalledWith({
-      pluginConfig: api.pluginConfig,
-    });
-    expect(api.registerService).toHaveBeenCalledWith(service);
-    expect(api.on).toHaveBeenCalledWith("reply_dispatch", tryDispatchAcpReplyHookMock);
-  });
-
-  it("preserves the ACP reply_dispatch runtime path through the registered hook", async () => {
-    const service = { id: "acpx-service", start: vi.fn() };
-    createAcpxRuntimeServiceMock.mockReturnValue(service);
-    tryDispatchAcpReplyHookMock.mockResolvedValue({
-      handled: true,
-      queuedFinal: true,
-      counts: { tool: 1, block: 0, final: 1 },
-    });
-
-    const on = vi.fn();
-    const api = createTestPluginApi({
-      pluginConfig: { stateDir: "/tmp/acpx" },
-      registerService: vi.fn(),
-      on,
-    });
-
-    plugin.register(api);
-
-    const hook = on.mock.calls.find(([hookName]) => hookName === "reply_dispatch")?.[1];
-    if (!hook) {
-      throw new Error("expected reply_dispatch hook to be registered");
-    }
-
-    const event = {
-      ctx: { raw: "reply ctx" },
-      runId: "run-1",
-      sessionKey: "agent:test:session",
-      inboundAudio: false,
-      shouldRouteToOriginating: false,
-      shouldSendToolSummaries: true,
-      sendPolicy: "allow",
-    };
-    const ctx = {
-      cfg: {},
-      dispatcher: { dispatch: vi.fn(), getQueuedCounts: vi.fn(), getFailedCounts: vi.fn() },
-      recordProcessed: vi.fn(),
-      markIdle: vi.fn(),
-    };
-
-    await expect(hook(event, ctx)).resolves.toEqual({
-      handled: true,
-      queuedFinal: true,
-      counts: { tool: 1, block: 0, final: 1 },
-    });
-    expect(tryDispatchAcpReplyHookMock).toHaveBeenCalledWith(event, ctx);
-  });
-
-  it("declares setup auto-enable reasons for ACPX-owned ACP config", () => {
-    const probe = registerAcpxAutoEnableProbe();
-
-    expect(probe({ config: { acp: { enabled: true } }, env: {} })).toBe("ACP runtime configured");
-    expect(probe({ config: { acp: { backend: "acpx" } }, env: {} })).toBe("ACP runtime configured");
-    expect(probe({ config: { acp: { enabled: true, backend: "custom-runtime" } }, env: {} })).toBe(
-      null,
-    );
-  });
-});

package/index.ts

@@ -1,19 +0,0 @@
-import { tryDispatchAcpReplyHook } from "openclaw/plugin-sdk/acp-runtime-backend";
-import { createAcpxRuntimeService } from "./register.runtime.js";
-import type { OpenClawPluginApi } from "./runtime-api.js";
-
-const plugin = {
-  id: "acpx",
-  name: "ACPX Runtime",
-  description: "Embedded ACP runtime backend with plugin-owned session and transport management.",
-  register(api: OpenClawPluginApi) {
-    api.registerService(
-      createAcpxRuntimeService({
-        pluginConfig: api.pluginConfig,
-      }),
-    );
-    api.on("reply_dispatch", tryDispatchAcpReplyHook);
-  },
-};
-
-export default plugin;

package/register.runtime.ts

@@ -1,154 +0,0 @@
-import {
-  getAcpRuntimeBackend,
-  registerAcpRuntimeBackend,
-  unregisterAcpRuntimeBackend,
-  type AcpRuntime,
-  type AcpRuntimeCapabilities,
-  type AcpRuntimeDoctorReport,
-  type AcpRuntimeStatus,
-} from "openclaw/plugin-sdk/acp-runtime-backend";
-import type { OpenClawPluginService, OpenClawPluginServiceContext } from "openclaw/plugin-sdk/core";
-
-const ACPX_BACKEND_ID = "acpx";
-const ENABLE_STARTUP_PROBE_ENV = "OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE";
-
-type RealAcpxServiceModule = typeof import("./src/service.js");
-type CreateAcpxRuntimeServiceParams = NonNullable<
-  Parameters<RealAcpxServiceModule["createAcpxRuntimeService"]>[0]
->;
-
-type AcpxRuntimeLike = AcpRuntime & {
-  probeAvailability(): Promise<void>;
-  doctor?(): Promise<AcpRuntimeDoctorReport>;
-  isHealthy(): boolean;
-};
-
-type DeferredServiceState = {
-  ctx: OpenClawPluginServiceContext | null;
-  params: CreateAcpxRuntimeServiceParams;
-  realRuntime: AcpxRuntimeLike | null;
-  realService: OpenClawPluginService | null;
-  startPromise: Promise<AcpxRuntimeLike> | null;
-};
-
-let serviceModulePromise: Promise<RealAcpxServiceModule> | null = null;
-
-function loadServiceModule(): Promise<RealAcpxServiceModule> {
-  serviceModulePromise ??= import("./src/service.js");
-  return serviceModulePromise;
-}
-
-function shouldRunStartupProbe(env: NodeJS.ProcessEnv = process.env): boolean {
-  return env[ENABLE_STARTUP_PROBE_ENV] === "1";
-}
-
-async function startRealService(state: DeferredServiceState): Promise<AcpxRuntimeLike> {
-  if (state.realRuntime) {
-    return state.realRuntime;
-  }
-  if (!state.ctx) {
-    throw new Error("ACPX runtime service is not started");
-  }
-  state.startPromise ??= (async () => {
-    const { createAcpxRuntimeService } = await loadServiceModule();
-    const service = createAcpxRuntimeService(state.params);
-    state.realService = service;
-    await service.start(state.ctx as OpenClawPluginServiceContext);
-    const backend = getAcpRuntimeBackend(ACPX_BACKEND_ID);
-    if (!backend?.runtime) {
-      throw new Error("ACPX runtime service did not register an ACP backend");
-    }
-    state.realRuntime = backend.runtime as AcpxRuntimeLike;
-    return state.realRuntime;
-  })();
-  return await state.startPromise;
-}
-
-function createDeferredRuntime(state: DeferredServiceState): AcpxRuntimeLike {
-  return {
-    async ensureSession(input) {
-      return await (await startRealService(state)).ensureSession(input);
-    },
-    async *runTurn(input) {
-      yield* (await startRealService(state)).runTurn(input);
-    },
-    async getCapabilities(input): Promise<AcpRuntimeCapabilities> {
-      const runtime = await startRealService(state);
-      return (await runtime.getCapabilities?.(input)) ?? { controls: [] };
-    },
-    async getStatus(input): Promise<AcpRuntimeStatus> {
-      const runtime = await startRealService(state);
-      return (await runtime.getStatus?.(input)) ?? {};
-    },
-    async setMode(input) {
-      await (await startRealService(state)).setMode?.(input);
-    },
-    async setConfigOption(input) {
-      await (await startRealService(state)).setConfigOption?.(input);
-    },
-    async doctor(): Promise<AcpRuntimeDoctorReport> {
-      const runtime = await startRealService(state);
-      return (await runtime.doctor?.()) ?? { ok: true, message: "ok" };
-    },
-    async prepareFreshSession(input) {
-      await (await startRealService(state)).prepareFreshSession?.(input);
-    },
-    async cancel(input) {
-      await (await startRealService(state)).cancel(input);
-    },
-    async close(input) {
-      await (await startRealService(state)).close(input);
-    },
-    async probeAvailability() {
-      await (await startRealService(state)).probeAvailability();
-    },
-    isHealthy() {
-      return state.realRuntime?.isHealthy() ?? false;
-    },
-  };
-}
-
-export function createAcpxRuntimeService(
-  params: CreateAcpxRuntimeServiceParams = {},
-): OpenClawPluginService {
-  const state: DeferredServiceState = {
-    ctx: null,
-    params,
-    realRuntime: null,
-    realService: null,
-    startPromise: null,
-  };
-
-  return {
-    id: "acpx-runtime",
-    async start(ctx) {
-      if (process.env.OPENCLAW_SKIP_ACPX_RUNTIME === "1") {
-        ctx.logger.info("skipping embedded acpx runtime backend (OPENCLAW_SKIP_ACPX_RUNTIME=1)");
-        return;
-      }
-
-      state.ctx = ctx;
-      if (shouldRunStartupProbe()) {
-        await startRealService(state);
-        return;
-      }
-
-      registerAcpRuntimeBackend({
-        id: ACPX_BACKEND_ID,
-        runtime: createDeferredRuntime(state),
-      });
-      ctx.logger.info("embedded acpx runtime backend registered lazily");
-    },
-    async stop(ctx) {
-      if (state.realService) {
-        await state.realService.stop?.(ctx);
-      } else {
-        unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
-      }
-      state.ctx = null;
-      state.realRuntime = null;
-      state.realService = null;
-      state.startPromise = null;
-    },
-  };
-}

package/runtime-api.ts

@@ -1,46 +0,0 @@
-export type { AcpRuntimeErrorCode } from "openclaw/plugin-sdk/acp-runtime-backend";
-export {
-  AcpRuntimeError,
-  getAcpRuntimeBackend,
-  tryDispatchAcpReplyHook,
-  registerAcpRuntimeBackend,
-  unregisterAcpRuntimeBackend,
-} from "openclaw/plugin-sdk/acp-runtime-backend";
-export type {
-  AcpRuntime,
-  AcpRuntimeCapabilities,
-  AcpRuntimeDoctorReport,
-  AcpRuntimeEnsureInput,
-  AcpRuntimeEvent,
-  AcpRuntimeHandle,
-  AcpRuntimeStatus,
-  AcpRuntimeTurnAttachment,
-  AcpRuntimeTurnInput,
-  AcpSessionUpdateTag,
-} from "openclaw/plugin-sdk/acp-runtime-backend";
-export type {
-  OpenClawPluginApi,
-  OpenClawPluginConfigSchema,
-  OpenClawPluginService,
-  OpenClawPluginServiceContext,
-  PluginLogger,
-} from "openclaw/plugin-sdk/core";
-export type {
-  PluginHookReplyDispatchContext,
-  PluginHookReplyDispatchEvent,
-  PluginHookReplyDispatchResult,
-} from "openclaw/plugin-sdk/core";
-export type {
-  WindowsSpawnProgram,
-  WindowsSpawnProgramCandidate,
-  WindowsSpawnResolution,
-} from "openclaw/plugin-sdk/windows-spawn";
-export {
-  applyWindowsSpawnProgramPolicy,
-  materializeWindowsSpawnProgram,
-  resolveWindowsSpawnProgramCandidate,
-} from "openclaw/plugin-sdk/windows-spawn";
-export {
-  listKnownProviderAuthEnvVarNames,
-  omitEnvKeysCaseInsensitive,
-} from "openclaw/plugin-sdk/provider-env-vars";

package/setup-api.ts

@@ -1,18 +0,0 @@
-import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
-
-export default definePluginEntry({
-  id: "acpx",
-  name: "ACPX Setup",
-  description: "Lightweight ACPX setup hooks",
-  register(api) {
-    api.registerAutoEnableProbe(({ config }) => {
-      const backendRaw = normalizeLowercaseStringOrEmpty(config.acp?.backend);
-      const configured =
-        config.acp?.enabled === true ||
-        config.acp?.dispatch?.enabled === true ||
-        backendRaw === "acpx";
-      return configured && (!backendRaw || backendRaw === "acpx") ? "ACP runtime configured" : null;
-    });
-  },
-});

package/src/acpx-runtime-compat.d.ts

@@ -1,62 +0,0 @@
-declare module "acpx/runtime" {
-  export const ACPX_BACKEND_ID: string;
-
-  export type AcpRuntimeDoctorReport = import("../runtime-api.js").AcpRuntimeDoctorReport;
-  export type AcpRuntimeEnsureInput = import("../runtime-api.js").AcpRuntimeEnsureInput;
-  export type AcpRuntimeEvent = import("../runtime-api.js").AcpRuntimeEvent;
-  export type AcpRuntimeHandle = import("../runtime-api.js").AcpRuntimeHandle;
-  export type AcpRuntimeCapabilities = import("../runtime-api.js").AcpRuntimeCapabilities;
-  export type AcpRuntimeStatus = import("../runtime-api.js").AcpRuntimeStatus;
-  export type AcpRuntimeTurnInput = import("../runtime-api.js").AcpRuntimeTurnInput;
-
-  export type AcpAgentRegistry = {
-    resolve(agent: string): string | undefined;
-    list(): string[];
-  };
-
-  export type AcpSessionRecord = Record<string, unknown>;
-
-  export type AcpSessionStore = {
-    load(sessionId: string): Promise<AcpSessionRecord | undefined>;
-    save(record: AcpSessionRecord): Promise<void>;
-  };
-
-  export type AcpRuntimeOptions = {
-    cwd: string;
-    sessionStore: AcpSessionStore;
-    agentRegistry: AcpAgentRegistry;
-    probeAgent?: string;
-    mcpServers?: unknown;
-    permissionMode?: unknown;
-    nonInteractivePermissions?: unknown;
-    timeoutMs?: number;
-    probeAgent?: string;
-  };
-
-  export class AcpxRuntime {
-    constructor(options: AcpRuntimeOptions, testOptions?: unknown);
-    isHealthy(): boolean;
-    probeAvailability(): Promise<void>;
-    doctor(): Promise<AcpRuntimeDoctorReport>;
-    ensureSession(input: AcpRuntimeEnsureInput): Promise<AcpRuntimeHandle>;
-    runTurn(input: AcpRuntimeTurnInput): AsyncIterable<AcpRuntimeEvent>;
-    getCapabilities(input?: {
-      handle?: AcpRuntimeHandle;
-    }): AcpRuntimeCapabilities | Promise<AcpRuntimeCapabilities>;
-    getStatus(input: { handle: AcpRuntimeHandle; signal?: AbortSignal }): Promise<AcpRuntimeStatus>;
-    setMode(input: { handle: AcpRuntimeHandle; mode: string }): Promise<void>;
-    setConfigOption(input: { handle: AcpRuntimeHandle; key: string; value: string }): Promise<void>;
-    cancel(input: { handle: AcpRuntimeHandle; reason?: string }): Promise<void>;
-    close(input: {
-      handle: AcpRuntimeHandle;
-      reason?: string;
-      discardPersistentState?: boolean;
-    }): Promise<void>;
-  }
-
-  export function createAcpRuntime(...args: unknown[]): AcpxRuntime;
-  export function createAgentRegistry(params: { overrides?: unknown }): AcpAgentRegistry;
-  export function createFileSessionStore(params: { stateDir: string }): AcpSessionStore;
-  export function decodeAcpxRuntimeHandleState(...args: unknown[]): unknown;
-  export function encodeAcpxRuntimeHandleState(...args: unknown[]): unknown;
-}

package/src/claude-agent-acp-completion.test.ts

@@ -1,129 +0,0 @@
-import { ClaudeAcpAgent } from "@agentclientprotocol/claude-agent-acp";
-import { describe, expect, it, vi } from "vitest";
-
-type IteratorResultResolver = (value: IteratorResult<unknown>) => void;
-
-class ManualAsyncIterator implements AsyncIterator<unknown> {
-  private readonly pending: IteratorResultResolver[] = [];
-  private readonly queued: IteratorResult<unknown>[] = [];
-
-  next(): Promise<IteratorResult<unknown>> {
-    const next = this.queued.shift();
-    if (next) {
-      return Promise.resolve(next);
-    }
-    return new Promise((resolve) => {
-      this.pending.push(resolve);
-    });
-  }
-
-  push(value: unknown): void {
-    this.resolve({ value, done: false });
-  }
-
-  end(): void {
-    this.resolve({ value: undefined, done: true });
-  }
-
-  private resolve(value: IteratorResult<unknown>): void {
-    const pending = this.pending.shift();
-    if (pending) {
-      pending(value);
-      return;
-    }
-    this.queued.push(value);
-  }
-}
-
-function makeResultMessage() {
-  return {
-    type: "result",
-    subtype: "success",
-    is_error: false,
-    result: "finished",
-    stop_reason: null,
-    total_cost_usd: 0,
-    usage: {
-      input_tokens: 1,
-      output_tokens: 1,
-      cache_read_input_tokens: 0,
-      cache_creation_input_tokens: 0,
-    },
-    modelUsage: [],
-  };
-}
-
-function makeIdleMessage() {
-  return {
-    type: "system",
-    subtype: "session_state_changed",
-    state: "idle",
-    session_id: "session-1",
-  };
-}
-
-async function flushMicrotasks(): Promise<void> {
-  await Promise.resolve();
-  await Promise.resolve();
-}
-
-describe("patched claude-agent-acp completion", () => {
-  it("does not resolve a prompt on idle before the result message", async () => {
-    const query = new ManualAsyncIterator();
-    const agent = new ClaudeAcpAgent({
-      sessionUpdate: vi.fn(),
-      extNotification: vi.fn(),
-    } as unknown as ConstructorParameters<typeof ClaudeAcpAgent>[0]);
-    agent.sessions["session-1"] = {
-      cancelled: false,
-      accumulatedUsage: {
-        inputTokens: 0,
-        outputTokens: 0,
-        cachedReadTokens: 0,
-        cachedWriteTokens: 0,
-      },
-      contextWindowSize: 200_000,
-      cwd: "/tmp",
-      emitRawSDKMessages: false,
-      input: {
-        push: vi.fn(),
-        end: vi.fn(),
-      },
-      nextPendingOrder: 0,
-      pendingMessages: new Map(),
-      promptRunning: false,
-      query,
-      settingsManager: {
-        dispose: vi.fn(),
-      },
-    } as unknown as (typeof agent.sessions)[string];
-
-    let resolved = false;
-    const promptPromise = agent
-      .prompt({
-        sessionId: "session-1",
-        prompt: [{ type: "text", text: "do work" }],
-      })
-      .then((value) => {
-        resolved = true;
-        return value;
-      });
-
-    query.push(makeIdleMessage());
-    await flushMicrotasks();
-    expect(resolved).toBe(false);
-
-    query.push(makeResultMessage());
-    await flushMicrotasks();
-    expect(resolved).toBe(false);
-
-    query.push(makeIdleMessage());
-    await expect(promptPromise).resolves.toMatchObject({
-      stopReason: "end_turn",
-      usage: {
-        inputTokens: 1,
-        outputTokens: 1,
-      },
-    });
-  });
-});