@coder/ai-sdk-agent 0.8.0 → 0.9.1

package/dist/index.d.ts

@@ -344,12 +344,27 @@ interface TransportEventBase {
     /** Wall-clock observation time in ms since epoch (`Date.now()`). */
     timestamp: number;
 }
+/**
+ * Names the `CoderChatClient` operation performing an HTTP exchange (issue
+ * #112). The public client method names are the stable vocabulary, so
+ * subscribers can classify per-operation timings without reverse-engineering
+ * `path` (whose API prefix is private and may change). New client methods
+ * extend this union; treat unrecognized values as "some other operation"
+ * rather than matching exhaustively.
+ */
+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
      * per client instance.
      */
     id: number;
+    /**
+     * The client operation performing this exchange — the public
+     * `CoderChatClient` method name. `archiveChat` stamps its own operation
+     * even though it issues the same `PATCH` as `updateChat`.
+     */
+    op: CoderClientOperation;
     /** HTTP method, e.g. `POST`. */
     method: string;
     /**
@@ -415,14 +430,31 @@ interface StreamOpenTransportEvent extends StreamTransportEventBase {
 }
 /**
  * A decoded stream event arrived on the wire. Emitted at arrival time for
- * every event in a frame batch, BEFORE replay dedup — after a redial, chatd's
- * replay of the in-progress episode is visible here even though the reader
- * suppresses the duplicates it forwards. `event` is the decoded object by
- * reference (no copy): do not mutate it.
+ * every event in a frame batch — after a redial, chatd's replay of the
+ * in-progress episode is still visible here, stamped with the reader's own
+ * replay verdict (`forwarded`). `event` is the decoded object by reference
+ * (no copy): do not mutate it.
  */
 interface StreamEventTransportEvent extends StreamTransportEventBase {
     type: "ws:event";
     event: ChatStreamEvent;
+    /**
+     * The reader's replay disposition for this frame (issue #111): `false`
+     * exactly when the episode filter suppresses it from the consumption path —
+     * a redial's replay of an in-progress delta at or below the last yielded
+     * `seq` of the same episode — and `true` when the reader forwards it to its
+     * consumer. It is a dedup verdict, not a delivery receipt: a consumer
+     * tearing down mid-queue can still discard a forwarded frame.
+     *
+     * Snapshot dedup is deliberately NOT reflected here: repeated or revised
+     * `message` snapshots are always `forwarded: true`, because reconciling
+     * them is the consumer's job past the transport layer — TurnTranslator's
+     * per-message emitted-content ledger decides what a revision re-emits.
+     * That disposition is not stamped on transport frames; subscribers needing
+     * content fidelity must consume model output (or TurnTranslator), not
+     * `ws:event`.
+     */
+    forwarded: boolean;
 }
 /**
  * The connection ended. Exactly one per dial: carries `code`/`reason` when
@@ -586,7 +618,10 @@ interface StreamChatEventsOptions {
  * in-progress generation attempt's `message_part` deltas from `seq` 1, so
  * parts of an episode
  * (`history_version`, `generation_attempt`) at or below the last yielded `seq`
- * are suppressed here rather than double-yielded. The iteration ends in five
+ * are suppressed here rather than double-yielded. That episode filter runs at
+ * frame arrival (not at consumption), so each frame's `ws:event` can carry
+ * the reader's own verdict as `forwarded` (issue #111) while `timestamp`
+ * keeps meaning arrival time. The iteration ends in five
  * ways: `signal` aborting (clean return), a non-transient 4xx upgrade
  * rejection (terminal {@link CoderApiError} — bad/expired token or a deleted
  * chat cannot succeed on retry, while 408/425/429 consume the redial budget),
@@ -690,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>;
@@ -815,6 +859,37 @@ interface ChatAttachment extends UploadedChatFile {
      */
     toFilePart(): FilePart;
 }
+/**
+ * Result of {@link CoderAgent.interrupt}: `interrupted: false` means there was
+ * no chat to interrupt (neither a live session nor a
+ * {@link CoderAgent.lastKnownChatId}) and no server call was made.
+ */
+type CoderInterruptResult = {
+    interrupted: true;
+    chatId: string;
+} | {
+    interrupted: false;
+    chatId?: undefined;
+};
+/**
+ * Result of {@link CoderAgent.archive}: `archived: false` means there was no
+ * chat to archive (neither a live session nor a
+ * {@link CoderAgent.lastKnownChatId}) and no server call was made. Failures
+ * still throw — see {@link CoderAgent.archive}. `chatId` is the primary
+ * target (the session's or last-known chat); `archivedChatIds` additionally
+ * lists every chat archived by the call, oldest first — more than one when
+ * earlier stranded chats ({@link CoderAgent.strandedChatIds}) were retired
+ * alongside it.
+ */
+type CoderArchiveResult = {
+    archived: true;
+    chatId: string;
+    archivedChatIds: string[];
+} | {
+    archived: false;
+    chatId?: undefined;
+    archivedChatIds?: undefined;
+};
 interface CoderAgentSettings<TOOLS extends ToolSet = {}> {
     /**
      * A pre-built {@link CoderChatClient}, used instead of constructing one from
@@ -859,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`. */
@@ -964,6 +1049,33 @@ 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
+     * the session ({@link CoderAgent.chatId} becomes `undefined`, so a retry
+     * starts fresh), but the failed chat still exists server-side.
+     * {@link CoderAgent.archive} and {@link CoderAgent.interrupt} fall back to
+     * this id; generation never does. Superseded when a later turn creates or
+     * attaches to another chat; cleared once {@link CoderAgent.archive}
+     * succeeds against it.
+     */
+    get lastKnownChatId(): string | undefined;
+    /**
+     * Chat ids stranded by automatic session discards and not yet cleaned up,
+     * oldest first. Each retryable fresh-chat stream failure strands one chat,
+     * so with `maxRetries` > 0 several can accumulate while only the final
+     * attempt's error (and {@link CoderAgent.lastKnownChatId}) names the
+     * newest. {@link CoderAgent.archive} retires all of them.
+     */
+    get strandedChatIds(): string[];
     generate(options: Parameters<InnerAgent<TOOLS>["generate"]>[0]): ReturnType<InnerAgent<TOOLS>["generate"]>;
     stream(options: Parameters<InnerAgent<TOOLS>["stream"]>[0]): ReturnType<InnerAgent<TOOLS>["stream"]>;
     /**
@@ -972,33 +1084,61 @@ declare class CoderAgent<TOOLS extends ToolSet = {}> implements Agent<never, TOO
      * `id`, `provider`/`model`, or `display_name`.
      */
     listModels(signal?: AbortSignal): Promise<ChatModelConfig[]>;
-    /** Start a fresh chatd chat on the next turn. */
+    /**
+     * Start a fresh chatd chat on the next turn. The dropped chat still exists
+     * server-side: {@link CoderAgent.archive} / {@link CoderAgent.interrupt}
+     * keep targeting it (via {@link CoderAgent.lastKnownChatId}) until a new
+     * chat supersedes it or an archive succeeds against it.
+     */
     resetSession(): void;
     /**
      * Interrupt the in-flight generation, if any. Resolves as soon as the server
      * acknowledges the interrupt — the run keeps winding down asynchronously for
      * a few seconds afterwards (see {@link CoderAgent.archive}).
+     *
+     * Targets the session's chat, or — after the session was dropped (a
+     * fresh-chat stream failure, or {@link CoderAgent.resetSession}) — the
+     * {@link CoderAgent.lastKnownChatId}, whose run may still be winding down
+     * server-side. With neither, there is nothing to interrupt and it resolves
+     * `{ interrupted: false }` without a server call (inspect the result rather
+     * than relying on a silent no-op).
      */
     interrupt(opts?: {
         signal?: AbortSignal;
-    }): Promise<void>;
+    }): Promise<CoderInterruptResult>;
     /**
      * Archive the underlying chat (safe cleanup; hides it from listings).
      *
+     * Targets the session's chat, or — after the session was dropped (a
+     * fresh-chat stream failure, or {@link CoderAgent.resetSession}) — the
+     * {@link CoderAgent.lastKnownChatId}, so the stranded chat is still cleaned
+     * up; chats stranded by EARLIER automatic discards
+     * ({@link CoderAgent.strandedChatIds} — `maxRetries` can accumulate several)
+     * are retired in the same call. On success each archived id is cleared as a
+     * cleanup target; with no id at all, there is nothing to archive and it
+     * resolves `{ archived: false }` without a server call (inspect the result
+     * rather than relying on a silent no-op).
+     *
      * A freshly interrupted/settled chat can keep winding down server-side for a
      * few seconds, during which the server rejects archiving with a 409. Those
-     * 409s are retried (~1s apart, ~15s overall — see `settleDeadlineMs` /
-     * `settleRetryDelayMs`) and the last one is rethrown if the chat never
-     * settles; any other failure, including a caller abort, rethrows immediately.
+     * 409s are retried (~1s apart — see `settleRetryDelayMs`) inside ONE
+     * `settleDeadlineMs` window (~15s) shared by the whole call — however many
+     * chats it archives — and the last 409 is rethrown if the window closes
+     * first; any other failure, including a caller abort, rethrows immediately.
+     * Chats are archived oldest first, each id cleared as its archive succeeds —
+     * a mid-list failure rethrows and leaves the remaining ids targetable by a
+     * later retry.
      */
     archive(opts?: {
         signal?: AbortSignal;
-    }): Promise<void>;
+    }): Promise<CoderArchiveResult>;
     /**
      * Clean up the chat when the agent leaves an `await using` scope, so cleanup
      * rides scope exit instead of a separate call you have to remember in a
      * `finally`. Interrupts any in-flight server run, then archives the chat
-     * (retrying while the interrupted run settles). Best-effort and bounded
+     * (retrying while the interrupted run settles) — including a chat stranded
+     * by a session discard (see {@link CoderAgent.lastKnownChatId}), which a
+     * failed `generate()` would otherwise leak. Best-effort and bounded
      * (~15s overall): disposal errors are swallowed after the bounded attempts
      * so they can't mask the scope's own error — call {@link CoderAgent.archive}
      * directly when you need guaranteed cleanup.
@@ -1074,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
@@ -1128,10 +1279,52 @@ 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
+     * {@link resetSession} (including the automatic session discard after a
+     * fresh-chat stream failure, which clears {@link chatId} so a retry starts
+     * fresh while the failed chat still exists server-side), is superseded when
+     * a later turn creates or attaches to another chat, and is cleared via
+     * {@link noteChatCleanedUp} once cleanup actually succeeded against it.
+     */
+    get lastKnownChatId(): string | undefined;
+    /**
+     * Chat ids stranded by automatic session discards and not yet cleaned up,
+     * oldest first. Each retryable fresh-chat stream failure strands one chat;
+     * under AI-SDK `maxRetries` several can accumulate while only the final
+     * attempt's error (and {@link lastKnownChatId}) names the newest —
+     * `CoderAgent.archive()` retires all of them. Ids leave the list only via
+     * {@link noteChatCleanedUp}.
+     */
+    get strandedChatIds(): string[];
+    /**
+     * Forgets `chatId` as a cleanup target — call it only after cleanup
+     * actually succeeded against that chat (e.g. `CoderAgent.archive()`
+     * archived it), so later cleanup calls don't re-target an already-archived
+     * chat: removes it from {@link strandedChatIds} and, when it is the
+     * last-known id, clears {@link lastKnownChatId} (match-guarded: a stale
+     * completion must not erase a newer chat's id). The session field
+     * ({@link chatId}) is deliberately untouched — archiving does not reset the
+     * session.
+     */
+    noteChatCleanedUp(chatId: string): void;
     /**
      * Drops the current session so the next turn creates a fresh chat. Also
      * closes the retained event stream, if any (fire-and-forget — a sync reset
      * must not wait on socket teardown, and `close()` never rejects).
+     * {@link lastKnownChatId} deliberately survives the reset: the dropped chat
+     * still exists server-side and cleanup must still be able to target it.
      */
     resetSession(): void;
     /**
@@ -1158,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.
@@ -1178,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[];
 }
@@ -1340,11 +1574,21 @@ declare class CoderApiError extends CoderAgentError {
  */
 declare class CoderStreamError extends APICallError {
     name: string;
+    /**
+     * The chatd chat id the failed turn had created or attached to, when known.
+     * A fresh-chat stream failure discards the session so a retry starts on a
+     * fresh chat (`CoderAgent.chatId` becomes `undefined`), but the failed chat
+     * still exists server-side — this field names it so callers can clean it up
+     * (`CoderAgent.archive()` also retains it as the last-known cleanup target).
+     * `undefined` when the failure happened before any chat existed.
+     */
+    readonly chatId: string | undefined;
     constructor(args: {
         message: string;
         url: string;
         cause?: unknown;
         isRetryable?: boolean;
+        chatId?: string;
     });
 }
 /** A chat generation ended in an error status. */
@@ -1357,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, CoderChatClient, type CoderChatClientOptions, CoderChatError, type CoderFileProviderOptions, 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 };