@librechat/agents 3.4.7 → 3.5.1

package/dist/esm/llm/vertexai/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/llm/vertexai/index.ts"],"sourcesContent":["import { ChatGoogle } from '@langchain/google-gauth';\nimport { ChatConnection } from '@langchain/google-common';\nimport { AIMessageChunk, isAIMessage } from '@langchain/core/messages';\nimport type {\n  GeminiContent,\n  GeminiRequest,\n  GoogleAIModelRequestParams,\n  GoogleAbstractedClient,\n} from '@langchain/google-common';\nimport type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';\nimport type { BaseMessage, UsageMetadata } from '@langchain/core/messages';\nimport type { ChatGenerationChunk } from '@langchain/core/outputs';\nimport type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';\nimport {\n  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,\n  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,\n  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,\n} from '@/tools/streamedToolCallSeals';\nimport { smoothGenerationChunks } from '@/llm/stream/chunkAdapters';\nimport { resolveStreamDelay } from '@/llm/stream/smoother';\n\n/**\n * `@langchain/google-common`'s `_streamResponseChunks` emits usage on TWO\n * different paths within the same stream:\n *\n *   - Streaming chunks set `chunk.generationInfo.usage_metadata` via\n *     `responseToUsageMetadata`, which correctly sums\n *     `candidatesTokenCount + thoughtsTokenCount` and includes\n *     `output_token_details.reasoning`.\n *   - The trailing fallback chunk (emitted after the API stream exhausts)\n *     attaches its own `chunk.message.usage_metadata` built inline as\n *     `output_tokens = candidatesTokenCount` only — dropping\n *     `thoughtsTokenCount` and `output_token_details` entirely.\n *\n * After `AIMessageChunk.concat`, only `message.usage_metadata` survives —\n * which is the buggy fallback value. This breaks the documented\n * `total_tokens === input_tokens + output_tokens` invariant and silently\n * undercharges thinking models for reasoning tokens.\n *\n * The repair: track the last `generationInfo.usage_metadata` we see, and\n * when the fallback chunk arrives with its buggy `message.usage_metadata`,\n * replace it with the tracked good value. `CustomChatGoogleGenerativeAI`\n * solves the same problem for the Google API path differently — by\n * overriding `_convertToUsageMetadata`.\n */\nexport function repairStreamUsageMetadata(\n  current: UsageMetadata | undefined,\n  generationInfoUsage: UsageMetadata | undefined\n): UsageMetadata | undefined {\n  if (!current) return current;\n  if (!generationInfoUsage) return current;\n  if (generationInfoUsage.total_tokens !== current.total_tokens) return current;\n  if (generationInfoUsage.output_tokens <= current.output_tokens)\n    return current;\n  return generationInfoUsage;\n}\n\n/**\n * The Gemini API delivers function calls as complete objects — never as\n * partial arg deltas. `@langchain/google-common` pre-parses each streamed\n * functionCall part into `tool_calls` (invalid args land in\n * `invalid_tool_calls` instead), so a chunk whose tool-call chunks all parsed\n * cleanly is sealed on arrival for eager tool execution. Anything that fails\n * the parse check is left unstamped and falls back to the lazy path.\n */\nexport function sealCompleteStreamedToolCalls(message: AIMessageChunk): void {\n  const chunkCount = message.tool_call_chunks?.length ?? 0;\n  if (\n    chunkCount === 0 ||\n    (message.invalid_tool_calls?.length ?? 0) > 0 ||\n    (message.tool_calls?.length ?? 0) !== chunkCount\n  ) {\n    return;\n  }\n  message.response_metadata = {\n    ...message.response_metadata,\n    [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:\n      GOOGLE_STREAMED_TOOL_CALL_ADAPTER,\n    [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'all' },\n  };\n}\n\ntype AdditionalKwargs =\n  | undefined\n  | (BaseMessage['additional_kwargs'] & {\n      signatures?: Array<string | undefined>;\n    });\n\n/**\n * Fixes thought signatures on functionCall parts in the formatted Gemini request.\n *\n * `@langchain/google-common` stores signatures as a flat array in\n * `additional_kwargs.signatures` (one per response part) and re-attaches them\n * by index only when `signatures.length === parts.length`. This fails when:\n * - The API omits a signature (length mismatch)\n * - Streaming chunks merge with different part counts\n * - The signature for a functionCall part is an empty string\n *\n * This function correlates each \"model\" content block in the formatted request\n * back to its originating AI message by *position*, then re-attaches non-empty\n * signatures that the library failed to apply. AI messages without signatures\n * still consume their slot — filtering them out shifted later messages onto\n * the wrong content block and dropped real signatures on the floor.\n */\nexport function fixThoughtSignatures(\n  contents: GeminiContent[],\n  input: BaseMessage[]\n): void {\n  // All AI messages, in order — non-signature ones still consume positional\n  // slots so later messages line up with their model content blocks.\n  const aiMessages = input.filter(isAIMessage);\n  const modelContents = contents.filter((c) => c.role === 'model');\n\n  const count = Math.min(aiMessages.length, modelContents.length);\n  for (let i = 0; i < count; i++) {\n    const signatures = (aiMessages[i].additional_kwargs as AdditionalKwargs)\n      ?.signatures;\n    if (!Array.isArray(signatures) || signatures.length === 0) continue;\n\n    const content = modelContents[i];\n    const attachedSignatures = new Set(\n      content.parts\n        .map((p) => p.thoughtSignature)\n        .filter((s): s is string => s != null && s !== '')\n    );\n    const availableSignatures = signatures.filter(\n      (s): s is string => s != null && s !== '' && !attachedSignatures.has(s)\n    );\n\n    let sigIdx = 0;\n    for (const part of content.parts) {\n      if (\n        'functionCall' in part &&\n        (part.thoughtSignature == null || part.thoughtSignature === '') &&\n        sigIdx < availableSignatures.length\n      ) {\n        part.thoughtSignature = availableSignatures[sigIdx];\n        sigIdx++;\n      }\n    }\n  }\n}\n\nclass CustomChatConnection extends ChatConnection<VertexAIClientOptions> {\n  thinkingConfig?: GoogleThinkingConfig;\n\n  async formatData(\n    input: BaseMessage[],\n    parameters: GoogleAIModelRequestParams\n  ): Promise<unknown> {\n    const formattedData = (await super.formatData(\n      input,\n      parameters\n    )) as GeminiRequest;\n    if (formattedData.generationConfig?.thinkingConfig?.thinkingBudget === -1) {\n      // -1 means \"let the model decide\" - delete the property so the API doesn't receive an invalid value\n      if (\n        formattedData.generationConfig.thinkingConfig.includeThoughts === false\n      ) {\n        formattedData.generationConfig.thinkingConfig.includeThoughts = true;\n      }\n      delete formattedData.generationConfig.thinkingConfig.thinkingBudget;\n    }\n    if (this.thinkingConfig?.thinkingLevel != null) {\n      formattedData.generationConfig ??= {};\n      // thinkingLevel and thinkingBudget cannot coexist — the API rejects the request.\n      // Remove thinkingBudget when thinkingLevel is set.\n      const { thinkingBudget: _, ...existingThinkingConfig } =\n        (formattedData.generationConfig.thinkingConfig as\n          | Record<string, unknown>\n          | undefined) ?? {};\n      (\n        formattedData.generationConfig as Record<string, unknown>\n      ).thinkingConfig = {\n        ...existingThinkingConfig,\n        thinkingLevel: this.thinkingConfig.thinkingLevel,\n        ...(this.thinkingConfig.includeThoughts != null && {\n          includeThoughts: this.thinkingConfig.includeThoughts,\n        }),\n      };\n    }\n    if (formattedData.contents) {\n      fixThoughtSignatures(formattedData.contents, input);\n      // gemini-3.1+ models reject role=\"function\"; convert to role=\"user\"\n      for (const content of formattedData.contents) {\n        if (content.role === 'function') {\n          (content as { role: string }).role = 'user';\n        }\n      }\n    }\n    return formattedData;\n  }\n}\n\n/**\n * Integration with Google Vertex AI chat models.\n *\n * Setup:\n * Install `@langchain/google-vertexai` and set your stringified\n * Vertex AI credentials as an environment variable named `GOOGLE_APPLICATION_CREDENTIALS`.\n *\n * ```bash\n * npm install @langchain/google-vertexai\n * export GOOGLE_APPLICATION_CREDENTIALS=\"path/to/credentials\"\n * ```\n *\n * ## [Constructor args](https://api.js.langchain.com/classes/_langchain_google_vertexai.index.ChatVertexAI.html#constructor.new_ChatVertexAI)\n *\n * ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_google_common_types.GoogleAIBaseLanguageModelCallOptions.html)\n *\n * Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.\n * They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:\n *\n * ```typescript\n * // When calling `.withConfig`, call options should be passed via the first argument\n * const llmWithArgsBound = llm.withConfig({\n *   stop: [\"\\n\"],\n *   tools: [...],\n * });\n *\n * // When calling `.bindTools`, call options should be passed via the second argument\n * const llmWithTools = llm.bindTools(\n *   [...],\n *   {\n *     tool_choice: \"auto\",\n *   }\n * );\n * ```\n *\n * ## Examples\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { ChatVertexAI } from '@langchain/google-vertexai';\n *\n * const llm = new ChatVertexAI({\n *   model: \"gemini-1.5-pro\",\n *   temperature: 0,\n *   // other params...\n * });\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Invoking</strong></summary>\n *\n * ```typescript\n * const input = `Translate \"I love programming\" into French.`;\n *\n * // Models also accept a list of chat messages or a formatted prompt\n * const result = await llm.invoke(input);\n * console.log(result);\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"content\": \"\\\"J'adore programmer\\\" \\n\\nHere's why this is the best translation:\\n\\n* **J'adore** means \\\"I love\\\" and conveys a strong passion.\\n* **Programmer** is the French verb for \\\"to program.\\\"\\n\\nThis translation is natural and idiomatic in French. \\n\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {},\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": [],\n *   \"usage_metadata\": {\n *     \"input_tokens\": 9,\n *     \"output_tokens\": 63,\n *     \"total_tokens\": 72\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Streaming Chunks</strong></summary>\n *\n * ```typescript\n * for await (const chunk of await llm.stream(input)) {\n *   console.log(chunk);\n * }\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"content\": \"\\\"\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {},\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": []\n * }\n * AIMessageChunk {\n *   \"content\": \"J'adore programmer\\\" \\n\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {},\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": []\n * }\n * AIMessageChunk {\n *   \"content\": \"\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {},\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": []\n * }\n * AIMessageChunk {\n *   \"content\": \"\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {\n *     \"finishReason\": \"stop\"\n *   },\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": [],\n *   \"usage_metadata\": {\n *     \"input_tokens\": 9,\n *     \"output_tokens\": 8,\n *     \"total_tokens\": 17\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Aggregate Streamed Chunks</strong></summary>\n *\n * ```typescript\n * import { AIMessageChunk } from '@langchain/core/messages';\n * import { concat } from '@langchain/core/utils/stream';\n *\n * const stream = await llm.stream(input);\n * let full: AIMessageChunk | undefined;\n * for await (const chunk of stream) {\n *   full = !full ? chunk : concat(full, chunk);\n * }\n * console.log(full);\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"content\": \"\\\"J'adore programmer\\\" \\n\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {\n *     \"finishReason\": \"stop\"\n *   },\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": [],\n *   \"usage_metadata\": {\n *     \"input_tokens\": 9,\n *     \"output_tokens\": 8,\n *     \"total_tokens\": 17\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Bind tools</strong></summary>\n *\n * ```typescript\n * import { z } from 'zod';\n *\n * const GetWeather = {\n *   name: \"GetWeather\",\n *   description: \"Get the current weather in a given location\",\n *   schema: z.object({\n *     location: z.string().describe(\"The city and state, e.g. San Francisco, CA\")\n *   }),\n * }\n *\n * const GetPopulation = {\n *   name: \"GetPopulation\",\n *   description: \"Get the current population in a given location\",\n *   schema: z.object({\n *     location: z.string().describe(\"The city and state, e.g. San Francisco, CA\")\n *   }),\n * }\n *\n * const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);\n * const aiMsg = await llmWithTools.invoke(\n *   \"Which city is hotter today and which is bigger: LA or NY?\"\n * );\n * console.log(aiMsg.tool_calls);\n * ```\n *\n * ```txt\n * [\n *   {\n *     name: 'GetPopulation',\n *     args: { location: 'New York City, NY' },\n *     id: '33c1c1f47e2f492799c77d2800a43912',\n *     type: 'tool_call'\n *   }\n * ]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Structured Output</strong></summary>\n *\n * ```typescript\n * import { z } from 'zod';\n *\n * const Joke = z.object({\n *   setup: z.string().describe(\"The setup of the joke\"),\n *   punchline: z.string().describe(\"The punchline to the joke\"),\n *   rating: z.number().optional().describe(\"How funny the joke is, from 1 to 10\")\n * }).describe('Joke to tell user.');\n *\n * const structuredLlm = llm.withStructuredOutput(Joke, { name: \"Joke\" });\n * const jokeResult = await structuredLlm.invoke(\"Tell me a joke about cats\");\n * console.log(jokeResult);\n * ```\n *\n * ```txt\n * {\n *   setup: 'What do you call a cat that loves to bowl?',\n *   punchline: 'An alley cat!'\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Usage Metadata</strong></summary>\n *\n * ```typescript\n * const aiMsgForMetadata = await llm.invoke(input);\n * console.log(aiMsgForMetadata.usage_metadata);\n * ```\n *\n * ```txt\n * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Stream Usage Metadata</strong></summary>\n *\n * ```typescript\n * const streamForMetadata = await llm.stream(\n *   input,\n *   {\n *     streamUsage: true\n *   }\n * );\n * let fullForMetadata: AIMessageChunk | undefined;\n * for await (const chunk of streamForMetadata) {\n *   fullForMetadata = !fullForMetadata ? chunk : concat(fullForMetadata, chunk);\n * }\n * console.log(fullForMetadata?.usage_metadata);\n * ```\n *\n * ```txt\n * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }\n * ```\n * </details>\n *\n * <br />\n */\nexport class ChatVertexAI extends ChatGoogle {\n  lc_namespace = ['langchain', 'chat_models', 'vertexai'];\n  _lc_stream_delay: number;\n  dynamicThinkingBudget = false;\n  thinkingConfig?: GoogleThinkingConfig;\n\n  static lc_name(): 'LibreChatVertexAI' {\n    return 'LibreChatVertexAI';\n  }\n\n  constructor(model: string, fields?: Omit<VertexAIClientOptions, 'model'>);\n  constructor(fields?: VertexAIClientOptions);\n  constructor(\n    modelOrFields?: string | VertexAIClientOptions,\n    params?: Omit<VertexAIClientOptions, 'model'>\n  ) {\n    const fields =\n      typeof modelOrFields === 'string'\n        ? { ...(params ?? {}), model: modelOrFields }\n        : modelOrFields;\n    const dynamicThinkingBudget = fields?.thinkingBudget === -1;\n    super({\n      ...fields,\n      platformType: 'gcp',\n    });\n    this.dynamicThinkingBudget = dynamicThinkingBudget;\n    this.thinkingConfig = fields?.thinkingConfig;\n    this._lc_stream_delay = resolveStreamDelay(fields?._lc_stream_delay);\n  }\n  invocationParams(\n    options?: this['ParsedCallOptions'] | undefined\n  ): GoogleAIModelRequestParams {\n    const params = super.invocationParams(options);\n    if (this.dynamicThinkingBudget) {\n      params.maxReasoningTokens = -1;\n    }\n    return params;\n  }\n  async *_streamResponseChunks(\n    messages: BaseMessage[],\n    options: this['ParsedCallOptions'],\n    runManager?: CallbackManagerForLLMRun\n  ): AsyncGenerator<ChatGenerationChunk> {\n    yield* smoothGenerationChunks({\n      chunks: this._streamRepairedChunks(messages, options),\n      delayMs: this._lc_stream_delay,\n      signal: options.signal,\n      runManager,\n    });\n  }\n\n  private async *_streamRepairedChunks(\n    messages: BaseMessage[],\n    options: this['ParsedCallOptions']\n  ): AsyncGenerator<ChatGenerationChunk> {\n    let lastGoodUsage: UsageMetadata | undefined;\n    for await (const chunk of super._streamResponseChunks(\n      messages,\n      options,\n      undefined\n    )) {\n      const genUsage = (\n        chunk.generationInfo as { usage_metadata?: UsageMetadata } | undefined\n      )?.usage_metadata;\n      if (genUsage) {\n        lastGoodUsage = genUsage;\n      }\n      if (chunk.message instanceof AIMessageChunk) {\n        const repaired = repairStreamUsageMetadata(\n          chunk.message.usage_metadata,\n          lastGoodUsage\n        );\n        if (repaired !== chunk.message.usage_metadata) {\n          chunk.message.usage_metadata = repaired;\n        }\n        sealCompleteStreamedToolCalls(chunk.message);\n      }\n      yield chunk;\n    }\n  }\n  buildConnection(\n    fields: VertexAIClientOptions | undefined,\n    client: GoogleAbstractedClient\n  ): void {\n    // Note: buildConnection is called from super() BEFORE this.thinkingConfig is set,\n    // so we must read thinkingConfig from `fields` directly.\n    const thinkingConfig = fields?.thinkingConfig ?? this.thinkingConfig;\n\n    const connection = new CustomChatConnection(\n      { ...fields, ...this },\n      this.caller,\n      client,\n      false\n    );\n    connection.thinkingConfig = thinkingConfig;\n    this.connection = connection;\n\n    const streamedConnection = new CustomChatConnection(\n      { ...fields, ...this },\n      this.caller,\n      client,\n      true\n    );\n    streamedConnection.thinkingConfig = thinkingConfig;\n    this.streamedConnection = streamedConnection;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/llm/vertexai/index.ts"],"mappings":"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"}

package/dist/esm/messages/alternation.mjs

@@ -2,27 +2,12 @@ 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;
@@ -39,15 +24,6 @@ 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;
@@ -60,29 +36,10 @@ function coalesceAdjacentUserTurns(messages) {
 		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

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

@@ -1 +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"}
+{"version":3,"file":"alternation.mjs","names":[],"sources":["../../../src/messages/alternation.ts"],"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/anthropicToolCache.mjs

@@ -17,32 +17,13 @@ function isAnthropicBuiltInTool(tool) {
 	const { type } = tool;
 	return typeof type === "string" && ANTHROPIC_BUILT_IN_TOOL_PREFIXES.some((prefix) => type.startsWith(prefix));
 }
-/**
-* Whether a tool already carries a cache breakpoint. Built-ins use a direct
-* `cache_control`; custom tools normally carry it under `extras`, but a
-* caller-supplied Anthropic-native tool object can also put it directly on the
-* block — check both so stale markers are never missed.
-*/
 function hasCacheControl(tool) {
 	if (isAnthropicBuiltInTool(tool)) return tool.cache_control != null;
 	return tool.cache_control != null || tool.extras?.cache_control != null;
 }
-/**
-* Return the `cache_control` from the location that actually reaches the
-* Anthropic payload for this tool's shape: directly on the block for
-* provider-shaped tools (built-ins and raw Anthropic tools), or under `extras`
-* for LangChain custom tools (the adapter promotes only that). Returns
-* `undefined` when no marker sits in the effective location — a marker in the
-* wrong place (e.g. a direct marker on a custom tool) does not count.
-*/
 function getEffectiveCacheControl(tool) {
 	return isProviderShapedTool(tool) ? tool.cache_control : tool.extras?.cache_control;
 }
-/**
-* Return a clone of `tool` with any `cache_control` removed — both the direct
-* block marker and the `extras` marker — preserving the prototype chain. Used
-* to clear stray markers off tools that must not anchor a competing breakpoint.
-*/
 function stripCacheControl(tool) {
 	const prototype = Object.getPrototypeOf(tool) ?? Object.prototype;
 	const wrapped = { ...tool };
@@ -53,13 +34,6 @@ function stripCacheControl(tool) {
 	}
 	return Object.assign(Object.create(prototype), wrapped);
 }
-/**
-* Whether `tool` is already in the Anthropic provider payload shape — an
-* Anthropic built-in or a raw Anthropic tool object (has `input_schema`). These
-* carry `cache_control` directly on the block; the LangChain adapter does NOT
-* promote `extras.cache_control` for them. LangChain StructuredTools, by
-* contrast, expose the marker via `extras`.
-*/
 function isProviderShapedTool(tool) {
 	return isAnthropicBuiltInTool(tool) || "input_schema" in tool;
 }
@@ -78,12 +52,6 @@ function markCacheControl(tool, ttl) {
 		cache_control: cacheControl
 	} });
 }
-/**
-* Returns a callable that reports whether a given tool *name* is deferred
-* according to the supplied registry of tool definitions. Tools without
-* a registry entry are treated as non-deferred (i.e. static), matching
-* the host-supplied `graphTools` semantics elsewhere in the SDK.
-*/
 function makeIsDeferred(toolDefinitions) {
 	if (toolDefinitions == null || toolDefinitions.length === 0) return () => false;
 	const deferred = /* @__PURE__ */ new Set();
@@ -91,19 +59,6 @@ function makeIsDeferred(toolDefinitions) {
 	if (deferred.size === 0) return () => false;
 	return (name) => deferred.has(name);
 }
-/**
-* Stable-partition `tools` into [static..., deferred...] and stamp the
-* Anthropic `cache_control: ephemeral` marker on the last static tool.
-*
-* If `tools` is undefined or empty, or no entry has a usable `.name`,
-* returns the input unchanged. If there are no static tools at all,
-* also returns unchanged (nothing to cache).
-*
-* The original tool instances are never mutated. The marked entry is a
-* shallow wrapper that preserves the prototype chain so downstream
-* `instanceof` checks still pass. For custom tools, `extras` is merged
-* so any existing `providerToolDefinition` / other extras are kept.
-*/
 function partitionAndMarkAnthropicToolCache(tools, isDeferred, ttl) {
 	if (tools == null || tools.length === 0) return tools;
 	const staticTools = [];

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

@@ -1 +1 @@
-{"version":3,"file":"anthropicToolCache.mjs","names":[],"sources":["../../../src/messages/anthropicToolCache.ts"],"sourcesContent":["/**\n * Anthropic prompt-caching helper for the `tools[]` request field.\n *\n * Anthropic accepts `cache_control: { type: 'ephemeral' }` on individual\n * tool definitions. Whichever tool carries the marker becomes the end of\n * a cached prefix: `tools[0..N]` (everything up to and including the\n * marked tool) is cached and rebated on subsequent matching requests.\n *\n * For agents that mix static and deferred (lazily-discovered) tools, the\n * winning configuration is:\n *\n *   1. Stable-partition tools so all *static* (non-deferred) tools come\n *      first and discovered-deferred tools come last.\n *   2. Stamp `cache_control` on the LAST static tool.\n *\n * That way, the cached prefix covers exactly the static tool inventory.\n * Discovered tools that show up later (or vary turn-to-turn as new ones\n * get discovered) never invalidate the prefix because they sit *after*\n * the breakpoint.\n *\n * LangChain's Anthropic adapter passes the marker through via\n * `tool.extras.cache_control` for custom tools, while Anthropic built-ins\n * require direct `cache_control`. Either way, we stamp a fresh wrapper —\n * never mutating the original tool instance, since callers may share them\n * across runs.\n */\n\nimport type { GraphTools } from '@/types';\nimport {\n  buildAnthropicCacheControl,\n  type PromptCacheTtl,\n} from '@/messages/cache';\n\nconst ANTHROPIC_BUILT_IN_TOOL_PREFIXES = [\n  'text_editor_',\n  'computer_',\n  'bash_',\n  'web_search_',\n  'web_fetch_',\n  'str_replace_editor_',\n  'str_replace_based_edit_tool_',\n  'code_execution_',\n  'memory_',\n  'tool_search_',\n  'mcp_toolset',\n] as const;\n\ntype AnthropicToolCacheCandidate = {\n  name?: unknown;\n  type?: unknown;\n  extras?: Record<string, unknown>;\n  cache_control?: unknown;\n};\n\nfunction isAnthropicBuiltInTool(\n  tool: AnthropicToolCacheCandidate\n): tool is AnthropicToolCacheCandidate & { type: string } {\n  const { type } = tool;\n  return (\n    typeof type === 'string' &&\n    ANTHROPIC_BUILT_IN_TOOL_PREFIXES.some((prefix) => type.startsWith(prefix))\n  );\n}\n\n/**\n * Whether a tool already carries a cache breakpoint. Built-ins use a direct\n * `cache_control`; custom tools normally carry it under `extras`, but a\n * caller-supplied Anthropic-native tool object can also put it directly on the\n * block — check both so stale markers are never missed.\n */\nfunction hasCacheControl(tool: AnthropicToolCacheCandidate): boolean {\n  if (isAnthropicBuiltInTool(tool)) {\n    return tool.cache_control != null;\n  }\n  return tool.cache_control != null || tool.extras?.cache_control != null;\n}\n\n/**\n * Return the `cache_control` from the location that actually reaches the\n * Anthropic payload for this tool's shape: directly on the block for\n * provider-shaped tools (built-ins and raw Anthropic tools), or under `extras`\n * for LangChain custom tools (the adapter promotes only that). Returns\n * `undefined` when no marker sits in the effective location — a marker in the\n * wrong place (e.g. a direct marker on a custom tool) does not count.\n */\nfunction getEffectiveCacheControl(\n  tool: AnthropicToolCacheCandidate\n): { ttl?: unknown } | undefined {\n  return (\n    isProviderShapedTool(tool) ? tool.cache_control : tool.extras?.cache_control\n  ) as { ttl?: unknown } | undefined;\n}\n\n/**\n * Return a clone of `tool` with any `cache_control` removed — both the direct\n * block marker and the `extras` marker — preserving the prototype chain. Used\n * to clear stray markers off tools that must not anchor a competing breakpoint.\n */\nfunction stripCacheControl(\n  tool: AnthropicToolCacheCandidate\n): AnthropicToolCacheCandidate {\n  const prototype = Object.getPrototypeOf(tool) ?? Object.prototype;\n  const wrapped = { ...tool };\n  delete wrapped.cache_control;\n  if (wrapped.extras != null) {\n    wrapped.extras = { ...wrapped.extras };\n    delete wrapped.extras.cache_control;\n  }\n  return Object.assign(Object.create(prototype), wrapped);\n}\n\n/**\n * Whether `tool` is already in the Anthropic provider payload shape — an\n * Anthropic built-in or a raw Anthropic tool object (has `input_schema`). These\n * carry `cache_control` directly on the block; the LangChain adapter does NOT\n * promote `extras.cache_control` for them. LangChain StructuredTools, by\n * contrast, expose the marker via `extras`.\n */\nfunction isProviderShapedTool(tool: AnthropicToolCacheCandidate): boolean {\n  return (\n    isAnthropicBuiltInTool(tool) ||\n    'input_schema' in (tool as Record<string, unknown>)\n  );\n}\n\nfunction markCacheControl(\n  tool: AnthropicToolCacheCandidate,\n  ttl?: PromptCacheTtl\n): AnthropicToolCacheCandidate {\n  const cacheControl = buildAnthropicCacheControl(ttl);\n  const prototype = Object.getPrototypeOf(tool) ?? Object.prototype;\n  if (isProviderShapedTool(tool)) {\n    // Built-ins and raw Anthropic tool objects carry cache_control directly on\n    // the block; `extras` is not promoted onto the payload for these shapes.\n    const wrapped = { ...tool };\n    delete wrapped.extras;\n    return Object.assign(Object.create(prototype), wrapped, {\n      cache_control: cacheControl,\n    });\n  }\n\n  // LangChain custom tools: drop any direct marker and expose the breakpoint via\n  // `extras`, which the Anthropic adapter promotes onto the payload.\n  const wrapped = { ...tool };\n  delete wrapped.cache_control;\n  return Object.assign(Object.create(prototype), wrapped, {\n    extras: {\n      ...(tool.extras ?? {}),\n      cache_control: cacheControl,\n    },\n  });\n}\n\n/**\n * Returns a callable that reports whether a given tool *name* is deferred\n * according to the supplied registry of tool definitions. Tools without\n * a registry entry are treated as non-deferred (i.e. static), matching\n * the host-supplied `graphTools` semantics elsewhere in the SDK.\n */\nexport function makeIsDeferred(\n  toolDefinitions:\n    | ReadonlyArray<{ name: string; defer_loading?: boolean }>\n    | undefined\n): (toolName: string) => boolean {\n  if (toolDefinitions == null || toolDefinitions.length === 0) {\n    return () => false;\n  }\n  const deferred = new Set<string>();\n  for (const def of toolDefinitions) {\n    if (def.defer_loading === true) deferred.add(def.name);\n  }\n  if (deferred.size === 0) return () => false;\n  return (name) => deferred.has(name);\n}\n\n/**\n * Stable-partition `tools` into [static..., deferred...] and stamp the\n * Anthropic `cache_control: ephemeral` marker on the last static tool.\n *\n * If `tools` is undefined or empty, or no entry has a usable `.name`,\n * returns the input unchanged. If there are no static tools at all,\n * also returns unchanged (nothing to cache).\n *\n * The original tool instances are never mutated. The marked entry is a\n * shallow wrapper that preserves the prototype chain so downstream\n * `instanceof` checks still pass. For custom tools, `extras` is merged\n * so any existing `providerToolDefinition` / other extras are kept.\n */\nexport function partitionAndMarkAnthropicToolCache(\n  tools: GraphTools | undefined,\n  isDeferred: (toolName: string) => boolean,\n  ttl?: PromptCacheTtl\n): GraphTools | undefined {\n  if (tools == null || tools.length === 0) return tools;\n\n  // Use unknown[] internally to avoid GraphTools' union-array variance\n  // (each member is one of three array types). We cast back to\n  // GraphTools when returning.\n  const staticTools: unknown[] = [];\n  const deferredTools: unknown[] = [];\n\n  for (const tool of tools) {\n    const name = (tool as { name?: unknown }).name;\n    if (typeof name === 'string' && isDeferred(name)) {\n      deferredTools.push(tool);\n    } else {\n      staticTools.push(tool);\n    }\n  }\n\n  // Anthropic serializes ALL tools before system/messages, so a stray\n  // cache_control on any tool — static or deferred — that survives the resolved\n  // breakpoint would violate the longer-TTL-first ordering. Strip stale markers\n  // off the deferred tools first (they sit after the breakpoint but still before\n  // system/messages, and the all-deferred case has no breakpoint of its own).\n  let mutated = false;\n  for (let i = 0; i < deferredTools.length; i++) {\n    const candidate = deferredTools[i] as AnthropicToolCacheCandidate;\n    if (hasCacheControl(candidate)) {\n      deferredTools[i] = stripCacheControl(candidate);\n      mutated = true;\n    }\n  }\n\n  if (staticTools.length === 0) {\n    return mutated ? ([...deferredTools] as GraphTools) : tools;\n  }\n\n  // Strip any stray cache_control off the earlier static tools so a leftover\n  // 5-minute marker never sits ahead of the resolved breakpoint, then stamp (or\n  // re-stamp) only the last static tool with the resolved TTL.\n  for (let i = 0; i < staticTools.length - 1; i++) {\n    const candidate = staticTools[i] as AnthropicToolCacheCandidate;\n    if (hasCacheControl(candidate)) {\n      staticTools[i] = stripCacheControl(candidate);\n      mutated = true;\n    }\n  }\n\n  const last = staticTools[\n    staticTools.length - 1\n  ] as AnthropicToolCacheCandidate;\n  const desiredTtl: '1h' | undefined = ttl === '1h' ? '1h' : undefined;\n  // \"Already correct\" requires a marker IN the effective location (one that\n  // reaches the payload for this tool's shape) carrying the resolved TTL. A\n  // marker in the wrong place — e.g. a direct `cache_control` on a LangChain\n  // custom tool — is ineffective and must be re-stamped.\n  const effective = getEffectiveCacheControl(last);\n  const lastAlreadyCorrect =\n    effective != null &&\n    (effective.ttl === '1h' ? '1h' : undefined) === desiredTtl;\n  if (!lastAlreadyCorrect) {\n    staticTools[staticTools.length - 1] = markCacheControl(last, ttl);\n    mutated = true;\n  }\n\n  // Return the original reference only when nothing changed AND partitioning\n  // moved nothing. When deferred tools exist they must end up after the cache\n  // breakpoint, so the partitioned array is returned even if no marker changed.\n  if (!mutated && deferredTools.length === 0) {\n    return tools;\n  }\n  return [...staticTools, ...deferredTools] as GraphTools;\n}\n"],"mappings":"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"}
+{"version":3,"file":"anthropicToolCache.mjs","names":[],"sources":["../../../src/messages/anthropicToolCache.ts"],"mappings":"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"}

package/dist/esm/messages/assistantPhase.mjs

@@ -4,16 +4,9 @@ import "../common/index.mjs";
 function toAssistantTextPhase(value) {
 	return value === "commentary" || value === "final_answer" ? value : void 0;
 }
-/** Reads both provider-native and LangChain standard-content phase fields. */
 function getAssistantTextPhase(contentPart) {
 	return toAssistantTextPhase(contentPart.phase) ?? toAssistantTextPhase(contentPart.extras?.phase);
 }
-/**
-* Keeps provider-authored text phases in distinct message-creation steps.
-* Open Responses may return commentary and final-answer blocks in one chunk;
-* collapsing the array into one step would assign the first block's phase to
-* every block and hide the boundary that closes an activity phase.
-*/
 function splitAssistantTextContentByPhase(content) {
 	const groups = [];
 	for (const contentPart of content) {
@@ -33,11 +26,6 @@ function isTextPart(contentPart) {
 function isReasoningPart(contentPart) {
 	return contentPart.type === "think" || (contentPart.type?.startsWith("thinking") ?? false) || (contentPart.type?.startsWith("reasoning") ?? false) || (contentPart.type?.startsWith("reasoning_content") ?? false) || contentPart.type === "redacted_thinking";
 }
-/**
-* Derives additive message-creation metadata before a content delta is
-* dispatched. The fallback covers string-only providers whose semantic lane
-* is tracked by the stream handler rather than represented on a block.
-*/
 function getMessageCreationContentMetadata(content, fallbackContentType) {
 	if (!Array.isArray(content)) return fallbackContentType == null ? {} : { content_type: fallbackContentType };
 	const textPart = content.find(isTextPart);

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

@@ -1 +1 @@
-{"version":3,"file":"assistantPhase.mjs","names":[],"sources":["../../../src/messages/assistantPhase.ts"],"sourcesContent":["import type { AssistantTextPhase } from '@/types/assistantPhase';\nimport type { MessageContentComplex } from '@/types/stream';\nimport { ContentTypes } from '@/common';\n\nexport type MessageCreationContentMetadata = {\n  content_type?: ContentTypes.TEXT | ContentTypes.THINK;\n  phase?: AssistantTextPhase;\n};\n\nfunction toAssistantTextPhase(value: unknown): AssistantTextPhase | undefined {\n  return value === 'commentary' || value === 'final_answer' ? value : undefined;\n}\n\n/** Reads both provider-native and LangChain standard-content phase fields. */\nexport function getAssistantTextPhase(\n  contentPart: MessageContentComplex\n): AssistantTextPhase | undefined {\n  return (\n    toAssistantTextPhase(contentPart.phase) ??\n    toAssistantTextPhase(contentPart.extras?.phase)\n  );\n}\n\n/**\n * Keeps provider-authored text phases in distinct message-creation steps.\n * Open Responses may return commentary and final-answer blocks in one chunk;\n * collapsing the array into one step would assign the first block's phase to\n * every block and hide the boundary that closes an activity phase.\n */\nexport function splitAssistantTextContentByPhase(\n  content: MessageContentComplex[]\n): MessageContentComplex[][] {\n  const groups: MessageContentComplex[][] = [];\n  for (const contentPart of content) {\n    const phase = getAssistantTextPhase(contentPart);\n    const currentGroup = groups.at(-1);\n    if (\n      currentGroup == null ||\n      getAssistantTextPhase(currentGroup[0]) !== phase\n    ) {\n      groups.push([contentPart]);\n      continue;\n    }\n    currentGroup.push(contentPart);\n  }\n  return groups;\n}\n\nfunction isTextPart(contentPart: MessageContentComplex): boolean {\n  return contentPart.type?.startsWith(ContentTypes.TEXT) ?? false;\n}\n\nfunction isReasoningPart(contentPart: MessageContentComplex): boolean {\n  return (\n    contentPart.type === ContentTypes.THINK ||\n    (contentPart.type?.startsWith(ContentTypes.THINKING) ?? false) ||\n    (contentPart.type?.startsWith(ContentTypes.REASONING) ?? false) ||\n    (contentPart.type?.startsWith(ContentTypes.REASONING_CONTENT) ?? false) ||\n    contentPart.type === 'redacted_thinking'\n  );\n}\n\n/**\n * Derives additive message-creation metadata before a content delta is\n * dispatched. The fallback covers string-only providers whose semantic lane\n * is tracked by the stream handler rather than represented on a block.\n */\nexport function getMessageCreationContentMetadata(\n  content: string | MessageContentComplex[] | undefined,\n  fallbackContentType?: ContentTypes.TEXT | ContentTypes.THINK\n): MessageCreationContentMetadata {\n  if (!Array.isArray(content)) {\n    return fallbackContentType == null\n      ? {}\n      : { content_type: fallbackContentType };\n  }\n  const textPart = content.find(isTextPart);\n  if (textPart != null) {\n    const phase = getAssistantTextPhase(textPart);\n    return {\n      content_type: ContentTypes.TEXT,\n      ...(phase == null ? {} : { phase }),\n    };\n  }\n  if (content.some(isReasoningPart)) {\n    return { content_type: ContentTypes.THINK };\n  }\n  return fallbackContentType == null\n    ? {}\n    : { content_type: fallbackContentType };\n}\n"],"mappings":";;;AASA,SAAS,qBAAqB,OAAgD;CAC5E,OAAO,UAAU,gBAAgB,UAAU,iBAAiB,QAAQ,KAAA;AACtE;;AAGA,SAAgB,sBACd,aACgC;CAChC,OACE,qBAAqB,YAAY,KAAK,KACtC,qBAAqB,YAAY,QAAQ,KAAK;AAElD;;;;;;;AAQA,SAAgB,iCACd,SAC2B;CAC3B,MAAM,SAAoC,CAAC;CAC3C,KAAK,MAAM,eAAe,SAAS;EACjC,MAAM,QAAQ,sBAAsB,WAAW;EAC/C,MAAM,eAAe,OAAO,GAAG,EAAE;EACjC,IACE,gBAAgB,QAChB,sBAAsB,aAAa,EAAE,MAAM,OAC3C;GACA,OAAO,KAAK,CAAC,WAAW,CAAC;GACzB;EACF;EACA,aAAa,KAAK,WAAW;CAC/B;CACA,OAAO;AACT;AAEA,SAAS,WAAW,aAA6C;CAC/D,OAAO,YAAY,MAAM,WAAA,MAA4B,KAAK;AAC5D;AAEA,SAAS,gBAAgB,aAA6C;CACpE,OACE,YAAY,SAAA,YACX,YAAY,MAAM,WAAA,UAAgC,KAAK,WACvD,YAAY,MAAM,WAAA,WAAiC,KAAK,WACxD,YAAY,MAAM,WAAA,mBAAyC,KAAK,UACjE,YAAY,SAAS;AAEzB;;;;;;AAOA,SAAgB,kCACd,SACA,qBACgC;CAChC,IAAI,CAAC,MAAM,QAAQ,OAAO,GACxB,OAAO,uBAAuB,OAC1B,CAAC,IACD,EAAE,cAAc,oBAAoB;CAE1C,MAAM,WAAW,QAAQ,KAAK,UAAU;CACxC,IAAI,YAAY,MAAM;EACpB,MAAM,QAAQ,sBAAsB,QAAQ;EAC5C,OAAO;GACL,cAAA;GACA,GAAI,SAAS,OAAO,CAAC,IAAI,EAAE,MAAM;EACnC;CACF;CACA,IAAI,QAAQ,KAAK,eAAe,GAC9B,OAAO,EAAE,cAAA,QAAiC;CAE5C,OAAO,uBAAuB,OAC1B,CAAC,IACD,EAAE,cAAc,oBAAoB;AAC1C"}
+{"version":3,"file":"assistantPhase.mjs","names":[],"sources":["../../../src/messages/assistantPhase.ts"],"mappings":";;;AASA,SAAS,qBAAqB,OAAgD;CAC5E,OAAO,UAAU,gBAAgB,UAAU,iBAAiB,QAAQ,KAAA;AACtE;AAGA,SAAgB,sBACd,aACgC;CAChC,OACE,qBAAqB,YAAY,KAAK,KACtC,qBAAqB,YAAY,QAAQ,KAAK;AAElD;AAQA,SAAgB,iCACd,SAC2B;CAC3B,MAAM,SAAoC,CAAC;CAC3C,KAAK,MAAM,eAAe,SAAS;EACjC,MAAM,QAAQ,sBAAsB,WAAW;EAC/C,MAAM,eAAe,OAAO,GAAG,EAAE;EACjC,IACE,gBAAgB,QAChB,sBAAsB,aAAa,EAAE,MAAM,OAC3C;GACA,OAAO,KAAK,CAAC,WAAW,CAAC;GACzB;EACF;EACA,aAAa,KAAK,WAAW;CAC/B;CACA,OAAO;AACT;AAEA,SAAS,WAAW,aAA6C;CAC/D,OAAO,YAAY,MAAM,WAAA,MAA4B,KAAK;AAC5D;AAEA,SAAS,gBAAgB,aAA6C;CACpE,OACE,YAAY,SAAA,YACX,YAAY,MAAM,WAAA,UAAgC,KAAK,WACvD,YAAY,MAAM,WAAA,WAAiC,KAAK,WACxD,YAAY,MAAM,WAAA,mBAAyC,KAAK,UACjE,YAAY,SAAS;AAEzB;AAOA,SAAgB,kCACd,SACA,qBACgC;CAChC,IAAI,CAAC,MAAM,QAAQ,OAAO,GACxB,OAAO,uBAAuB,OAC1B,CAAC,IACD,EAAE,cAAc,oBAAoB;CAE1C,MAAM,WAAW,QAAQ,KAAK,UAAU;CACxC,IAAI,YAAY,MAAM;EACpB,MAAM,QAAQ,sBAAsB,QAAQ;EAC5C,OAAO;GACL,cAAA;GACA,GAAI,SAAS,OAAO,CAAC,IAAI,EAAE,MAAM;EACnC;CACF;CACA,IAAI,QAAQ,KAAK,eAAe,GAC9B,OAAO,EAAE,cAAA,QAAiC;CAE5C,OAAO,uBAAuB,OAC1B,CAAC,IACD,EAAE,cAAc,oBAAoB;AAC1C"}

package/dist/esm/messages/budget.mjs

@@ -1,13 +1,4 @@
 //#region src/messages/budget.ts
-/**
-* Reconciles a context-usage breakdown's instruction/available/message fields
-* from the pruner's budget metrics. `messageTokens` and `availableForMessages`
-* are DERIVED from `contextBudget` / `effectiveInstructionTokens` /
-* `remainingContextTokens` rather than summed from the index map — that map is
-* keyed by pre-prune indices, so summing it over the kept context would missum.
-* Shared by the live snapshot path (`Graph.createCallModel`) and the pre-send
-* projection (`AgentContext.projectContextUsage`) so both yield identical numbers.
-*/
 function syncBudgetDerivedFields(usage) {
 	const { breakdown, contextBudget, effectiveInstructionTokens } = usage;
 	if (effectiveInstructionTokens == null) return;

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

@@ -1 +1 @@
-{"version":3,"file":"budget.mjs","names":[],"sources":["../../../src/messages/budget.ts"],"sourcesContent":["import type * as t from '@/types';\n\n/**\n * Reconciles a context-usage breakdown's instruction/available/message fields\n * from the pruner's budget metrics. `messageTokens` and `availableForMessages`\n * are DERIVED from `contextBudget` / `effectiveInstructionTokens` /\n * `remainingContextTokens` rather than summed from the index map — that map is\n * keyed by pre-prune indices, so summing it over the kept context would missum.\n * Shared by the live snapshot path (`Graph.createCallModel`) and the pre-send\n * projection (`AgentContext.projectContextUsage`) so both yield identical numbers.\n */\nexport function syncBudgetDerivedFields(usage: t.ContextUsageEvent): void {\n  const { breakdown, contextBudget, effectiveInstructionTokens } = usage;\n  if (effectiveInstructionTokens == null) {\n    return;\n  }\n  breakdown.instructionTokens = effectiveInstructionTokens;\n  if (contextBudget == null) {\n    return;\n  }\n  breakdown.availableForMessages = Math.max(\n    0,\n    contextBudget - effectiveInstructionTokens\n  );\n  if (usage.remainingContextTokens == null) {\n    return;\n  }\n  breakdown.messageTokens = Math.max(\n    0,\n    contextBudget - effectiveInstructionTokens - usage.remainingContextTokens\n  );\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,wBAAwB,OAAkC;CACxE,MAAM,EAAE,WAAW,eAAe,+BAA+B;CACjE,IAAI,8BAA8B,MAChC;CAEF,UAAU,oBAAoB;CAC9B,IAAI,iBAAiB,MACnB;CAEF,UAAU,uBAAuB,KAAK,IACpC,GACA,gBAAgB,0BAClB;CACA,IAAI,MAAM,0BAA0B,MAClC;CAEF,UAAU,gBAAgB,KAAK,IAC7B,GACA,gBAAgB,6BAA6B,MAAM,sBACrD;AACF"}
+{"version":3,"file":"budget.mjs","names":[],"sources":["../../../src/messages/budget.ts"],"mappings":";AAWA,SAAgB,wBAAwB,OAAkC;CACxE,MAAM,EAAE,WAAW,eAAe,+BAA+B;CACjE,IAAI,8BAA8B,MAChC;CAEF,UAAU,oBAAoB;CAC9B,IAAI,iBAAiB,MACnB;CAEF,UAAU,uBAAuB,KAAK,IACpC,GACA,gBAAgB,0BAClB;CACA,IAAI,MAAM,0BAA0B,MAClC;CAEF,UAAU,gBAAgB,KAAK,IAC7B,GACA,gBAAgB,6BAA6B,MAAM,sBACrD;AACF"}

package/dist/esm/messages/cache.mjs

@@ -4,86 +4,32 @@ import { toLangChainContent } from "./langchain.mjs";
 import { BaseMessage } from "@langchain/core/messages";
 import { isProxy } from "node:util/types";
 //#region src/messages/cache.ts
-/**
-* Default TTL applied wherever a prompt-cache breakpoint is added. The 1-hour
-* extended cache keeps prefixes warm across longer gaps between turns, at the
-* cost of a higher one-time cache-write multiplier (2x vs 1.25x for 5m).
-*/
 const DEFAULT_PROMPT_CACHE_TTL = "1h";
-/**
-* Resolve an optionally-configured TTL to a concrete value, defaulting to the
-* 1-hour extended cache. Used at the Anthropic/Bedrock prompt-cache call sites.
-*/
 function resolvePromptCacheTtl(ttl) {
 	return ttl ?? "1h";
 }
-/**
-* Build an Anthropic `cache_control` breakpoint for the given TTL. `'5m'` (or
-* `undefined`) omits the `ttl` field — that is the provider default, so the
-* payload stays byte-identical to the legacy 5-minute marker. `'1h'` adds the
-* explicit extended-cache `ttl`.
-*/
 function buildAnthropicCacheControl(ttl) {
 	return ttl === "1h" ? {
 		type: "ephemeral",
 		ttl: "1h"
 	} : { type: "ephemeral" };
 }
-/**
-* Build a Bedrock `cachePoint` for the given TTL. Mirrors
-* {@link buildAnthropicCacheControl}: `'5m'`/`undefined` omits `ttl` (the
-* legacy default), `'1h'` adds the extended-cache `ttl`.
-*/
 function buildBedrockCachePoint(ttl) {
 	return ttl === "1h" ? {
 		type: "default",
 		ttl: "1h"
 	} : { type: "default" };
 }
-/**
-* Whether a Bedrock model id is an Anthropic Claude model. Claude is the only
-* Bedrock family that accepts the explicit cache features below; Amazon Nova and
-* others reject them. Matches both the `anthropic.` and cross-region
-* (`us.anthropic.`) / bare `claude` forms.
-*/
 function isBedrockAnthropicModel(model) {
 	return typeof model === "string" && /claude|anthropic/i.test(model);
 }
-/**
-* A `cachePoint` under `toolConfig.tools` is only accepted on Anthropic Claude
-* models. Amazon Nova rejects it outright — `Malformed input request:
-* #/toolConfig/tools/0: extraneous key [cachePoint] is not permitted` — even
-* though it accepts `cachePoint` in `system` and `messages` (verified live:
-* Nova returns HTTP 200 with real `cacheWriteInputTokens` for both). Per the AWS
-* prompt-caching docs the support table lists `tools` for Claude only.
-*
-* Gate ONLY the tool checkpoint on this, so a `promptCache: true` config on Nova
-* keeps its valid message/system caching instead of either 400-ing (tool point)
-* or losing caching entirely.
-*
-* @see https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
-* @see https://github.com/danny-avila/LibreChat/issues/13838
-*/
 function supportsBedrockToolCache(model) {
 	return isBedrockAnthropicModel(model);
 }
-/**
-* Resolve the Bedrock `cachePoint` TTL for a model. The extended `1h` TTL is
-* Anthropic-only: non-Claude models (e.g. Nova) hard-reject it with
-* `Extended TTL prompt caching is only supported for Anthropic models`, so they
-* are clamped to `5m` even when `1h` is configured (verified live). An omitted
-* model defaults to a Claude model, and Claude downgrades an unsupported `1h` to
-* `5m` server-side, so the `1h` default is safe for the Claude/undefined paths.
-*
-* @see https://github.com/danny-avila/LibreChat/issues/13838
-*/
 function resolveBedrockPromptCacheTtl(ttl, model) {
 	if (model != null && !isBedrockAnthropicModel(model)) return "5m";
 	return resolvePromptCacheTtl(ttl);
 }
-/**
-* Deep clones a message's content to prevent mutation of the original.
-*/
 function deepCloneContent(content, omittedProperty) {
 	if (typeof content === "string") return content;
 	if (Array.isArray(content)) return content.map((block) => {
@@ -98,12 +44,6 @@ function deepCloneContent(content, omittedProperty) {
 	});
 	return content;
 }
-/**
-* Clones a message with new content. For LangChain BaseMessage instances,
-* constructs a proper class instance so that `instanceof` checks are preserved
-* in downstream code (e.g., ensureThinkingBlockInMessages).
-* For plain objects (AnthropicMessage), uses object spread.
-*/
 function cloneMessage(message, content) {
 	if (message instanceof BaseMessage) {
 		const descriptors = Object.getOwnPropertyDescriptors(message);
@@ -140,15 +80,6 @@ function cloneMessage(message, content) {
 	}
 	return cloned;
 }
-/**
-* Sanitize a Bedrock system message: strip Anthropic `cache_control` (Bedrock
-* conversion can't use it) and normalize any existing `cachePoint` to the
-* resolved TTL. The normalization matters because Bedrock requires longer-TTL
-* checkpoints to appear before shorter ones — a stale 5-minute system cachePoint
-* (host-supplied or carried over from a 5m config) left ahead of a 1-hour
-* message tail would make the request invalid. System messages are never
-* anchored as the tail breakpoint; this only fixes markers already present.
-*/
 function sanitizeBedrockSystemMessage(message, ttl) {
 	const content = message.content;
 	if (!Array.isArray(content)) return message;
@@ -177,15 +108,6 @@ function sanitizeBedrockSystemMessage(message, ttl) {
 	if (!modified) return message;
 	return cloneMessage(message, sanitized);
 }
-/**
-* Anthropic API: Adds cache control to the appropriate user messages in the payload.
-* Strips ALL existing cache control (both Anthropic and Bedrock formats) from all messages,
-* then adds fresh cache control to the last 2 user messages in a single backward pass.
-* This ensures we don't accumulate stale cache points across multiple turns.
-* Returns a new array - only clones messages that require modification.
-* @param messages - The array of message objects.
-* @returns - A new array of message objects with cache control added.
-*/
 function addCacheControl(messages, ttl) {
 	if (!Array.isArray(messages) || messages.length < 2) return messages;
 	const updatedMessages = [...messages];
@@ -234,9 +156,6 @@ function addCacheControl(messages, ttl) {
 	}
 	return updatedMessages;
 }
-/**
-* Checks if a content block is a cache point
-*/
 function isCachePoint(block) {
 	if (typeof block !== "object" || block == null || isProxy(block)) return false;
 	try {
@@ -247,20 +166,6 @@ function isCachePoint(block) {
 		return false;
 	}
 }
-/**
-* Block types that must never anchor the tail cache breakpoint, because the
-* marker would not survive to the model call:
-* - `thinking` / `redacted_thinking`: native Anthropic reasoning — the API
-*   rejects `cache_control` on these blocks.
-* - `reasoning_content` / `reasoning` / `think`: foreign reasoning (Bedrock,
-*   Google, LibreChat) that `_convertMessagesToAnthropicPayload` DROPS on
-*   assistant turns during a cross-provider handoff.
-* - `input_json_delta`: persisted partial tool-input deltas, also DROPPED by
-*   `_convertMessagesToAnthropicPayload` (the assembled input is restored onto
-*   the tool_use block).
-* Anchoring the only breakpoint on a block that is about to disappear silently
-* loses tail caching, so all of these are excluded.
-*/
 const NON_ANCHORABLE_BLOCK_TYPES = new Set([
 	"thinking",
 	"redacted_thinking",
@@ -269,13 +174,6 @@ const NON_ANCHORABLE_BLOCK_TYPES = new Set([
 	"think",
 	"input_json_delta"
 ]);
-/**
-* A block can anchor the tail cache breakpoint when it is a real content block
-* that the Anthropic API accepts `cache_control` on and that survives provider
-* conversion. Reasoning / dropped-delta blocks are excluded (see
-* {@link NON_ANCHORABLE_BLOCK_TYPES}), and empty text blocks are not cacheable,
-* so both are skipped.
-*/
 function isTailCacheableBlock(block) {
 	if (isCachePoint(block)) return false;
 	const type = block.type;
@@ -286,24 +184,6 @@ function isTailCacheableBlock(block) {
 	}
 	return true;
 }
-/**
-* Anthropic API: single tail cache breakpoint (default strategy).
-*
-* Places exactly ONE `cache_control` marker on the last cacheable block of the
-* final non-synthetic message, mirroring the Claude Code strategy
-* (`markerIndex = messages.length - 1`). Because the marker always rides the
-* true tail, the entire conversation prefix is written once and read back on
-* the next turn as the history grows append-only — instead of the rolling
-* "last two user messages" markers, which leave freshly appended tool/assistant
-* turns outside the cached prefix and re-write large spans every step.
-*
-* Stale markers (Anthropic `cache_control` and Bedrock cache points) are
-* stripped from every message in a single backward pass so exactly one marker
-* survives. Synthetic skill/meta messages are skipped as anchors (their volatile
-* content must not pin the cache) but still have stale markers removed.
-*
-* Returns a new array; only messages that require modification are cloned.
-*/
 function addTailCacheControl(messages, ttl) {
 	if (!Array.isArray(messages) || messages.length === 0) return messages;
 	const updatedMessages = [...messages];
@@ -358,14 +238,6 @@ function getMessageRole(message) {
 	if ("role" in message && typeof message.role === "string") return message.role;
 }
 const SKILL_MESSAGE_SOURCE = "skill";
-/**
-* Synthetic skill/meta messages (reconstructed skill bodies, primed SKILL.md
-* instructions) are re-injected every turn and are not stable conversation
-* turns. They must not anchor a fresh prompt-cache marker — doing so pins the
-* cache to a volatile/duplicated prefix. Stale markers are still stripped from
-* them; only the *adding* of new markers is suppressed. Detected via
-* `additional_kwargs.isMeta === true` or `additional_kwargs.source === 'skill'`.
-*/
 function isSyntheticMetaMessage(message) {
 	const { additional_kwargs: kwargs } = message;
 	if (kwargs == null) return false;
@@ -438,9 +310,6 @@ function addCacheControlToStablePrefixMessages(messages, maxCachePoints, ttl) {
 	if (assistantMarked.some(hasCacheMarker)) return assistantMarked;
 	return addCacheControlToRecentMessages(messages, maxCachePoints, isCacheableConversationMessage, ttl);
 }
-/**
-* Checks if a message's content has Anthropic cache_control fields.
-*/
 function hasAnthropicCacheControl(content) {
 	for (let i = 0; i < content.length; i++) {
 		const block = content[i];
@@ -453,11 +322,6 @@ function hasAnthropicCacheControl(content) {
 	}
 	return false;
 }
-/**
-* Removes all Anthropic cache_control fields from messages
-* Used when switching from Anthropic to Bedrock provider
-* Returns a new array - only clones messages that require modification.
-*/
 function stripAnthropicCacheControl(messages) {
 	if (!Array.isArray(messages)) return messages;
 	const updatedMessages = [...messages];
@@ -469,18 +333,10 @@ function stripAnthropicCacheControl(messages) {
 	}
 	return updatedMessages;
 }
-/**
-* Checks if a message's content has Bedrock cachePoint blocks.
-*/
 function hasBedrockCachePoint(content) {
 	for (let i = 0; i < content.length; i++) if (isCachePoint(content[i])) return true;
 	return false;
 }
-/**
-* Removes all Bedrock cachePoint blocks from messages
-* Used when switching from Bedrock to Anthropic provider
-* Returns a new array - only clones messages that require modification.
-*/
 function stripBedrockCacheControl(messages) {
 	if (!Array.isArray(messages)) return messages;
 	const updatedMessages = [...messages];
@@ -492,17 +348,6 @@ function stripBedrockCacheControl(messages) {
 	}
 	return updatedMessages;
 }
-/**
-* Adds Bedrock Converse API cache points to the latest two user messages.
-* Inserts `{ cachePoint: { type: 'default' } }` as a separate content block
-* immediately after the last text block in each targeted message.
-* Strips ALL existing cache control (both Bedrock and Anthropic formats) from all messages,
-* then adds fresh cache points to the latest two non-tool user messages in a single backward pass.
-* This ensures we don't accumulate stale cache points across multiple turns.
-* Returns a new array - only clones messages that require modification.
-* @param messages - The array of message objects.
-* @returns - A new array of message objects with cache points added.
-*/
 function addBedrockCacheControl(messages, ttl) {
 	if (!Array.isArray(messages) || messages.length === 0) return messages;
 	const updatedMessages = [...messages];
@@ -563,23 +408,6 @@ function addBedrockCacheControl(messages, ttl) {
 	}
 	return updatedMessages;
 }
-/**
-* Bedrock Converse API: single tail cache breakpoint (default strategy).
-*
-* The Bedrock counterpart of {@link addTailCacheControl}. Strips ALL existing
-* cache control (Bedrock cache points and Anthropic `cache_control`) from every
-* message, then inserts exactly ONE `{ cachePoint: { type: 'default' } }` block
-* immediately after the last non-empty text block of the most recent
-* non-synthetic, non-system message. Anchoring on the rolling tail keeps the
-* cached prefix append-only as the conversation grows, instead of re-writing
-* large spans every turn with the legacy "last two user messages" cache points.
-*
-* System messages are sanitized (Anthropic `cache_control` stripped) but never
-* anchored. Synthetic skill/meta messages are skipped as anchors so their
-* volatile content cannot pin the cache.
-*
-* Returns a new array - only clones messages that require modification.
-*/
 function addBedrockTailCacheControl(messages, ttl) {
 	if (!Array.isArray(messages) || messages.length === 0) return messages;
 	const updatedMessages = [...messages];