@ai-sdk/harness 1.0.133 → 1.0.134

package/dist/bridge/index.d.ts

@@ -1,36 +1,37 @@
-import { ToolResultPart } from '@ai-sdk/provider-utils';
-
+import { ToolResultPart } from "@ai-sdk/provider-utils";
+//#region src/bridge/harness-bridge-capability-unsupported-error.d.ts
 /**
  * Signals an unsupported capability discovered inside a sandbox bridge.
  * `isInstance` also recognizes the serialized error shape received by the
  * host, where it can be translated to `HarnessCapabilityUnsupportedError`.
  */
-declare class HarnessBridgeCapabilityUnsupportedError extends Error {
-    readonly harnessId?: string;
-    readonly cause?: unknown;
-    constructor({ message, harnessId, cause, }: {
-        message: string;
-        harnessId?: string;
-        cause?: unknown;
-    });
-    static isInstance(error: unknown): error is HarnessBridgeCapabilityUnsupportedError;
+export declare class HarnessBridgeCapabilityUnsupportedError extends Error {
+  readonly harnessId?: string;
+  readonly cause?: unknown;
+  constructor({ message, harnessId, cause }: {
+    message: string;
+    harnessId?: string;
+    cause?: unknown;
+  });
+  static isInstance(error: unknown): error is HarnessBridgeCapabilityUnsupportedError;
 }
-
+//#endregion
+//#region src/bridge/index.d.ts
 type BridgeState = 'init' | 'waiting' | 'running' | 'draining' | 'done';
 /** Outbound turn event the adapter emits. `seq` is added by the runtime. */
 type BridgeEvent = Record<string, unknown> & {
-    type: string;
+  type: string;
 };
 type BridgeDebugLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
 interface Experimental_BridgeUserMessage {
-    readonly messageId: string;
-    readonly text: string;
-    accept(): void;
-    reject(error: unknown): void;
+  readonly messageId: string;
+  readonly text: string;
+  accept(): void;
+  reject(error: unknown): void;
 }
 interface Experimental_BridgeUserMessageQueue extends AsyncIterable<Experimental_BridgeUserMessage> {
-    readonly pendingCount: number;
-    close(error?: unknown): void;
+  readonly pendingCount: number;
+  close(error?: unknown): void;
 }
 /**
  * Per-session diagnostics config. The host resolves it from settings +
@@ -39,127 +40,127 @@ interface Experimental_BridgeUserMessageQueue extends AsyncIterable<Experimental
  * emitted and no `seq` is consumed.
  */
 interface BridgeDebugConfig {
-    enabled?: boolean;
-    level?: BridgeDebugLevel;
-    subsystems?: string[];
+  enabled?: boolean;
+  level?: BridgeDebugLevel;
+  subsystems?: string[];
 }
 /**
  * Per-turn surface handed to {@link RunBridgeOptions.onStart}. The adapter
  * drives its runtime against these primitives; the runtime owns the transport.
  */
 interface BridgeTurn {
-    /**
-     * Emit a turn event to the host. Stamps a monotonic `seq`, appends to the
-     * in-memory replay log, and sends to the live socket (best-effort — if the
-     * host is mid-reconnect the event waits in the log and is replayed on
-     * resume).
-     */
-    emit(event: BridgeEvent): void;
-    /**
-     * Register interest in a host-executed tool result and resolve when the
-     * matching `tool-result` arrives. The adapter emits the `tool-call` event
-     * itself (via {@link emit}) using the same `toolCallId`.
-     */
-    requestToolResult(input: string | {
-        toolCallId: string;
-        matches?: (result: {
-            output: unknown;
-            isError?: boolean;
-            toolResult?: ToolResultPart;
-        }) => boolean;
-    }): Promise<{
-        output: unknown;
-        isError?: boolean;
-        toolResult?: ToolResultPart;
-    }>;
-    /**
-     * Register interest in a host approval decision and resolve when the matching
-     * `tool-approval-response` arrives. The adapter emits the
-     * `tool-approval-request` event itself using the same `approvalId`.
-     */
-    requestToolApproval(approvalId: string): Promise<{
-        approved: boolean;
-        reason?: string;
-    }>;
-    readonly experimental_userMessages: Experimental_BridgeUserMessageQueue;
-    /** Aborts when the host sends `abort`. */
-    readonly abortSignal: AbortSignal;
-    /** True for the first turn since this bridge process started. */
-    readonly firstTurn: boolean;
-    /**
-     * Emit a structured diagnostic. Gated by the session's debug level +
-     * subsystem filter; a no-op when diagnostics are disabled. Adapters use this
-     * for runtime-level instrumentation; raw `console.*` output is captured and
-     * forwarded automatically.
-     */
-    bridgeLog(input: {
-        level?: BridgeDebugLevel;
-        subsystem: string;
-        message: string;
-        attrs?: Record<string, unknown>;
-        error?: unknown;
-    }): void;
-    /**
-     * Emit a non-fatal bridge warning to stderr using the runtime's harness
-     * prefix. This is diagnostic-only: it does not emit a stream event, does not
-     * consume a `seq`, and does not fail the turn.
-     */
-    emitWarning(input: {
-        message: string;
-    }): void;
-    emitError(input: {
-        error: unknown;
-        message?: string;
-    }): void;
+  /**
+   * Emit a turn event to the host. Stamps a monotonic `seq`, appends to the
+   * in-memory replay log, and sends to the live socket (best-effort — if the
+   * host is mid-reconnect the event waits in the log and is replayed on
+   * resume).
+   */
+  emit(event: BridgeEvent): void;
+  /**
+   * Register interest in a host-executed tool result and resolve when the
+   * matching `tool-result` arrives. The adapter emits the `tool-call` event
+   * itself (via {@link emit}) using the same `toolCallId`.
+   */
+  requestToolResult(input: string | {
+    toolCallId: string;
+    matches?: (result: {
+      output: unknown;
+      isError?: boolean;
+      toolResult?: ToolResultPart;
+    }) => boolean;
+  }): Promise<{
+    output: unknown;
+    isError?: boolean;
+    toolResult?: ToolResultPart;
+  }>;
+  /**
+   * Register interest in a host approval decision and resolve when the matching
+   * `tool-approval-response` arrives. The adapter emits the
+   * `tool-approval-request` event itself using the same `approvalId`.
+   */
+  requestToolApproval(approvalId: string): Promise<{
+    approved: boolean;
+    reason?: string;
+  }>;
+  readonly experimental_userMessages: Experimental_BridgeUserMessageQueue;
+  /** Aborts when the host sends `abort`. */
+  readonly abortSignal: AbortSignal;
+  /** True for the first turn since this bridge process started. */
+  readonly firstTurn: boolean;
+  /**
+   * Emit a structured diagnostic. Gated by the session's debug level +
+   * subsystem filter; a no-op when diagnostics are disabled. Adapters use this
+   * for runtime-level instrumentation; raw `console.*` output is captured and
+   * forwarded automatically.
+   */
+  bridgeLog(input: {
+    level?: BridgeDebugLevel;
+    subsystem: string;
+    message: string;
+    attrs?: Record<string, unknown>;
+    error?: unknown;
+  }): void;
+  /**
+   * Emit a non-fatal bridge warning to stderr using the runtime's harness
+   * prefix. This is diagnostic-only: it does not emit a stream event, does not
+   * consume a `seq`, and does not fail the turn.
+   */
+  emitWarning(input: {
+    message: string;
+  }): void;
+  emitError(input: {
+    error: unknown;
+    message?: string;
+  }): void;
 }
 interface RunBridgeOptions<TStart extends {
-    type: 'start';
+  type: 'start';
 }> {
-    /** Identifier written into `bridge-meta.json` (`'claude-code'` / `'codex'`). */
-    bridgeType: string;
-    /** Directory for `bridge-meta.json` / `start-config.json`. Created if absent. */
-    bridgeStateDir: string;
-    /**
-     * Drive one prompt turn. Rejections surface to the host as an `error`
-     * event.
-     *
-     * Contract: once `turn.abortSignal` fires, wind down promptly — turns are
-     * serialized, and a replacement `start` waits up to
-     * {@link turnTeardownGraceMs} for this promise to settle before it
-     * proceeds anyway.
-     */
-    onStart(start: TStart, turn: BridgeTurn): Promise<void>;
-    /**
-     * How long a replacement `start` waits for the previous turn's teardown
-     * after aborting it, in milliseconds. Turns are serialized so an aborted
-     * turn cannot emit into its replacement's event log or overlap its runtime
-     * process — but only within this bound: an adapter that does not settle
-     * `onStart` after its abort signal fires forfeits the protection for that
-     * boundary, and the new turn proceeds anyway rather than blocking forever.
-     * The default of ten seconds exceeds the Claude bridge's five-second
-     * hard-abort fallback.
-     */
-    turnTeardownGraceMs?: number;
-    /**
-     * Produce the adapter-defined runtime resume data for `stop`. Defaults to
-     * `{}`.
-     */
-    onStop?(): unknown | Promise<unknown>;
-    /**
-     * Perform adapter-defined destruction before the bridge exits.
-     */
-    onDestroy?(): void | Promise<void>;
-    /** WS port. Defaults to `BRIDGE_WS_PORT` env (0 = OS-assigned). */
-    port?: number;
-    /** Auth token. Defaults to `BRIDGE_CHANNEL_TOKEN` env. */
-    token?: string;
-    /** Called with the bound port once the server is listening. */
-    onListening?(port: number): void;
-    /**
-     * Tear the process down after `stop` / `destroy`. Defaults to closing
-     * the server and calling `process.exit(0)`. Overridable for tests.
-     */
-    onExit?(): void;
+  /** Identifier written into `bridge-meta.json` (`'claude-code'` / `'codex'`). */
+  bridgeType: string;
+  /** Directory for `bridge-meta.json` / `start-config.json`. Created if absent. */
+  bridgeStateDir: string;
+  /**
+   * Drive one prompt turn. Rejections surface to the host as an `error`
+   * event.
+   *
+   * Contract: once `turn.abortSignal` fires, wind down promptly — turns are
+   * serialized, and a replacement `start` waits up to
+   * {@link turnTeardownGraceMs} for this promise to settle before it
+   * proceeds anyway.
+   */
+  onStart(start: TStart, turn: BridgeTurn): Promise<void>;
+  /**
+   * How long a replacement `start` waits for the previous turn's teardown
+   * after aborting it, in milliseconds. Turns are serialized so an aborted
+   * turn cannot emit into its replacement's event log or overlap its runtime
+   * process — but only within this bound: an adapter that does not settle
+   * `onStart` after its abort signal fires forfeits the protection for that
+   * boundary, and the new turn proceeds anyway rather than blocking forever.
+   * The default of ten seconds exceeds the Claude bridge's five-second
+   * hard-abort fallback.
+   */
+  turnTeardownGraceMs?: number;
+  /**
+   * Produce the adapter-defined runtime resume data for `stop`. Defaults to
+   * `{}`.
+   */
+  onStop?(): unknown | Promise<unknown>;
+  /**
+   * Perform adapter-defined destruction before the bridge exits.
+   */
+  onDestroy?(): void | Promise<void>;
+  /** WS port. Defaults to `BRIDGE_WS_PORT` env (0 = OS-assigned). */
+  port?: number;
+  /** Auth token. Defaults to `BRIDGE_CHANNEL_TOKEN` env. */
+  token?: string;
+  /** Called with the bound port once the server is listening. */
+  onListening?(port: number): void;
+  /**
+   * Tear the process down after `stop` / `destroy`. Defaults to closing
+   * the server and calling `process.exit(0)`. Overridable for tests.
+   */
+  onExit?(): void;
 }
 /**
  * Boot the bridge: bind the WebSocket server, announce `bridge-ready`, and
@@ -168,13 +169,14 @@ interface RunBridgeOptions<TStart extends {
  * `stop` / `destroy` exits it.
  */
 interface BridgeHandle {
-    /** The port the WebSocket server bound to. */
-    readonly port: number;
-    /** Close the WebSocket server. Does not call `process.exit`. */
-    close(): Promise<void>;
+  /** The port the WebSocket server bound to. */
+  readonly port: number;
+  /** Close the WebSocket server. Does not call `process.exit`. */
+  close(): Promise<void>;
 }
-declare function runBridge<TStart extends {
-    type: 'start';
+export declare function runBridge<TStart extends {
+  type: 'start';
 }>(options: RunBridgeOptions<TStart>): Promise<BridgeHandle>;
-
-export { type BridgeDebugConfig, type BridgeDebugLevel, type BridgeEvent, type BridgeHandle, type BridgeState, type BridgeTurn, type Experimental_BridgeUserMessage, type Experimental_BridgeUserMessageQueue, HarnessBridgeCapabilityUnsupportedError, type RunBridgeOptions, runBridge };
+//#endregion
+export type { BridgeDebugConfig, BridgeDebugLevel, BridgeEvent, BridgeHandle, BridgeState, BridgeTurn, Experimental_BridgeUserMessage, Experimental_BridgeUserMessageQueue, RunBridgeOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/bridge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/bridge/harness-bridge-capability-unsupported-error.ts","../../src/bridge/index.ts"],"mappings":";;;;;;;qBAOa,gDAAgD;WAClD;WACA;EAEG,cACV,SACA,WACA;IAEA;IACA;IACA;;SAQK,WACL,iBACC,SAAS;;;;KCVF;;KAGA,cAAc;EAA4B;;KAE1C;UAEK;WACN;WACA;EACT;EACA,OAAO;;UAGQ,4CAA4C,cAAc;WAChE;EACT,MAAM;;;;;;;;UAoBS;EACf;EACA,QAAQ;EACR;;;;;;UA+Ke;;;;;;;EAOf,KAAK,OAAO;;;;;;EAOZ,kBACE;IAGM;IACA,WAAW;MACT;MACA;MACA,aAAa;;MAGpB;IACD;IACA;IACA,aAAa;;;;;;;EAQf,oBACE,qBACC;IAAU;IAAmB;;WAEvB,2BAA2B;;WAG3B,aAAa;;WAGb;;;;;;;EAQT,UAAU;IACR,QAAQ;IACR;IACA;IACA,QAAQ;IACR;;;;;;;EAQF,YAAY;IAAS;;EAErB,UAAU;IAAS;IAAgB;;;UAGpB,iBAAiB;EAAiB;;;EAEjD;;EAEA;;;;;;;;;;EAUA,QAAQ,OAAO,QAAQ,MAAM,aAAa;;;;;;;;;;;EAW1C;;;;;EAKA,qBAAqB;;;;EAIrB,qBAAqB;;EAErB;;EAEA;;EAEA,aAAa;;;;;EAKb;;;;;;;;UA+Be;;WAEN;;EAET,SAAS;;wBAGW,UAAU;EAAiB;GAC/C,SAAS,iBAAiB,UACzB,QAAQ"}