agents 0.11.5 → 0.11.6

package/dist/browser/ai.js

@@ -1,4 +1,4 @@
-import { n as SEARCH_DESCRIPTION, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-BovR6hRc.js";
+import { n as SEARCH_DESCRIPTION, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-mfBbxjS1.js";
 import { z } from "zod";
 import { tool } from "ai";
 //#region src/browser/ai.ts

package/dist/browser/index.js

@@ -1,2 +1,2 @@
-import { a as connectBrowser, i as CdpSession, n as SEARCH_DESCRIPTION, o as connectUrl, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-BovR6hRc.js";
+import { a as connectBrowser, i as CdpSession, n as SEARCH_DESCRIPTION, o as connectUrl, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-mfBbxjS1.js";
 export { CdpSession, EXECUTE_DESCRIPTION, SEARCH_DESCRIPTION, connectBrowser, connectUrl, createBrowserToolHandlers };

package/dist/browser/tanstack-ai.js

@@ -1,4 +1,4 @@
-import { n as SEARCH_DESCRIPTION, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-BovR6hRc.js";
+import { n as SEARCH_DESCRIPTION, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-mfBbxjS1.js";
 import { z } from "zod";
 import { toolDefinition } from "@tanstack/ai";
 //#region src/browser/tanstack-ai.ts

package/dist/browser/tanstack-ai.js.map

@@ -1 +1 @@
-{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../src/browser/tanstack-ai.ts"],"sourcesContent":["import { toolDefinition } from \"@tanstack/ai\";\nimport type { ServerTool } from \"@tanstack/ai\";\nimport { z } from \"zod\";\nimport {\n  createBrowserToolHandlers,\n  SEARCH_DESCRIPTION,\n  EXECUTE_DESCRIPTION,\n  type BrowserToolsOptions\n} from \"./shared\";\n\nexport type { BrowserToolsOptions } from \"./shared\";\n\n/**\n * Create TanStack AI tools for browser automation via CDP code mode.\n *\n * Returns an array of `ServerTool`s: `browser_search` (query the CDP spec)\n * and `browser_execute` (run CDP commands against a live browser).\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * const browserTools = createBrowserTools({\n *   browser: env.BROWSER,\n *   loader: env.LOADER,\n * });\n *\n * const stream = chat({\n *   adapter: openaiText(\"gpt-4o\"),\n *   tools: [...browserTools, ...otherTools],\n *   messages,\n * });\n * ```\n */\nexport function createBrowserTools(options: BrowserToolsOptions): ServerTool[] {\n  const handlers = createBrowserToolHandlers(options);\n\n  const search = toolDefinition({\n    name: \"browser_search\" as const,\n    description: SEARCH_DESCRIPTION,\n    inputSchema: z.object({\n      code: z.string().meta({\n        description: \"JavaScript async arrow function that queries the CDP spec\"\n      })\n    })\n  }).server(async ({ code }) => {\n    const result = await handlers.search(code);\n    if (result.isError) {\n      throw new Error(result.text);\n    }\n    return { text: result.text };\n  });\n\n  const execute = toolDefinition({\n    name: \"browser_execute\" as const,\n    description: EXECUTE_DESCRIPTION,\n    inputSchema: z.object({\n      code: z.string().meta({\n        description: \"JavaScript async arrow function that uses the cdp helper\"\n      })\n    })\n  }).server(async ({ code }) => {\n    const result = await handlers.execute(code);\n    if (result.isError) {\n      throw new Error(result.text);\n    }\n    return { text: result.text };\n  });\n\n  return [search, execute];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,mBAAmB,SAA4C;CAC7E,MAAM,WAAW,0BAA0B,QAAQ;AAkCnD,QAAO,CAhCQ,eAAe;EAC5B,MAAM;EACN,aAAa;EACb,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,QAAQ,CAAC,KAAK,EACpB,aAAa,6DACd,CAAC,EACH,CAAC;EACH,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,MAAM,SAAS,MAAM,SAAS,OAAO,KAAK;AAC1C,MAAI,OAAO,QACT,OAAM,IAAI,MAAM,OAAO,KAAK;AAE9B,SAAO,EAAE,MAAM,OAAO,MAAM;GAC5B,EAEc,eAAe;EAC7B,MAAM;EACN,aAAa;EACb,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,QAAQ,CAAC,KAAK,EACpB,aAAa,4DACd,CAAC,EACH,CAAC;EACH,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,MAAM,SAAS,MAAM,SAAS,QAAQ,KAAK;AAC3C,MAAI,OAAO,QACT,OAAM,IAAI,MAAM,OAAO,KAAK;AAE9B,SAAO,EAAE,MAAM,OAAO,MAAM;GAC5B,CAEsB"}
+{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../src/browser/tanstack-ai.ts"],"sourcesContent":["import { toolDefinition } from \"@tanstack/ai\";\nimport type { ServerTool } from \"@tanstack/ai\";\nimport { z } from \"zod\";\nimport {\n  createBrowserToolHandlers,\n  SEARCH_DESCRIPTION,\n  EXECUTE_DESCRIPTION,\n  type BrowserToolsOptions\n} from \"./shared\";\n\nexport type { BrowserToolsOptions } from \"./shared\";\n\n/**\n * Create TanStack AI tools for browser automation via CDP code mode.\n *\n * Returns an array of `ServerTool`s: `browser_search` (query the CDP spec)\n * and `browser_execute` (run CDP commands against a live browser).\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * const browserTools = createBrowserTools({\n *   browser: env.BROWSER,\n *   loader: env.LOADER,\n * });\n *\n * const stream = chat({\n *   adapter: openaiText(\"gpt-4o\"),\n *   tools: [...browserTools, ...otherTools],\n *   messages,\n * });\n * ```\n */\nexport function createBrowserTools(options: BrowserToolsOptions): ServerTool[] {\n  const handlers = createBrowserToolHandlers(options);\n\n  const search = toolDefinition({\n    name: \"browser_search\" as const,\n    description: SEARCH_DESCRIPTION,\n    inputSchema: z.object({\n      code: z.string().meta({\n        description: \"JavaScript async arrow function that queries the CDP spec\"\n      })\n    })\n  }).server(async ({ code }) => {\n    const result = await handlers.search(code);\n    if (result.isError) {\n      throw new Error(result.text);\n    }\n    return { text: result.text };\n  });\n\n  const execute = toolDefinition({\n    name: \"browser_execute\" as const,\n    description: EXECUTE_DESCRIPTION,\n    inputSchema: z.object({\n      code: z.string().meta({\n        description: \"JavaScript async arrow function that uses the cdp helper\"\n      })\n    })\n  }).server(async ({ code }) => {\n    const result = await handlers.execute(code);\n    if (result.isError) {\n      throw new Error(result.text);\n    }\n    return { text: result.text };\n  });\n\n  return [search, execute];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,mBAAmB,SAA4C;CAC7E,MAAM,WAAW,0BAA0B,QAAQ;AAkCnD,QAAO,CAhCQ,eAAe;EAC5B,MAAM;EACN,aAAa;EACb,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,QAAQ,CAAC,KAAK,EACpB,aAAa,6DACd,CAAC,EACH,CAAC;EACH,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,MAAM,SAAS,MAAM,SAAS,OAAO,KAAK;AAC1C,MAAI,OAAO,QACT,OAAM,IAAI,MAAM,OAAO,KAAK;AAE9B,SAAO,EAAE,MAAM,OAAO,MAAM;GAmBhB,EAhBE,eAAe;EAC7B,MAAM;EACN,aAAa;EACb,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,QAAQ,CAAC,KAAK,EACpB,aAAa,4DACd,CAAC,EACH,CAAC;EACH,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,MAAM,SAAS,MAAM,SAAS,QAAQ,KAAK;AAC3C,MAAI,OAAO,QACT,OAAM,IAAI,MAAM,OAAO,KAAK;AAE9B,SAAO,EAAE,MAAM,OAAO,MAAM;GAGP,CAAC"}

package/dist/chat/index.d.ts

@@ -188,6 +188,147 @@ declare class TurnQueue {
   private _decrementCount;
 }
 //#endregion
+//#region src/chat/client-tools.d.ts
+/**
+ * Wire-format tool schema sent from the client.
+ * Uses `parameters` (JSONSchema7) rather than AI SDK's `inputSchema`
+ * because Zod schemas cannot be serialized over the wire.
+ */
+type ClientToolSchema = {
+  /** Unique name for the tool */name: string; /** Human-readable description of what the tool does */
+  description?: Tool["description"]; /** JSON Schema defining the tool's input parameters */
+  parameters?: JSONSchema7;
+};
+/**
+ * Converts client tool schemas to AI SDK tool format.
+ *
+ * These tools have no `execute` function — when the AI model calls them,
+ * the tool call is sent back to the client for execution.
+ *
+ * @param clientTools - Array of tool schemas from the client
+ * @returns Record of AI SDK tools that can be spread into your tools object
+ */
+declare function createToolsFromClientSchemas(clientTools?: ClientToolSchema[]): ToolSet;
+//#endregion
+//#region src/chat/lifecycle.d.ts
+/**
+ * Result passed to the `onChatResponse` lifecycle hook after a chat
+ * turn completes.
+ */
+type ChatResponseResult = {
+  /** The finalized assistant message from this turn. */message: UIMessage; /** The request ID associated with this turn. */
+  requestId: string; /** Whether this turn was a continuation of a previous assistant turn. */
+  continuation: boolean; /** How the turn ended. */
+  status: "completed" | "error" | "aborted"; /** Error message when `status` is `"error"`. */
+  error?: string;
+};
+/**
+ * Result returned by programmatic entry points that may skip execution
+ * when the chat state has been invalidated mid-flight (e.g. by a
+ * `CHAT_CLEAR` protocol message).
+ */
+type SaveMessagesResult = {
+  /** Server-generated request ID for the chat turn. */requestId: string; /** Whether the turn ran or was skipped (e.g. because the chat was cleared). */
+  status: "completed" | "skipped";
+};
+/**
+ * Context passed to the `onChatRecovery` hook when an interrupted chat
+ * stream is detected after DO restart.
+ */
+type ChatRecoveryContext = {
+  /** Stream ID from the interrupted stream. */streamId: string; /** Request ID from the interrupted stream. */
+  requestId: string; /** Partial text extracted from stored chunks. */
+  partialText: string; /** Partial message parts reconstructed from chunks. */
+  partialParts: MessagePart[]; /** Checkpoint data from `this.stash()` during the interrupted stream. */
+  recoveryData: unknown | null; /** Current persisted messages. */
+  messages: UIMessage[]; /** Custom body from the last chat request. */
+  lastBody?: Record<string, unknown>; /** Client tool schemas from the last chat request. */
+  lastClientTools?: ClientToolSchema[];
+  /**
+   * Epoch milliseconds when the underlying fiber was started. Compare
+   * against `Date.now()` to suppress continuations for turns that have
+   * been orphaned too long to safely replay.
+   */
+  createdAt: number;
+};
+/**
+ * Options returned from `onChatRecovery` to control recovery behavior.
+ */
+type ChatRecoveryOptions = {
+  /** Save the partial response from stored chunks. Default: true. */persist?: boolean; /** Schedule a continuation via `continueLastTurn()`. Default: true. */
+  continue?: boolean;
+};
+/**
+ * Controls how overlapping user submit requests behave while another
+ * chat turn is already active or queued.
+ *
+ * - `"queue"` (default) — queue every submit and process them in order.
+ * - `"latest"` — keep only the latest overlapping submit; superseded
+ *   submits still persist their user messages, but do not start their
+ *   own model turn.
+ * - `"merge"` — coalesce overlapping submits into one model turn while
+ *   preserving the submitted user content. Exact persistence depends on
+ *   the chat package's message model.
+ * - `"drop"` — ignore overlapping submits entirely (messages not
+ *   persisted).
+ * - `{ strategy: "debounce", debounceMs? }` — trailing-edge latest with
+ *   a quiet window.
+ *
+ * Only applies to `submit-message` requests. Regenerations, tool
+ * continuations, approvals, clears, programmatic `saveMessages`, and
+ * `continueLastTurn` keep their existing serialized behavior.
+ */
+type MessageConcurrency = "queue" | "latest" | "merge" | "drop" | {
+  strategy: "debounce";
+  debounceMs?: number;
+};
+//#endregion
+//#region src/chat/submit-concurrency.d.ts
+type NormalizedMessageConcurrency = "queue" | "latest" | "merge" | "drop" | {
+  strategy: "debounce";
+  debounceMs: number;
+};
+type SubmitConcurrencyDecision = {
+  action: "execute" | "drop";
+  strategy: NormalizedMessageConcurrency | null;
+  submitSequence: number | null;
+  debounceUntilMs: number | null;
+};
+declare class SubmitConcurrencyController {
+  private readonly options;
+  private _submitSequence;
+  private _latestOverlappingSubmitSequence;
+  private _pendingEnqueueCount;
+  private _resetEpoch;
+  private _activeDebounceTimers;
+  private _activeDebounceResolves;
+  constructor(options: {
+    defaultDebounceMs: number;
+  });
+  get pendingEnqueueCount(): number;
+  get overlappingSubmitCount(): number;
+  decide(options: {
+    concurrency: MessageConcurrency;
+    isSubmitMessage: boolean;
+    queuedTurns: number;
+  }): SubmitConcurrencyDecision;
+  /**
+   * Mark a submit as accepted and in-flight between admission and turn
+   * queue registration. Returns an idempotent `release()` function that
+   * must be called when the submit either reaches the turn queue or is
+   * abandoned. The returned function is bound to the controller's reset
+   * epoch — releases from before the most recent `reset()` are no-ops,
+   * so post-reset submits keep an accurate count.
+   */
+  beginEnqueue(): () => void;
+  isSuperseded(submitSequence: number | null): boolean;
+  waitForTimestamp(timestampMs: number): Promise<void>;
+  cancelActiveDebounce(): void;
+  reset(): void;
+  waitForIdle(waitForQueueIdle: () => Promise<void>): Promise<void>;
+  private normalize;
+}
+//#endregion
 //#region src/chat/broadcast-state.d.ts
 type BroadcastStreamState = {
   status: "idle";
@@ -341,28 +482,6 @@ declare class ResumableStream {
   insertStaleStream(streamId: string, requestId: string, ageMs: number): void;
 }
 //#endregion
-//#region src/chat/client-tools.d.ts
-/**
- * Wire-format tool schema sent from the client.
- * Uses `parameters` (JSONSchema7) rather than AI SDK's `inputSchema`
- * because Zod schemas cannot be serialized over the wire.
- */
-type ClientToolSchema = {
-  /** Unique name for the tool */name: string; /** Human-readable description of what the tool does */
-  description?: Tool["description"]; /** JSON Schema defining the tool's input parameters */
-  parameters?: JSONSchema7;
-};
-/**
- * Converts client tool schemas to AI SDK tool format.
- *
- * These tools have no `execute` function — when the AI model calls them,
- * the tool call is sent back to the client for execution.
- *
- * @param clientTools - Array of tool schemas from the client
- * @returns Record of AI SDK tools that can be spread into your tools object
- */
-declare function createToolsFromClientSchemas(clientTools?: ClientToolSchema[]): ToolSet;
-//#endregion
 //#region src/chat/protocol.d.ts
 /**
  * Wire protocol message type constants for the cf_agent_chat_* protocol.
@@ -599,77 +718,32 @@ type ChatProtocolEvent = {
  */
 declare function parseProtocolMessage(raw: string): ChatProtocolEvent | null;
 //#endregion
-//#region src/chat/lifecycle.d.ts
+//#region src/chat/message-reconciler.d.ts
 /**
- * Result passed to the `onChatResponse` lifecycle hook after a chat
- * turn completes.
- */
-type ChatResponseResult = {
-  /** The finalized assistant message from this turn. */message: UIMessage; /** The request ID associated with this turn. */
-  requestId: string; /** Whether this turn was a continuation of a previous assistant turn. */
-  continuation: boolean; /** How the turn ended. */
-  status: "completed" | "error" | "aborted"; /** Error message when `status` is `"error"`. */
-  error?: string;
-};
-/**
- * Result returned by programmatic entry points that may skip execution
- * when the chat state has been invalidated mid-flight (e.g. by a
- * `CHAT_CLEAR` protocol message).
- */
-type SaveMessagesResult = {
-  /** Server-generated request ID for the chat turn. */requestId: string; /** Whether the turn ran or was skipped (e.g. because the chat was cleared). */
-  status: "completed" | "skipped";
-};
-/**
- * Context passed to the `onChatRecovery` hook when an interrupted chat
- * stream is detected after DO restart.
+ * Reconcile incoming client messages against server state.
+ *
+ * 1. Merges server-known tool outputs into incoming messages that still
+ *    show stale states (input-available, approval-requested, approval-responded)
+ * 2. Reconciles assistant IDs: exact match → content-key match → toolCallId match
+ *
+ * @param incoming - Messages from the client
+ * @param serverMessages - Current server-side messages (source of truth)
+ * @param sanitizeForContentKey - Function to sanitize a message before computing
+ *   its content key (typically strips ephemeral provider metadata)
+ * @returns Reconciled messages ready for persistence
  */
-type ChatRecoveryContext = {
-  /** Stream ID from the interrupted stream. */streamId: string; /** Request ID from the interrupted stream. */
-  requestId: string; /** Partial text extracted from stored chunks. */
-  partialText: string; /** Partial message parts reconstructed from chunks. */
-  partialParts: MessagePart[]; /** Checkpoint data from `this.stash()` during the interrupted stream. */
-  recoveryData: unknown | null; /** Current persisted messages. */
-  messages: UIMessage[]; /** Custom body from the last chat request. */
-  lastBody?: Record<string, unknown>; /** Client tool schemas from the last chat request. */
-  lastClientTools?: ClientToolSchema[];
-  /**
-   * Epoch milliseconds when the underlying fiber was started. Compare
-   * against `Date.now()` to suppress continuations for turns that have
-   * been orphaned too long to safely replay.
-   */
-  createdAt: number;
-};
+declare function reconcileMessages(incoming: UIMessage[], serverMessages: readonly UIMessage[], sanitizeForContentKey?: (message: UIMessage) => UIMessage): UIMessage[];
 /**
- * Options returned from `onChatRecovery` to control recovery behavior.
+ * For a single message, resolve its ID by matching toolCallId against server state.
+ * Prevents duplicate DB rows when client IDs differ from server IDs.
+ * Tool call IDs are unique per conversation, so matching is safe regardless of state.
  */
-type ChatRecoveryOptions = {
-  /** Save the partial response from stored chunks. Default: true. */persist?: boolean; /** Schedule a continuation via `continueLastTurn()`. Default: true. */
-  continue?: boolean;
-};
+declare function resolveToolMergeId(message: UIMessage, serverMessages: readonly UIMessage[]): UIMessage;
 /**
- * Controls how overlapping user submit requests behave while another
- * chat turn is already active or queued.
- *
- * - `"queue"` (default) — queue every submit and process them in order.
- * - `"latest"` — keep only the latest overlapping submit; superseded
- *   submits still persist their user messages, but do not start their
- *   own model turn.
- * - `"merge"` — like `latest`, but all overlapping user messages remain
- *   in the conversation history. The model sees them all in one turn.
- * - `"drop"` — ignore overlapping submits entirely (messages not
- *   persisted).
- * - `{ strategy: "debounce", debounceMs? }` — trailing-edge latest with
- *   a quiet window.
- *
- * Only applies to `submit-message` requests. Regenerations, tool
- * continuations, approvals, clears, programmatic `saveMessages`, and
- * `continueLastTurn` keep their existing serialized behavior.
+ * Content key for assistant messages used for dedup of identical short replies.
+ * Returns JSON of sanitized parts, or undefined for non-assistant messages.
  */
-type MessageConcurrency = "queue" | "latest" | "merge" | "drop" | {
-  strategy: "debounce";
-  debounceMs?: number;
-};
+declare function assistantContentKey(message: UIMessage, sanitize?: (message: UIMessage) => UIMessage): string | undefined;
 //#endregion
-export { AbortRegistry, type BroadcastStreamEvent, type BroadcastStreamState, type TransitionResult as BroadcastTransitionResult, CHAT_MESSAGE_TYPES, type ChatProtocolEvent, type ChatRecoveryContext, type ChatRecoveryOptions, type ChatResponseResult, type ChunkAction, type ChunkResult, type ClientToolSchema, type ContinuationConnection, type ContinuationDeferred, type ContinuationPending, ContinuationState, type EnqueueOptions, type MessageConcurrency, type MessagePart, type MessageParts, ROW_MAX_BYTES, ResumableStream, type SaveMessagesResult, type SqlTaggedTemplate, StreamAccumulator, type StreamAccumulatorOptions, type StreamChunkData, type ToolPartUpdate, TurnQueue, type TurnResult, applyChunkToParts, applyToolUpdate, transition as broadcastTransition, byteLength, createToolsFromClientSchemas, enforceRowSizeLimit, parseProtocolMessage, sanitizeMessage, toolApprovalUpdate, toolResultUpdate };
+export { AbortRegistry, type BroadcastStreamEvent, type BroadcastStreamState, type TransitionResult as BroadcastTransitionResult, CHAT_MESSAGE_TYPES, type ChatProtocolEvent, type ChatRecoveryContext, type ChatRecoveryOptions, type ChatResponseResult, type ChunkAction, type ChunkResult, type ClientToolSchema, type ContinuationConnection, type ContinuationDeferred, type ContinuationPending, ContinuationState, type EnqueueOptions, type MessageConcurrency, type MessagePart, type MessageParts, type NormalizedMessageConcurrency, ROW_MAX_BYTES, ResumableStream, type SaveMessagesResult, type SqlTaggedTemplate, StreamAccumulator, type StreamAccumulatorOptions, type StreamChunkData, SubmitConcurrencyController, type SubmitConcurrencyDecision, type ToolPartUpdate, TurnQueue, type TurnResult, applyChunkToParts, applyToolUpdate, assistantContentKey, transition as broadcastTransition, byteLength, createToolsFromClientSchemas, enforceRowSizeLimit, parseProtocolMessage, reconcileMessages, resolveToolMergeId, sanitizeMessage, toolApprovalUpdate, toolResultUpdate };
 //# sourceMappingURL=index.d.ts.map

package/dist/chat/index.js

@@ -574,6 +574,126 @@ var TurnQueue = class {
 	}
 };
 //#endregion
+//#region src/chat/submit-concurrency.ts
+var SubmitConcurrencyController = class {
+	constructor(options) {
+		this.options = options;
+		this._submitSequence = 0;
+		this._latestOverlappingSubmitSequence = 0;
+		this._pendingEnqueueCount = 0;
+		this._resetEpoch = 0;
+		this._activeDebounceTimers = /* @__PURE__ */ new Set();
+		this._activeDebounceResolves = /* @__PURE__ */ new Set();
+	}
+	get pendingEnqueueCount() {
+		return this._pendingEnqueueCount;
+	}
+	get overlappingSubmitCount() {
+		return this._latestOverlappingSubmitSequence;
+	}
+	decide(options) {
+		const queuedTurnsInCurrentEpoch = options.queuedTurns + this._pendingEnqueueCount;
+		if (!options.isSubmitMessage || queuedTurnsInCurrentEpoch === 0) return {
+			action: "execute",
+			strategy: null,
+			submitSequence: null,
+			debounceUntilMs: null
+		};
+		const concurrency = this.normalize(options.concurrency);
+		if (concurrency === "drop") return {
+			action: "drop",
+			strategy: concurrency,
+			submitSequence: null,
+			debounceUntilMs: null
+		};
+		if (concurrency === "queue") return {
+			action: "execute",
+			strategy: concurrency,
+			submitSequence: null,
+			debounceUntilMs: null
+		};
+		const submitSequence = ++this._submitSequence;
+		this._latestOverlappingSubmitSequence = submitSequence;
+		if (concurrency === "latest" || concurrency === "merge") return {
+			action: "execute",
+			strategy: concurrency,
+			submitSequence,
+			debounceUntilMs: null
+		};
+		return {
+			action: "execute",
+			strategy: concurrency,
+			submitSequence,
+			debounceUntilMs: Date.now() + concurrency.debounceMs
+		};
+	}
+	/**
+	* Mark a submit as accepted and in-flight between admission and turn
+	* queue registration. Returns an idempotent `release()` function that
+	* must be called when the submit either reaches the turn queue or is
+	* abandoned. The returned function is bound to the controller's reset
+	* epoch — releases from before the most recent `reset()` are no-ops,
+	* so post-reset submits keep an accurate count.
+	*/
+	beginEnqueue() {
+		this._pendingEnqueueCount++;
+		const epoch = this._resetEpoch;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			if (this._resetEpoch !== epoch) return;
+			this._pendingEnqueueCount = Math.max(0, this._pendingEnqueueCount - 1);
+		};
+	}
+	isSuperseded(submitSequence) {
+		return submitSequence !== null && submitSequence < this._latestOverlappingSubmitSequence;
+	}
+	async waitForTimestamp(timestampMs) {
+		const remainingMs = timestampMs - Date.now();
+		if (remainingMs <= 0) return;
+		await new Promise((resolve) => {
+			const wrappedResolve = () => {
+				this._activeDebounceResolves.delete(wrappedResolve);
+				resolve();
+			};
+			const timer = setTimeout(() => {
+				this._activeDebounceTimers.delete(timer);
+				wrappedResolve();
+			}, remainingMs);
+			this._activeDebounceTimers.add(timer);
+			this._activeDebounceResolves.add(wrappedResolve);
+		});
+	}
+	cancelActiveDebounce() {
+		for (const timer of this._activeDebounceTimers) clearTimeout(timer);
+		this._activeDebounceTimers.clear();
+		const resolves = [...this._activeDebounceResolves];
+		this._activeDebounceResolves.clear();
+		for (const resolve of resolves) resolve();
+	}
+	reset() {
+		this._resetEpoch++;
+		this._pendingEnqueueCount = 0;
+		this.cancelActiveDebounce();
+	}
+	async waitForIdle(waitForQueueIdle) {
+		while (true) {
+			await waitForQueueIdle();
+			if (this._pendingEnqueueCount === 0) return;
+			await new Promise((resolve) => setTimeout(resolve, 5));
+		}
+	}
+	normalize(concurrency) {
+		if (typeof concurrency === "string") return concurrency;
+		const debounceMs = concurrency.debounceMs;
+		return {
+			strategy: "debounce",
+			debounceMs: typeof debounceMs === "number" && Number.isFinite(debounceMs) && debounceMs >= 0 ? debounceMs : this.options.defaultDebounceMs
+		};
+	}
+};
+//#endregion
 //#region src/chat/broadcast-state.ts
 function transition(state, event) {
 	switch (event.type) {
@@ -1300,6 +1420,117 @@ function parseProtocolMessage(raw) {
 	}
 }
 //#endregion
-export { AbortRegistry, CHAT_MESSAGE_TYPES, ContinuationState, ROW_MAX_BYTES, ResumableStream, StreamAccumulator, TurnQueue, applyChunkToParts, applyToolUpdate, transition as broadcastTransition, byteLength, createToolsFromClientSchemas, enforceRowSizeLimit, parseProtocolMessage, sanitizeMessage, toolApprovalUpdate, toolResultUpdate };
+//#region src/chat/message-reconciler.ts
+/**
+* Reconcile incoming client messages against server state.
+*
+* 1. Merges server-known tool outputs into incoming messages that still
+*    show stale states (input-available, approval-requested, approval-responded)
+* 2. Reconciles assistant IDs: exact match → content-key match → toolCallId match
+*
+* @param incoming - Messages from the client
+* @param serverMessages - Current server-side messages (source of truth)
+* @param sanitizeForContentKey - Function to sanitize a message before computing
+*   its content key (typically strips ephemeral provider metadata)
+* @returns Reconciled messages ready for persistence
+*/
+function reconcileMessages(incoming, serverMessages, sanitizeForContentKey) {
+	return reconcileAssistantIds(mergeServerToolOutputs(incoming, serverMessages), serverMessages, sanitizeForContentKey);
+}
+/**
+* For a single message, resolve its ID by matching toolCallId against server state.
+* Prevents duplicate DB rows when client IDs differ from server IDs.
+* Tool call IDs are unique per conversation, so matching is safe regardless of state.
+*/
+function resolveToolMergeId(message, serverMessages) {
+	if (message.role !== "assistant") return message;
+	for (const part of message.parts) if ("toolCallId" in part && part.toolCallId) {
+		const toolCallId = part.toolCallId;
+		const existing = findMessageByToolCallId(serverMessages, toolCallId);
+		if (existing && existing.id !== message.id) return {
+			...message,
+			id: existing.id
+		};
+	}
+	return message;
+}
+/**
+* Content key for assistant messages used for dedup of identical short replies.
+* Returns JSON of sanitized parts, or undefined for non-assistant messages.
+*/
+function assistantContentKey(message, sanitize) {
+	if (message.role !== "assistant") return;
+	const sanitized = sanitize ? sanitize(message) : message;
+	return JSON.stringify(sanitized.parts);
+}
+function mergeServerToolOutputs(incoming, serverMessages) {
+	const serverToolOutputs = /* @__PURE__ */ new Map();
+	for (const msg of serverMessages) {
+		if (msg.role !== "assistant") continue;
+		for (const part of msg.parts) if ("toolCallId" in part && "state" in part && part.state === "output-available" && "output" in part) serverToolOutputs.set(part.toolCallId, part.output);
+	}
+	if (serverToolOutputs.size === 0) return incoming;
+	return incoming.map((msg) => {
+		if (msg.role !== "assistant") return msg;
+		let hasChanges = false;
+		const updatedParts = msg.parts.map((part) => {
+			if ("toolCallId" in part && "state" in part && (part.state === "input-available" || part.state === "approval-requested" || part.state === "approval-responded") && serverToolOutputs.has(part.toolCallId)) {
+				hasChanges = true;
+				return {
+					...part,
+					state: "output-available",
+					output: serverToolOutputs.get(part.toolCallId)
+				};
+			}
+			return part;
+		});
+		return hasChanges ? {
+			...msg,
+			parts: updatedParts
+		} : msg;
+	});
+}
+function reconcileAssistantIds(incoming, serverMessages, sanitize) {
+	if (serverMessages.length === 0) return incoming;
+	const claimedServerIndices = /* @__PURE__ */ new Set();
+	const exactMatchMap = /* @__PURE__ */ new Map();
+	for (let i = 0; i < incoming.length; i++) {
+		const serverIdx = serverMessages.findIndex((sm, si) => !claimedServerIndices.has(si) && sm.id === incoming[i].id);
+		if (serverIdx !== -1) {
+			claimedServerIndices.add(serverIdx);
+			exactMatchMap.set(i, serverIdx);
+		}
+	}
+	return incoming.map((incomingMessage, incomingIdx) => {
+		if (exactMatchMap.has(incomingIdx)) return incomingMessage;
+		if (incomingMessage.role !== "assistant" || hasToolCallPart(incomingMessage)) return incomingMessage;
+		const incomingKey = assistantContentKey(incomingMessage, sanitize);
+		if (!incomingKey) return incomingMessage;
+		for (let i = 0; i < serverMessages.length; i++) {
+			if (claimedServerIndices.has(i)) continue;
+			const serverMessage = serverMessages[i];
+			if (serverMessage.role !== "assistant" || hasToolCallPart(serverMessage)) continue;
+			if (assistantContentKey(serverMessage, sanitize) === incomingKey) {
+				claimedServerIndices.add(i);
+				return {
+					...incomingMessage,
+					id: serverMessage.id
+				};
+			}
+		}
+		return incomingMessage;
+	});
+}
+function hasToolCallPart(message) {
+	return message.parts.some((part) => "toolCallId" in part);
+}
+function findMessageByToolCallId(messages, toolCallId) {
+	for (const msg of messages) {
+		if (msg.role !== "assistant") continue;
+		for (const part of msg.parts) if ("toolCallId" in part && part.toolCallId === toolCallId) return msg;
+	}
+}
+//#endregion
+export { AbortRegistry, CHAT_MESSAGE_TYPES, ContinuationState, ROW_MAX_BYTES, ResumableStream, StreamAccumulator, SubmitConcurrencyController, TurnQueue, applyChunkToParts, applyToolUpdate, assistantContentKey, transition as broadcastTransition, byteLength, createToolsFromClientSchemas, enforceRowSizeLimit, parseProtocolMessage, reconcileMessages, resolveToolMergeId, sanitizeMessage, toolApprovalUpdate, toolResultUpdate };
 
 //# sourceMappingURL=index.js.map