@tanstack/ai-acp 0.1.0

package/dist/esm/permissions.d.ts

@@ -0,0 +1,8 @@
+import { AcpPermissionMode, AcpPermissionOutcome, AcpPermissionRequest, PermissionHandler } from './types/acp-types.js';
+export type { AcpPermissionMode, PermissionHandler };
+export declare function resolvePermission(request: AcpPermissionRequest, mode: AcpPermissionMode, bridgedToolNames: ReadonlySet<string> | undefined): AcpPermissionOutcome;
+export declare function resolveInteractivePermission(request: AcpPermissionRequest, mode: AcpPermissionMode, bridgedToolNames: ReadonlySet<string> | undefined, approvals: ReadonlyMap<string, boolean> | undefined, provider: string): {
+    outcome: AcpPermissionOutcome;
+    approvalId?: string;
+    title?: string;
+};

package/dist/esm/permissions.js

@@ -0,0 +1,44 @@
+import { approvalId } from "@tanstack/ai-sandbox";
+import { matchBridgedToolName } from "./stream/translate.js";
+const EDIT_KINDS = /* @__PURE__ */ new Set(["edit", "move", "delete"]);
+function pickOption(request, kinds) {
+  for (const kind of kinds) {
+    const option = request.options.find((candidate) => candidate.kind === kind);
+    if (option) return { outcome: "selected", optionId: option.optionId };
+  }
+  return { outcome: "cancelled" };
+}
+function resolvePermission(request, mode, bridgedToolNames) {
+  const allow = () => pickOption(request, ["allow_once", "allow_always"]);
+  const reject = () => pickOption(request, ["reject_once", "reject_always"]);
+  if (matchBridgedToolName(request.toolCall.title, bridgedToolNames) !== void 0) {
+    return allow();
+  }
+  if (mode === "bypassPermissions") return allow();
+  if (mode === "acceptEdits" && EDIT_KINDS.has(request.toolCall.kind ?? "")) {
+    return allow();
+  }
+  return reject();
+}
+function resolveInteractivePermission(request, mode, bridgedToolNames, approvals, provider) {
+  const allow = () => pickOption(request, ["allow_once", "allow_always"]);
+  const reject = () => pickOption(request, ["reject_once", "reject_always"]);
+  const title = request.toolCall.title ?? request.toolCall.toolCallId;
+  if (matchBridgedToolName(title, bridgedToolNames) !== void 0) {
+    return { outcome: allow() };
+  }
+  if (mode === "bypassPermissions") return { outcome: allow() };
+  if (mode === "acceptEdits" && EDIT_KINDS.has(request.toolCall.kind ?? "")) {
+    return { outcome: allow() };
+  }
+  const id = approvalId({ provider, kind: "tool", target: title });
+  const granted = approvals?.get(id);
+  if (granted === true) return { outcome: allow() };
+  if (granted === false) return { outcome: reject() };
+  return { outcome: reject(), approvalId: id, title };
+}
+export {
+  resolveInteractivePermission,
+  resolvePermission
+};
+//# sourceMappingURL=permissions.js.map

package/dist/esm/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.js","sources":["../../src/permissions.ts"],"sourcesContent":["import { approvalId } from '@tanstack/ai-sandbox'\nimport { matchBridgedToolName } from './stream/translate'\nimport type {\n  AcpPermissionMode,\n  AcpPermissionOutcome,\n  AcpPermissionRequest,\n  PermissionHandler,\n} from './types/acp-types'\n\nexport type { AcpPermissionMode, PermissionHandler }\n\nconst EDIT_KINDS = new Set(['edit', 'move', 'delete'])\n\nfunction pickOption(\n  request: AcpPermissionRequest,\n  kinds: Array<string>,\n): AcpPermissionOutcome {\n  for (const kind of kinds) {\n    const option = request.options.find((candidate) => candidate.kind === kind)\n    if (option) return { outcome: 'selected', optionId: option.optionId }\n  }\n  return { outcome: 'cancelled' }\n}\n\nexport function resolvePermission(\n  request: AcpPermissionRequest,\n  mode: AcpPermissionMode,\n  bridgedToolNames: ReadonlySet<string> | undefined,\n): AcpPermissionOutcome {\n  const allow = () => pickOption(request, ['allow_once', 'allow_always'])\n  const reject = () => pickOption(request, ['reject_once', 'reject_always'])\n\n  if (\n    matchBridgedToolName(request.toolCall.title, bridgedToolNames) !== undefined\n  ) {\n    return allow()\n  }\n  if (mode === 'bypassPermissions') return allow()\n  if (mode === 'acceptEdits' && EDIT_KINDS.has(request.toolCall.kind ?? '')) {\n    return allow()\n  }\n  return reject()\n}\n\nexport function resolveInteractivePermission(\n  request: AcpPermissionRequest,\n  mode: AcpPermissionMode,\n  bridgedToolNames: ReadonlySet<string> | undefined,\n  approvals: ReadonlyMap<string, boolean> | undefined,\n  provider: string,\n): { outcome: AcpPermissionOutcome; approvalId?: string; title?: string } {\n  const allow = (): AcpPermissionOutcome =>\n    pickOption(request, ['allow_once', 'allow_always'])\n  const reject = (): AcpPermissionOutcome =>\n    pickOption(request, ['reject_once', 'reject_always'])\n  const title = request.toolCall.title ?? request.toolCall.toolCallId\n\n  if (matchBridgedToolName(title, bridgedToolNames) !== undefined) {\n    return { outcome: allow() }\n  }\n  if (mode === 'bypassPermissions') return { outcome: allow() }\n  if (mode === 'acceptEdits' && EDIT_KINDS.has(request.toolCall.kind ?? '')) {\n    return { outcome: allow() }\n  }\n\n  const id = approvalId({ provider, kind: 'tool', target: title })\n  const granted = approvals?.get(id)\n  if (granted === true) return { outcome: allow() }\n  if (granted === false) return { outcome: reject() }\n  return { outcome: reject(), approvalId: id, title }\n}\n"],"names":[],"mappings":";;AAWA,MAAM,aAAa,oBAAI,IAAI,CAAC,QAAQ,QAAQ,QAAQ,CAAC;AAErD,SAAS,WACP,SACA,OACsB;AACtB,aAAW,QAAQ,OAAO;AACxB,UAAM,SAAS,QAAQ,QAAQ,KAAK,CAAC,cAAc,UAAU,SAAS,IAAI;AAC1E,QAAI,OAAQ,QAAO,EAAE,SAAS,YAAY,UAAU,OAAO,SAAA;AAAA,EAC7D;AACA,SAAO,EAAE,SAAS,YAAA;AACpB;AAEO,SAAS,kBACd,SACA,MACA,kBACsB;AACtB,QAAM,QAAQ,MAAM,WAAW,SAAS,CAAC,cAAc,cAAc,CAAC;AACtE,QAAM,SAAS,MAAM,WAAW,SAAS,CAAC,eAAe,eAAe,CAAC;AAEzE,MACE,qBAAqB,QAAQ,SAAS,OAAO,gBAAgB,MAAM,QACnE;AACA,WAAO,MAAA;AAAA,EACT;AACA,MAAI,SAAS,oBAAqB,QAAO,MAAA;AACzC,MAAI,SAAS,iBAAiB,WAAW,IAAI,QAAQ,SAAS,QAAQ,EAAE,GAAG;AACzE,WAAO,MAAA;AAAA,EACT;AACA,SAAO,OAAA;AACT;AAEO,SAAS,6BACd,SACA,MACA,kBACA,WACA,UACwE;AACxE,QAAM,QAAQ,MACZ,WAAW,SAAS,CAAC,cAAc,cAAc,CAAC;AACpD,QAAM,SAAS,MACb,WAAW,SAAS,CAAC,eAAe,eAAe,CAAC;AACtD,QAAM,QAAQ,QAAQ,SAAS,SAAS,QAAQ,SAAS;AAEzD,MAAI,qBAAqB,OAAO,gBAAgB,MAAM,QAAW;AAC/D,WAAO,EAAE,SAAS,QAAM;AAAA,EAC1B;AACA,MAAI,SAAS,oBAAqB,QAAO,EAAE,SAAS,QAAM;AAC1D,MAAI,SAAS,iBAAiB,WAAW,IAAI,QAAQ,SAAS,QAAQ,EAAE,GAAG;AACzE,WAAO,EAAE,SAAS,QAAM;AAAA,EAC1B;AAEA,QAAM,KAAK,WAAW,EAAE,UAAU,MAAM,QAAQ,QAAQ,OAAO;AAC/D,QAAM,UAAU,WAAW,IAAI,EAAE;AACjC,MAAI,YAAY,KAAM,QAAO,EAAE,SAAS,QAAM;AAC9C,MAAI,YAAY,MAAO,QAAO,EAAE,SAAS,SAAO;AAChD,SAAO,EAAE,SAAS,OAAA,GAAU,YAAY,IAAI,MAAA;AAC9C;"}

package/dist/esm/session/acp-client.d.ts

@@ -0,0 +1,37 @@
+import { AcpPermissionOutcome, AcpPermissionRequest, AcpSessionUpdate, AcpStopReason, AcpUsage } from '../types/acp-types.js';
+import { AcpSessionTransport } from '../transport/types.js';
+export interface AcpSessionHandle {
+    sessionId: string;
+    resumed: boolean;
+    prompt: (text: string) => Promise<{
+        stopReason: AcpStopReason;
+        usage?: AcpUsage;
+    }>;
+    cancel: () => Promise<void>;
+    dispose: () => Promise<void>;
+}
+export interface StartAcpSessionOptions {
+    transport: AcpSessionTransport;
+    cwd: string;
+    authMethodId?: string;
+    mcpServers?: Array<{
+        name: string;
+        url: string;
+        headers?: Array<{
+            name: string;
+            value: string;
+        }>;
+    }>;
+    resumeSessionId?: string;
+    onUpdate: (update: AcpSessionUpdate) => void;
+    onPermissionRequest: (request: AcpPermissionRequest) => Promise<AcpPermissionOutcome> | AcpPermissionOutcome;
+    /**
+     * Harness-specific JSON-RPC notifications (e.g. Grok `_x.ai/session_notification`).
+     * Return without throwing — unknown vendor extensions must not tear down the session.
+     */
+    onExtNotification?: (method: string, params: Record<string, unknown>) => void;
+}
+/**
+ * Drive an ACP harness over stdio or a pre-connected JSON-RPC stream.
+ */
+export declare function startAcpSession(options: StartAcpSessionOptions): Promise<AcpSessionHandle>;

package/dist/esm/session/acp-client.js

@@ -0,0 +1,140 @@
+import { ClientSideConnection, PROTOCOL_VERSION, ndJsonStream } from "@agentclientprotocol/sdk";
+import { spawnHandleToAcpTransport } from "../transport/stdio.js";
+const CLIENT_INFO = {
+  name: "@tanstack/ai-acp",
+  title: "TanStack AI",
+  version: "0.1.0"
+};
+function streamFromTransport(transport) {
+  if (transport.kind === "stdio") {
+    const byteTransport = spawnHandleToAcpTransport(transport.process);
+    return {
+      stream: ndJsonStream(byteTransport.writable, byteTransport.readable),
+      teardown: () => byteTransport.kill(),
+      exited: byteTransport.exited,
+      stderrTail: byteTransport.stderrTail
+    };
+  }
+  return {
+    stream: transport.stream,
+    teardown: transport.dispose,
+    exited: void 0,
+    stderrTail: transport.stderrTail ?? (() => "")
+  };
+}
+async function startAcpSession(options) {
+  const { stream, teardown, exited, stderrTail } = streamFromTransport(
+    options.transport
+  );
+  let replaying = false;
+  const client = {
+    requestPermission: async (params) => {
+      const outcome = await options.onPermissionRequest(params);
+      return { outcome };
+    },
+    sessionUpdate: (params) => {
+      if (!replaying) {
+        options.onUpdate(params.update);
+      }
+      return Promise.resolve();
+    },
+    extNotification: (method, params) => {
+      options.onExtNotification?.(method, params);
+      return Promise.resolve();
+    }
+  };
+  const race = (work) => exited !== void 0 ? Promise.race([work, exited]) : work;
+  try {
+    const connection = new ClientSideConnection(() => client, stream);
+    const initResult = await race(
+      connection.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientInfo: CLIENT_INFO,
+        clientCapabilities: {
+          // The agent runs inside the sandbox with direct filesystem + shell
+          // access, so it never needs to delegate file/terminal I/O back to the
+          // client. We advertise these as unsupported; per the ACP spec the
+          // agent MUST then treat them as unavailable and not call them.
+          fs: { readTextFile: false, writeTextFile: false }
+        }
+      })
+    );
+    if (typeof initResult.protocolVersion === "number" && initResult.protocolVersion > PROTOCOL_VERSION) {
+      throw new Error(
+        `ACP agent negotiated protocol version ${initResult.protocolVersion}, but this client supports up to ${PROTOCOL_VERSION}. Update @tanstack/ai-acp.`
+      );
+    }
+    if (options.authMethodId !== void 0) {
+      const available = initResult.authMethods ?? [];
+      if (!available.some((method) => method.id === options.authMethodId)) {
+        throw new Error(
+          `Harness does not advertise the ACP auth method '${options.authMethodId}'. Available: ${available.map((method) => method.id).join(", ") || "(none)"}.`
+        );
+      }
+      await race(connection.authenticate({ methodId: options.authMethodId }));
+    }
+    const mcpServers = (options.mcpServers ?? []).map(
+      (server) => ({
+        type: "http",
+        name: server.name,
+        url: server.url,
+        headers: server.headers ?? []
+      })
+    );
+    let sessionId;
+    let resumed = false;
+    if (options.resumeSessionId !== void 0 && initResult.agentCapabilities?.loadSession === true) {
+      replaying = true;
+      try {
+        await race(
+          connection.loadSession({
+            sessionId: options.resumeSessionId,
+            cwd: options.cwd,
+            mcpServers
+          })
+        );
+        sessionId = options.resumeSessionId;
+        resumed = true;
+      } catch {
+      } finally {
+        replaying = false;
+      }
+    }
+    if (sessionId === void 0) {
+      const session = await race(
+        connection.newSession({ cwd: options.cwd, mcpServers })
+      );
+      sessionId = session.sessionId;
+    }
+    return {
+      sessionId,
+      resumed,
+      prompt: async (text) => {
+        const response = await race(
+          connection.prompt({
+            sessionId,
+            prompt: [{ type: "text", text }]
+          })
+        );
+        return {
+          stopReason: response.stopReason,
+          ...response.usage != null && { usage: response.usage }
+        };
+      },
+      cancel: () => connection.cancel({ sessionId }),
+      dispose: teardown
+    };
+  } catch (error) {
+    await teardown();
+    const tail = stderrTail().trim();
+    if (error instanceof Error && tail !== "" && !error.message.includes(tail)) {
+      throw new Error(`${error.message}
+stderr: ${tail}`, { cause: error });
+    }
+    throw error;
+  }
+}
+export {
+  startAcpSession
+};
+//# sourceMappingURL=acp-client.js.map

package/dist/esm/session/acp-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-client.js","sources":["../../../src/session/acp-client.ts"],"sourcesContent":["import {\n  ClientSideConnection,\n  PROTOCOL_VERSION,\n  ndJsonStream,\n} from '@agentclientprotocol/sdk'\nimport { spawnHandleToAcpTransport } from '../transport/stdio'\nimport type {\n  Client,\n  McpServer,\n  RequestPermissionRequest,\n  RequestPermissionResponse,\n  SessionNotification,\n} from '@agentclientprotocol/sdk'\nimport type {\n  AcpPermissionOutcome,\n  AcpPermissionRequest,\n  AcpSessionUpdate,\n  AcpStopReason,\n  AcpUsage,\n} from '../types/acp-types'\nimport type { AcpJsonRpcStream, AcpSessionTransport } from '../transport/types'\n\n/**\n * Identifies this client to the agent in the ACP `initialize` handshake. The\n * `version` is informational (sent in `clientInfo`); keep it loosely in step\n * with the package version. `clientInfo` is currently optional in the protocol\n * but will become required, so we always send it.\n * ponytail: hardcoded — clientInfo is diagnostic; a stale patch version is harmless.\n */\nconst CLIENT_INFO = {\n  name: '@tanstack/ai-acp',\n  title: 'TanStack AI',\n  version: '0.1.0',\n} as const\n\nexport interface AcpSessionHandle {\n  sessionId: string\n  resumed: boolean\n  prompt: (\n    text: string,\n  ) => Promise<{ stopReason: AcpStopReason; usage?: AcpUsage }>\n  cancel: () => Promise<void>\n  dispose: () => Promise<void>\n}\n\nexport interface StartAcpSessionOptions {\n  transport: AcpSessionTransport\n  cwd: string\n  authMethodId?: string\n  mcpServers?: Array<{\n    name: string\n    url: string\n    headers?: Array<{ name: string; value: string }>\n  }>\n  resumeSessionId?: string\n  onUpdate: (update: AcpSessionUpdate) => void\n  onPermissionRequest: (\n    request: AcpPermissionRequest,\n  ) => Promise<AcpPermissionOutcome> | AcpPermissionOutcome\n  /**\n   * Harness-specific JSON-RPC notifications (e.g. Grok `_x.ai/session_notification`).\n   * Return without throwing — unknown vendor extensions must not tear down the session.\n   */\n  onExtNotification?: (method: string, params: Record<string, unknown>) => void\n}\n\nfunction streamFromTransport(transport: AcpSessionTransport): {\n  stream: AcpJsonRpcStream\n  teardown: () => Promise<void>\n  exited: Promise<never> | undefined\n  stderrTail: () => string\n} {\n  if (transport.kind === 'stdio') {\n    const byteTransport = spawnHandleToAcpTransport(transport.process)\n    return {\n      stream: ndJsonStream(byteTransport.writable, byteTransport.readable),\n      teardown: () => byteTransport.kill(),\n      exited: byteTransport.exited,\n      stderrTail: byteTransport.stderrTail,\n    }\n  }\n\n  return {\n    stream: transport.stream,\n    teardown: transport.dispose,\n    exited: undefined,\n    stderrTail: transport.stderrTail ?? (() => ''),\n  }\n}\n\n/**\n * Drive an ACP harness over stdio or a pre-connected JSON-RPC stream.\n */\nexport async function startAcpSession(\n  options: StartAcpSessionOptions,\n): Promise<AcpSessionHandle> {\n  const { stream, teardown, exited, stderrTail } = streamFromTransport(\n    options.transport,\n  )\n\n  let replaying = false\n\n  const client: Client = {\n    requestPermission: async (\n      params: RequestPermissionRequest,\n    ): Promise<RequestPermissionResponse> => {\n      const outcome = await options.onPermissionRequest(params)\n      return { outcome }\n    },\n    sessionUpdate: (params: SessionNotification): Promise<void> => {\n      if (!replaying) {\n        options.onUpdate(params.update as AcpSessionUpdate)\n      }\n      return Promise.resolve()\n    },\n    extNotification: (method, params) => {\n      options.onExtNotification?.(method, params)\n      return Promise.resolve()\n    },\n  }\n\n  const race = <T>(work: Promise<T>): Promise<T> =>\n    exited !== undefined ? Promise.race([work, exited]) : work\n\n  try {\n    const connection = new ClientSideConnection(() => client, stream)\n\n    const initResult = await race(\n      connection.initialize({\n        protocolVersion: PROTOCOL_VERSION,\n        clientInfo: CLIENT_INFO,\n        clientCapabilities: {\n          // The agent runs inside the sandbox with direct filesystem + shell\n          // access, so it never needs to delegate file/terminal I/O back to the\n          // client. We advertise these as unsupported; per the ACP spec the\n          // agent MUST then treat them as unavailable and not call them.\n          fs: { readTextFile: false, writeTextFile: false },\n        },\n      }),\n    )\n\n    // Protocol-version negotiation: the agent echoes the version it will speak.\n    // The spec says a client SHOULD close the connection if that version is one\n    // it doesn't support. We only implement the current PROTOCOL_VERSION, so a\n    // higher number means the agent needs a newer client than this one.\n    if (\n      typeof initResult.protocolVersion === 'number' &&\n      initResult.protocolVersion > PROTOCOL_VERSION\n    ) {\n      throw new Error(\n        `ACP agent negotiated protocol version ${initResult.protocolVersion}, ` +\n          `but this client supports up to ${PROTOCOL_VERSION}. Update @tanstack/ai-acp.`,\n      )\n    }\n\n    if (options.authMethodId !== undefined) {\n      const available = initResult.authMethods ?? []\n      if (!available.some((method) => method.id === options.authMethodId)) {\n        throw new Error(\n          `Harness does not advertise the ACP auth method '${options.authMethodId}'. Available: ${\n            available.map((method) => method.id).join(', ') || '(none)'\n          }.`,\n        )\n      }\n      await race(connection.authenticate({ methodId: options.authMethodId }))\n    }\n\n    const mcpServers: Array<McpServer> = (options.mcpServers ?? []).map(\n      (server) => ({\n        type: 'http' as const,\n        name: server.name,\n        url: server.url,\n        headers: server.headers ?? [],\n      }),\n    )\n\n    let sessionId: string | undefined\n    let resumed = false\n    if (\n      options.resumeSessionId !== undefined &&\n      initResult.agentCapabilities?.loadSession === true\n    ) {\n      replaying = true\n      try {\n        await race(\n          connection.loadSession({\n            sessionId: options.resumeSessionId,\n            cwd: options.cwd,\n            mcpServers,\n          }),\n        )\n        sessionId = options.resumeSessionId\n        resumed = true\n      } catch {\n        // Session unknown — fall through to a fresh one.\n      } finally {\n        replaying = false\n      }\n    }\n\n    if (sessionId === undefined) {\n      const session = await race(\n        connection.newSession({ cwd: options.cwd, mcpServers }),\n      )\n      sessionId = session.sessionId\n    }\n\n    return {\n      sessionId,\n      resumed,\n      prompt: async (text: string) => {\n        const response = await race(\n          connection.prompt({\n            sessionId,\n            prompt: [{ type: 'text', text }],\n          }),\n        )\n        return {\n          stopReason: response.stopReason,\n          ...(response.usage != null && { usage: response.usage }),\n        }\n      },\n      cancel: () => connection.cancel({ sessionId }),\n      dispose: teardown,\n    }\n  } catch (error) {\n    await teardown()\n    const tail = stderrTail().trim()\n    if (\n      error instanceof Error &&\n      tail !== '' &&\n      !error.message.includes(tail)\n    ) {\n      throw new Error(`${error.message}\\nstderr: ${tail}`, { cause: error })\n    }\n    throw error\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/session/sandbox-server.d.ts

@@ -0,0 +1,46 @@
+import { SandboxChannel, SandboxHandle } from '@tanstack/ai-sandbox';
+import { AcpMessageFraming } from '../transport/types.js';
+import { AcpWebSocketConnection } from '../transport/websocket.js';
+export interface AcpSandboxServer {
+    /** WebSocket URL the orchestrator uses to reach the in-sandbox ACP server. */
+    wsUrl: string;
+    /** Sandbox channel used to build {@link wsUrl} (auth headers, when issued). */
+    channel: SandboxChannel;
+    /** Open the ACP JSON-RPC stream over WebSocket. */
+    connect: (signal?: AbortSignal) => Promise<AcpWebSocketConnection>;
+    /** Stop the in-sandbox server process. */
+    dispose: () => Promise<void>;
+}
+export interface StartAcpServerOptions {
+    port: number;
+    cwd: string;
+    /** Full shell command that starts the harness ACP server inside the sandbox. */
+    command: string;
+    /** Build the WebSocket URL once the server is ready and the port is exposed. */
+    buildWsUrl: (input: {
+        channel: SandboxChannel;
+        port: number;
+        stdout: string;
+    }) => string;
+    /**
+     * Return true once {@link buildWsUrl} can be called. Receives accumulated
+     * stdout from the server process.
+     */
+    isReady?: (stdout: string) => boolean;
+    /** Substring/regex marker used when {@link isReady} is omitted. */
+    readyMarker?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    framing?: AcpMessageFraming;
+    hostname?: string;
+}
+/**
+ * Boot a harness ACP WebSocket server inside a sandbox and expose its port via
+ * {@link SandboxHandle.ports.connect}. Mirrors the `opencode serve` pattern.
+ */
+export declare function startAcpServerInSandbox(sandbox: SandboxHandle, options: StartAcpServerOptions): Promise<AcpSandboxServer>;
+/** Parse a `WebSocket URL: ws://…` line printed by `grok agent serve`. */
+export declare function parseWebSocketUrlFromServeOutput(output: string): string | undefined;
+/** Build a Grok `agent serve` WebSocket URL from a sandbox channel + secret. */
+export declare function buildGrokServeWebSocketUrl(channelUrl: string, secret: string): string;

package/dist/esm/session/sandbox-server.js

@@ -0,0 +1,114 @@
+import { connectAcpWebSocket } from "../transport/websocket.js";
+const DEFAULT_READY_MARKER = "WebSocket URL:";
+function waitForReady(proc, options) {
+  const readyMarker = options.readyMarker ?? DEFAULT_READY_MARKER;
+  const isReady = options.isReady ?? ((output) => output.includes(readyMarker));
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const state = { settled: false };
+    const settle = (fn) => {
+      if (state.settled) return;
+      state.settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    const diagnostics = () => [stdout, stderr].map((s) => s.trim()).filter(Boolean).join("\n").slice(-500);
+    const combined = () => stdout + stderr;
+    let stdoutDone = false;
+    let stderrDone = false;
+    const tryFinish = () => {
+      if (state.settled) return;
+      if (isReady(combined())) {
+        settle(() => resolve({ stdout, stderr }));
+        return;
+      }
+      if (stdoutDone && stderrDone) {
+        settle(
+          () => reject(
+            new Error(
+              `ACP server exited before becoming ready${diagnostics() ? `: ${diagnostics()}` : " (no output)"}`
+            )
+          )
+        );
+      }
+    };
+    const timer = setTimeout(
+      () => settle(
+        () => reject(
+          new Error(
+            `ACP server did not become ready within ${options.timeoutMs ?? 3e4}ms${diagnostics() ? `: ${diagnostics()}` : ""}`
+          )
+        )
+      ),
+      options.timeoutMs ?? 3e4
+    );
+    void (async () => {
+      try {
+        for await (const chunk of proc.stderr) {
+          stderr += chunk;
+          tryFinish();
+          if (state.settled) return;
+        }
+      } catch {
+      } finally {
+        stderrDone = true;
+        tryFinish();
+      }
+    })();
+    void (async () => {
+      try {
+        for await (const chunk of proc.stdout) {
+          stdout += chunk;
+          tryFinish();
+          if (state.settled) return;
+        }
+      } catch (error) {
+        settle(() => reject(error));
+        return;
+      } finally {
+        stdoutDone = true;
+        tryFinish();
+      }
+    })();
+  });
+}
+async function startAcpServerInSandbox(sandbox, options) {
+  const proc = await sandbox.process.spawn(options.command, {
+    cwd: options.cwd,
+    ...options.env ? { env: options.env } : {},
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  const { stdout } = await waitForReady(proc, options);
+  const channel = await sandbox.ports.connect(options.port);
+  const wsUrl = options.buildWsUrl({
+    channel,
+    port: options.port,
+    stdout
+  });
+  const headers = channel.headers ?? (channel.token ? { Authorization: `Bearer ${channel.token}` } : void 0);
+  return {
+    wsUrl,
+    channel,
+    connect: (signal) => connectAcpWebSocket(wsUrl, {
+      ...headers ? { headers } : {},
+      ...signal ? { signal } : {},
+      framing: options.framing ?? "frame"
+    }),
+    dispose: () => proc.kill()
+  };
+}
+function parseWebSocketUrlFromServeOutput(output) {
+  const match = output.match(/WebSocket URL:\s*(ws\S+)/i);
+  return match?.[1];
+}
+function buildGrokServeWebSocketUrl(channelUrl, secret) {
+  const wsBase = channelUrl.replace(/^http/i, "ws").replace(/\/$/, "");
+  return `${wsBase}/ws?server-key=${encodeURIComponent(secret)}`;
+}
+export {
+  buildGrokServeWebSocketUrl,
+  parseWebSocketUrlFromServeOutput,
+  startAcpServerInSandbox
+};
+//# sourceMappingURL=sandbox-server.js.map

package/dist/esm/session/sandbox-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-server.js","sources":["../../../src/session/sandbox-server.ts"],"sourcesContent":["import { connectAcpWebSocket } from '../transport/websocket'\nimport type {\n  SandboxChannel,\n  SandboxHandle,\n  SpawnHandle,\n} from '@tanstack/ai-sandbox'\nimport type { AcpMessageFraming } from '../transport/types'\nimport type { AcpWebSocketConnection } from '../transport/websocket'\n\nexport interface AcpSandboxServer {\n  /** WebSocket URL the orchestrator uses to reach the in-sandbox ACP server. */\n  wsUrl: string\n  /** Sandbox channel used to build {@link wsUrl} (auth headers, when issued). */\n  channel: SandboxChannel\n  /** Open the ACP JSON-RPC stream over WebSocket. */\n  connect: (signal?: AbortSignal) => Promise<AcpWebSocketConnection>\n  /** Stop the in-sandbox server process. */\n  dispose: () => Promise<void>\n}\n\nexport interface StartAcpServerOptions {\n  port: number\n  cwd: string\n  /** Full shell command that starts the harness ACP server inside the sandbox. */\n  command: string\n  /** Build the WebSocket URL once the server is ready and the port is exposed. */\n  buildWsUrl: (input: {\n    channel: SandboxChannel\n    port: number\n    stdout: string\n  }) => string\n  /**\n   * Return true once {@link buildWsUrl} can be called. Receives accumulated\n   * stdout from the server process.\n   */\n  isReady?: (stdout: string) => boolean\n  /** Substring/regex marker used when {@link isReady} is omitted. */\n  readyMarker?: string\n  env?: Record<string, string>\n  timeoutMs?: number\n  signal?: AbortSignal\n  framing?: AcpMessageFraming\n  hostname?: string\n}\n\nconst DEFAULT_READY_MARKER = 'WebSocket URL:'\n\nfunction waitForReady(\n  proc: SpawnHandle,\n  options: Pick<StartAcpServerOptions, 'isReady' | 'readyMarker' | 'timeoutMs'>,\n): Promise<{ stdout: string; stderr: string }> {\n  const readyMarker = options.readyMarker ?? DEFAULT_READY_MARKER\n  const isReady =\n    options.isReady ?? ((output: string) => output.includes(readyMarker))\n\n  return new Promise((resolve, reject) => {\n    let stdout = ''\n    let stderr = ''\n    const state = { settled: false }\n    const settle = (fn: () => void): void => {\n      if (state.settled) return\n      state.settled = true\n      clearTimeout(timer)\n      fn()\n    }\n    const diagnostics = (): string =>\n      [stdout, stderr]\n        .map((s) => s.trim())\n        .filter(Boolean)\n        .join('\\n')\n        .slice(-500)\n    const combined = (): string => stdout + stderr\n    let stdoutDone = false\n    let stderrDone = false\n    const tryFinish = (): void => {\n      if (state.settled) return\n      if (isReady(combined())) {\n        settle(() => resolve({ stdout, stderr }))\n        return\n      }\n      if (stdoutDone && stderrDone) {\n        settle(() =>\n          reject(\n            new Error(\n              `ACP server exited before becoming ready${\n                diagnostics() ? `: ${diagnostics()}` : ' (no output)'\n              }`,\n            ),\n          ),\n        )\n      }\n    }\n\n    const timer = setTimeout(\n      () =>\n        settle(() =>\n          reject(\n            new Error(\n              `ACP server did not become ready within ${options.timeoutMs ?? 30_000}ms${\n                diagnostics() ? `: ${diagnostics()}` : ''\n              }`,\n            ),\n          ),\n        ),\n      options.timeoutMs ?? 30_000,\n    )\n\n    void (async () => {\n      try {\n        for await (const chunk of proc.stderr) {\n          stderr += chunk\n          tryFinish()\n          if (state.settled) return\n        }\n      } catch {\n        // non-fatal\n      } finally {\n        stderrDone = true\n        tryFinish()\n      }\n    })()\n\n    void (async () => {\n      try {\n        for await (const chunk of proc.stdout) {\n          stdout += chunk\n          tryFinish()\n          if (state.settled) return\n        }\n      } catch (error) {\n        settle(() => reject(error))\n        return\n      } finally {\n        stdoutDone = true\n        tryFinish()\n      }\n    })()\n  })\n}\n\n/**\n * Boot a harness ACP WebSocket server inside a sandbox and expose its port via\n * {@link SandboxHandle.ports.connect}. Mirrors the `opencode serve` pattern.\n */\nexport async function startAcpServerInSandbox(\n  sandbox: SandboxHandle,\n  options: StartAcpServerOptions,\n): Promise<AcpSandboxServer> {\n  const proc = await sandbox.process.spawn(options.command, {\n    cwd: options.cwd,\n    ...(options.env ? { env: options.env } : {}),\n    ...(options.signal ? { signal: options.signal } : {}),\n  })\n\n  const { stdout } = await waitForReady(proc, options)\n  const channel = await sandbox.ports.connect(options.port)\n  const wsUrl = options.buildWsUrl({\n    channel,\n    port: options.port,\n    stdout,\n  })\n\n  const headers =\n    channel.headers ??\n    (channel.token ? { Authorization: `Bearer ${channel.token}` } : undefined)\n\n  return {\n    wsUrl,\n    channel,\n    connect: (signal?: AbortSignal) =>\n      connectAcpWebSocket(wsUrl, {\n        ...(headers ? { headers } : {}),\n        ...(signal ? { signal } : {}),\n        framing: options.framing ?? 'frame',\n      }),\n    dispose: () => proc.kill(),\n  }\n}\n\n/** Parse a `WebSocket URL: ws://…` line printed by `grok agent serve`. */\nexport function parseWebSocketUrlFromServeOutput(\n  output: string,\n): string | undefined {\n  const match = output.match(/WebSocket URL:\\s*(ws\\S+)/i)\n  return match?.[1]\n}\n\n/** Build a Grok `agent serve` WebSocket URL from a sandbox channel + secret. */\nexport function buildGrokServeWebSocketUrl(\n  channelUrl: string,\n  secret: string,\n): string {\n  const wsBase = channelUrl.replace(/^http/i, 'ws').replace(/\\/$/, '')\n  return `${wsBase}/ws?server-key=${encodeURIComponent(secret)}`\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/stream/queue.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Minimal promise-based async queue bridging callback-style ACP notifications
+ * into the async-iterable world the stream translator consumes.
+ */
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private readonly values;
+    private readonly waiters;
+    private ended;
+    private error;
+    private failed;
+    push(value: T): void;
+    end(): void;
+    fail(error: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/dist/esm/stream/queue.js

@@ -0,0 +1,54 @@
+class AsyncQueue {
+  values = [];
+  waiters = [];
+  ended = false;
+  error = void 0;
+  failed = false;
+  push(value) {
+    if (this.ended || this.failed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve({ value, done: false });
+    } else {
+      this.values.push(value);
+    }
+  }
+  end() {
+    if (this.ended || this.failed) return;
+    this.ended = true;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter.resolve({ value: void 0, done: true });
+    }
+  }
+  fail(error) {
+    if (this.ended || this.failed) return;
+    this.failed = true;
+    this.error = error;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter.reject(error);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.values.length > 0) {
+          return Promise.resolve({
+            value: this.values.shift(),
+            done: false
+          });
+        }
+        if (this.failed) return Promise.reject(this.error);
+        if (this.ended) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve, reject) => {
+          this.waiters.push({ resolve, reject });
+        });
+      }
+    };
+  }
+}
+export {
+  AsyncQueue
+};
+//# sourceMappingURL=queue.js.map

package/dist/esm/stream/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sources":["../../../src/stream/queue.ts"],"sourcesContent":["/**\n * Minimal promise-based async queue bridging callback-style ACP notifications\n * into the async-iterable world the stream translator consumes.\n */\nexport class AsyncQueue<T> implements AsyncIterable<T> {\n  private readonly values: Array<T> = []\n  private readonly waiters: Array<{\n    resolve: (result: IteratorResult<T>) => void\n    reject: (error: unknown) => void\n  }> = []\n  private ended = false\n  private error: unknown = undefined\n  private failed = false\n\n  push(value: T): void {\n    if (this.ended || this.failed) return\n    const waiter = this.waiters.shift()\n    if (waiter) {\n      waiter.resolve({ value, done: false })\n    } else {\n      this.values.push(value)\n    }\n  }\n\n  end(): void {\n    if (this.ended || this.failed) return\n    this.ended = true\n    for (const waiter of this.waiters.splice(0)) {\n      waiter.resolve({ value: undefined, done: true })\n    }\n  }\n\n  fail(error: unknown): void {\n    if (this.ended || this.failed) return\n    this.failed = true\n    this.error = error\n    for (const waiter of this.waiters.splice(0)) {\n      waiter.reject(error)\n    }\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return {\n      next: (): Promise<IteratorResult<T>> => {\n        if (this.values.length > 0) {\n          return Promise.resolve({\n            value: this.values.shift() as T,\n            done: false,\n          })\n        }\n        if (this.failed) return Promise.reject(this.error)\n        if (this.ended) {\n          return Promise.resolve({ value: undefined, done: true })\n        }\n        return new Promise((resolve, reject) => {\n          this.waiters.push({ resolve, reject })\n        })\n      },\n    }\n  }\n}\n"],"names":[],"mappings":"AAIO,MAAM,WAA0C;AAAA,EACpC,SAAmB,CAAA;AAAA,EACnB,UAGZ,CAAA;AAAA,EACG,QAAQ;AAAA,EACR,QAAiB;AAAA,EACjB,SAAS;AAAA,EAEjB,KAAK,OAAgB;AACnB,QAAI,KAAK,SAAS,KAAK,OAAQ;AAC/B,UAAM,SAAS,KAAK,QAAQ,MAAA;AAC5B,QAAI,QAAQ;AACV,aAAO,QAAQ,EAAE,OAAO,MAAM,OAAO;AAAA,IACvC,OAAO;AACL,WAAK,OAAO,KAAK,KAAK;AAAA,IACxB;AAAA,EACF;AAAA,EAEA,MAAY;AACV,QAAI,KAAK,SAAS,KAAK,OAAQ;AAC/B,SAAK,QAAQ;AACb,eAAW,UAAU,KAAK,QAAQ,OAAO,CAAC,GAAG;AAC3C,aAAO,QAAQ,EAAE,OAAO,QAAW,MAAM,MAAM;AAAA,IACjD;AAAA,EACF;AAAA,EAEA,KAAK,OAAsB;AACzB,QAAI,KAAK,SAAS,KAAK,OAAQ;AAC/B,SAAK,SAAS;AACd,SAAK,QAAQ;AACb,eAAW,UAAU,KAAK,QAAQ,OAAO,CAAC,GAAG;AAC3C,aAAO,OAAO,KAAK;AAAA,IACrB;AAAA,EACF;AAAA,EAEA,CAAC,OAAO,aAAa,IAAsB;AACzC,WAAO;AAAA,MACL,MAAM,MAAkC;AACtC,YAAI,KAAK,OAAO,SAAS,GAAG;AAC1B,iBAAO,QAAQ,QAAQ;AAAA,YACrB,OAAO,KAAK,OAAO,MAAA;AAAA,YACnB,MAAM;AAAA,UAAA,CACP;AAAA,QACH;AACA,YAAI,KAAK,OAAQ,QAAO,QAAQ,OAAO,KAAK,KAAK;AACjD,YAAI,KAAK,OAAO;AACd,iBAAO,QAAQ,QAAQ,EAAE,OAAO,QAAW,MAAM,MAAM;AAAA,QACzD;AACA,eAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,eAAK,QAAQ,KAAK,EAAE,SAAS,QAAQ;AAAA,QACvC,CAAC;AAAA,MACH;AAAA,IAAA;AAAA,EAEJ;AACF;"}

package/dist/esm/stream/translate.d.ts

@@ -0,0 +1,38 @@
+import { StreamChunk } from '@tanstack/ai';
+import { AcpSessionUpdate, AcpStopReason, AcpUsage } from '../types/acp-types.js';
+export declare const BRIDGED_MCP_SERVER_NAME = "tanstack";
+export type AcpStreamEvent = {
+    kind: 'session';
+    sessionId: string;
+} | {
+    kind: 'update';
+    update: AcpSessionUpdate;
+} | {
+    kind: 'done';
+    stopReason: AcpStopReason;
+    usage?: AcpUsage;
+};
+export interface AcpTranslateLabels {
+    sessionIdEvent: string;
+    planEvent?: string;
+    refusalMessage?: string;
+    /**
+     * When set, non-text agent message content (image / audio / resource /
+     * resource_link blocks) is surfaced as a CUSTOM event under this name instead
+     * of being dropped. Each event's `value` is `{ content: <ACP content block> }`.
+     * Omit to keep the text-only behavior.
+     */
+    contentEvent?: string;
+}
+export interface TranslateContext {
+    model: string;
+    runId: string;
+    threadId: string;
+    parentRunId?: string;
+    genId: () => string;
+    labels: AcpTranslateLabels;
+    bridgedToolNames?: ReadonlySet<string>;
+    onAcpEvent?: (event: AcpStreamEvent) => void;
+}
+export declare function matchBridgedToolName(title: string | null | undefined, bridgedToolNames: ReadonlySet<string> | undefined): string | undefined;
+export declare function translateAcpStream(events: AsyncIterable<AcpStreamEvent>, ctx: TranslateContext): AsyncIterable<StreamChunk>;