@librechat/agents 3.2.31 → 3.2.33

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

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