agents 0.26.0 → 0.27.0

package/dist/harness/think/index.d.ts

@@ -0,0 +1,821 @@
+import {
+  _ as LifecycleJobContext,
+  o as MemoryLimitContext,
+  s as LifecycleCapability,
+  t as CapabilityRequestContext,
+  v as LifecycleJobOutcome,
+  x as Connection
+} from "../../capability-runner-O5VbQzqg.js";
+import { n as ClientToolSchema } from "../../client-tools-aIBO0Fk7.js";
+import { o as SearchResult } from "../../types-B7LojTe4.js";
+import { n as WebSocketHandlers } from "../../options-pwTNq9z6.js";
+import {
+  a as HarnessSessions,
+  c as OperationStatus,
+  g as ToolAnswer,
+  i as HarnessSession,
+  l as Receipt,
+  m as SessionWatch,
+  n as HarnessInput,
+  s as OperationResult,
+  t as AgentHarness
+} from "../../harness-B6B9S3rb.js";
+import { n as Session, o as CompactResult } from "../../handle-zAzh0UW2.js";
+import {
+  JSONValue,
+  LanguageModel,
+  ModelMessage,
+  ToolChoice,
+  ToolSet,
+  UIMessage,
+  UIMessageChunk
+} from "ai";
+
+//#region src/harness/think/events.d.ts
+/**
+ * Something that happened in a session, as the AI SDK describes it.
+ *
+ * @experimental
+ */
+type ThinkSessionEvent =
+  | {
+      readonly type: "operation";
+      readonly status: OperationStatus;
+    }
+  | {
+      readonly type: "run-start";
+      readonly operationId: string /** Whether the operation continues an assistant message already persisted. */;
+      readonly continuation: boolean;
+    }
+  | {
+      readonly type: "run-end";
+      readonly operationId: string;
+    }
+  /**
+   * A streamed chunk of the operation's assistant message. Chunks of one
+   * model call continue the message as persisted before that call.
+   */
+  | {
+      readonly type: "chunk";
+      readonly operationId: string;
+      readonly chunk: UIMessageChunk;
+    } /** A message was persisted; it replaces any message with its id. */
+  | {
+      readonly type: "message";
+      readonly message: UIMessage /** The operation that wrote it. */;
+      readonly operationId?: string;
+    } /** The session was reset. Messages that follow belong to the new context. */
+  | {
+      readonly type: "reset";
+    }
+  /**
+   * The transcript changed in a way no single message describes: messages
+   * were deleted, or a compaction changed what the model sees. Re-read it.
+   */
+  | {
+      readonly type: "transcript";
+    };
+/** A listener for a session's events. @experimental */
+type ThinkSessionListener = (event: ThinkSessionEvent) => void;
+/** A listener for every session's events. @experimental */
+type ThinkHarnessListener = (session: string, event: ThinkSessionEvent) => void;
+//#endregion
+//#region src/harness/think/records.d.ts
+/** What an operation asks the harness to do, as stored. */
+type OperationInput = /** Place these user messages, then answer them. */ | {
+      readonly kind: "messages";
+      readonly messages: readonly UIMessage[];
+    } /** Record a tool result or approval, then continue the turn it unblocks. */
+  | {
+      readonly kind: "answer";
+      readonly answer: ToolAnswer /** Whether to continue the turn once nothing else is awaited. */;
+      readonly autoContinue: boolean;
+    } /** Answer a user message again, on a new branch beside earlier answers. */
+  | {
+      readonly kind: "regenerate";
+      readonly messageId?: string;
+    } /** Continue the latest assistant message. */
+  | {
+      readonly kind: "continue";
+    };
+//#endregion
+//#region src/harness/think/types.d.ts
+/**
+ * A session id. The root session is `""`, the Sessions capability's default
+ * session, which is where `@cloudflare/think` keeps its one conversation.
+ *
+ * @experimental
+ */
+type ThinkSessionId = string;
+/**
+ * What a session accepts as input:
+ *
+ * - a string, as one user text message;
+ * - one `UIMessage` or several, placed in order;
+ * - the shared harness input (`{ parts }`);
+ * - a tool result or an approval (`ToolAnswer`), which continues the turn
+ *   that was waiting for it.
+ *
+ * @experimental
+ */
+type ThinkInput =
+  | string
+  | UIMessage
+  | readonly UIMessage[]
+  | HarnessInput
+  | ToolAnswer;
+/**
+ * What a submission does when the session is already running. Only
+ * `followUp` (the default) is supported: the input is answered after the
+ * current turn, as its own turn. Steering a running turn is not supported,
+ * and a `"steer"` passed through the shared harness interface is refused
+ * with `SteerNotSupportedError`.
+ *
+ * @experimental
+ */
+type ThinkWhenBusy = "followUp";
+/** Options for `submit()` and `prompt()`. @experimental */
+type ThinkSubmitOptions = {
+  /** Idempotency key. Submitting the same id twice returns the same receipt. */ readonly operationId?: string;
+  readonly whenBusy?: ThinkWhenBusy;
+  /**
+   * Who wrote the input. `"client"` input is untrusted: it may only add
+   * `user` messages (an operation with any other role ends `unanswered`
+   * with reason `"client_role"`), a message whose id is already stored is
+   * dropped rather than rewritten, and reserved metadata keys are
+   * stripped. Default `"server"`.
+   */
+  readonly source?: "client" | "server";
+  /**
+   * Tools the session's client runs, replacing any it declared before. They
+   * are kept with the session, so later turns, including continuations
+   * after an eviction, still offer them to the model.
+   */
+  readonly clientTools?: readonly ClientToolSchema[];
+  /**
+   * For a tool result or an approval: whether to continue the turn once
+   * nothing else is awaited. Default `true`. With `false` the answer is
+   * recorded and the turn waits for `session.continue()`.
+   */
+  readonly autoContinue?: boolean;
+};
+/** Returned once a submission is durable. @experimental */
+type ThinkReceipt = Receipt;
+/** How one operation ended. @experimental */
+type ThinkOperationResult = OperationResult & {
+  /** The assistant message the operation wrote, if it wrote one. */ readonly messageId?: string;
+};
+/** A prompt's result, with the transcript after it. @experimental */
+type ThinkPromptResponse = ThinkOperationResult & {
+  /** The session's active transcript. */ readonly messages: readonly UIMessage[];
+};
+/** An operation not settled yet. @experimental */
+type ThinkPendingOperation = {
+  readonly operationId: string;
+  readonly session: ThinkSessionId /** `queued` behind other work, or `running`. */;
+  readonly status: "queued" | "running";
+};
+/** The operation a session is running, mid model call. @experimental */
+type ThinkInFlight = {
+  readonly operationId: string;
+  /**
+   * Whether the model call continues an assistant message already
+   * persisted, so its chunks extend that message rather than start one.
+   */
+  readonly continuation: boolean /** The call's chunks so far. */;
+  readonly chunks: readonly UIMessageChunk[];
+};
+/** An operation's status: open, or how it ended. @experimental */
+type ThinkOperationStatus =
+  | {
+      readonly operationId: string;
+      readonly session: ThinkSessionId;
+      readonly status: "queued" | "running";
+    }
+  | ThinkOperationResult;
+/**
+ * Receives one operation's answer as it streams, as Think's `chat()`
+ * callback does.
+ *
+ * @experimental
+ */
+type ThinkStreamCallback = {
+  /** The submission is durable. */ onStart?(event: {
+    readonly operationId: string;
+  }): void | Promise<void> /** One UI message chunk, as JSON. */;
+  onEvent(json: string): void | Promise<void>;
+  onDone(): void | Promise<void> /** The operation ended unanswered, with the reason. */;
+  onError(error: string): void | Promise<void>;
+};
+/** A session the harness knows of. @experimental */
+type ThinkSessionInfo = {
+  readonly id: ThinkSessionId /** The session this one was forked from. */;
+  readonly parent?: ThinkSessionId;
+  readonly busy: boolean;
+};
+/**
+ * What the harness does with a tool call an eviction interrupted, set on
+ * the tool as its `recovery` field.
+ *
+ * - `report` (default): record the call as failed with an "interrupted"
+ *   error, so the model sees it and decides. Right for any tool whose
+ *   effect may have happened.
+ * - `rerun`: run it again. Only for tools that are safe to repeat.
+ *
+ * ```ts
+ * tools: {
+ *   search: { ...tool({ description, inputSchema, execute }), recovery: "rerun" }
+ * }
+ * ```
+ *
+ * @experimental
+ */
+type ToolRecovery = "report" | "rerun";
+/** The optional field a tool carries to set its recovery. @experimental */
+type RecoverableTool = {
+  readonly recovery?: ToolRecovery;
+};
+/** Recovery policy. @experimental */
+type ThinkRecoveryOptions = {
+  /**
+   * Interruptions one operation survives without progress before it is
+   * settled as `unanswered` with reason `"interrupted"`. A finished model
+   * call or tool call is progress and resets the count. Default 10.
+   */
+  readonly maxAttempts?: number;
+  /**
+   * Delay before the second recovery attempt, doubled for each after it,
+   * up to a minute. The first is immediate. Default 1000.
+   */
+  readonly backoffMs?: number;
+  /**
+   * A model stream that sends nothing for this long is treated as
+   * interrupted and recovered. `0` turns the watchdog off. Default 120000.
+   */
+  readonly stallTimeoutMs?: number;
+};
+/** Context for every hook. @experimental */
+type ThinkHookContext = {
+  readonly session: ThinkSessionId;
+  readonly operationId: string;
+};
+/** Context for `beforeTurn`. @experimental */
+type ThinkTurnContext = ThinkHookContext & {
+  /** Model calls this operation made before this one. */ readonly step: number /** Whether this call continues an assistant message already started. */;
+  readonly continuation: boolean /** The transcript the model will see, with compaction applied. */;
+  readonly messages: readonly UIMessage[] /** The system prompt from the options, if any. */;
+  readonly system: string | undefined /** Names of the tools on offer. */;
+  readonly tools: readonly string[];
+};
+/**
+ * What `beforeTurn` may change for one model call. Unset fields keep the
+ * harness's own values.
+ *
+ * @experimental
+ */
+type ThinkTurnConfig = {
+  readonly model?: LanguageModel;
+  readonly system?: string /** Replace the model messages the transcript converts to. */;
+  readonly messages?: ModelMessage[] /** Only offer these tools on this call. */;
+  readonly activeTools?: readonly string[];
+  readonly toolChoice?: ToolChoice<ToolSet>;
+  readonly providerOptions?: Record<string, Record<string, JSONValue>>;
+  readonly maxOutputTokens?: number;
+  readonly temperature?: number;
+};
+/** Context for `beforeToolCall`. @experimental */
+type ThinkToolCallContext = ThinkHookContext & {
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown /** Runs of this call so far, counting this one. */;
+  readonly attempt: number;
+};
+/**
+ * What `beforeToolCall` decides.
+ *
+ * - `{ action: "run" }` (or nothing): run the tool, with `input` replaced
+ *   when given.
+ * - `{ action: "block", reason }`: do not run it; the model sees the reason
+ *   as the tool's error.
+ * - `{ action: "substitute", output }`: do not run it; the model sees
+ *   `output` as its result.
+ *
+ * @experimental
+ */
+type ThinkToolCallDecision =
+  | {
+      readonly action: "run";
+      readonly input?: unknown;
+    }
+  | {
+      readonly action: "block";
+      readonly reason: string;
+    }
+  | {
+      readonly action: "substitute";
+      readonly output: unknown;
+    };
+/** Context for `afterToolCall`. @experimental */
+type ThinkToolCallResultContext = ThinkToolCallContext &
+  (
+    | {
+        readonly ok: true;
+        readonly output: unknown;
+      }
+    | {
+        readonly ok: false;
+        readonly errorText: string;
+      }
+  );
+/** Context for `onStepFinish`. @experimental */
+type ThinkStepFinishContext = ThinkHookContext & {
+  readonly step: number /** The assistant message as persisted after this model call. */;
+  readonly message: UIMessage;
+  readonly finishReason: string | undefined;
+};
+/** Context for `onChunk`. @experimental */
+type ThinkChunkContext = ThinkHookContext & {
+  readonly chunk: UIMessageChunk;
+};
+/** Context for `onTurnEnd`. @experimental */
+type ThinkTurnEndContext = ThinkOperationResult & {
+  /** The assistant message the operation wrote, as persisted. */ readonly message?: UIMessage;
+};
+/**
+ * How the harness treats a model call's error.
+ *
+ * - `fail` (default): settle the operation `unanswered` with the error.
+ * - `context-overflow`: compact the session, if it has a compaction
+ *   function, and call the model again, once.
+ * - `retry`: treat it like an interruption, within the recovery budget.
+ *
+ * @experimental
+ */
+type ThinkErrorClass = "fail" | "context-overflow" | "retry";
+/** Context for `onRecovery`. @experimental */
+type ThinkRecoveryContext = ThinkHookContext & {
+  /** Interruptions without progress, counting this one. */ readonly attempt: number /** The partial assistant message rebuilt from the interrupted stream. */;
+  readonly partial: UIMessage | undefined;
+};
+/**
+ * Hooks into the turn loop. All are optional, and each may be async. A
+ * throwing hook ends the operation `unanswered`, except `onChunk`,
+ * `onTurnEnd` and `onError`, whose errors are logged and ignored.
+ *
+ * @experimental
+ */
+type ThinkHarnessHooks = {
+  /**
+   * Before every model call. A turn makes several, and after an eviction
+   * the harness has no memory of what an earlier call returned, so it asks
+   * again each time.
+   */
+  readonly beforeTurn?: (
+    context: ThinkTurnContext
+  ) =>
+    | ThinkTurnConfig
+    | void
+    | Promise<ThinkTurnConfig | void> /** Before each server tool call the harness runs. */;
+  readonly beforeToolCall?: (
+    context: ThinkToolCallContext
+  ) =>
+    | ThinkToolCallDecision
+    | void
+    | Promise<ThinkToolCallDecision | void> /** After each server tool call, with its result. */;
+  readonly afterToolCall?: (
+    context: ThinkToolCallResultContext
+  ) => void | Promise<void> /** After each model call's message is persisted. */;
+  readonly onStepFinish?: (
+    context: ThinkStepFinishContext
+  ) => void | Promise<void> /** For each UI chunk the model streams. */;
+  readonly onChunk?: (
+    context: ThinkChunkContext
+  ) => void /** After an operation settles. */;
+  readonly onTurnEnd?: (
+    context: ThinkTurnEndContext
+  ) => void | Promise<void> /** Observe a model call's error, before it is classified. */;
+  readonly onError?: (
+    error: unknown,
+    context: ThinkHookContext
+  ) => void | Promise<void> /** Classify a model call's error. Default: everything is `fail`. */;
+  readonly classifyError?: (error: unknown) => ThinkErrorClass;
+  /**
+   * Decide what to do with an interrupted model call. Default: `continue`
+   * while within `recovery.maxAttempts`.
+   */
+  readonly onRecovery?: (
+    context: ThinkRecoveryContext
+  ) => "continue" | "abandon" | Promise<"continue" | "abandon">;
+};
+/** Context for options computed per session. @experimental */
+type ThinkSessionContext = {
+  readonly session: ThinkSessionId;
+};
+/**
+ * Something given directly or computed for each session.
+ *
+ * @experimental
+ */
+type PerSession<T> = T | ((context: ThinkSessionContext) => T | Promise<T>);
+/** `ThinkHarness`'s options. @experimental */
+type ThinkHarnessOptions<TOOLS extends ToolSet = ToolSet> = {
+  /**
+   * Message-metadata keys only the server may write. The transcript strips
+   * them from input submitted with `source: "client"`. Default: none.
+   */
+  readonly reservedMetadataKeys?: readonly string[];
+  readonly model: PerSession<LanguageModel>;
+  readonly system?: PerSession<string | undefined>;
+  /**
+   * Server tools, which the harness runs itself, one durable call at a
+   * time, and tools without `execute`, which a client runs. A server tool
+   * may carry `recovery: "rerun"` (see `ToolRecovery`).
+   */
+  readonly tools?: PerSession<TOOLS>;
+  /**
+   * Most model calls one operation makes. Default 10. As with the AI SDK's
+   * `stepCountIs`, when the last allowed call asks for tools, the tools run
+   * and the operation ends without another model reply.
+   */
+  readonly maxSteps?: number;
+  /**
+   * Whether a tool call needs approval before it runs. A tool's own
+   * `needsApproval` is honored too.
+   */
+  readonly toolApproval?: (call: {
+    readonly session: ThinkSessionId;
+    readonly toolName: string;
+    readonly toolCallId: string;
+    readonly input: unknown;
+  }) =>
+    | boolean
+    | Promise<boolean> /** The budget for recovering interrupted work. */;
+  readonly recovery?: ThinkRecoveryOptions;
+  /**
+   * Configure a session's transcript handle the first time the harness
+   * uses it, for example its compaction function and threshold.
+   */
+  readonly configureSession?: (session: Session, id: ThinkSessionId) => void;
+  readonly hooks?: ThinkHarnessHooks;
+};
+//#endregion
+//#region src/harness/think/harness.d.ts
+/**
+ * Thrown by `submit()` when asked to steer a running turn, which
+ * ThinkHarness does not support. Submit without `whenBusy` to queue the
+ * input behind the running turn instead.
+ *
+ * @experimental
+ */
+declare class SteerNotSupportedError extends Error {
+  readonly session: ThinkSessionId;
+  /** Stable tag for matching without `instanceof`. */
+  readonly _tag: "SteerNotSupportedError";
+  /** @param session - The session the submission was for. */
+  constructor(session: ThinkSessionId);
+}
+/** The root session's id: the Sessions capability's default session. */
+declare const ROOT_SESSION: ThinkSessionId;
+/**
+ * Think's agent loop hosted in a Durable Object, behind the same small
+ * harness interface as `PiHarness`: `harness.prompt()`, `harness.sessions`,
+ * `harness.session(id)`. It implements the shared `AgentHarness`
+ * interface, so a Channels host can serve its sessions.
+ *
+ * Transcripts live in a Sessions capability and in-flight model output in
+ * a Streams capability, both owned by the harness, and the harness's queue
+ * of operations in its own table. The harness runs every server tool call itself, so after an
+ * eviction it knows exactly which call was cut short and applies that
+ * tool's recovery policy.
+ *
+ * Durability is the Lifecycle's job queue, used directly: one wake job per
+ * session. A submission is written, then the session's wake is scheduled.
+ * While a session has work, the wake job reschedules itself as a heartbeat,
+ * so an eviction leaves it due and its alarm restarts the object. Each step
+ * of a turn reads only durable state, so the restarted object continues
+ * where the last write left off.
+ *
+ * @experimental The API may change between releases.
+ */
+declare class ThinkHarness<TOOLS extends ToolSet = ToolSet>
+  extends LifecycleCapability
+  implements AgentHarness
+{
+  #private;
+  /** Every session in this object. */
+  readonly sessions: ThinkSessions;
+  /**
+   * @param options - The model, tools and hooks.
+   */
+  constructor(options: ThinkHarnessOptions<TOOLS>);
+  /** Create the harness's tables and wake every session with open work. */
+  onStart(): Promise<void>;
+  /**
+   * The alarm memory-limit breaker sealed: the work it stopped would only
+   * run out of memory again. Mark the running operations to be settled
+   * `unanswered` with reason `"out_of_memory"` rather than run again.
+   * Queued operations behind them still run. Runs after the isolate's
+   * work unwound, so it keeps to small synchronous writes.
+   */
+  onMemoryLimit(context: MemoryLimitContext): void;
+  /** Run a session's wake job. */
+  onJob(context: LifecycleJobContext): Promise<LifecycleJobOutcome | void>;
+  /**
+   * A handle on one session. No I/O until you call it.
+   *
+   * @param id - The session. Default: the root session.
+   */
+  session(id?: ThinkSessionId): ThinkSession;
+  /** Submit to the root session and wait for the answer. */
+  prompt(
+    input: ThinkInput,
+    options?: ThinkSubmitOptions
+  ): Promise<ThinkPromptResponse>;
+  /** Durably submit to the root session. Resolves before the model runs. */
+  submit(
+    input: ThinkInput,
+    options?: ThinkSubmitOptions
+  ): Promise<ThinkReceipt>;
+  /** Operations not settled yet, oldest first, in one session or all. */
+  pending(session?: ThinkSessionId): Promise<ThinkPendingOperation[]>;
+  /** @internal */
+  enqueue(
+    session: ThinkSessionId,
+    input: OperationInput,
+    options: ThinkSubmitOptions
+  ): Promise<ThinkReceipt>;
+  /** @internal Stop one operation, or everything open in a session. */
+  abort(session: ThinkSessionId, operationId?: string): Promise<boolean>;
+  /** @internal Wait for an operation to settle. */
+  wait(
+    session: ThinkSessionId,
+    operationId: string,
+    signal?: AbortSignal
+  ): Promise<ThinkOperationResult>;
+  /** @internal */
+  inspect(
+    session: ThinkSessionId,
+    operationId: string
+  ): Promise<ThinkOperationStatus | undefined>;
+  /** @internal The active transcript of a session. */
+  messages(session: ThinkSessionId): Promise<UIMessage[]>;
+  /** @internal Abort everything in a session and clear its transcript. */
+  reset(session: ThinkSessionId, handoff?: string): Promise<void>;
+  /** @internal */
+  subscribe(
+    session: ThinkSessionId,
+    listener: ThinkSessionListener
+  ): () => void;
+  /** @internal The shared harness interface's watch. */
+  watch(session: ThinkSessionId): Promise<SessionWatch>;
+  /** @internal The running operation and its model call's chunks so far. */
+  inFlight(session: ThinkSessionId): Promise<ThinkInFlight | undefined>;
+  /**
+   * Listen to every session's events, for a host that serves several
+   * sessions over one set of connections. Returns the unsubscribe.
+   */
+  observe(listener: ThinkHarnessListener): () => void;
+  /** @internal */
+  createSession(parent?: ThinkSessionId): Promise<ThinkSession>;
+  /** @internal Copy a session's active path into a new session. */
+  fork(from: ThinkSessionId): Promise<ThinkSession>;
+  /** @internal */
+  listSessions(): Promise<ThinkSessionInfo[]>;
+  /** @internal The answers to a message: its children in the tree. */
+  branches(session: ThinkSessionId, messageId: string): Promise<UIMessage[]>;
+  /** @internal Full-text search over a session's messages. */
+  search(
+    session: ThinkSessionId,
+    query: string,
+    options?: {
+      readonly limit?: number;
+    }
+  ): Promise<SearchResult[]>;
+  /** @internal Compact a session with its compaction function. */
+  compact(session: ThinkSessionId): Promise<CompactResult | null>;
+}
+/**
+ * Classify the context-window overflow errors of common providers
+ * (Anthropic, OpenAI, Google, Bedrock, Mistral and others) as
+ * `"context-overflow"`, and everything else as `"fail"`. Pass it as
+ * `hooks.classifyError`, or call it from your own classifier.
+ *
+ * @param error - The model call's error.
+ * @returns `"context-overflow"` or `"fail"`.
+ * @experimental
+ */
+declare function classifyContextOverflow(error: unknown): ThinkErrorClass;
+/**
+ * One session, addressed through the harness.
+ *
+ * @experimental
+ */
+declare class ThinkSession implements HarnessSession {
+  #private;
+  /** The session's id. */
+  readonly id: ThinkSessionId;
+  /**
+   * @param harness - The harness that owns the session.
+   * @param id - The session's id.
+   */
+  constructor(harness: ThinkHarness, id: ThinkSessionId);
+  /** Durably submit input. Resolves before the model runs. */
+  submit(
+    input: ThinkInput,
+    options?: ThinkSubmitOptions
+  ): Promise<ThinkReceipt>;
+  /** Submit and wait for the answer and the updated transcript. */
+  prompt(
+    input: ThinkInput,
+    options?: ThinkSubmitOptions
+  ): Promise<ThinkPromptResponse>;
+  /**
+   * Answer a user message again. The new answer is a branch beside the
+   * earlier ones, which `Session.getBranches()` still reads.
+   *
+   * @param messageId - The user message. Default: the latest one.
+   */
+  regenerate(
+    messageId?: string,
+    options?: Pick<ThinkSubmitOptions, "operationId">
+  ): Promise<ThinkReceipt>;
+  /** Call the model again to continue the latest message. */
+  continue(
+    options?: Pick<ThinkSubmitOptions, "operationId">
+  ): Promise<ThinkReceipt>;
+  /** Wait for an operation to settle. Aborting `signal` stops only the wait. */
+  wait(
+    operationId: string,
+    signal?: AbortSignal
+  ): Promise<ThinkOperationResult>;
+  /**
+   * Withdraw one queued operation or abort it while it runs; with no id,
+   * everything open in the session.
+   */
+  abort(operationId?: string): Promise<boolean>;
+  /** Abort everything and clear the transcript, optionally leaving a note. */
+  reset(handoff?: string): Promise<void>;
+  /** The active transcript. */
+  messages(): Promise<UIMessage[]>;
+  /** Operations not settled yet, oldest first. */
+  pending(): Promise<ThinkPendingOperation[]>;
+  /**
+   * The running operation, with the chunks its model call has streamed so
+   * far, including those an eviction left behind. Send them, then
+   * `subscribe()`'s chunk events, to a client that joins mid-turn.
+   */
+  inFlight(): Promise<ThinkInFlight | undefined>;
+  /**
+   * The answers to a message: its children in the transcript tree. A
+   * regenerated answer is a branch beside the earlier ones.
+   *
+   * @param messageId - The message, usually a user message.
+   */
+  branches(messageId: string): Promise<UIMessage[]>;
+  /** Full-text search over this session's messages. */
+  search(
+    query: string,
+    options?: {
+      readonly limit?: number;
+    }
+  ): Promise<SearchResult[]>;
+  /**
+   * Summarize older messages with the compaction function set in
+   * `configureSession`. Resolves to null when there was nothing to compact.
+   */
+  compact(): Promise<CompactResult | null>;
+  /** Listen to the session's events in the AI SDK's vocabulary. */
+  subscribe(listener: ThinkSessionListener): () => void;
+  /** The shared harness interface's watch: the state, then every change. */
+  watch(): Promise<SessionWatch>;
+  /**
+   * Submit input and stream its answer to `callback`, as Think's `chat()`
+   * does: `onStart`, then `onEvent` with each UI chunk as JSON, then
+   * `onDone` or `onError`. Works over RPC with an `RpcTarget` callback.
+   *
+   * The callback lives in memory. If the object is evicted mid-turn the
+   * turn still finishes, but the callback is gone; a caller that must not
+   * lose the answer should `wait()` on the receipt as well.
+   */
+  chat(
+    input: ThinkInput,
+    callback: ThinkStreamCallback,
+    options?: ThinkSubmitOptions
+  ): Promise<ThinkOperationResult>;
+  /** One operation's status, or undefined when the id is unknown. */
+  inspect(operationId: string): Promise<ThinkOperationStatus | undefined>;
+  /** Whether the session has open work. */
+  busy(): Promise<boolean>;
+}
+/**
+ * Every session in this object.
+ *
+ * @experimental
+ */
+declare class ThinkSessions implements HarnessSessions {
+  #private;
+  /** @param harness - The harness that owns the sessions. */
+  constructor(harness: ThinkHarness);
+  /** A handle on one session. */
+  get(id: ThinkSessionId): ThinkSession;
+  /** A new, empty session. */
+  create(): Promise<ThinkSession>;
+  /** A new session that starts with `from`'s active transcript. */
+  fork(from: ThinkSessionId): Promise<ThinkSession>;
+  /** Every session, with whether it has open work. */
+  list(): Promise<ThinkSessionInfo[]>;
+}
+//#endregion
+//#region src/harness/think/chat.d.ts
+/**
+ * The connections the chat protocol talks to: the WebSockets capability
+ * fits as is.
+ *
+ * @experimental
+ */
+type ThinkChatConnections = {
+  getConnections(): Iterable<Connection>;
+  use(handlers: WebSocketHandlers): void;
+};
+/** `ThinkChat`'s options. @experimental */
+type ThinkChatOptions = {
+  readonly harness: ThinkHarness /** The WebSockets capability the clients connect through. */;
+  readonly webSockets: ThinkChatConnections /** The session the chat serves. Default: the root session. */;
+  readonly session?: ThinkSessionId;
+};
+/**
+ * Serves one ThinkHarness session over Think's chat WebSocket protocol and
+ * its `GET …/get-messages` route. Install it on the Lifecycle after the
+ * harness and the WebSockets capability:
+ *
+ * ```ts
+ * readonly webSockets = new WebSockets();
+ * readonly chat = new ThinkChat({ harness: this.harness, webSockets: this.webSockets });
+ * readonly lifecycle = Lifecycle.install(this)
+ *   .use(this.harness)
+ *   .use(this.webSockets).use(this.chat);
+ * ```
+ *
+ * Supported: chat requests (`submit-message` and `regenerate-message`),
+ * cancel, clear, client tool results, approvals, and stream resume after
+ * a reconnect or an eviction. Not supported: `messageConcurrency`
+ * strategies other than queueing, client transcript sync, and the
+ * recovery progress frame.
+ *
+ * @experimental The API may change between releases.
+ */
+declare class ThinkChat extends LifecycleCapability {
+  #private;
+  /** @param options - The harness, its WebSockets, and the session to serve. */
+  constructor(options: ThinkChatOptions);
+  /** Answer `GET …/get-messages` with the session's transcript. */
+  onRequest(context: CapabilityRequestContext): Promise<Response | undefined>;
+  /** Stop listening to the harness. */
+  dispose(): void;
+}
+//#endregion
+export {
+  type PerSession,
+  ROOT_SESSION,
+  type RecoverableTool,
+  SteerNotSupportedError,
+  ThinkChat,
+  type ThinkChatConnections,
+  type ThinkChatOptions,
+  type ThinkChunkContext,
+  type ThinkErrorClass,
+  ThinkHarness,
+  type ThinkHarnessHooks,
+  type ThinkHarnessListener,
+  type ThinkHarnessOptions,
+  type ThinkHookContext,
+  type ThinkInFlight,
+  type ThinkInput,
+  type ThinkOperationResult,
+  type ThinkOperationStatus,
+  type ThinkPendingOperation,
+  type ThinkPromptResponse,
+  type ThinkReceipt,
+  type ThinkRecoveryContext,
+  type ThinkRecoveryOptions,
+  ThinkSession,
+  type ThinkSessionContext,
+  type ThinkSessionEvent,
+  type ThinkSessionId,
+  type ThinkSessionInfo,
+  type ThinkSessionListener,
+  ThinkSessions,
+  type ThinkStepFinishContext,
+  type ThinkStreamCallback,
+  type ThinkSubmitOptions,
+  type ThinkToolCallContext,
+  type ThinkToolCallDecision,
+  type ThinkToolCallResultContext,
+  type ThinkTurnConfig,
+  type ThinkTurnContext,
+  type ThinkTurnEndContext,
+  type ThinkWhenBusy,
+  type ToolRecovery,
+  classifyContextOverflow
+};
+//# sourceMappingURL=index.d.ts.map