@illuma-ai/agents 1.0.90 → 1.0.94

package/dist/cjs/llm/vertexai/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":["../../../../src/llm/vertexai/index.ts"],"sourcesContent":["import { ChatGoogle } from '@langchain/google-gauth';\nimport { ChatConnection } from '@langchain/google-common';\nimport type {\n  GeminiRequest,\n  GoogleAIModelRequestParams,\n  GoogleAbstractedClient,\n} from '@langchain/google-common';\nimport type { BaseMessage } from '@langchain/core/messages';\nimport type { VertexAIClientOptions } from '@/types';\n\nclass CustomChatConnection extends ChatConnection<VertexAIClientOptions> {\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    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  dynamicThinkingBudget = false;\n\n  static lc_name(): 'IllumaVertexAI' {\n    return 'IllumaVertexAI';\n  }\n\n  constructor(fields?: VertexAIClientOptions) {\n    const dynamicThinkingBudget = fields?.thinkingBudget === -1;\n    super({\n      ...fields,\n      platformType: 'gcp',\n    });\n    this.dynamicThinkingBudget = dynamicThinkingBudget;\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\n  buildConnection(\n    fields: VertexAIClientOptions,\n    client: GoogleAbstractedClient\n  ): void {\n    this.connection = new CustomChatConnection(\n      { ...fields, ...this },\n      this.caller,\n      client,\n      false\n    );\n\n    this.streamedConnection = new CustomChatConnection(\n      { ...fields, ...this },\n      this.caller,\n      client,\n      true\n    );\n  }\n}\n"],"names":["ChatConnection","ChatGoogle"],"mappings":";;;;;AAUA,MAAM,oBAAqB,SAAQA,2BAAqC,CAAA;AACtE,IAAA,MAAM,UAAU,CACd,KAAoB,EACpB,UAAsC,EAAA;AAEtC,QAAA,MAAM,aAAa,IAAI,MAAM,KAAK,CAAC,UAAU,CAC3C,KAAK,EACL,UAAU,CACX,CAAkB;QACnB,IAAI,aAAa,CAAC,gBAAgB,EAAE,cAAc,EAAE,cAAc,KAAK,EAAE,EAAE;;YAEzE,IACE,aAAa,CAAC,gBAAgB,CAAC,cAAc,CAAC,eAAe,KAAK,KAAK,EACvE;gBACA,aAAa,CAAC,gBAAgB,CAAC,cAAc,CAAC,eAAe,GAAG,IAAI;;AAEtE,YAAA,OAAO,aAAa,CAAC,gBAAgB,CAAC,cAAc,CAAC,cAAc;;AAErE,QAAA,OAAO,aAAa;;AAEvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyRG;AACG,MAAO,YAAa,SAAQC,sBAAU,CAAA;IAC1C,YAAY,GAAG,CAAC,WAAW,EAAE,aAAa,EAAE,UAAU,CAAC;IACvD,qBAAqB,GAAG,KAAK;AAE7B,IAAA,OAAO,OAAO,GAAA;AACZ,QAAA,OAAO,gBAAgB;;AAGzB,IAAA,WAAA,CAAY,MAA8B,EAAA;QACxC,MAAM,qBAAqB,GAAG,MAAM,EAAE,cAAc,KAAK,EAAE;AAC3D,QAAA,KAAK,CAAC;AACJ,YAAA,GAAG,MAAM;AACT,YAAA,YAAY,EAAE,KAAK;AACpB,SAAA,CAAC;AACF,QAAA,IAAI,CAAC,qBAAqB,GAAG,qBAAqB;;AAEpD,IAAA,gBAAgB,CACd,OAA+C,EAAA;QAE/C,MAAM,MAAM,GAAG,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC;AAC9C,QAAA,IAAI,IAAI,CAAC,qBAAqB,EAAE;AAC9B,YAAA,MAAM,CAAC,kBAAkB,GAAG,EAAE;;AAEhC,QAAA,OAAO,MAAM;;IAGf,eAAe,CACb,MAA6B,EAC7B,MAA8B,EAAA;QAE9B,IAAI,CAAC,UAAU,GAAG,IAAI,oBAAoB,CACxC,EAAE,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,EACtB,IAAI,CAAC,MAAM,EACX,MAAM,EACN,KAAK,CACN;QAED,IAAI,CAAC,kBAAkB,GAAG,IAAI,oBAAoB,CAChD,EAAE,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,EACtB,IAAI,CAAC,MAAM,EACX,MAAM,EACN,IAAI,CACL;;AAEJ;;;;"}
+{"version":3,"file":"index.cjs","sources":["../../../../src/llm/vertexai/index.ts"],"sourcesContent":["import { ChatGoogle } from '@langchain/google-gauth';\nimport { ChatConnection } from '@langchain/google-common';\nimport type {\n  GeminiContent,\n  GeminiRequest,\n  GoogleAIModelRequestParams,\n  GoogleAbstractedClient,\n} from '@langchain/google-common';\nimport type { BaseMessage } from '@langchain/core/messages';\nimport { isAIMessage } from '@langchain/core/messages';\nimport type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';\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, then re-attaches non-empty signatures\n * that the library failed to apply.\n */\nfunction fixThoughtSignatures(\n  contents: GeminiContent[],\n  input: BaseMessage[]\n): void {\n  // Collect AI messages that have signatures, in order\n  const aiMessages = input.filter(\n    (msg) =>\n      isAIMessage(msg) &&\n      Array.isArray((msg.additional_kwargs as AdditionalKwargs)?.signatures) &&\n      (msg.additional_kwargs.signatures as string[]).length > 0\n  );\n\n  // Collect \"model\" content blocks from the formatted request, in order\n  const modelContents = contents.filter((c) => c.role === 'model');\n\n  // They should correspond 1:1 in order (both derived from the same input sequence)\n  const count = Math.min(aiMessages.length, modelContents.length);\n  for (let i = 0; i < count; i++) {\n    const msg = aiMessages[i];\n    const content = modelContents[i];\n    const signatures = (msg.additional_kwargs as AdditionalKwargs)?.signatures;\n\n    // Collect non-empty signatures that aren't already attached to any part\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 != null && s !== '' && !attachedSignatures.has(s)\n    );\n\n    // Assign available signatures to functionCall parts missing one, in order\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 ?? 0)\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 (\n      this.thinkingConfig?.thinkingLevel != null &&\n      this.thinkingConfig.thinkingLevel !== ''\n    ) {\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  dynamicThinkingBudget = false;\n  thinkingConfig?: GoogleThinkingConfig;\n\n  static lc_name(): 'IllumaVertexAI' {\n    return 'IllumaVertexAI';\n  }\n\n  constructor(fields?: VertexAIClientOptions) {\n    const dynamicThinkingBudget = fields?.thinkingBudget === -1;\n    super({\n      ...fields,\n      platformType: 'gcp',\n    });\n    this.dynamicThinkingBudget = dynamicThinkingBudget;\n    this.thinkingConfig = fields?.thinkingConfig;\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  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"],"names":["isAIMessage","ChatConnection","ChatGoogle"],"mappings":"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"}

package/dist/cjs/main.cjs

@@ -11,6 +11,7 @@ var format = require('./messages/format.cjs');
 var cache = require('./messages/cache.cjs');
 var content = require('./messages/content.cjs');
 var tools = require('./messages/tools.cjs');
+var summarize = require('./messages/summarize.cjs');
 var Graph = require('./graphs/Graph.cjs');
 var MultiAgentGraph = require('./graphs/MultiAgentGraph.cjs');
 var Calculator = require('./tools/Calculator.cjs');
@@ -19,22 +20,26 @@ var BrowserTools = require('./tools/BrowserTools.cjs');
 var ProgrammaticToolCalling = require('./tools/ProgrammaticToolCalling.cjs');
 var ToolSearch = require('./tools/ToolSearch.cjs');
 var ToolNode = require('./tools/ToolNode.cjs');
-var schema = require('./tools/schema.cjs');
-var handlers = require('./tools/handlers.cjs');
+var AskUser = require('./tools/AskUser.cjs');
+var schema$1 = require('./tools/schema.cjs');
+var handlers$1 = require('./tools/handlers.cjs');
 var tool = require('./tools/search/tool.cjs');
-var schema$1 = require('./tools/search/schema.cjs');
+var schema = require('./tools/search/schema.cjs');
 var validate = require('./schemas/validate.cjs');
 var _enum = require('./common/enum.cjs');
+var constants = require('./common/constants.cjs');
 var graph = require('./utils/graph.cjs');
 var llm = require('./utils/llm.cjs');
 var misc = require('./utils/misc.cjs');
-var handlers$1 = require('./utils/handlers.cjs');
+var handlers = require('./utils/handlers.cjs');
 var run$1 = require('./utils/run.cjs');
 var tokens = require('./utils/tokens.cjs');
 var toonFormat = require('./utils/toonFormat.cjs');
 var contextAnalytics = require('./utils/contextAnalytics.cjs');
 var schema$2 = require('./utils/schema.cjs');
-var index = require('./llm/openai/index.cjs');
+var toolCallContinuation = require('./utils/toolCallContinuation.cjs');
+var index$1 = require('./llm/openai/index.cjs');
+var index = require('./llm/openrouter/index.cjs');
 var providers = require('./llm/providers.cjs');
 
 
@@ -64,6 +69,7 @@ exports.getMessageId = ids.getMessageId;
 exports.calculateTotalTokens = prune.calculateTotalTokens;
 exports.checkValidNumber = prune.checkValidNumber;
 exports.createPruneMessages = prune.createPruneMessages;
+exports.getContextUtilization = prune.getContextUtilization;
 exports.getMessagesWithinTokenLimit = prune.getMessagesWithinTokenLimit;
 exports.ensureThinkingBlockInMessages = format.ensureThinkingBlockInMessages;
 exports.formatAgentMessages = format.formatAgentMessages;
@@ -80,6 +86,14 @@ exports.stripBedrockCacheControl = cache.stripBedrockCacheControl;
 exports.formatContentStrings = content.formatContentStrings;
 exports.extractToolDiscoveries = tools.extractToolDiscoveries;
 exports.hasToolSearchInCurrentTurn = tools.hasToolSearchInCurrentTurn;
+exports.FULL_SUMMARY_TEMPLATE = summarize.FULL_SUMMARY_TEMPLATE;
+exports.SIMPLE_SUMMARY_TEMPLATE = summarize.SIMPLE_SUMMARY_TEMPLATE;
+exports.buildFullSummaryPrompt = summarize.buildFullSummaryPrompt;
+exports.buildSimpleSummaryPrompt = summarize.buildSimpleSummaryPrompt;
+exports.createEmergencySummary = summarize.createEmergencySummary;
+exports.formatMessagesForSummary = summarize.formatMessagesForSummary;
+exports.summarize = summarize.summarize;
+exports.validateSummarySize = summarize.validateSummarySize;
 exports.Graph = Graph.Graph;
 exports.StandardGraph = Graph.StandardGraph;
 exports.MultiAgentGraph = MultiAgentGraph.MultiAgentGraph;
@@ -132,29 +146,34 @@ exports.performLocalSearch = ToolSearch.performLocalSearch;
 exports.sanitizeRegex = ToolSearch.sanitizeRegex;
 exports.ToolNode = ToolNode.ToolNode;
 exports.toolsCondition = ToolNode.toolsCondition;
-exports.createSchemaOnlyTool = schema.createSchemaOnlyTool;
-exports.createSchemaOnlyTools = schema.createSchemaOnlyTools;
-exports.handleServerToolResult = handlers.handleServerToolResult;
-exports.handleToolCallChunks = handlers.handleToolCallChunks;
-exports.handleToolCalls = handlers.handleToolCalls;
-exports.toolResultTypes = handlers.toolResultTypes;
+exports.AskUserDescription = AskUser.AskUserDescription;
+exports.AskUserStepSchema = AskUser.AskUserStepSchema;
+exports.AskUserToolName = AskUser.AskUserToolName;
+exports.HITL_FIELDS = AskUser.HITL_FIELDS;
+exports.createAskUserTool = AskUser.createAskUserTool;
+exports.createSchemaOnlyTool = schema$1.createSchemaOnlyTool;
+exports.createSchemaOnlyTools = schema$1.createSchemaOnlyTools;
+exports.handleServerToolResult = handlers$1.handleServerToolResult;
+exports.handleToolCallChunks = handlers$1.handleToolCallChunks;
+exports.handleToolCalls = handlers$1.handleToolCalls;
+exports.toolResultTypes = handlers$1.toolResultTypes;
 exports.createSearchTool = tool.createSearchTool;
 Object.defineProperty(exports, "DATE_RANGE", {
 	enumerable: true,
-	get: function () { return schema$1.DATE_RANGE; }
-});
-exports.DEFAULT_COUNTRY_DESCRIPTION = schema$1.DEFAULT_COUNTRY_DESCRIPTION;
-exports.DEFAULT_QUERY_DESCRIPTION = schema$1.DEFAULT_QUERY_DESCRIPTION;
-exports.WebSearchToolDefinition = schema$1.WebSearchToolDefinition;
-exports.WebSearchToolDescription = schema$1.WebSearchToolDescription;
-exports.WebSearchToolName = schema$1.WebSearchToolName;
-exports.WebSearchToolSchema = schema$1.WebSearchToolSchema;
-exports.countrySchema = schema$1.countrySchema;
-exports.dateSchema = schema$1.dateSchema;
-exports.imagesSchema = schema$1.imagesSchema;
-exports.newsSchema = schema$1.newsSchema;
-exports.querySchema = schema$1.querySchema;
-exports.videosSchema = schema$1.videosSchema;
+	get: function () { return schema.DATE_RANGE; }
+});
+exports.DEFAULT_COUNTRY_DESCRIPTION = schema.DEFAULT_COUNTRY_DESCRIPTION;
+exports.DEFAULT_QUERY_DESCRIPTION = schema.DEFAULT_QUERY_DESCRIPTION;
+exports.WebSearchToolDefinition = schema.WebSearchToolDefinition;
+exports.WebSearchToolDescription = schema.WebSearchToolDescription;
+exports.WebSearchToolName = schema.WebSearchToolName;
+exports.WebSearchToolSchema = schema.WebSearchToolSchema;
+exports.countrySchema = schema.countrySchema;
+exports.dateSchema = schema.dateSchema;
+exports.imagesSchema = schema.imagesSchema;
+exports.newsSchema = schema.newsSchema;
+exports.querySchema = schema.querySchema;
+exports.videosSchema = schema.videosSchema;
 exports.createValidationErrorMessage = validate.createValidationErrorMessage;
 exports.isValidJsonSchema = validate.isValidJsonSchema;
 exports.normalizeJsonSchema = validate.normalizeJsonSchema;
@@ -177,10 +196,18 @@ Object.defineProperty(exports, "ContentTypes", {
 	enumerable: true,
 	get: function () { return _enum.ContentTypes; }
 });
+Object.defineProperty(exports, "EdgeType", {
+	enumerable: true,
+	get: function () { return _enum.EdgeType; }
+});
 Object.defineProperty(exports, "EnvVar", {
 	enumerable: true,
 	get: function () { return _enum.EnvVar; }
 });
+Object.defineProperty(exports, "FinishReasons", {
+	enumerable: true,
+	get: function () { return _enum.FinishReasons; }
+});
 Object.defineProperty(exports, "GraphEvents", {
 	enumerable: true,
 	get: function () { return _enum.GraphEvents; }
@@ -213,17 +240,20 @@ Object.defineProperty(exports, "ToolCallTypes", {
 	enumerable: true,
 	get: function () { return _enum.ToolCallTypes; }
 });
+exports.MIN_THINKING_BUDGET = constants.MIN_THINKING_BUDGET;
+exports.TOOL_TURN_THINKING_BUDGET = constants.TOOL_TURN_THINKING_BUDGET;
 exports.joinKeys = graph.joinKeys;
 exports.resetIfNotEmpty = graph.resetIfNotEmpty;
 exports.isGoogleLike = llm.isGoogleLike;
 exports.isOpenAILike = llm.isOpenAILike;
 exports.isPresent = misc.isPresent;
 exports.unescapeObject = misc.unescapeObject;
-exports.createHandlers = handlers$1.createHandlers;
+exports.createHandlers = handlers.createHandlers;
 exports.RunnableCallable = run$1.RunnableCallable;
 exports.sleep = run$1.sleep;
 exports.TokenEncoderManager = tokens.TokenEncoderManager;
 exports.createTokenCounter = tokens.createTokenCounter;
+exports.encodingForModel = tokens.encodingForModel;
 exports.getTokenCountForMessage = tokens.getTokenCountForMessage;
 exports.ensureToonLoaded = toonFormat.ensureToonLoaded;
 exports.extractFirstJson = toonFormat.extractFirstJson;
@@ -234,7 +264,10 @@ exports.processToolOutput = toonFormat.processToolOutput;
 exports.buildContextAnalytics = contextAnalytics.buildContextAnalytics;
 exports.isZodSchema = schema$2.isZodSchema;
 exports.toJsonSchema = schema$2.toJsonSchema;
-exports.CustomOpenAIClient = index.CustomOpenAIClient;
+exports.extractFinishReason = toolCallContinuation.extractFinishReason;
+exports.isMaxTokensFinish = toolCallContinuation.isMaxTokensFinish;
+exports.CustomOpenAIClient = index$1.CustomOpenAIClient;
+exports.ChatOpenRouter = index.ChatOpenRouter;
 exports.getChatModelClass = providers.getChatModelClass;
 exports.llmProviders = providers.llmProviders;
 //# sourceMappingURL=main.cjs.map

package/dist/cjs/main.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/messages/cache.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var messages = require('@langchain/core/messages');
 var _enum = require('../common/enum.cjs');
 
 /** Debug logger for cache operations - set ILLUMA_DEBUG_CACHE=true to enable */
@@ -22,11 +23,38 @@ function deepCloneContent(content) {
     return content;
 }
 /**
- * Clones a message with deep-cloned content, explicitly excluding LangChain
- * serialization metadata to prevent coercion issues.
- * Keeps lc_kwargs in sync with content to prevent LangChain serialization issues.
+ * 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 messages.BaseMessage) {
+        const baseParams = {
+            content,
+            additional_kwargs: { ...message.additional_kwargs },
+            response_metadata: { ...message.response_metadata },
+            id: message.id,
+            name: message.name,
+        };
+        const msgType = message.getType();
+        switch (msgType) {
+            case 'ai':
+                return new messages.AIMessage({
+                    ...baseParams,
+                    tool_calls: message.tool_calls,
+                });
+            case 'human':
+                return new messages.HumanMessage(baseParams);
+            case 'system':
+                return new messages.SystemMessage(baseParams);
+            case 'tool':
+                return new messages.ToolMessage({
+                    ...baseParams,
+                    tool_call_id: message.tool_call_id,
+                });
+        }
+    }
     const { lc_kwargs: _lc_kwargs, lc_serializable: _lc_serializable, lc_namespace: _lc_namespace, ...rest } = message;
     const cloned = { ...rest, content };
     // Sync lc_kwargs.content with the new content to prevent LangChain coercion issues
@@ -214,7 +242,7 @@ function stripBedrockCacheControl(messages) {
  *
  * Why this works:
  * - System message has its own cachePoint (added in AgentContext)
- * - Tools have their own cachePoint (added in CustomChatBedrockConverse)
+ * - Tools have their own cachePoint (added in IllumaBedrockConverse)
  * - Conversation history grows, but the PREFIX stays the same
  * - Only the NEW user message is uncached (it's always different)
  *
@@ -240,22 +268,27 @@ function addBedrockCacheControl(messages) {
     debugCache('addBedrockCacheControl: Processing messages with stable prefix strategy', {
         count: messages.length,
     });
-    const updatedMessages = messages.slice();
-    // First pass: Remove ALL existing cache points to ensure clean state
-    // This prevents accumulation of stale cache points
-    for (const message of updatedMessages) {
-        const content = message.content;
+    // Clone messages to avoid mutating originals
+    const updatedMessages = messages.map((msg) => {
+        const content = msg.content;
         if (Array.isArray(content)) {
-            message.content = content.filter((block) => !isCachePoint(block));
-            // Also remove Anthropic-style cache_control
-            for (let j = 0; j < message.content.length; j++) {
-                const block = message.content[j];
-                if ('cache_control' in block) {
-                    delete block.cache_control;
+            // Strip existing cachePoint blocks and Anthropic-style cache_control
+            const stripped = content
+                .filter((block) => !isCachePoint(block))
+                .map((block) => {
+                const rec = block;
+                if ('cache_control' in rec) {
+                    const { cache_control: _, ...rest } = rec;
+                    return rest;
                 }
+                return block;
+            });
+            if (needsCacheStripping(content) || hasAnthropicCacheControl(content)) {
+                return cloneMessage(msg, stripped);
             }
         }
-    }
+        return cloneMessage(msg, content);
+    });
     // Helper function to check if a message contains reasoning/thinking blocks
     const hasReasoningBlock = (message) => {
         const content = message.content;
@@ -264,11 +297,6 @@ function addBedrockCacheControl(messages) {
         }
         for (const block of content) {
             const type = block.type;
-            // Check for all reasoning/thinking block types:
-            // - reasoning_content: Bedrock Anthropic extended thinking
-            // - reasoning: Generic reasoning format
-            // - thinking: Anthropic direct API thinking
-            // - redacted_thinking: Anthropic redacted thinking blocks
             if (type === 'reasoning_content' ||
                 type === 'reasoning' ||
                 type === 'thinking' ||
@@ -278,103 +306,98 @@ function addBedrockCacheControl(messages) {
         }
         return false;
     };
-    // Second pass: Find the LAST assistant message WITHOUT reasoning blocks and add a cache point there
-    // Messages with reasoning/thinking blocks cannot have cache points after them (Bedrock limitation)
-    let lastAssistantIndex = -1;
-    let skippedWithReasoning = 0;
-    // Count message types for logging
-    const messageTypes = {};
-    for (const message of updatedMessages) {
-        const msgType = 'getType' in message && typeof message.getType === 'function'
-            ? message.getType()
-            : 'unknown';
-        messageTypes[msgType] = (messageTypes[msgType] || 0) + 1;
-    }
-    for (let i = updatedMessages.length - 1; i >= 0; i--) {
+    /**
+     * Helper to add a cachePoint to a message's content.
+     * For strings: wraps into [{type: 'text', text}, {cachePoint}]
+     * For arrays: inserts cachePoint after the last non-whitespace text block
+     * Returns the new message or null if no suitable insertion point.
+     */
+    const addCachePointToMessage = (message) => {
+        const msgContent = message.content;
+        if (typeof msgContent === 'string' && msgContent !== '') {
+            const newContent = [
+                { type: _enum.ContentTypes.TEXT, text: msgContent },
+                { cachePoint: { type: 'default' } },
+            ];
+            return cloneMessage(message, newContent);
+        }
+        if (Array.isArray(msgContent) && msgContent.length > 0) {
+            if (hasReasoningBlock(message)) {
+                return null;
+            }
+            // Find the last text block and insert cache point after it
+            for (let j = msgContent.length - 1; j >= 0; j--) {
+                const type = msgContent[j].type;
+                if (type === _enum.ContentTypes.TEXT || type === 'text') {
+                    const text = msgContent[j].text;
+                    if (text != null && text.trim() !== '') {
+                        const newContent = [
+                            ...msgContent.slice(0, j + 1),
+                            { cachePoint: { type: 'default' } },
+                            ...msgContent.slice(j + 1),
+                        ];
+                        return cloneMessage(message, newContent);
+                    }
+                }
+            }
+        }
+        return null;
+    };
+    // Add cache points to the last 2 messages (from the end) that have eligible content.
+    // This mirrors Anthropic's two-breakpoint strategy for Bedrock's cache API.
+    // Skip messages with only whitespace, empty content, or reasoning blocks.
+    const MAX_CACHE_POINTS = 2;
+    let applied = 0;
+    for (let i = updatedMessages.length - 1; i >= 0 && applied < MAX_CACHE_POINTS; i--) {
         const message = updatedMessages[i];
+        const msgContent = message.content;
+        // Skip empty/whitespace-only content
+        if (msgContent == null)
+            continue;
+        if (typeof msgContent === 'string' && msgContent.trim() === '')
+            continue;
+        if (Array.isArray(msgContent) && msgContent.length === 0)
+            continue;
+        // Skip non-string, non-array content (e.g., number, object without type)
+        if (typeof msgContent !== 'string' && !Array.isArray(msgContent))
+            continue;
+        // Skip AI messages with only whitespace text and reasoning blocks (tool-call scenario)
         const messageType = 'getType' in message && typeof message.getType === 'function'
             ? message.getType()
             : 'unknown';
-        if (messageType === 'ai') {
-            // Skip assistant messages with reasoning blocks - cache points not allowed after them
-            if (hasReasoningBlock(message)) {
-                skippedWithReasoning++;
-                debugCache('addBedrockCacheControl: Skipping assistant message with reasoning block', { index: i });
-                continue;
-            }
-            lastAssistantIndex = i;
-            break;
-        }
-    }
-    // Log message summary
-    debugCache(`📨 Messages | total=${updatedMessages.length} | ${Object.entries(messageTypes)
-        .map(([k, v]) => `${k}:${v}`)
-        .join(' ')} | skippedReasoning=${skippedWithReasoning}`);
-    // If no suitable assistant message found, skip conversation caching
-    // (System and Tools caching are still handled separately)
-    if (lastAssistantIndex === -1) {
-        debugCache('📨 Messages | No suitable assistant message for cachePoint (first turn or all have reasoning)');
-        return updatedMessages;
-    }
-    // Add cache point to the last assistant message (without reasoning blocks)
-    const assistantMessage = updatedMessages[lastAssistantIndex];
-    const content = assistantMessage.content;
-    if (typeof content === 'string' && content !== '') {
-        assistantMessage.content = [
-            { type: _enum.ContentTypes.TEXT, text: content },
-            { cachePoint: { type: 'default' } },
-        ];
-        debugCache(`📍 Message cachePoint at index ${lastAssistantIndex} (string, ${content.length} chars)`);
-        debugCache('addBedrockCacheControl: Added cachePoint to assistant message (string content)', {
-            index: lastAssistantIndex,
-            contentLength: content.length,
-        });
-    }
-    else if (Array.isArray(assistantMessage.content) &&
-        assistantMessage.content.length > 0) {
-        // Double-check: If this message has reasoning blocks, skip adding cache point entirely
-        // This handles edge cases where the initial skip check might have missed it
-        if (hasReasoningBlock(assistantMessage)) {
-            debugCache(`⚠️ Message cachePoint SKIPPED at index ${lastAssistantIndex} (has reasoning blocks)`);
-            debugCache('addBedrockCacheControl: Skipping - assistant message has reasoning blocks (safety check)', {
-                index: lastAssistantIndex,
-            });
-            return updatedMessages;
-        }
-        // Find the last text block and insert cache point after it
-        let inserted = false;
-        for (let j = assistantMessage.content.length - 1; j >= 0; j--) {
-            const block = assistantMessage.content[j];
-            const type = block.type;
-            if (type === _enum.ContentTypes.TEXT || type === 'text') {
-                const text = block.text;
-                if (text != null && text !== '') {
-                    assistantMessage.content.splice(j + 1, 0, {
-                        cachePoint: { type: 'default' },
-                    });
-                    inserted = true;
-                    debugCache(`📍 Message cachePoint at index ${lastAssistantIndex} (array, block ${j}, ${text.length} chars)`);
-                    debugCache('addBedrockCacheControl: Added cachePoint after text block in assistant message', {
-                        index: lastAssistantIndex,
-                        textBlockIndex: j,
-                        contentLength: text.length,
-                    });
-                    break;
+        const role = message.role;
+        const isAi = messageType === 'ai' || role === 'assistant';
+        if (isAi && hasReasoningBlock(message)) {
+            // Check if all text blocks are whitespace-only
+            if (Array.isArray(msgContent)) {
+                const hasNonWhitespaceText = msgContent.some((block) => {
+                    const type = block.type;
+                    if (type === _enum.ContentTypes.TEXT || type === 'text') {
+                        const text = block.text;
+                        return text != null && text.trim() !== '';
+                    }
+                    return false;
+                });
+                if (!hasNonWhitespaceText) {
+                    debugCache(`⚠️ Message cachePoint SKIPPED at index ${i} (AI with whitespace-only text + reasoning)`);
+                    continue;
                 }
             }
         }
-        // If no text block found, don't append cache point as the message structure is unexpected
-        if (!inserted) {
-            const contentTypes = assistantMessage.content.map((b) => b.type);
-            debugCache(`⚠️ Message cachePoint SKIPPED at index ${lastAssistantIndex} (no text block, types: ${contentTypes.join(',')})`);
-            debugCache('addBedrockCacheControl: No suitable text block found, skipping cache point', {
-                index: lastAssistantIndex,
-                contentTypes,
-            });
+        // Skip messages that already have cache points (multi-agent scenarios)
+        if (Array.isArray(msgContent) &&
+            msgContent.some((b) => isCachePoint(b))) {
+            continue;
+        }
+        const updated = addCachePointToMessage(message);
+        if (updated != null) {
+            updatedMessages[i] = updated;
+            applied++;
+            debugCache(`📍 Message cachePoint at index ${i} (${typeof message.content === 'string' ? 'string' : 'array'})`);
         }
     }
     debugCache('addBedrockCacheControl: Complete - stable prefix caching applied', {
-        lastAssistantIndex,
+        appliedCachePoints: applied,
         totalMessages: updatedMessages.length,
     });
     return updatedMessages;