@librechat/agents 3.3.4 → 3.3.6

package/dist/cjs/llm/preempt.cjs

@@ -0,0 +1,132 @@
+require("../common/constants.cjs");
+require("../common/enum.cjs");
+require("../common/index.cjs");
+//#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
+exports.canSealPreempt = canSealPreempt;
+exports.resolveMaxSeals = resolveMaxSeals;
+
+//# sourceMappingURL=preempt.cjs.map

package/dist/cjs/llm/preempt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"preempt.cjs","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/cjs/main.cjs

@@ -5,6 +5,7 @@ const require_enum = require("./common/enum.cjs");
 require("./common/index.cjs");
 const require_truncation = require("./utils/truncation.cjs");
 const require_tokens = require("./utils/tokens.cjs");
+const require_preempt = require("./llm/preempt.cjs");
 const require_cache = require("./messages/cache.cjs");
 const require_core = require("./messages/core.cjs");
 const require_ids = require("./messages/ids.cjs");
@@ -16,12 +17,16 @@ const require_format = require("./messages/format.cjs");
 const require_anthropicToolCache = require("./messages/anthropicToolCache.cjs");
 const require_content = require("./messages/content.cjs");
 const require_tools = require("./messages/tools.cjs");
+const require_injected = require("./messages/injected.cjs");
+const require_alternation = require("./messages/alternation.cjs");
+const require_handoffCue = require("./messages/handoffCue.cjs");
 const require_reducer = require("./messages/reducer.cjs");
 const require_recency = require("./messages/recency.cjs");
 require("./messages/index.cjs");
 const require_graph = require("./utils/graph.cjs");
 const require_llm = require("./utils/llm.cjs");
 const require_handlers = require("./tools/handlers.cjs");
+const require_intentArg = require("./tools/intentArg.cjs");
 const require_stream = require("./stream.cjs");
 const require_events = require("./events.cjs");
 const require_handlers$1 = require("./utils/handlers.cjs");
@@ -75,7 +80,6 @@ const require_fake = require("./llm/fake.cjs");
 const require_Graph = require("./graphs/Graph.cjs");
 const require_MultiAgentGraph = require("./graphs/MultiAgentGraph.cjs");
 const require_run$1 = require("./run.cjs");
-const require_splitStream = require("./splitStream.cjs");
 require("./graphs/index.cjs");
 const require_projection = require("./agents/projection.cjs");
 const require_Calculator = require("./tools/Calculator.cjs");
@@ -182,8 +186,10 @@ exports.DATE_RANGE = require_schema$2.DATE_RANGE;
 exports.DEFAULT_CONTEXT_PRUNING_SETTINGS = require_contextPruningSettings.DEFAULT_CONTEXT_PRUNING_SETTINGS;
 exports.DEFAULT_COUNTRY_DESCRIPTION = require_schema$2.DEFAULT_COUNTRY_DESCRIPTION;
 exports.DEFAULT_HOOK_TIMEOUT_MS = require_executeHooks.DEFAULT_HOOK_TIMEOUT_MS;
+exports.DEFAULT_MAX_SEALS = require_constants.DEFAULT_MAX_SEALS;
 exports.DEFAULT_PROMPT_CACHE_TTL = require_cache.DEFAULT_PROMPT_CACHE_TTL;
 exports.DEFAULT_QUERY_DESCRIPTION = require_schema$2.DEFAULT_QUERY_DESCRIPTION;
+exports.DEFAULT_RECURSION_LIMIT = require_constants.DEFAULT_RECURSION_LIMIT;
 exports.DEFAULT_RESERVE_RATIO = require_prune.DEFAULT_RESERVE_RATIO;
 exports.DEFAULT_RETAIN_RECENT_TURNS = require_recency.DEFAULT_RETAIN_RECENT_TURNS;
 exports.DEFAULT_TOOL_TOKEN_MULTIPLIER = require_constants.DEFAULT_TOOL_TOKEN_MULTIPLIER;
@@ -204,6 +210,7 @@ exports.HARD_MAX_TOOL_RESULT_CHARS = require_truncation.HARD_MAX_TOOL_RESULT_CHA
 exports.HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE = require_truncation.HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE;
 exports.HOOK_EVENTS = require_types.HOOK_EVENTS;
 exports.HOOK_INJECTED_MESSAGES_CAPABLE = require_index$5.HOOK_INJECTED_MESSAGES_CAPABLE;
+exports.HOOK_PREEMPT_BOUNDARY_CAPABLE = require_index$5.HOOK_PREEMPT_BOUNDARY_CAPABLE;
 exports.HandlerRegistry = require_events.HandlerRegistry;
 exports.HookRegistry = require_HookRegistry.HookRegistry;
 Object.defineProperty(exports, "HumanMessage", {
@@ -213,6 +220,9 @@ Object.defineProperty(exports, "HumanMessage", {
 	}
 });
 exports.IMAGE_TOKEN_SAFETY_MARGIN = require_tokens.IMAGE_TOKEN_SAFETY_MARGIN;
+exports.INTENT_ARG = require_intentArg.INTENT_ARG;
+exports.INTENT_DESCRIPTION = require_intentArg.INTENT_DESCRIPTION;
+exports.INTENT_PROPERTY = require_intentArg.INTENT_PROPERTY;
 Object.defineProperty(exports, "INTERRUPT", {
 	enumerable: true,
 	get: function() {
@@ -249,6 +259,8 @@ Object.defineProperty(exports, "MemorySaver", {
 exports.ModelEndHandler = require_events.ModelEndHandler;
 exports.MultiAgentGraph = require_MultiAgentGraph.MultiAgentGraph;
 exports.ORIGINAL_CONTENT_MAX_CHARS = require_prune.ORIGINAL_CONTENT_MAX_CHARS;
+exports.PREDECESSOR_HANDOFF_CUE = require_handoffCue.PREDECESSOR_HANDOFF_CUE;
+exports.PREEMPT_BOUNDARY_HOOK_TIMEOUT_MS = require_constants.PREEMPT_BOUNDARY_HOOK_TIMEOUT_MS;
 exports.ProgrammaticToolCallingDefinition = require_ProgrammaticToolCalling.ProgrammaticToolCallingDefinition;
 exports.ProgrammaticToolCallingDescription = require_ProgrammaticToolCalling.ProgrammaticToolCallingDescription;
 exports.ProgrammaticToolCallingName = require_ProgrammaticToolCalling.ProgrammaticToolCallingName;
@@ -286,7 +298,7 @@ Object.defineProperty(exports, "RunnableSequence", {
 		return _langchain_core_runnables.RunnableSequence;
 	}
 });
-exports.SEPARATORS = require_splitStream.SEPARATORS;
+exports.SDK_STREAM_DISPATCH = require_stream.SDK_STREAM_DISPATCH;
 exports.STATEFUL_BASH_NOTE = require_BashExecutor.STATEFUL_BASH_NOTE;
 exports.STATEFUL_ENV_NOTE = require_CodeExecutor.STATEFUL_ENV_NOTE;
 exports.SessionManager = require_JsonlSessionStore.SessionManager;
@@ -294,7 +306,6 @@ exports.SkillToolDefinition = require_SkillTool.SkillToolDefinition;
 exports.SkillToolDescription = require_SkillTool.SkillToolDescription;
 exports.SkillToolName = require_SkillTool.SkillToolName;
 exports.SkillToolSchema = require_SkillTool.SkillToolSchema;
-exports.SplitStreamHandler = require_splitStream.SplitStreamHandler;
 exports.StandardGraph = require_Graph.StandardGraph;
 exports.StatefulBashExecutionToolDescription = require_BashExecutor.StatefulBashExecutionToolDescription;
 exports.StatefulCodeExecutionToolDescription = require_CodeExecutor.StatefulCodeExecutionToolDescription;
@@ -356,9 +367,11 @@ exports.addCacheControlToStablePrefixMessages = require_cache.addCacheControlToS
 exports.addTailCacheControl = require_cache.addTailCacheControl;
 exports.appendCodeSessionFileSummary = require_CodeSessionFileSummary.appendCodeSessionFileSummary;
 exports.appendFailedExecutionFileReminder = require_CodeExecutor.appendFailedExecutionFileReminder;
+exports.appendPredecessorHandoffCue = require_handoffCue.appendPredecessorHandoffCue;
 exports.appendTmpScratchReminder = require_CodeExecutor.appendTmpScratchReminder;
 exports.applyContextPruning = require_contextPruning.applyContextPruning;
 exports.applyEdit = require_editStrategies.applyEdit;
+exports.applyOutcome = require_intentArg.applyOutcome;
 exports.applyPreToolUseHooksForBridge = require_LocalProgrammaticToolCalling.applyPreToolUseHooksForBridge;
 exports.apportionTokenCounts = require_tokens.apportionTokenCounts;
 exports.askUserQuestion = require_askUserQuestion.askUserQuestion;
@@ -379,13 +392,16 @@ exports.calculateMaxToolCallInputChars = require_prune.calculateMaxToolCallInput
 exports.calculateMaxToolResultChars = require_truncation.calculateMaxToolResultChars;
 exports.calculateMaxTotalToolOutputSize = require_truncation.calculateMaxTotalToolOutputSize;
 exports.calculateTotalTokens = require_prune.calculateTotalTokens;
+exports.canSealPreempt = require_preempt.canSealPreempt;
 exports.checkValidNumber = require_prune.checkValidNumber;
 exports.clampCalibrationRatio = require_prune.clampCalibrationRatio;
 exports.classifyAttachment = require_attachments.classifyAttachment;
 exports.clientExecTimeoutMs = require_CloudflareSandboxExecutionEngine.clientExecTimeoutMs;
 exports.clientFsTimeoutMs = require_CloudflareSandboxExecutionEngine.clientFsTimeoutMs;
 exports.cloneMessage = require_cache.cloneMessage;
+exports.coalesceAdjacentUserTurns = require_alternation.coalesceAdjacentUserTurns;
 exports.composeEventHandlers = require_events.composeEventHandlers;
+exports.convertInjectedMessages = require_injected.convertInjectedMessages;
 exports.convertMessagesToContent = require_core.convertMessagesToContent;
 exports.countNestedGroups = require_ToolSearch.countNestedGroups;
 exports.countrySchema = require_schema$2.countrySchema;
@@ -435,6 +451,7 @@ exports.createSchemaOnlyTools = require_schema$1.createSchemaOnlyTools;
 exports.createSearchTool = require_tool.createSearchTool;
 exports.createSubagentToolDefinition = require_SubagentTool.createSubagentToolDefinition;
 exports.createTokenCounter = require_tokens.createTokenCounter;
+exports.createToolErrorOwnership = require_ToolNode.createToolErrorOwnership;
 exports.createToolPolicyHook = require_createToolPolicyHook.createToolPolicyHook;
 exports.createToolSearch = require_ToolSearch.createToolSearch;
 exports.createWorkspacePolicyHook = require_createWorkspacePolicyHook.createWorkspacePolicyHook;
@@ -442,6 +459,7 @@ exports.dateSchema = require_schema$2.dateSchema;
 exports.decodeFile = require_textEncoding.decodeFile;
 exports.defaultOmitOptions = require_run$1.defaultOmitOptions;
 exports.deserializeMessage = require_messageSerialization.deserializeMessage;
+exports.dispatchesChatModelStream = require_stream.dispatchesChatModelStream;
 exports.emptyOutputMessage = require_CodeExecutor.emptyOutputMessage;
 exports.encodeFile = require_textEncoding.encodeFile;
 exports.encodingForModel = require_tokens.encodingForModel;
@@ -548,6 +566,7 @@ exports.isDangerousPattern = require_ToolSearch.isDangerousPattern;
 exports.isFromAnyMcpServer = require_ToolSearch.isFromAnyMcpServer;
 exports.isFromMcpServer = require_ToolSearch.isFromMcpServer;
 exports.isGoogleLike = require_llm.isGoogleLike;
+exports.isIntentLabelProperty = require_intentArg.isIntentLabelProperty;
 Object.defineProperty(exports, "isInterrupted", {
 	enumerable: true,
 	get: function() {
@@ -582,6 +601,7 @@ exports.normalizeCodeApiRequestError = require_CodeExecutor.normalizeCodeApiRequ
 exports.normalizeServerFilter = require_ToolSearch.normalizeServerFilter;
 exports.normalizeToBashIdentifier = require_BashProgrammaticToolCalling.normalizeToBashIdentifier;
 exports.normalizeToPythonIdentifier = require_ProgrammaticToolCalling.normalizeToPythonIdentifier;
+exports.outcomeFieldsFromResult = require_intentArg.outcomeFieldsFromResult;
 exports.parseBooleanEnv = require_misc.parseBooleanEnv;
 exports.partitionAndMarkAnthropicToolCache = require_anthropicToolCache.partitionAndMarkAnthropicToolCache;
 exports.performLocalSearch = require_ToolSearch.performLocalSearch;
@@ -601,6 +621,9 @@ exports.projectStructuredToolOutputsToText = require_core.projectStructuredToolO
 exports.projectToolCallInputs = require_prune.projectToolCallInputs;
 exports.projectToolStreamContentForProvider = require_core.projectToolStreamContentForProvider;
 exports.querySchema = require_schema$2.querySchema;
+exports.readIntent = require_intentArg.readIntent;
+exports.readOutcomeFields = require_intentArg.readOutcomeFields;
+exports.removePredecessorHandoffCue = require_handoffCue.removePredecessorHandoffCue;
 exports.repairOrphanedToolMessages = require_prune.repairOrphanedToolMessages;
 exports.resetIfNotEmpty = require_graph.resetIfNotEmpty;
 exports.resolveBedrockPromptCacheTtl = require_cache.resolveBedrockPromptCacheTtl;
@@ -612,7 +635,9 @@ exports.resolveLocalExecutionTools = require_resolveLocalExecutionTools.resolveL
 exports.resolveLocalToolRegistry = require_resolveLocalExecutionTools.resolveLocalToolRegistry;
 exports.resolveLocalToolsForBinding = require_resolveLocalExecutionTools.resolveLocalToolsForBinding;
 exports.resolvePromptCacheTtl = require_cache.resolvePromptCacheTtl;
+exports.resolveSearchOutcome = require_tool.resolveSearchOutcome;
 exports.resolveSubagentConfigs = require_SubagentExecutor.resolveSubagentConfigs;
+exports.resolveToolOutcome = require_intentArg.resolveToolOutcome;
 exports.resolveWorkspacePath = require_LocalExecutionEngine.resolveWorkspacePath;
 exports.resolveWorkspacePathSafe = require_LocalExecutionEngine.resolveWorkspacePathSafe;
 exports.runBashAstChecks = require_bashAst.runBashAstChecks;
@@ -627,9 +652,11 @@ exports.shouldTriggerSummarization = require_index$9.shouldTriggerSummarization;
 exports.sleep = require_run.sleep;
 exports.spawnLocalProcess = require_LocalExecutionEngine.spawnLocalProcess;
 exports.splitAtRecencyBoundary = require_recency.splitAtRecencyBoundary;
+exports.strictAlternationProviders = require_alternation.strictAlternationProviders;
 exports.stripAnthropicCacheControl = require_cache.stripAnthropicCacheControl;
 exports.stripBedrockCacheControl = require_cache.stripBedrockCacheControl;
 exports.stripCodeSessionFileSummary = require_CodeSessionFileSummary.stripCodeSessionFileSummary;
+exports.stripIntent = require_intentArg.stripIntent;
 exports.summarizeEvent = require_SubagentExecutor.summarizeEvent;
 exports.supportsBedrockToolCache = require_cache.supportsBedrockToolCache;
 exports.syncBudgetDerivedFields = require_budget.syncBudgetDerivedFields;
@@ -652,4 +679,5 @@ exports.validateBashCommand = require_LocalExecutionEngine.validateBashCommand;
 exports.validateCloudflareBashCommand = require_CloudflareSandboxExecutionEngine.validateCloudflareBashCommand;
 exports.videosSchema = require_schema$2.videosSchema;
 exports.withClientTimeout = require_CloudflareSandboxExecutionEngine.withClientTimeout;
+exports.withIntent = require_intentArg.withIntent;
 exports.withMessageRole = require_format.withMessageRole;

package/dist/cjs/messages/alternation.cjs

@@ -0,0 +1,92 @@
+require("../common/enum.cjs");
+require("../common/index.cjs");
+let _langchain_core_messages = require("@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 _langchain_core_messages.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
+exports.coalesceAdjacentUserTurns = coalesceAdjacentUserTurns;
+exports.strictAlternationProviders = strictAlternationProviders;
+
+//# sourceMappingURL=alternation.cjs.map

package/dist/cjs/messages/alternation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"alternation.cjs","names":["HumanMessage"],"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,IAAIA,yBAAAA,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/cjs/messages/format.cjs

@@ -182,6 +182,19 @@ function formatToolCallOutput(output) {
 	return require_toolContent.compactToolContent(output, require_truncation.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 _langchain_core_messages.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;