@coder/ai-sdk-agent 0.9.0 → 0.9.2

package/README.md

@@ -223,9 +223,11 @@ conversation with server‑side history). `agent.chatId` is the current chat id.
 - `agent.interrupt({ signal? })` — interrupt an in‑flight generation.
 - `agent.archive({ signal? })` — archive the underlying chat (cleanup; see [Cleanup](#cleanup)).
 - `agent.listModels()` — list the deployment's model configs, so you don't have to guess the `model` hint.
-- Resume a prior chat: `new CoderAgent({ …, chatId: "…" })` — see
-  [Durable workflows](#durable-workflows-persist-resume-recover) for the full
-  resumption how‑to.
+- Resume a prior chat: `new CoderAgent({ …, chatId: "…" })` — optionally with
+  `lastSeenMessageId` (the persisted resume cursor, read from
+  `agent.lastSeenMessageId`) to skip the resumed turn's pre‑prompt history
+  probe. See [Durable workflows](#durable-workflows-persist-resume-recover)
+  for the full resumption how‑to.
 
 Interrupting is asynchronous on the server: `interrupt()` resolves as soon as the
 interrupt is acknowledged, and the run keeps winding down for a few seconds
@@ -883,24 +885,25 @@ sequence pinpoints _where_ a turn died:
 
 `CoderAgentSettings`:
 
-| field                             | description                                                                                      |
-| --------------------------------- | ------------------------------------------------------------------------------------------------ |
-| `client` \| (`baseUrl` + `token`) | connection (one or the other; `baseUrl`/`token` default from `CODER_URL`/`CODER_SESSION_TOKEN`)  |
-| `organizationId`                  | org UUID that owns the chat (required)                                                           |
-| `model`                           | model hint: UUID, `provider:model`, model id, or display‑name substring                          |
-| `instructions`                    | system prompt                                                                                    |
-| `tools`                           | AI SDK `ToolSet` (client‑executed)                                                               |
-| `workspaceId`                     | bind the chat to a Coder workspace (enables workspace‑scoped tools)                              |
-| `workspaceFiles`                  | adapter enabling `uploadToWorkspace()` (write files to the workspace FS)                         |
-| `mcpServerIds`                    | server‑side MCP servers to enable                                                                |
-| `planMode`                        | enable plan mode (`"plan"`)                                                                      |
-| `stopWhen`                        | AI SDK stop condition(s); default `stepCountIs(64)`                                              |
-| `maxRetries`                      | default `0` — SDK retries can duplicate server‑side turns; override with care                    |
-| `requestTimeoutMs`                | per‑turn time budget (ms); interrupts the run and rejects (`kind: "timeout"`) instead of hanging |
-| `onTransportEvent`                | observability hook for typed transport events (see [Observability](#observability))              |
-| `settleDeadlineMs`                | overall deadline for bounded cleanup (`archive()` 409 retries, disposal); default 15 000         |
-| `settleRetryDelayMs`              | pause between `archive()` retries while the chat settles; default 1000                           |
-| `chatId`                          | resume an existing chat                                                                          |
+| field                             | description                                                                                                        |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `client` \| (`baseUrl` + `token`) | connection (one or the other; `baseUrl`/`token` default from `CODER_URL`/`CODER_SESSION_TOKEN`)                    |
+| `organizationId`                  | org UUID that owns the chat (required)                                                                             |
+| `model`                           | model hint: UUID, `provider:model`, model id, or display‑name substring                                            |
+| `instructions`                    | system prompt                                                                                                      |
+| `tools`                           | AI SDK `ToolSet` (client‑executed)                                                                                 |
+| `workspaceId`                     | bind the chat to a Coder workspace (enables workspace‑scoped tools)                                                |
+| `workspaceFiles`                  | adapter enabling `uploadToWorkspace()` (write files to the workspace FS)                                           |
+| `mcpServerIds`                    | server‑side MCP servers to enable                                                                                  |
+| `planMode`                        | enable plan mode (`"plan"`)                                                                                        |
+| `stopWhen`                        | AI SDK stop condition(s); default `stepCountIs(64)`                                                                |
+| `maxRetries`                      | default `0` — SDK retries can duplicate server‑side turns; override with care                                      |
+| `requestTimeoutMs`                | per‑turn time budget (ms); interrupts the run and rejects (`kind: "timeout"`) instead of hanging                   |
+| `onTransportEvent`                | observability hook for typed transport events (see [Observability](#observability))                                |
+| `settleDeadlineMs`                | overall deadline for bounded cleanup (`archive()` 409 retries, disposal); default 15 000                           |
+| `settleRetryDelayMs`              | pause between `archive()` retries while the chat settles; default 1000                                             |
+| `chatId`                          | resume an existing chat                                                                                            |
+| `lastSeenMessageId`               | resume cursor for `chatId` (persist `agent.lastSeenMessageId`) — skips the resumed turn's pre‑prompt history probe |
 
 The `model` hint resolves against the deployment's model configs in order: a
 config UUID is used as‑is, then an exact `provider:model` match, an exact model
@@ -943,7 +946,9 @@ Two facts make the pattern work:
 
 - **All chat state lives on the Coder server.** Messages, tool activity, the
   run itself — none of it is in your process. The only durable thing a
-  workflow has to carry between steps is **`agent.chatId`: a string.**
+  workflow has to carry between steps is **`agent.chatId`: a string** — plus,
+  optionally, **`agent.lastSeenMessageId`: the resume cursor**, which saves the
+  resumed turn one serial round‑trip (below).
 - **`CoderAgent` can't ride a `fetch`‑shim durability layer** (it talks REST +
   WebSocket through its own client), so each turn runs **inside** a durable
   step — and the checkpointed chat id is the thread between steps.
@@ -956,18 +961,29 @@ on another machine, hours apart, retried after failures.
 ```ts
 import { CoderAgent, type CoderTransportEvent } from "@coder/ai-sdk-agent";
 
+interface WorkflowCheckpoint {
+  chatId: string;
+  /** The resume cursor — pairs with chatId, never persisted without it. */
+  lastSeenMessageId?: number;
+}
+
 // Any durable KV your engine gives you: step state, a job row, a DB table.
 declare const checkpoints: {
-  get(workflowId: string): Promise<string | undefined>;
-  set(workflowId: string, chatId: string): Promise<void>;
+  get(workflowId: string): Promise<WorkflowCheckpoint | undefined>;
+  set(workflowId: string, checkpoint: WorkflowCheckpoint): Promise<void>;
 };
 
 export async function runTurn(workflowId: string, prompt: string): Promise<string> {
+  const checkpoint = await checkpoints.get(workflowId); // undefined on the first step → the turn creates the chat
   const agent = new CoderAgent({
     baseUrl: process.env.CODER_URL!,
     token: process.env.CODER_SESSION_TOKEN!, // read per step — never checkpoint or log it
     organizationId: process.env.CODER_ORG_ID!,
-    chatId: await checkpoints.get(workflowId), // undefined on the first step → the turn creates the chat
+    chatId: checkpoint?.chatId,
+    // The previous step's cursor lets this step skip its pre-prompt history
+    // probe; absent (first resume, older checkpoints), the turn seeds it from
+    // the chat's newest message instead — one extra GET, same result.
+    lastSeenMessageId: checkpoint?.lastSeenMessageId,
     requestTimeoutMs: 300_000, // always bound workflow steps — see below
     onTransportEvent: observe, // per-step telemetry — see below
   });
@@ -990,7 +1006,15 @@ export async function runTurn(workflowId: string, prompt: string): Promise<strin
     // CoderStreamError's chatId still names the stranded chat, and
     // agent.archive() retires it via agent.lastKnownChatId — see the
     // CoderStreamError notes below for what retrying means then.
-    if (agent.chatId) await checkpoints.set(workflowId, agent.chatId);
+    if (agent.chatId) {
+      const next: WorkflowCheckpoint = { chatId: agent.chatId };
+      // The cursor is optional sugar: persist it when a turn established one
+      // (a turn that failed before streaming may not have), skip it otherwise.
+      if (agent.lastSeenMessageId !== undefined) {
+        next.lastSeenMessageId = agent.lastSeenMessageId;
+      }
+      await checkpoints.set(workflowId, next);
+    }
   }
 }
 ```
@@ -1023,12 +1047,16 @@ await archiveWorkflowChat("wf-1042");
 
 What resuming does (and doesn't do):
 
-- **Construction is free.** `new CoderAgent({ …, chatId })` performs no I/O
-  and no validation — a bad or archived id fails the _turn_, not the
-  constructor.
+- **Construction is free.** `new CoderAgent({ …, chatId })` performs no I/O —
+  a bad or archived id fails the _turn_, not the constructor. (The one
+  exception is local validation of `lastSeenMessageId`: a cursor that isn't a
+  positive integer, or arrives without its `chatId`, throws immediately.)
 - **The first resumed turn seeds its cursor** from the chat's newest message
   (one single‑message history probe), so it streams only its own events —
-  it never re‑absorbs earlier turns' content or usage.
+  it never re‑absorbs earlier turns' content or usage. Supplying the
+  checkpointed `lastSeenMessageId` skips that probe: the previous step already
+  knew the cursor, so the resumed prompt goes out without any pre‑prompt
+  round‑trip.
 - **Re‑supply process‑local configuration.** Client `tools` live in your
   process, not on the server, so each step that expects tool calls must pass
   them again. The workspace binding is the opposite: fixed at creation,
@@ -1036,7 +1064,10 @@ What resuming does (and doesn't do):
 - **Sessions stay single‑flight across the whole system**, not just within one
   process: run steps strictly sequentially per chat. A second job posting to
   the same chat queues behind the live run and burns its own
-  `requestTimeoutMs` waiting.
+  `requestTimeoutMs` waiting — it attributes nothing of the live run's output
+  to itself (its window opens only when its own queued prompt materializes),
+  and if it times out first, it withdraws its queued prompt rather than
+  leaving it to run unattended.
 
 ### Let the SDK absorb drops — and handle what it re‑throws
 
@@ -1162,9 +1193,11 @@ checkpoint:
   turns into resuming the dead chat.)
 - **Crashed after the checkpoint** — the chat is resumable, but don't just
   resubmit. The crashed attempt's run may still be live server‑side, and a
-  resumed turn seeds its message cursor _before_ submitting — whatever the
-  old run commits after that point would be absorbed into the resumed turn's
-  output and usage. A crash _inside one of your client tools_ is worse: the
+  resubmission then queues behind it: nothing the old run commits is
+  attributed to the resumed turn (its window opens only at its own queued
+  prompt's materialization), but the step burns its `requestTimeoutMs`
+  waiting for the old run to finish first — and a timeout withdraws the
+  queued prompt again. A crash _inside one of your client tools_ is worse: the
   chat is paused in `requires_action`, where new messages wait forever — and
   if the tool's external effect committed before the crash, that pause is the
   only pending record of it, so reconcile the tool ledger **before** any

package/dist/index.d.ts

@@ -352,7 +352,7 @@ interface TransportEventBase {
  * extend this union; treat unrecognized values as "some other operation"
  * rather than matching exhaustively.
  */
-type CoderClientOperation = "listModelConfigs" | "resolveModelConfigId" | "createChat" | "getChat" | "createChatMessage" | "getMessages" | "submitToolResults" | "interruptChat" | "updateChat" | "archiveChat" | "uploadChatFile" | "getChatFile";
+type CoderClientOperation = "listModelConfigs" | "resolveModelConfigId" | "createChat" | "getChat" | "createChatMessage" | "getMessages" | "submitToolResults" | "interruptChat" | "deleteQueuedMessage" | "updateChat" | "archiveChat" | "uploadChatFile" | "getChatFile";
 interface HttpTransportEventBase extends TransportEventBase {
     /**
      * Correlates a request with its response/error. Monotonically increasing
@@ -725,6 +725,15 @@ declare class CoderChatClient {
         wait?: boolean;
         signal?: AbortSignal;
     }): Promise<Chat>;
+    /**
+     * Withdraw a QUEUED (not yet materialized) message from the chat's
+     * submission queue (`DELETE /queue/{id}`). `queuedMessageId` is the
+     * queue-entry id from `CreateChatMessageResponse.queued_message` — a
+     * different id space from committed chat message ids. Rejects with a
+     * {@link CoderApiError}: 404 when the entry no longer exists (already
+     * promoted into history, or deleted), 409 when the chat has no queue.
+     */
+    deleteQueuedMessage(chatId: string, queuedMessageId: number, signal?: AbortSignal): Promise<void>;
     updateChat(chatId: string, req: UpdateChatRequest, signal?: AbortSignal): Promise<void>;
     /** Convenience: archive a chat (soft-hide; safe for cleanup). */
     archiveChat(chatId: string, signal?: AbortSignal): Promise<void>;
@@ -925,6 +934,16 @@ interface CoderAgentSettings<TOOLS extends ToolSet = {}> {
     planMode?: "" | "plan";
     /** Resume an existing chat (session) instead of creating a new one. */
     chatId?: string;
+    /**
+     * Resume cursor for `chatId`: the newest chat message id a previous
+     * instance had already seen. Persist {@link CoderAgent.lastSeenMessageId}
+     * alongside the chat id when a turn ends and supply both here — the resumed
+     * turn then skips its pre-prompt seed GET (the single-message history probe
+     * that would otherwise establish the cursor). Without it, behavior is
+     * unchanged. Must be a positive integer obtained from the getter, and
+     * requires `chatId`; anything else fails construction.
+     */
+    lastSeenMessageId?: number;
     /** Stable agent id (exposed as {@link CoderAgent.id}). */
     id?: string;
     /** System instructions → chatd `system_prompt`. */
@@ -1030,6 +1049,14 @@ declare class CoderAgent<TOOLS extends ToolSet = {}> implements Agent<never, TOO
     get client(): CoderChatClient;
     /** The current chatd chat id, once a turn has started. */
     get chatId(): string | undefined;
+    /**
+     * The session's resume cursor: the newest chat message id observed, or
+     * `undefined` before any turn has streamed. Persist it alongside
+     * {@link chatId} when a turn ends and supply both to a future instance
+     * ({@link CoderAgentSettings.lastSeenMessageId}) to skip the resumed turn's
+     * pre-prompt seed GET. Read it between turns, not mid-generation.
+     */
+    get lastSeenMessageId(): number | undefined;
     /**
      * The last chat id this agent created or attached to, retained for CLEANUP
      * even after the session was dropped — a fresh-chat stream failure discards
@@ -1187,6 +1214,17 @@ interface CoderLanguageModelConfig {
     planMode?: "" | "plan";
     /** Resume an existing chat instead of creating a new one. */
     chatId?: string;
+    /**
+     * Resume cursor for `chatId`: the newest chat message id a previous
+     * instance had already seen — persist {@link CoderLanguageModel.lastSeenMessageId}
+     * alongside the chat id and supply both here. Skips the resumed turn's
+     * pre-prompt seed GET (the single-message history probe that would
+     * otherwise establish the cursor); without it, behavior is unchanged and
+     * the seed GET remains the fallback. Must be a positive integer obtained
+     * from the getter, and requires `chatId` (the constructor rejects anything
+     * else — a wrong cursor would silently misattribute replayed history).
+     */
+    lastSeenMessageId?: number;
     /**
      * Per-segment time budget in milliseconds, applied to each model round-trip
      * (one `doStream`/`doGenerate` call: chat creation or message/tool-result
@@ -1241,6 +1279,16 @@ declare class CoderLanguageModel implements LanguageModelV4 {
     readonly supportedUrls: Record<string, RegExp[]>;
     constructor(config: CoderLanguageModelConfig);
     get chatId(): string | undefined;
+    /**
+     * The resume cursor: the newest chat message id this session has observed,
+     * or `undefined` before any turn has streamed (nothing to persist then —
+     * a fresh instance seeds from history instead). Persist it alongside
+     * {@link chatId} once a turn settles and supply both to a future instance
+     * ({@link CoderLanguageModelConfig.lastSeenMessageId}) to skip the resumed
+     * turn's pre-prompt seed GET. Read it between turns, not mid-generation:
+     * the cursor advances when a segment ends.
+     */
+    get lastSeenMessageId(): number | undefined;
     /**
      * The last chat id this model created or attached to, for CLEANUP targeting
      * only — generation always targets {@link chatId}. It survives
@@ -1303,6 +1351,34 @@ declare class CoderLanguageModel implements LanguageModelV4 {
     doGenerate(options: LanguageModelV4CallOptions): Promise<LanguageModelV4GenerateResult>;
 }
 
+/** Constructor options for {@link TurnTranslator}. */
+interface TurnTranslatorOptions {
+    dynamicToolNames: ReadonlySet<string>;
+    turnCursor?: number;
+    /**
+     * Tool-call ids whose results the session already submitted. With the
+     * stream retained across segments (and redialed with the turn's original
+     * cursor), a reconnect can replay a previous segment's `action_required`
+     * snapshot; re-emitting an already-answered call would make the AI SDK
+     * execute the tool a second time. A live reference — the set grows as
+     * later segments submit results.
+     */
+    submittedToolCallIds?: ReadonlySet<string>;
+    /**
+     * Present when the submission was QUEUED (`CreateChatMessageResponse`
+     * carried no committed `message`): `turnCursor` is then only the PRE-TURN
+     * cursor, and attribution is withheld until the queue entry materializes as
+     * this turn's own user message — see {@link QueuedSubmissionGate} for the
+     * correlation protocol. `id`/`content` come from the response's
+     * `queued_message`; either may be absent on unexpected wire shapes, which
+     * degrades matching (no confirmation / match-any) but never widens
+     * attribution beyond the first observed user message.
+     */
+    queuedSubmission?: {
+        id?: number;
+        content?: readonly ChatMessagePart[];
+    };
+}
 /**
  * Translates one chatd turn's {@link ChatStreamEvent} stream into a sequence of
  * `LanguageModelV4StreamPart`s for the AI SDK.
@@ -1323,27 +1399,40 @@ declare class CoderLanguageModel implements LanguageModelV4 {
  * Client (custom) tool calls are emitted from the reliable `action_required`
  * event and left for the AI SDK to execute. chatd's own server-side tools are
  * surfaced best-effort as `providerExecuted` tool calls/results.
+ *
+ * A QUEUED submission additionally starts behind an attribution gate: until
+ * the queue entry materializes as this turn's own user message, every event
+ * belongs to the chat's concurrent run and is withheld (see
+ * {@link QueuedSubmissionGate} and {@link TurnTranslatorOptions.queuedSubmission}).
  */
 declare class TurnTranslator {
     #private;
-    constructor(opts: {
-        dynamicToolNames: ReadonlySet<string>;
-        turnCursor?: number;
-        /**
-         * Tool-call ids whose results the session already submitted. With the
-         * stream retained across segments (and redialed with the turn's original
-         * cursor), a reconnect can replay a previous segment's `action_required`
-         * snapshot; re-emitting an already-answered call would make the AI SDK
-         * execute the tool a second time. A live reference — the set grows as
-         * later segments submit results.
-         */
-        submittedToolCallIds?: ReadonlySet<string>;
-    });
+    constructor(opts: TurnTranslatorOptions);
     get terminalStatus(): ChatStatus | undefined;
     /** Whether a client (custom) tool call has been emitted this turn. */
     get clientToolCallSeen(): boolean;
     get maxMessageId(): number;
     get error(): ChatErrorPayload | undefined;
+    /**
+     * The turn's EFFECTIVE attribution cursor: the constructor's `turnCursor`
+     * until a queued submission anchors, the materialized user message's id
+     * after. Distinct from the stream's redial cursor, which deliberately stays
+     * the turn's original `after_id` (see `streamChatEvents`).
+     */
+    get turnCursor(): number;
+    /**
+     * Whether a queued submission is still awaiting its own user-message
+     * snapshot (#114). While true, nothing is attributed to this turn — no
+     * content, usage, tool calls, or settle statuses — because the stream
+     * window still belongs to the chat's concurrent run.
+     */
+    get awaitingQueuedSubmission(): boolean;
+    /**
+     * Set when a queued submission's wait can never complete (see
+     * {@link QueuedSubmissionGate}); the model layer throws it so the turn
+     * fails fast instead of hanging until timeout/abort.
+     */
+    get queuedSubmissionDeadEnd(): ChatErrorPayload | undefined;
     ingest(ev: ChatStreamEvent): LanguageModelV4StreamPart[];
     finish(): LanguageModelV4StreamPart[];
 }
@@ -1512,4 +1601,4 @@ declare class CoderChatError extends CoderAgentError {
     constructor(payload: ChatErrorPayload);
 }
 
-export { CHAT_ATTACHMENT_MEDIA_TYPES, CODER_PROVIDER_OPTIONS, type Chat, type ChatAttachment, type ChatAttachmentMediaType, type ChatBusyBehavior, type ChatClientType, type ChatErrorPayload, type ChatFileInput, type ChatInputPart, type ChatInputPartType, type ChatMessage, type ChatMessagePart, type ChatMessagePartType, type ChatMessageRole, type ChatMessageUsage, type ChatMessagesResponse, type ChatMessagesToUIMessagesOptions, type ChatModelConfig, type ChatPlanMode, type ChatQueuedMessage, type ChatStatus, type ChatStreamActionRequired, type ChatStreamEvent, type ChatStreamEventType, type ChatStreamMessagePart, type ChatStreamRetry, type ChatStreamStatus, type ChatStreamToolCall, type ChatWatchEvent, type ChatWatchEventKind, CoderAgent, CoderAgentError, type CoderAgentSettings, CoderApiError, type CoderArchiveResult, CoderChatClient, type CoderChatClientOptions, CoderChatError, type CoderClientOperation, type CoderFileProviderOptions, type CoderInterruptResult, CoderLanguageModel, type CoderLanguageModelConfig, CoderStreamError, type CoderTransportEvent, type CreateChatMessageRequest, type CreateChatMessageResponse, type CreateChatRequest, type DynamicTool, type FileContent, type FilePartUploader, type HttpErrorTransportEvent, type HttpRequestTransportEvent, type HttpResponseTransportEvent, MAX_CHAT_FILE_SIZE_BYTES, type PreviewShareLevel, type ResolvedFile, type SegmentSettleTransportEvent, type SegmentStartTransportEvent, type SharePreviewOptions, type SharedWorkspacePreview, type StreamCloseTransportEvent, type StreamDialTransportEvent, type StreamErrorTransportEvent, type StreamEventTransportEvent, type StreamOpenTransportEvent, type StreamRedialTransportEvent, type SubmitToolResultsRequest, TERMINAL_STATUSES, type ToolResult, type TransportEventHandler, type TurnAction, TurnTranslator, type UpdateChatRequest, type UploadChatFileResponse, type UploadedChatFile, type UserContent, type WatchChatEventsOptions, type WebSocketFactory, type WebSocketLike, type WorkspaceFileStore, type WorkspacePlacement, type WorkspacePreview, type WorkspacePreviewOptions, chatMessagesToUIMessages, classifyTurnAction, dataContentToFileContent, dynamicToolNames, extractSystemPrompt, resolveFileContent, streamChatEvents, toolsToDynamicTools, userContentToInputParts, watchChatEvents };
+export { CHAT_ATTACHMENT_MEDIA_TYPES, CODER_PROVIDER_OPTIONS, type Chat, type ChatAttachment, type ChatAttachmentMediaType, type ChatBusyBehavior, type ChatClientType, type ChatErrorPayload, type ChatFileInput, type ChatInputPart, type ChatInputPartType, type ChatMessage, type ChatMessagePart, type ChatMessagePartType, type ChatMessageRole, type ChatMessageUsage, type ChatMessagesResponse, type ChatMessagesToUIMessagesOptions, type ChatModelConfig, type ChatPlanMode, type ChatQueuedMessage, type ChatStatus, type ChatStreamActionRequired, type ChatStreamEvent, type ChatStreamEventType, type ChatStreamMessagePart, type ChatStreamRetry, type ChatStreamStatus, type ChatStreamToolCall, type ChatWatchEvent, type ChatWatchEventKind, CoderAgent, CoderAgentError, type CoderAgentSettings, CoderApiError, type CoderArchiveResult, CoderChatClient, type CoderChatClientOptions, CoderChatError, type CoderClientOperation, type CoderFileProviderOptions, type CoderInterruptResult, CoderLanguageModel, type CoderLanguageModelConfig, CoderStreamError, type CoderTransportEvent, type CreateChatMessageRequest, type CreateChatMessageResponse, type CreateChatRequest, type DynamicTool, type FileContent, type FilePartUploader, type HttpErrorTransportEvent, type HttpRequestTransportEvent, type HttpResponseTransportEvent, MAX_CHAT_FILE_SIZE_BYTES, type PreviewShareLevel, type ResolvedFile, type SegmentSettleTransportEvent, type SegmentStartTransportEvent, type SharePreviewOptions, type SharedWorkspacePreview, type StreamCloseTransportEvent, type StreamDialTransportEvent, type StreamErrorTransportEvent, type StreamEventTransportEvent, type StreamOpenTransportEvent, type StreamRedialTransportEvent, type SubmitToolResultsRequest, TERMINAL_STATUSES, type ToolResult, type TransportEventHandler, type TurnAction, TurnTranslator, type TurnTranslatorOptions, type UpdateChatRequest, type UploadChatFileResponse, type UploadedChatFile, type UserContent, type WatchChatEventsOptions, type WebSocketFactory, type WebSocketLike, type WorkspaceFileStore, type WorkspacePlacement, type WorkspacePreview, type WorkspacePreviewOptions, chatMessagesToUIMessages, classifyTurnAction, dataContentToFileContent, dynamicToolNames, extractSystemPrompt, resolveFileContent, streamChatEvents, toolsToDynamicTools, userContentToInputParts, watchChatEvents };