@librechat/agents 3.3.4 → 3.3.6

package/dist/esm/llm/preempt.mjs

@@ -0,0 +1,131 @@
+import "../common/constants.mjs";
+import "../common/enum.mjs";
+import "../common/index.mjs";
+//#region src/llm/preempt.ts
+/**
+* Normalizes a host-supplied seal budget.
+*
+* Read in two places that interpret it differently — a numeric comparison in
+* the seal gate and an addition into the recursion limit — so a value like
+* `1.5` would permit two seals while reserving fractional headroom, `NaN`
+* would poison the recursion limit outright, and `Infinity` would remove both
+* bounds at once. Normalizing once keeps the two readings in agreement.
+*
+* `0` is honored as a deliberate "never seal"; anything not finite falls back
+* to the default rather than silently disabling the feature.
+*/
+function resolveMaxSeals(maxSeals) {
+	if (maxSeals == null || !Number.isFinite(maxSeals)) return 8;
+	const whole = Math.floor(maxSeals);
+	return whole > 0 ? whole : 0;
+}
+/**
+* True when the accumulated content carries at least one non-whitespace text
+* block. `thinking` / `reasoning` blocks deliberately do not count: they are
+* stripped or signed on several providers and cannot stand in for the visible
+* assistant turn a sealed sequence needs.
+*/
+function hasNonEmptyTextContent(content) {
+	if (typeof content === "string") return content.trim() !== "";
+	for (const block of content) {
+		if (block.type !== "text") continue;
+		const text = block["text"];
+		if (typeof text === "string" && text.trim() !== "") return true;
+	}
+	return false;
+}
+/**
+* True while a Gemini server-side tool call is still awaiting its response.
+*
+* Google's server-side tools (Search, URL context) never populate
+* `tool_calls` or `tool_call_chunks` — those are derived from `functionCall`
+* parts only, while a server-side invocation arrives as a `toolCall` CONTENT
+* block and its result as a later `toolResponse` block. The tool-call gates
+* cannot see it, so sealing between the two would replay a model turn holding
+* an unanswered server-side call.
+*
+* Counted rather than id-matched: Google answers calls in order, and counting
+* stays correct when a part omits its id.
+*/
+function hasOpenGoogleServerToolCall(content) {
+	if (typeof content === "string") return false;
+	let calls = 0;
+	let responses = 0;
+	for (const block of content) if (block.type === "toolCall") calls += 1;
+	else if (block.type === "toolResponse") responses += 1;
+	return calls > responses;
+}
+/**
+* Ids of Anthropic server-side tool calls whose paired result block is already
+* on the accumulated content. Those calls are answered and cannot be orphaned
+* by a seal.
+*/
+function settledServerToolCallIds(content) {
+	const settled = /* @__PURE__ */ new Set();
+	if (typeof content === "string") return settled;
+	for (const block of content) {
+		if (block.type !== "web_search_tool_result") continue;
+		const id = block.tool_use_id;
+		if (typeof id === "string") settled.add(id);
+	}
+	return settled;
+}
+/** Tool calls still awaiting an answer, ignoring ones already settled. */
+function countOpenToolCalls(calls, settled) {
+	if (calls == null || calls.length === 0) return 0;
+	if (settled.size === 0) return calls.length;
+	let open = 0;
+	for (const call of calls) if (call.id == null || !settled.has(call.id)) open += 1;
+	return open;
+}
+/**
+* Cooperative mid-generation seal gate. Returns true ONLY when sealing here
+* yields a message sequence valid on EVERY supported provider:
+*  - non-whitespace TEXT content, so the FIRST injected user turn is preceded
+*    by a non-empty assistant turn — no empty-content 400s. Note this says
+*    nothing about adjacency AMONG several injected turns: a boundary that
+*    drains two steers emits two consecutive user messages, which strict
+*    providers reject. That is normalized at the provider-facing hop by
+*    `coalesceAdjacentUserTurns`, not here;
+*  - no tool call in flight, so no `tool_use` can be orphaned AND no eagerly
+*    prestarted execution can be stripped out from under the model.
+*
+* Anthropic's server-side tools need no check of their own. Every
+* `server_tool_use` content block also emits a `tool_call_chunk`
+* (`_makeMessageChunkFromAnthropicEvent`), and `concat` keeps that chunk on
+* the accumulated message for the remainder of the turn, so the tool-call
+* gates below already cover it. The practical consequence is worth stating
+* plainly: once a turn starts a web search it is no longer preemptible, and
+* a queued message waits for the ordinary tool boundary instead.
+*
+* Nothing is stripped and nothing is repaired: when the accumulated shape is
+* not already safe the stream simply runs on, and whatever the host queued
+* lands at the next tool boundary instead. Chunks accumulate monotonically
+* through `concat`, so an unsafe shape can never be observed at a seal point.
+*/
+function canSealPreempt(chunk) {
+	if (chunk == null) return false;
+	/**
+	* Anthropic's server-side tools run inside the provider, so unlike a client
+	* tool they never reach `ToolNode` and never produce a `PostToolBatch`
+	* boundary. `concat` also keeps their `server_tool_use` chunk on the
+	* accumulated message for the rest of the turn. Together that means a naive
+	* tool-call gate makes a turn permanently unsealable the moment a web
+	* search starts, with no later boundary to drain into — the queued message
+	* waits for the whole turn to finish rather than for the next tool step.
+	*
+	* So calls whose paired result block has already landed are treated as
+	* settled: they cannot be orphaned, because the provider has already
+	* answered them.
+	*/
+	const settled = settledServerToolCallIds(chunk.content);
+	if (countOpenToolCalls(chunk.tool_calls, settled) > 0) return false;
+	if (countOpenToolCalls(chunk.tool_call_chunks, settled) > 0) return false;
+	if ((chunk.invalid_tool_calls?.length ?? 0) > 0) return false;
+	if (hasOpenGoogleServerToolCall(chunk.content)) return false;
+	return hasNonEmptyTextContent(chunk.content);
+}
+//#endregion
+export { canSealPreempt, resolveMaxSeals };
+
+//# sourceMappingURL=preempt.mjs.map

package/dist/esm/llm/preempt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"preempt.mjs","names":[],"sources":["../../../src/llm/preempt.ts"],"sourcesContent":["// src/llm/preempt.ts\nimport type { AIMessageChunk } from '@langchain/core/messages';\nimport { ContentTypes, DEFAULT_MAX_SEALS } from '@/common';\n\n/**\n * Normalizes a host-supplied seal budget.\n *\n * Read in two places that interpret it differently — a numeric comparison in\n * the seal gate and an addition into the recursion limit — so a value like\n * `1.5` would permit two seals while reserving fractional headroom, `NaN`\n * would poison the recursion limit outright, and `Infinity` would remove both\n * bounds at once. Normalizing once keeps the two readings in agreement.\n *\n * `0` is honored as a deliberate \"never seal\"; anything not finite falls back\n * to the default rather than silently disabling the feature.\n */\nexport function resolveMaxSeals(maxSeals: number | undefined): number {\n  if (maxSeals == null || !Number.isFinite(maxSeals)) {\n    return DEFAULT_MAX_SEALS;\n  }\n  const whole = Math.floor(maxSeals);\n  return whole > 0 ? whole : 0;\n}\n\n/**\n * True when the accumulated content carries at least one non-whitespace text\n * block. `thinking` / `reasoning` blocks deliberately do not count: they are\n * stripped or signed on several providers and cannot stand in for the visible\n * assistant turn a sealed sequence needs.\n */\nfunction hasNonEmptyTextContent(content: AIMessageChunk['content']): boolean {\n  if (typeof content === 'string') {\n    return content.trim() !== '';\n  }\n  for (const block of content) {\n    if (block.type !== ContentTypes.TEXT) {\n      continue;\n    }\n    const text = block[ContentTypes.TEXT];\n    if (typeof text === 'string' && text.trim() !== '') {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * True while a Gemini server-side tool call is still awaiting its response.\n *\n * Google's server-side tools (Search, URL context) never populate\n * `tool_calls` or `tool_call_chunks` — those are derived from `functionCall`\n * parts only, while a server-side invocation arrives as a `toolCall` CONTENT\n * block and its result as a later `toolResponse` block. The tool-call gates\n * cannot see it, so sealing between the two would replay a model turn holding\n * an unanswered server-side call.\n *\n * Counted rather than id-matched: Google answers calls in order, and counting\n * stays correct when a part omits its id.\n */\nfunction hasOpenGoogleServerToolCall(\n  content: AIMessageChunk['content']\n): boolean {\n  if (typeof content === 'string') {\n    return false;\n  }\n  let calls = 0;\n  let responses = 0;\n  for (const block of content) {\n    if (block.type === 'toolCall') {\n      calls += 1;\n    } else if (block.type === 'toolResponse') {\n      responses += 1;\n    }\n  }\n  return calls > responses;\n}\n\n/**\n * Ids of Anthropic server-side tool calls whose paired result block is already\n * on the accumulated content. Those calls are answered and cannot be orphaned\n * by a seal.\n */\nfunction settledServerToolCallIds(\n  content: AIMessageChunk['content']\n): Set<string> {\n  const settled = new Set<string>();\n  if (typeof content === 'string') {\n    return settled;\n  }\n  for (const block of content) {\n    if (block.type !== 'web_search_tool_result') {\n      continue;\n    }\n    const id = block.tool_use_id;\n    if (typeof id === 'string') {\n      settled.add(id);\n    }\n  }\n  return settled;\n}\n\n/** Tool calls still awaiting an answer, ignoring ones already settled. */\nfunction countOpenToolCalls(\n  calls: ReadonlyArray<{ id?: string }> | undefined,\n  settled: Set<string>\n): number {\n  if (calls == null || calls.length === 0) {\n    return 0;\n  }\n  if (settled.size === 0) {\n    return calls.length;\n  }\n  let open = 0;\n  for (const call of calls) {\n    if (call.id == null || !settled.has(call.id)) {\n      open += 1;\n    }\n  }\n  return open;\n}\n\n/**\n * Cooperative mid-generation seal gate. Returns true ONLY when sealing here\n * yields a message sequence valid on EVERY supported provider:\n *  - non-whitespace TEXT content, so the FIRST injected user turn is preceded\n *    by a non-empty assistant turn — no empty-content 400s. Note this says\n *    nothing about adjacency AMONG several injected turns: a boundary that\n *    drains two steers emits two consecutive user messages, which strict\n *    providers reject. That is normalized at the provider-facing hop by\n *    `coalesceAdjacentUserTurns`, not here;\n *  - no tool call in flight, so no `tool_use` can be orphaned AND no eagerly\n *    prestarted execution can be stripped out from under the model.\n *\n * Anthropic's server-side tools need no check of their own. Every\n * `server_tool_use` content block also emits a `tool_call_chunk`\n * (`_makeMessageChunkFromAnthropicEvent`), and `concat` keeps that chunk on\n * the accumulated message for the remainder of the turn, so the tool-call\n * gates below already cover it. The practical consequence is worth stating\n * plainly: once a turn starts a web search it is no longer preemptible, and\n * a queued message waits for the ordinary tool boundary instead.\n *\n * Nothing is stripped and nothing is repaired: when the accumulated shape is\n * not already safe the stream simply runs on, and whatever the host queued\n * lands at the next tool boundary instead. Chunks accumulate monotonically\n * through `concat`, so an unsafe shape can never be observed at a seal point.\n */\nexport function canSealPreempt(chunk: AIMessageChunk | undefined): boolean {\n  if (chunk == null) {\n    return false;\n  }\n  /**\n   * Anthropic's server-side tools run inside the provider, so unlike a client\n   * tool they never reach `ToolNode` and never produce a `PostToolBatch`\n   * boundary. `concat` also keeps their `server_tool_use` chunk on the\n   * accumulated message for the rest of the turn. Together that means a naive\n   * tool-call gate makes a turn permanently unsealable the moment a web\n   * search starts, with no later boundary to drain into — the queued message\n   * waits for the whole turn to finish rather than for the next tool step.\n   *\n   * So calls whose paired result block has already landed are treated as\n   * settled: they cannot be orphaned, because the provider has already\n   * answered them.\n   */\n  const settled = settledServerToolCallIds(chunk.content);\n  if (countOpenToolCalls(chunk.tool_calls, settled) > 0) {\n    return false;\n  }\n  if (countOpenToolCalls(chunk.tool_call_chunks, settled) > 0) {\n    return false;\n  }\n  if ((chunk.invalid_tool_calls?.length ?? 0) > 0) {\n    return false;\n  }\n  if (hasOpenGoogleServerToolCall(chunk.content)) {\n    return false;\n  }\n  return hasNonEmptyTextContent(chunk.content);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,SAAgB,gBAAgB,UAAsC;CACpE,IAAI,YAAY,QAAQ,CAAC,OAAO,SAAS,QAAQ,GAC/C,OAAA;CAEF,MAAM,QAAQ,KAAK,MAAM,QAAQ;CACjC,OAAO,QAAQ,IAAI,QAAQ;AAC7B;;;;;;;AAQA,SAAS,uBAAuB,SAA6C;CAC3E,IAAI,OAAO,YAAY,UACrB,OAAO,QAAQ,KAAK,MAAM;CAE5B,KAAK,MAAM,SAAS,SAAS;EAC3B,IAAI,MAAM,SAAA,QACR;EAEF,MAAM,OAAO,MAAA;EACb,IAAI,OAAO,SAAS,YAAY,KAAK,KAAK,MAAM,IAC9C,OAAO;CAEX;CACA,OAAO;AACT;;;;;;;;;;;;;;AAeA,SAAS,4BACP,SACS;CACT,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,IAAI,QAAQ;CACZ,IAAI,YAAY;CAChB,KAAK,MAAM,SAAS,SAClB,IAAI,MAAM,SAAS,YACjB,SAAS;MACJ,IAAI,MAAM,SAAS,gBACxB,aAAa;CAGjB,OAAO,QAAQ;AACjB;;;;;;AAOA,SAAS,yBACP,SACa;CACb,MAAM,0BAAU,IAAI,IAAY;CAChC,IAAI,OAAO,YAAY,UACrB,OAAO;CAET,KAAK,MAAM,SAAS,SAAS;EAC3B,IAAI,MAAM,SAAS,0BACjB;EAEF,MAAM,KAAK,MAAM;EACjB,IAAI,OAAO,OAAO,UAChB,QAAQ,IAAI,EAAE;CAElB;CACA,OAAO;AACT;;AAGA,SAAS,mBACP,OACA,SACQ;CACR,IAAI,SAAS,QAAQ,MAAM,WAAW,GACpC,OAAO;CAET,IAAI,QAAQ,SAAS,GACnB,OAAO,MAAM;CAEf,IAAI,OAAO;CACX,KAAK,MAAM,QAAQ,OACjB,IAAI,KAAK,MAAM,QAAQ,CAAC,QAAQ,IAAI,KAAK,EAAE,GACzC,QAAQ;CAGZ,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,eAAe,OAA4C;CACzE,IAAI,SAAS,MACX,OAAO;;;;;;;;;;;;;;CAeT,MAAM,UAAU,yBAAyB,MAAM,OAAO;CACtD,IAAI,mBAAmB,MAAM,YAAY,OAAO,IAAI,GAClD,OAAO;CAET,IAAI,mBAAmB,MAAM,kBAAkB,OAAO,IAAI,GACxD,OAAO;CAET,KAAK,MAAM,oBAAoB,UAAU,KAAK,GAC5C,OAAO;CAET,IAAI,4BAA4B,MAAM,OAAO,GAC3C,OAAO;CAET,OAAO,uBAAuB,MAAM,OAAO;AAC7C"}

package/dist/esm/main.mjs

@@ -1,9 +1,10 @@
 import { isPresent, parseBooleanEnv, unescapeObject } from "./utils/misc.mjs";
-import { ANTHROPIC_TOOL_TOKEN_MULTIPLIER, DEFAULT_TOOL_TOKEN_MULTIPLIER } from "./common/constants.mjs";
+import { ANTHROPIC_TOOL_TOKEN_MULTIPLIER, DEFAULT_MAX_SEALS, DEFAULT_RECURSION_LIMIT, DEFAULT_TOOL_TOKEN_MULTIPLIER, PREEMPT_BOUNDARY_HOOK_TIMEOUT_MS } from "./common/constants.mjs";
 import { CODE_EXECUTION_TOOLS, Callback, CommonEvents, Constants, ContentTypes, EnvVar, GraphEvents, GraphNodeActions, GraphNodeKeys, LOCAL_CODING_BUNDLE_NAMES, LOCAL_CODING_TOOL_NAMES, Providers, StepTypes, TitleMethod, ToolCallTypes } from "./common/enum.mjs";
 import "./common/index.mjs";
 import { HARD_MAX_TOOL_RESULT_CHARS, HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE, calculateMaxToolResultChars, calculateMaxTotalToolOutputSize, truncateToolInput, truncateToolResultContent } from "./utils/truncation.mjs";
 import { IMAGE_TOKEN_SAFETY_MARGIN, TokenEncoderManager, apportionTokenCounts, createTokenCounter, encodingForModel, estimateAnthropicImageTokens, estimateDocumentBlockTokens, estimateImageBlockTokens, estimateOpenAIImageTokens, estimateTimedMediaBlockTokens, extractImageDimensions, getTokenCountForMessage, hasUnsafeStructuredSerialization } from "./utils/tokens.mjs";
+import { canSealPreempt } from "./llm/preempt.mjs";
 import { DEFAULT_PROMPT_CACHE_TTL, addBedrockCacheControl, addBedrockTailCacheControl, addCacheControl, addCacheControlToStablePrefixMessages, addTailCacheControl, buildAnthropicCacheControl, buildBedrockCachePoint, cloneMessage, resolveBedrockPromptCacheTtl, resolvePromptCacheTtl, stripAnthropicCacheControl, stripBedrockCacheControl, supportsBedrockToolCache } from "./messages/cache.mjs";
 import { convertMessagesToContent, findLastIndex, formatAnthropicArtifactContent, formatAnthropicMessage, formatArtifactPayload, getConverseOverrideMessage, modifyDeltaProperties, projectAnthropicArtifactContent, projectArtifactPayload, projectCacheControlledToolOutputsToText, projectComputerCallOutputsToText, projectOpenAIChatToolMessageContent, projectOpenAIResponsesToolMessageContent, projectOpenAIToolMessageContent, projectOpenRouterToolMessageContent, projectSingleTextToolOutputsToText, projectStructuredToolOutputsToText, projectToolStreamContentForProvider } from "./messages/core.mjs";
 import { getMessageId } from "./messages/ids.mjs";
@@ -15,13 +16,17 @@ import { ensureThinkingBlockInMessages, foldToolBlocksForToollessAgent, formatAg
 import { makeIsDeferred, partitionAndMarkAnthropicToolCache } from "./messages/anthropicToolCache.mjs";
 import { formatContentStrings, isLegacyConvertible } from "./messages/content.mjs";
 import { extractToolDiscoveries, hasToolSearchInCurrentTurn } from "./messages/tools.mjs";
+import { convertInjectedMessages } from "./messages/injected.mjs";
+import { coalesceAdjacentUserTurns, strictAlternationProviders } from "./messages/alternation.mjs";
+import { PREDECESSOR_HANDOFF_CUE, appendPredecessorHandoffCue, removePredecessorHandoffCue } from "./messages/handoffCue.mjs";
 import { REMOVE_ALL_MESSAGES, createRemoveAllMessage, messagesStateReducer } from "./messages/reducer.mjs";
 import { DEFAULT_RETAIN_RECENT_TURNS, splitAtRecencyBoundary } from "./messages/recency.mjs";
 import "./messages/index.mjs";
 import { joinKeys, resetIfNotEmpty } from "./utils/graph.mjs";
 import { isAnthropicLike, isGoogleLike, isOpenAILike } from "./utils/llm.mjs";
 import { handleServerToolResult, handleToolCallChunks, handleToolCalls, toolResultTypes } from "./tools/handlers.mjs";
-import { ChatModelStreamHandler, createContentAggregator, getChunkContent } from "./stream.mjs";
+import { INTENT_ARG, INTENT_DESCRIPTION, INTENT_PROPERTY, applyOutcome, isIntentLabelProperty, outcomeFieldsFromResult, readIntent, readOutcomeFields, resolveToolOutcome, stripIntent, withIntent } from "./tools/intentArg.mjs";
+import { ChatModelStreamHandler, SDK_STREAM_DISPATCH, createContentAggregator, dispatchesChatModelStream, getChunkContent } from "./stream.mjs";
 import { HandlerRegistry, LLMStreamHandler, ModelEndHandler, TestChatStreamHandler, TestLLMStreamHandler, ToolEndHandler, composeEventHandlers, createMetadataAggregator } from "./events.mjs";
 import { createHandlers } from "./utils/handlers.mjs";
 import { RunnableCallable, sleep } from "./utils/run.mjs";
@@ -47,7 +52,7 @@ import { DEFAULT_HOOK_TIMEOUT_MS, executeHooks } from "./hooks/executeHooks.mjs"
 import { createToolPolicyHook } from "./hooks/createToolPolicyHook.mjs";
 import { createWorkspacePolicyHook } from "./hooks/createWorkspacePolicyHook.mjs";
 import { HOOK_EVENTS } from "./hooks/types.mjs";
-import { HOOK_INJECTED_MESSAGES_CAPABLE } from "./hooks/index.mjs";
+import { HOOK_INJECTED_MESSAGES_CAPABLE, HOOK_PREEMPT_BOUNDARY_CAPABLE } from "./hooks/index.mjs";
 import { _createBashProgramForTests, applyPreToolUseHooksForBridge, createLocalBashProgrammaticToolCallingTool, createLocalProgrammaticToolCallingTool } from "./tools/local/LocalProgrammaticToolCalling.mjs";
 import { BashExecutionToolDefinition, BashExecutionToolDescription, BashExecutionToolName, BashExecutionToolSchema, BashToolOutputReferencesGuide, STATEFUL_BASH_NOTE, StatefulBashExecutionToolDescription, buildBashExecutionToolDescription, buildBashExecutionToolSchema, createBashExecutionTool } from "./tools/BashExecutor.mjs";
 import { LocalBashExecutionToolDescription, LocalCodeExecutionToolDescription, createLocalBashExecutionTool, createLocalCodeExecutionTool } from "./tools/local/LocalExecutionTools.mjs";
@@ -63,7 +68,7 @@ import { CLOUDFLARE_BASH_CODING_TOOL_NAMES, CLOUDFLARE_CODING_TOOL_NAMES, Cloudf
 import "./tools/cloudflare/index.mjs";
 import { resolveLocalExecutionTools, resolveLocalToolRegistry, resolveLocalToolsForBinding } from "./tools/local/resolveLocalExecutionTools.mjs";
 import "./tools/local/index.mjs";
-import { ToolNode, toolsCondition } from "./tools/ToolNode.mjs";
+import { ToolNode, createToolErrorOwnership, toolsCondition } from "./tools/ToolNode.mjs";
 import { SubagentExecutor, buildChildInputs, filterSubagentResult, resolveSubagentConfigs, summarizeEvent } from "./tools/subagent/SubagentExecutor.mjs";
 import "./tools/subagent/index.mjs";
 import { SubagentToolDefinition, SubagentToolDescription, SubagentToolName, SubagentToolSchema, buildSubagentToolParams, createSubagentToolDefinition } from "./tools/SubagentTool.mjs";
@@ -74,7 +79,6 @@ import { FakeChatModel, createFakeStreamingLLM } from "./llm/fake.mjs";
 import { Graph, StandardGraph } from "./graphs/Graph.mjs";
 import { MultiAgentGraph } from "./graphs/MultiAgentGraph.mjs";
 import { Run, defaultOmitOptions } from "./run.mjs";
-import { SEPARATORS, SplitStreamHandler } from "./splitStream.mjs";
 import "./graphs/index.mjs";
 import { projectAgentContextUsage } from "./agents/projection.mjs";
 import { Calculator, CalculatorSchema, CalculatorToolDefinition, CalculatorToolDescription, CalculatorToolName } from "./tools/Calculator.mjs";
@@ -83,7 +87,7 @@ import { ReadFileToolDefinition, ReadFileToolDescription, ReadFileToolName, Read
 import { formatSkillCatalog } from "./tools/skillCatalog.mjs";
 import { ToolSearchToolDefinition, ToolSearchToolDescription, ToolSearchToolName, ToolSearchToolSchema, countNestedGroups, createToolSearch, escapeRegexSpecialChars, extractMcpServerName, formatServerListing, getAvailableMcpServers, getBaseToolName, getDeferredToolsListing, hasNestedQuantifiers, isDangerousPattern, isFromAnyMcpServer, isFromMcpServer, normalizeServerFilter, performLocalSearch, sanitizeRegex } from "./tools/ToolSearch.mjs";
 import { DATE_RANGE, DEFAULT_COUNTRY_DESCRIPTION, DEFAULT_QUERY_DESCRIPTION, WebSearchToolDefinition, WebSearchToolDescription, WebSearchToolName, WebSearchToolSchema, countrySchema, dateSchema, imagesSchema, newsSchema, querySchema, videosSchema } from "./tools/search/schema.mjs";
-import { createSearchTool, executeParallelSearches } from "./tools/search/tool.mjs";
+import { createSearchTool, executeParallelSearches, resolveSearchOutcome } from "./tools/search/tool.mjs";
 import "./tools/search/index.mjs";
 import { deserializeMessage, extractTextFromContent, serializeMessage } from "./session/messageSerialization.mjs";
 import { JsonlSessionStore, SessionManager } from "./session/JsonlSessionStore.mjs";
@@ -98,4 +102,4 @@ import { Runnable, RunnableLambda, RunnableSequence } from "./langchain/runnable
 import { DynamicStructuredTool, StructuredTool, Tool, tool } from "./langchain/tools.mjs";
 import "./langchain/index.mjs";
 import { BaseCheckpointSaver, Command, INTERRUPT, MemorySaver, interrupt, isInterrupted } from "@langchain/langgraph";
-export { AIMessage, AIMessageChunk, ANTHROPIC_TOOL_TOKEN_MULTIPLIER, AgentSession, BASH_SHELL_GUIDANCE, BaseCheckpointSaver, BaseMessage, BaseMessageChunk, BashExecutionToolDefinition, BashExecutionToolDescription, BashExecutionToolName, BashExecutionToolSchema, BashProgrammaticToolCallingDefinition, BashProgrammaticToolCallingDescription, BashProgrammaticToolCallingName, BashProgrammaticToolCallingSchema, BashToolOutputReferencesGuide, CALIBRATION_RATIO_MAX, CALIBRATION_RATIO_MIN, CLOUDFLARE_BASH_CODING_TOOL_NAMES, CLOUDFLARE_CODING_TOOL_NAMES, CODE_API_AUTHORIZATION_ERROR_MESSAGE, CODE_API_EXECUTION_FAILED_ERROR_MESSAGE, CODE_API_INVALID_REQUEST_ERROR_MESSAGE, CODE_API_RATE_LIMITED_ERROR_MESSAGE, CODE_API_UNAVAILABLE_ERROR_MESSAGE, CODE_ARTIFACT_PATH_GUIDANCE, CODE_EXECUTION_TOOLS, Calculator, CalculatorSchema, CalculatorToolDefinition, CalculatorToolDescription, CalculatorToolName, Callback, ChatModelStreamHandler, ChatOpenRouter, CloudflareBashExecutionToolDescription, CloudflareCodeExecutionToolDescription, CodeApiRequestError, CodeExecutionToolDefinition, CodeExecutionToolDescription, CodeExecutionToolName, CodeExecutionToolSchema, Command, CommonEvents, CompileCheckToolName, Constants, ContentTypes, CustomOpenAIClient, DATE_RANGE, DEFAULT_CONTEXT_PRUNING_SETTINGS, DEFAULT_COUNTRY_DESCRIPTION, DEFAULT_HOOK_TIMEOUT_MS, DEFAULT_PROMPT_CACHE_TTL, DEFAULT_QUERY_DESCRIPTION, DEFAULT_RESERVE_RATIO, DEFAULT_RETAIN_RECENT_TURNS, DEFAULT_TOOL_TOKEN_MULTIPLIER, DynamicStructuredTool, EnvVar, FAILED_EXECUTION_FILE_REMINDER, FakeChatModel, Graph, GraphEvents, GraphNodeActions, GraphNodeKeys, HARD_MAX_TOOL_RESULT_CHARS, HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE, HOOK_EVENTS, HOOK_INJECTED_MESSAGES_CAPABLE, HandlerRegistry, HookRegistry, HumanMessage, IMAGE_TOKEN_SAFETY_MARGIN, INTERRUPT, JsonlSessionStore, LLMStreamHandler, LOCAL_CODING_BUNDLE_NAMES, LOCAL_CODING_TOOL_NAMES, LOCAL_SPAWN_TIMEOUT_MS, LocalBashExecutionToolDescription, LocalCodeExecutionToolDescription, LocalEditFileToolName, LocalEditFileToolSchema, LocalFileCheckpointerImpl, LocalGlobSearchToolName, LocalGlobSearchToolSchema, LocalGrepSearchToolName, LocalGrepSearchToolSchema, LocalListDirectoryToolName, LocalListDirectoryToolSchema, LocalReadFileToolSchema, LocalWriteFileToolName, LocalWriteFileToolSchema, MAX_CACHE_SIZE, MAX_PATTERN_LENGTH, MemorySaver, ModelEndHandler, MultiAgentGraph, ORIGINAL_CONTENT_MAX_CHARS, ProgrammaticToolCallingDefinition, ProgrammaticToolCallingDescription, ProgrammaticToolCallingName, ProgrammaticToolCallingSchema, PromptTemplate, Providers, REMOVE_ALL_MESSAGES, REPLY_PRIMER_TOKENS, ReadFileToolDefinition, ReadFileToolDescription, ReadFileToolName, ReadFileToolSchema, Run, Runnable, RunnableCallable, RunnableLambda, RunnableSequence, SEPARATORS, STATEFUL_BASH_NOTE, STATEFUL_ENV_NOTE, SessionManager, SkillToolDefinition, SkillToolDescription, SkillToolName, SkillToolSchema, SplitStreamHandler, StandardGraph, StatefulBashExecutionToolDescription, StatefulCodeExecutionToolDescription, StepTypes, StructuredTool, SubagentExecutor, SubagentToolDefinition, SubagentToolDescription, SubagentToolName, SubagentToolSchema, SystemMessage, TMP_SCRATCH_OUTPUT_REMINDER, TestChatStreamHandler, TestLLMStreamHandler, TitleMethod, TokenEncoderManager, Tool, ToolCallTypes, ToolEndHandler, ToolMessage, ToolNode, ToolSearchToolDefinition, ToolSearchToolDescription, ToolSearchToolName, ToolSearchToolSchema, WebSearchToolDefinition, WebSearchToolDescription, WebSearchToolName, WebSearchToolSchema, _createBashProgramForTests, _resetLocalEngineWarningsForTests, _resetRipgrepCacheForTests, _resetSyntaxCheckProbeCacheForTests, _resetUnrecognizedTriggerWarnings, addBedrockCacheControl, addBedrockTailCacheControl, addCacheControl, addCacheControlToStablePrefixMessages, addTailCacheControl, appendCodeSessionFileSummary, appendFailedExecutionFileReminder, appendTmpScratchReminder, applyContextPruning, applyEdit, applyPreToolUseHooksForBridge, apportionTokenCounts, askUserQuestion, attemptInvoke, bashAstFindingsToErrors, buildAnthropicCacheControl, buildBashExecutionToolDescription, buildBashExecutionToolSchema, buildBedrockCachePoint, buildChildInputs, buildCodeApiExecutionErrorMessage, buildCodeApiHttpErrorMessage, buildCodeExecutionToolDescription, buildCodeExecutionToolSchema, buildSandboxRuntimeConfig, buildSubagentToolParams, calculateMaxToolCallInputChars, calculateMaxToolResultChars, calculateMaxTotalToolOutputSize, calculateTotalTokens, checkValidNumber, clampCalibrationRatio, classifyAttachment, clientExecTimeoutMs, clientFsTimeoutMs, cloneMessage, composeEventHandlers, convertMessagesToContent, countNestedGroups, countrySchema, createAgentSession, createBashExecutionTool, createBashProgrammaticToolCallingSchema, createBashProgrammaticToolCallingTool, createCloudflareBashExecutionTool, createCloudflareBashProgrammaticToolCallingTool, createCloudflareBridgeRuntime, createCloudflareCodeExecutionTool, createCloudflareCodingToolBundle, createCloudflareCodingTools, createCloudflareExecutionTool, createCloudflareLocalExecutionConfig, createCloudflareProgrammaticToolCallingTool, createCloudflareWorkspaceFS, createCodeExecutionTool, createCompileCheckTool, createCompileCheckToolDefinition, createContentAggregator, createFakeStreamingLLM, createHandlers, createLocalBashExecutionTool, createLocalBashProgrammaticToolCallingTool, createLocalCodeExecutionTool, createLocalCodingToolBundle, createLocalCodingToolDefinitions, createLocalCodingToolRegistry, createLocalCodingTools, createLocalEditFileTool, createLocalFileCheckpointer, createLocalGlobSearchTool, createLocalGrepSearchTool, createLocalListDirectoryTool, createLocalProgrammaticToolCallingTool, createLocalReadFileTool, createLocalWriteFileTool, createMetadataAggregator, createProgrammaticToolCallingSchema, createProgrammaticToolCallingTool, createPruneMessages, createRemoveAllMessage, createRunHandlers, createSchemaOnlyTool, createSchemaOnlyTools, createSearchTool, createSubagentToolDefinition, createTokenCounter, createToolPolicyHook, createToolSearch, createWorkspacePolicyHook, dateSchema, decodeFile, defaultOmitOptions, deserializeMessage, emptyOutputMessage, encodeFile, encodingForModel, enforceOriginalContentCap, ensureThinkingBlockInMessages, escapeRegexSpecialChars, estimateAnthropicImageTokens, estimateDocumentBlockTokens, estimateImageBlockTokens, estimateOpenAIImageTokens, estimateTimedMediaBlockTokens, execWithClientTimeout, executeCloudflareBash, executeCloudflareCode, executeHooks, executeLocalBash, executeLocalBashWithArgs, executeLocalCode, executeParallelSearches, executeTools, extractErrorMessage, extractImageDimensions, extractMcpServerName, extractTextFromContent, extractToolDiscoveries, extractUsedBashToolNames, extractUsedToolNames, fetchSessionFiles, filterBashToolsByUsage, filterSubagentResult, filterToolsByUsage, findLastIndex, foldToolBlocksForToollessAgent, formatAgentMessages, formatAnthropicArtifactContent, formatAnthropicMessage, formatArtifactPayload, formatCloudflareOutput, formatCompletedResponse, formatContentStrings, formatFromLangChain, formatLangChainMessages, formatMediaMessage, formatMessage, formatServerListing, formatSkillCatalog, getAvailableMcpServers, getBaseToolName, getBufferString, getChatModelClass, getChunkContent, getCloudflareWorkspaceRoot, getCodeBaseURL, getContextOverflowInfo, getConverseOverrideMessage, getDeferredToolsListing, getLocalCwd, getLocalSessionId, getMaxOutputTokensKey, getMessageId, getMessagesWithinTokenLimit, getReadRoots, getSpawn, getTokenCountForMessage, getWorkspaceFS, getWorkspaceRoots, getWriteRoots, handleServerToolResult, handleToolCallChunks, handleToolCalls, hasNestedQuantifier, hasNestedQuantifiers, hasToolSearchInCurrentTurn, hasUnsafeStructuredSerialization, imageAttachmentContent, imagesSchema, initializeModel, interrupt, isAIMessage, isAnthropicLike, isBaseMessage, isContextOverflowError, isDangerousPattern, isFromAnyMcpServer, isFromMcpServer, isGoogleLike, isInterrupted, isLegacyConvertible, isLikelyContextOverflowError, isOpenAILike, isPresent, isSyntheticProviderContextMessage, isThinkingEnabled, isToolMessage, isZodSchema, joinKeys, labelContentByAgent, locateEdit, makeIsDeferred, makeRequest, maskConsumedToolResults, matchesQuery, messagesStateReducer, modifyDeltaProperties, newsSchema, normalizeBashToolResultsForReplay, normalizeCodeApiRequestError, normalizeServerFilter, normalizeToBashIdentifier, normalizeToPythonIdentifier, parseBooleanEnv, partitionAndMarkAnthropicToolCache, performLocalSearch, preFlightTruncateToolCallInputs, preFlightTruncateToolResults, projectAgentContextUsage, projectAnthropicArtifactContent, projectArtifactPayload, projectCacheControlledToolOutputsToText, projectComputerCallOutputsToText, projectOpenAIChatToolMessageContent, projectOpenAIResponsesToolMessageContent, projectOpenAIToolMessageContent, projectOpenRouterToolMessageContent, projectSingleTextToolOutputsToText, projectStructuredToolOutputsToText, projectToolCallInputs, projectToolStreamContentForProvider, querySchema, repairOrphanedToolMessages, resetIfNotEmpty, resolveBedrockPromptCacheTtl, resolveCloudflareSandbox, resolveCodeApiAuthHeaders, resolveContextPruningSettings, resolveLocalExecutionConfig, resolveLocalExecutionTools, resolveLocalToolRegistry, resolveLocalToolsForBinding, resolvePromptCacheTtl, resolveSubagentConfigs, resolveWorkspacePath, resolveWorkspacePathSafe, runBashAstChecks, runPostEditSyntaxCheck, sanitizeOrphanToolBlocks, sanitizeRegex, serializeMessage, serializeToolCallInput, shellQuote, shiftIndexTokenCountMap, shouldTriggerSummarization, sleep, spawnLocalProcess, splitAtRecencyBoundary, stripAnthropicCacheControl, stripBedrockCacheControl, stripCodeSessionFileSummary, summarizeEvent, supportsBedrockToolCache, syncBudgetDerivedFields, toJsonSchema, tool, toolResultTypes, toolsCondition, truncateLocalOutput, truncateToolInput, truncateToolResultContent, tryFallbackProviders, unescapeObject, unwrapToolResponse, validateBashCommand, validateCloudflareBashCommand, videosSchema, withClientTimeout, withMessageRole };
+export { AIMessage, AIMessageChunk, ANTHROPIC_TOOL_TOKEN_MULTIPLIER, AgentSession, BASH_SHELL_GUIDANCE, BaseCheckpointSaver, BaseMessage, BaseMessageChunk, BashExecutionToolDefinition, BashExecutionToolDescription, BashExecutionToolName, BashExecutionToolSchema, BashProgrammaticToolCallingDefinition, BashProgrammaticToolCallingDescription, BashProgrammaticToolCallingName, BashProgrammaticToolCallingSchema, BashToolOutputReferencesGuide, CALIBRATION_RATIO_MAX, CALIBRATION_RATIO_MIN, CLOUDFLARE_BASH_CODING_TOOL_NAMES, CLOUDFLARE_CODING_TOOL_NAMES, CODE_API_AUTHORIZATION_ERROR_MESSAGE, CODE_API_EXECUTION_FAILED_ERROR_MESSAGE, CODE_API_INVALID_REQUEST_ERROR_MESSAGE, CODE_API_RATE_LIMITED_ERROR_MESSAGE, CODE_API_UNAVAILABLE_ERROR_MESSAGE, CODE_ARTIFACT_PATH_GUIDANCE, CODE_EXECUTION_TOOLS, Calculator, CalculatorSchema, CalculatorToolDefinition, CalculatorToolDescription, CalculatorToolName, Callback, ChatModelStreamHandler, ChatOpenRouter, CloudflareBashExecutionToolDescription, CloudflareCodeExecutionToolDescription, CodeApiRequestError, CodeExecutionToolDefinition, CodeExecutionToolDescription, CodeExecutionToolName, CodeExecutionToolSchema, Command, CommonEvents, CompileCheckToolName, Constants, ContentTypes, CustomOpenAIClient, DATE_RANGE, DEFAULT_CONTEXT_PRUNING_SETTINGS, DEFAULT_COUNTRY_DESCRIPTION, DEFAULT_HOOK_TIMEOUT_MS, DEFAULT_MAX_SEALS, DEFAULT_PROMPT_CACHE_TTL, DEFAULT_QUERY_DESCRIPTION, DEFAULT_RECURSION_LIMIT, DEFAULT_RESERVE_RATIO, DEFAULT_RETAIN_RECENT_TURNS, DEFAULT_TOOL_TOKEN_MULTIPLIER, DynamicStructuredTool, EnvVar, FAILED_EXECUTION_FILE_REMINDER, FakeChatModel, Graph, GraphEvents, GraphNodeActions, GraphNodeKeys, HARD_MAX_TOOL_RESULT_CHARS, HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE, HOOK_EVENTS, HOOK_INJECTED_MESSAGES_CAPABLE, HOOK_PREEMPT_BOUNDARY_CAPABLE, HandlerRegistry, HookRegistry, HumanMessage, IMAGE_TOKEN_SAFETY_MARGIN, INTENT_ARG, INTENT_DESCRIPTION, INTENT_PROPERTY, INTERRUPT, JsonlSessionStore, LLMStreamHandler, LOCAL_CODING_BUNDLE_NAMES, LOCAL_CODING_TOOL_NAMES, LOCAL_SPAWN_TIMEOUT_MS, LocalBashExecutionToolDescription, LocalCodeExecutionToolDescription, LocalEditFileToolName, LocalEditFileToolSchema, LocalFileCheckpointerImpl, LocalGlobSearchToolName, LocalGlobSearchToolSchema, LocalGrepSearchToolName, LocalGrepSearchToolSchema, LocalListDirectoryToolName, LocalListDirectoryToolSchema, LocalReadFileToolSchema, LocalWriteFileToolName, LocalWriteFileToolSchema, MAX_CACHE_SIZE, MAX_PATTERN_LENGTH, MemorySaver, ModelEndHandler, MultiAgentGraph, ORIGINAL_CONTENT_MAX_CHARS, PREDECESSOR_HANDOFF_CUE, PREEMPT_BOUNDARY_HOOK_TIMEOUT_MS, ProgrammaticToolCallingDefinition, ProgrammaticToolCallingDescription, ProgrammaticToolCallingName, ProgrammaticToolCallingSchema, PromptTemplate, Providers, REMOVE_ALL_MESSAGES, REPLY_PRIMER_TOKENS, ReadFileToolDefinition, ReadFileToolDescription, ReadFileToolName, ReadFileToolSchema, Run, Runnable, RunnableCallable, RunnableLambda, RunnableSequence, SDK_STREAM_DISPATCH, STATEFUL_BASH_NOTE, STATEFUL_ENV_NOTE, SessionManager, SkillToolDefinition, SkillToolDescription, SkillToolName, SkillToolSchema, StandardGraph, StatefulBashExecutionToolDescription, StatefulCodeExecutionToolDescription, StepTypes, StructuredTool, SubagentExecutor, SubagentToolDefinition, SubagentToolDescription, SubagentToolName, SubagentToolSchema, SystemMessage, TMP_SCRATCH_OUTPUT_REMINDER, TestChatStreamHandler, TestLLMStreamHandler, TitleMethod, TokenEncoderManager, Tool, ToolCallTypes, ToolEndHandler, ToolMessage, ToolNode, ToolSearchToolDefinition, ToolSearchToolDescription, ToolSearchToolName, ToolSearchToolSchema, WebSearchToolDefinition, WebSearchToolDescription, WebSearchToolName, WebSearchToolSchema, _createBashProgramForTests, _resetLocalEngineWarningsForTests, _resetRipgrepCacheForTests, _resetSyntaxCheckProbeCacheForTests, _resetUnrecognizedTriggerWarnings, addBedrockCacheControl, addBedrockTailCacheControl, addCacheControl, addCacheControlToStablePrefixMessages, addTailCacheControl, appendCodeSessionFileSummary, appendFailedExecutionFileReminder, appendPredecessorHandoffCue, appendTmpScratchReminder, applyContextPruning, applyEdit, applyOutcome, applyPreToolUseHooksForBridge, apportionTokenCounts, askUserQuestion, attemptInvoke, bashAstFindingsToErrors, buildAnthropicCacheControl, buildBashExecutionToolDescription, buildBashExecutionToolSchema, buildBedrockCachePoint, buildChildInputs, buildCodeApiExecutionErrorMessage, buildCodeApiHttpErrorMessage, buildCodeExecutionToolDescription, buildCodeExecutionToolSchema, buildSandboxRuntimeConfig, buildSubagentToolParams, calculateMaxToolCallInputChars, calculateMaxToolResultChars, calculateMaxTotalToolOutputSize, calculateTotalTokens, canSealPreempt, checkValidNumber, clampCalibrationRatio, classifyAttachment, clientExecTimeoutMs, clientFsTimeoutMs, cloneMessage, coalesceAdjacentUserTurns, composeEventHandlers, convertInjectedMessages, convertMessagesToContent, countNestedGroups, countrySchema, createAgentSession, createBashExecutionTool, createBashProgrammaticToolCallingSchema, createBashProgrammaticToolCallingTool, createCloudflareBashExecutionTool, createCloudflareBashProgrammaticToolCallingTool, createCloudflareBridgeRuntime, createCloudflareCodeExecutionTool, createCloudflareCodingToolBundle, createCloudflareCodingTools, createCloudflareExecutionTool, createCloudflareLocalExecutionConfig, createCloudflareProgrammaticToolCallingTool, createCloudflareWorkspaceFS, createCodeExecutionTool, createCompileCheckTool, createCompileCheckToolDefinition, createContentAggregator, createFakeStreamingLLM, createHandlers, createLocalBashExecutionTool, createLocalBashProgrammaticToolCallingTool, createLocalCodeExecutionTool, createLocalCodingToolBundle, createLocalCodingToolDefinitions, createLocalCodingToolRegistry, createLocalCodingTools, createLocalEditFileTool, createLocalFileCheckpointer, createLocalGlobSearchTool, createLocalGrepSearchTool, createLocalListDirectoryTool, createLocalProgrammaticToolCallingTool, createLocalReadFileTool, createLocalWriteFileTool, createMetadataAggregator, createProgrammaticToolCallingSchema, createProgrammaticToolCallingTool, createPruneMessages, createRemoveAllMessage, createRunHandlers, createSchemaOnlyTool, createSchemaOnlyTools, createSearchTool, createSubagentToolDefinition, createTokenCounter, createToolErrorOwnership, createToolPolicyHook, createToolSearch, createWorkspacePolicyHook, dateSchema, decodeFile, defaultOmitOptions, deserializeMessage, dispatchesChatModelStream, emptyOutputMessage, encodeFile, encodingForModel, enforceOriginalContentCap, ensureThinkingBlockInMessages, escapeRegexSpecialChars, estimateAnthropicImageTokens, estimateDocumentBlockTokens, estimateImageBlockTokens, estimateOpenAIImageTokens, estimateTimedMediaBlockTokens, execWithClientTimeout, executeCloudflareBash, executeCloudflareCode, executeHooks, executeLocalBash, executeLocalBashWithArgs, executeLocalCode, executeParallelSearches, executeTools, extractErrorMessage, extractImageDimensions, extractMcpServerName, extractTextFromContent, extractToolDiscoveries, extractUsedBashToolNames, extractUsedToolNames, fetchSessionFiles, filterBashToolsByUsage, filterSubagentResult, filterToolsByUsage, findLastIndex, foldToolBlocksForToollessAgent, formatAgentMessages, formatAnthropicArtifactContent, formatAnthropicMessage, formatArtifactPayload, formatCloudflareOutput, formatCompletedResponse, formatContentStrings, formatFromLangChain, formatLangChainMessages, formatMediaMessage, formatMessage, formatServerListing, formatSkillCatalog, getAvailableMcpServers, getBaseToolName, getBufferString, getChatModelClass, getChunkContent, getCloudflareWorkspaceRoot, getCodeBaseURL, getContextOverflowInfo, getConverseOverrideMessage, getDeferredToolsListing, getLocalCwd, getLocalSessionId, getMaxOutputTokensKey, getMessageId, getMessagesWithinTokenLimit, getReadRoots, getSpawn, getTokenCountForMessage, getWorkspaceFS, getWorkspaceRoots, getWriteRoots, handleServerToolResult, handleToolCallChunks, handleToolCalls, hasNestedQuantifier, hasNestedQuantifiers, hasToolSearchInCurrentTurn, hasUnsafeStructuredSerialization, imageAttachmentContent, imagesSchema, initializeModel, interrupt, isAIMessage, isAnthropicLike, isBaseMessage, isContextOverflowError, isDangerousPattern, isFromAnyMcpServer, isFromMcpServer, isGoogleLike, isIntentLabelProperty, isInterrupted, isLegacyConvertible, isLikelyContextOverflowError, isOpenAILike, isPresent, isSyntheticProviderContextMessage, isThinkingEnabled, isToolMessage, isZodSchema, joinKeys, labelContentByAgent, locateEdit, makeIsDeferred, makeRequest, maskConsumedToolResults, matchesQuery, messagesStateReducer, modifyDeltaProperties, newsSchema, normalizeBashToolResultsForReplay, normalizeCodeApiRequestError, normalizeServerFilter, normalizeToBashIdentifier, normalizeToPythonIdentifier, outcomeFieldsFromResult, parseBooleanEnv, partitionAndMarkAnthropicToolCache, performLocalSearch, preFlightTruncateToolCallInputs, preFlightTruncateToolResults, projectAgentContextUsage, projectAnthropicArtifactContent, projectArtifactPayload, projectCacheControlledToolOutputsToText, projectComputerCallOutputsToText, projectOpenAIChatToolMessageContent, projectOpenAIResponsesToolMessageContent, projectOpenAIToolMessageContent, projectOpenRouterToolMessageContent, projectSingleTextToolOutputsToText, projectStructuredToolOutputsToText, projectToolCallInputs, projectToolStreamContentForProvider, querySchema, readIntent, readOutcomeFields, removePredecessorHandoffCue, repairOrphanedToolMessages, resetIfNotEmpty, resolveBedrockPromptCacheTtl, resolveCloudflareSandbox, resolveCodeApiAuthHeaders, resolveContextPruningSettings, resolveLocalExecutionConfig, resolveLocalExecutionTools, resolveLocalToolRegistry, resolveLocalToolsForBinding, resolvePromptCacheTtl, resolveSearchOutcome, resolveSubagentConfigs, resolveToolOutcome, resolveWorkspacePath, resolveWorkspacePathSafe, runBashAstChecks, runPostEditSyntaxCheck, sanitizeOrphanToolBlocks, sanitizeRegex, serializeMessage, serializeToolCallInput, shellQuote, shiftIndexTokenCountMap, shouldTriggerSummarization, sleep, spawnLocalProcess, splitAtRecencyBoundary, strictAlternationProviders, stripAnthropicCacheControl, stripBedrockCacheControl, stripCodeSessionFileSummary, stripIntent, summarizeEvent, supportsBedrockToolCache, syncBudgetDerivedFields, toJsonSchema, tool, toolResultTypes, toolsCondition, truncateLocalOutput, truncateToolInput, truncateToolResultContent, tryFallbackProviders, unescapeObject, unwrapToolResponse, validateBashCommand, validateCloudflareBashCommand, videosSchema, withClientTimeout, withIntent, withMessageRole };

package/dist/esm/messages/alternation.mjs

@@ -0,0 +1,91 @@
+import "../common/enum.mjs";
+import "../common/index.mjs";
+import { HumanMessage } from "@langchain/core/messages";
+//#region src/messages/alternation.ts
+/**
+* Providers whose APIs specify strict user/assistant alternation. Mistral
+* rejects consecutive user turns outright. Bedrock's Converse API documents
+* the alternation requirement across many model families; enforcement varies
+* by family — Claude on Converse currently tolerates adjacent user turns
+* (verified live, 2026-07-28) — so the payload is normalized for all of them
+* rather than betting on per-family leniency. Anthropic's own Messages API,
+* OpenAI and Gemini all accept consecutive user turns, so they are
+* deliberately absent.
+*/
+const strictAlternationProviders = new Set([
+	"bedrock",
+	"mistral",
+	"mistralai"
+]);
+const TOOL_RESULT_TYPES = new Set(["tool_result", "toolResult"]);
+/**
+* True when every block is a tool result. Both vendored converters already
+* merge adjacent runs of these, and folding one into a text turn would break
+* the tool pairing they depend on — so they are left alone here.
+*/
+function isToolResultMessage(message) {
+	const { content } = message;
+	if (typeof content === "string" || content.length === 0) return false;
+	return content.every((block) => typeof block.type === "string" && TOOL_RESULT_TYPES.has(block.type));
+}
+function toBlocks(content) {
+	if (typeof content === "string") return content === "" ? [] : [{
+		type: "text",
+		text: content
+	}];
+	return content;
+}
+function joinContent(left, right) {
+	if (typeof left === "string" && typeof right === "string") return left === "" ? right : `${left}\n\n${right}`;
+	return [...toBlocks(left), ...toBlocks(right)];
+}
+/**
+* Merges runs of consecutive human turns into one, for providers that reject
+* them. Purely a wire-shaping pass: it returns a new array of new messages,
+* so graph state and the host's persisted messages keep the per-message
+* identity that steer rendering and the trailing-steer anchor rely on.
+*
+* Tool-result turns are excluded — the converters merge those themselves, and
+* combining one with a text turn would orphan the pairing.
+*/
+function coalesceAdjacentUserTurns(messages) {
+	const result = [];
+	let mergedAny = false;
+	for (const message of messages) {
+		const previous = result[result.length - 1];
+		if (!(result.length > 0 && previous.getType() === "human" && message.getType() === "human" && !isToolResultMessage(previous) && !isToolResultMessage(message))) {
+			result.push(message);
+			continue;
+		}
+		mergedAny = true;
+		result[result.length - 1] = new HumanMessage({
+			content: joinContent(previous.content, message.content),
+			/**
+			* The LATER turn's kwargs, deliberately. The one provider-path consumer
+			* of these flags is the prompt-cache tail anchor, and it reasons
+			* positionally: `isSyntheticMetaMessage` decides whether a breakpoint
+			* may be inserted after the message's LAST text block. Merging keeps
+			* the last block's provenance only if the last part's kwargs survive —
+			* a skill body absorbed into a real user turn must stay anchorable
+			* (the real turn ends it), while a real steer absorbed into a trailing
+			* skill body must not pin the cache to the volatile body. The first
+			* turn's id is kept so origin tracking can re-attach by key.
+			*/
+			additional_kwargs: message.additional_kwargs,
+			...previous.id != null && { id: previous.id }
+		});
+	}
+	/**
+	* Identity on the no-merge path. The pass runs twice for a primary
+	* Bedrock/Mistral call — once in `createCallModel` (must precede the cache
+	* breakpoint) and once in the `attemptInvoke` funnel (must cover fallback
+	* and summarization sends) — so the already-normalized second pass returns
+	* the SAME array rather than reallocating a context-sized copy, and
+	* callers can cheaply detect "nothing changed" by identity.
+	*/
+	return mergedAny ? result : messages;
+}
+//#endregion
+export { coalesceAdjacentUserTurns, strictAlternationProviders };
+
+//# sourceMappingURL=alternation.mjs.map

package/dist/esm/messages/alternation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"alternation.mjs","names":[],"sources":["../../../src/messages/alternation.ts"],"sourcesContent":["// src/messages/alternation.ts\nimport { HumanMessage } from '@langchain/core/messages';\nimport type { BaseMessage, MessageContent } from '@langchain/core/messages';\nimport { Providers } from '@/common';\n\n/**\n * Providers whose APIs specify strict user/assistant alternation. Mistral\n * rejects consecutive user turns outright. Bedrock's Converse API documents\n * the alternation requirement across many model families; enforcement varies\n * by family — Claude on Converse currently tolerates adjacent user turns\n * (verified live, 2026-07-28) — so the payload is normalized for all of them\n * rather than betting on per-family leniency. Anthropic's own Messages API,\n * OpenAI and Gemini all accept consecutive user turns, so they are\n * deliberately absent.\n */\nexport const strictAlternationProviders: ReadonlySet<Providers> = new Set([\n  Providers.BEDROCK,\n  Providers.MISTRAL,\n  Providers.MISTRALAI,\n]);\n\nconst TOOL_RESULT_TYPES = new Set(['tool_result', 'toolResult']);\n\n/**\n * True when every block is a tool result. Both vendored converters already\n * merge adjacent runs of these, and folding one into a text turn would break\n * the tool pairing they depend on — so they are left alone here.\n */\nfunction isToolResultMessage(message: BaseMessage): boolean {\n  const { content } = message;\n  if (typeof content === 'string' || content.length === 0) {\n    return false;\n  }\n  return content.every(\n    (block) =>\n      typeof block.type === 'string' && TOOL_RESULT_TYPES.has(block.type)\n  );\n}\n\nfunction toBlocks(content: MessageContent): Exclude<MessageContent, string> {\n  if (typeof content === 'string') {\n    return content === '' ? [] : [{ type: 'text', text: content }];\n  }\n  return content;\n}\n\nfunction joinContent(\n  left: MessageContent,\n  right: MessageContent\n): MessageContent {\n  if (typeof left === 'string' && typeof right === 'string') {\n    return left === '' ? right : `${left}\\n\\n${right}`;\n  }\n  return [...toBlocks(left), ...toBlocks(right)];\n}\n\n/**\n * Merges runs of consecutive human turns into one, for providers that reject\n * them. Purely a wire-shaping pass: it returns a new array of new messages,\n * so graph state and the host's persisted messages keep the per-message\n * identity that steer rendering and the trailing-steer anchor rely on.\n *\n * Tool-result turns are excluded — the converters merge those themselves, and\n * combining one with a text turn would orphan the pairing.\n */\nexport function coalesceAdjacentUserTurns(\n  messages: BaseMessage[]\n): BaseMessage[] {\n  const result: BaseMessage[] = [];\n  let mergedAny = false;\n  for (const message of messages) {\n    const previous = result[result.length - 1];\n    const mergeable =\n      result.length > 0 &&\n      previous.getType() === 'human' &&\n      message.getType() === 'human' &&\n      !isToolResultMessage(previous) &&\n      !isToolResultMessage(message);\n\n    if (!mergeable) {\n      result.push(message);\n      continue;\n    }\n    mergedAny = true;\n\n    result[result.length - 1] = new HumanMessage({\n      content: joinContent(previous.content, message.content),\n      /**\n       * The LATER turn's kwargs, deliberately. The one provider-path consumer\n       * of these flags is the prompt-cache tail anchor, and it reasons\n       * positionally: `isSyntheticMetaMessage` decides whether a breakpoint\n       * may be inserted after the message's LAST text block. Merging keeps\n       * the last block's provenance only if the last part's kwargs survive —\n       * a skill body absorbed into a real user turn must stay anchorable\n       * (the real turn ends it), while a real steer absorbed into a trailing\n       * skill body must not pin the cache to the volatile body. The first\n       * turn's id is kept so origin tracking can re-attach by key.\n       */\n      additional_kwargs: message.additional_kwargs,\n      ...(previous.id != null && { id: previous.id }),\n    });\n  }\n  /**\n   * Identity on the no-merge path. The pass runs twice for a primary\n   * Bedrock/Mistral call — once in `createCallModel` (must precede the cache\n   * breakpoint) and once in the `attemptInvoke` funnel (must cover fallback\n   * and summarization sends) — so the already-normalized second pass returns\n   * the SAME array rather than reallocating a context-sized copy, and\n   * callers can cheaply detect \"nothing changed\" by identity.\n   */\n  return mergedAny ? result : messages;\n}\n"],"mappings":";;;;;;;;;;;;;;AAeA,MAAa,6BAAqD,IAAI,IAAI;;;;AAI1E,CAAC;AAED,MAAM,oBAAoB,IAAI,IAAI,CAAC,eAAe,YAAY,CAAC;;;;;;AAO/D,SAAS,oBAAoB,SAA+B;CAC1D,MAAM,EAAE,YAAY;CACpB,IAAI,OAAO,YAAY,YAAY,QAAQ,WAAW,GACpD,OAAO;CAET,OAAO,QAAQ,OACZ,UACC,OAAO,MAAM,SAAS,YAAY,kBAAkB,IAAI,MAAM,IAAI,CACtE;AACF;AAEA,SAAS,SAAS,SAA0D;CAC1E,IAAI,OAAO,YAAY,UACrB,OAAO,YAAY,KAAK,CAAC,IAAI,CAAC;EAAE,MAAM;EAAQ,MAAM;CAAQ,CAAC;CAE/D,OAAO;AACT;AAEA,SAAS,YACP,MACA,OACgB;CAChB,IAAI,OAAO,SAAS,YAAY,OAAO,UAAU,UAC/C,OAAO,SAAS,KAAK,QAAQ,GAAG,KAAK,MAAM;CAE7C,OAAO,CAAC,GAAG,SAAS,IAAI,GAAG,GAAG,SAAS,KAAK,CAAC;AAC/C;;;;;;;;;;AAWA,SAAgB,0BACd,UACe;CACf,MAAM,SAAwB,CAAC;CAC/B,IAAI,YAAY;CAChB,KAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,WAAW,OAAO,OAAO,SAAS;EAQxC,IAAI,EANF,OAAO,SAAS,KAChB,SAAS,QAAQ,MAAM,WACvB,QAAQ,QAAQ,MAAM,WACtB,CAAC,oBAAoB,QAAQ,KAC7B,CAAC,oBAAoB,OAAO,IAEd;GACd,OAAO,KAAK,OAAO;GACnB;EACF;EACA,YAAY;EAEZ,OAAO,OAAO,SAAS,KAAK,IAAI,aAAa;GAC3C,SAAS,YAAY,SAAS,SAAS,QAAQ,OAAO;;;;;;;;;;;;GAYtD,mBAAmB,QAAQ;GAC3B,GAAI,SAAS,MAAM,QAAQ,EAAE,IAAI,SAAS,GAAG;EAC/C,CAAC;CACH;;;;;;;;;CASA,OAAO,YAAY,SAAS;AAC9B"}

package/dist/esm/messages/format.mjs

@@ -182,6 +182,19 @@ function formatToolCallOutput(output) {
 	return compactToolContent(output, HARD_MAX_TOOL_RESULT_CHARS).content;
 }
 /**
+* Content for the synthetic assistant turn that separates a trailing steer
+* from the next user turn. Non-empty by necessity — see the push site.
+*/
+const STEER_ANCHOR_PLACEHOLDER = "_";
+/**
+* True when an assistant message replayed as a steer and nothing followed it,
+* so the emitted run ends on the steer's `HumanMessage`.
+*/
+function endsWithSteerMessage(formatted) {
+	if (formatted.length === 0) return false;
+	return formatted[formatted.length - 1].additional_kwargs.source === "steer";
+}
+/**
 * Helper function to format an assistant message
 * @param message The message to format
 * @param options Optional formatting options
@@ -617,6 +630,27 @@ function extractSkillName(args) {
 */
 const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options) => {
 	const messages = [];
+	/**
+	* A steer ended the previous payload entry, so the next message emitted —
+	* whichever entry finally produces one — must be separated from it by an
+	* assistant turn. Held rather than emitted so an entry that produces
+	* nothing cannot leave the anchor stranded as the final turn.
+	*/
+	let pendingSteerAnchor = false;
+	/**
+	* Emits the deferred anchor ahead of `next` — the message about to be
+	* pushed. When that message is itself an assistant turn, it already IS the
+	* separation the anchor exists to synthesize, so the intent is simply
+	* discharged: emitting the placeholder anyway would put two assistant turns
+	* back to back, which strict-alternation providers can reject and nothing downstream
+	* repairs (`coalesceAdjacentUserTurns` merges user turns only).
+	*/
+	const flushSteerAnchor = (next) => {
+		if (!pendingSteerAnchor) return;
+		pendingSteerAnchor = false;
+		if (next.role === "assistant") return;
+		messages.push(withMessageRole(new AIMessage({ content: STEER_ANCHOR_PLACEHOLDER }), "assistant"));
+	};
 	const updatedIndexTokenCountMap = {};
 	let boundaryTokenAdjustment;
 	const indexMapping = {};
@@ -652,6 +686,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 				langChain: true
 			});
 			if (sourceMessageId != null && sourceMessageId !== "") formattedMessage.id = sourceMessageId;
+			flushSteerAnchor(formattedMessage);
 			messages.push(formattedMessage);
 			indexMapping[i] = [messages.length - 1];
 			continue;
@@ -755,7 +790,44 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 			provider: options?.provider
 		});
 		if (sourceMessageId != null && sourceMessageId !== "") for (const formattedMessage of formattedMessages) formattedMessage.id = sourceMessageId;
+		/**
+		* A steer that ends an assistant message leaves the replay on a
+		* `HumanMessage`. The next payload message is itself a user turn, so the
+		* sequence would reach the provider as two adjacent user turns — rejected
+		* by strict-alternation providers. Anchor it with a placeholder assistant
+		* turn.
+		*
+		* The placeholder must be NON-EMPTY. A string-content assistant message
+		* with no tool calls passes through `_convertMessagesToAnthropicPayload`
+		* verbatim — the empty-text repair there only covers array content and
+		* tool-call turns — so an empty anchor would reach Anthropic as
+		* `{role: 'assistant', content: ''}` and trade one invalid sequence for
+		* another. Same single-underscore convention the Anthropic converter
+		* already uses when it has to synthesize a non-empty block.
+		*
+		* Deferred rather than decided by lookahead. `i < payload.length - 1` only
+		* proves a later ENTRY exists, not that it EMITS: entries with empty
+		* content, and entries dropped by `applySummaryBoundary`, are skipped
+		* silently. A trailing steer followed only by those would get the anchor
+		* as the FINAL turn — an assistant prefill with no request after it, which
+		* the model may simply never answer. So the intent is recorded and flushed
+		* only when a message actually follows.
+		*
+		* Pushed AFTER the id stamping above, deliberately. `messagesStateReducer`
+		* treats a repeated id as replace-in-place, so an anchor carrying the
+		* shared `sourceMessageId` would overwrite the steer it exists to protect.
+		* Left unstamped, it reaches the reducer with a null id and is assigned a
+		* fresh one. `endsWithSteerMessage` reads only `additional_kwargs.source`,
+		* so the deferral cannot change which messages get anchored.
+		*/
+		/**
+		* Guarded on emission: an assistant entry whose blocks all filtered away
+		* emits nothing, and flushing for it would strand the anchor as the final
+		* turn — the pending flag stays set for whichever entry emits next.
+		*/
+		if (formattedMessages.length > 0) flushSteerAnchor(formattedMessages[0]);
 		messages.push(...formattedMessages);
+		if (endsWithSteerMessage(formattedMessages)) pendingSteerAnchor = true;
 		const endMessageIndex = messages.length;
 		if (pendingSkillNames?.size != null && pendingSkillNames.size > 0) {
 			const skipSkillBodyNames = options?.skipSkillBodyNames;