@langchain/google-common 0.2.3 → 0.2.5

package/dist/chat_models.cjs

@@ -144,6 +144,12 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "maxReasoningTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "topP", {
             enumerable: true,
             configurable: true,
@@ -369,7 +375,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
         let outputParser;
         let tools;
         if (isZodSchema(schema)) {
-            const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(schema);
+            const jsonSchema = (0, zod_to_gemini_parameters_js_1.schemaToGeminiParameters)(schema);
             tools = [
                 {
                     functionDeclarations: [

package/dist/chat_models.d.ts

@@ -39,6 +39,7 @@ export declare abstract class ChatGoogleBase<AuthOptions> extends BaseChatModel<
     modelName: string;
     temperature: number;
     maxOutputTokens: number;
+    maxReasoningTokens: number;
     topP: number;
     topK: number;
     presencePenalty: number;

package/dist/chat_models.js

@@ -10,7 +10,7 @@ import { AbstractGoogleLLMConnection } from "./connection.js";
 import { DefaultGeminiSafetyHandler, getGeminiAPI } from "./utils/gemini.js";
 import { ApiKeyGoogleAuth } from "./auth.js";
 import { ensureParams } from "./utils/failed_handler.js";
-import { zodToGeminiParameters } from "./utils/zod_to_gemini_parameters.js";
+import { schemaToGeminiParameters } from "./utils/zod_to_gemini_parameters.js";
 export class ChatConnection extends AbstractGoogleLLMConnection {
     constructor(fields, caller, client, streaming) {
         super(fields, caller, client, streaming);
@@ -140,6 +140,12 @@ export class ChatGoogleBase extends BaseChatModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "maxReasoningTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "topP", {
             enumerable: true,
             configurable: true,
@@ -365,7 +371,7 @@ export class ChatGoogleBase extends BaseChatModel {
         let outputParser;
         let tools;
         if (isZodSchema(schema)) {
-            const jsonSchema = zodToGeminiParameters(schema);
+            const jsonSchema = schemaToGeminiParameters(schema);
             tools = [
                 {
                     functionDeclarations: [

package/dist/types-anthropic.d.ts

@@ -13,8 +13,11 @@ export interface AnthropicMessageContentImage extends AnthropicMessageContentBas
     type: "image";
     source: {
         type: "base64" | string;
-        media_type: string;
+        media_type?: string;
         data: string;
+    } | {
+        type: "url" | string;
+        url: string;
     };
 }
 export interface AnthropicMessageContentThinking extends AnthropicMessageContentBase {
@@ -22,6 +25,38 @@ export interface AnthropicMessageContentThinking extends AnthropicMessageContent
     thinking: string;
     signature: string;
 }
+export interface AnthropicMessageContentDocument extends AnthropicMessageContentBase {
+    type: "document";
+    source: {
+        type: "base64" | "text" | string;
+        media_type?: "application/pdf" | "text/plain" | string;
+        data: string;
+    } | {
+        type: "url" | string;
+        url: string;
+    } | {
+        type: "content" | string;
+        content: {
+            type: "image" | string;
+            source: {
+                type: "base64" | string;
+                data: string;
+                media_type?: "image/jpeg" | "image/png" | "image/gif" | "image/webp" | string;
+            } | {
+                type: "url" | string;
+                url: string;
+            } | {
+                type: "text" | string;
+                text: string;
+            };
+        }[];
+    };
+    citations?: {
+        enabled?: boolean;
+    };
+    context?: string;
+    title?: string;
+}
 export interface AnthropicMessageContentRedactedThinking extends AnthropicMessageContentBase {
     type: "redacted_thinking";
     data: string;

package/dist/types.d.ts

@@ -85,6 +85,10 @@ export interface GoogleAISafetySetting {
 }
 export type GoogleAIResponseMimeType = "text/plain" | "application/json";
 export type GoogleAIModelModality = "TEXT" | "IMAGE" | "AUDIO" | string;
+export interface GoogleThinkingConfig {
+    thinkingBudget?: number;
+    includeThoughts?: boolean;
+}
 export interface GoogleAIModelParams {
     /** Model to use */
     model?: string;
@@ -97,8 +101,22 @@ export interface GoogleAIModelParams {
     temperature?: number;
     /**
      * Maximum number of tokens to generate in the completion.
+     * This may include reasoning tokens (for backwards compatibility).
      */
     maxOutputTokens?: number;
+    /**
+     * The maximum number of the output tokens that will be used
+     * for the "thinking" or "reasoning" stages.
+     */
+    maxReasoningTokens?: number;
+    /**
+     * An alias for "maxReasoningTokens"
+     */
+    thinkingBudget?: number;
+    /**
+     * An OpenAI compatible parameter that will map to "maxReasoningTokens"
+     */
+    reasoningEffort?: "low" | "medium" | "high";
     /**
      * Top-p changes how the model selects tokens for output.
      *
@@ -398,6 +416,7 @@ export interface GeminiGenerationConfig {
     responseLogprobs?: boolean;
     logprobs?: number;
     responseModalities?: GoogleAIModelModality[];
+    thinkingConfig?: GoogleThinkingConfig;
 }
 export interface GeminiRequest {
     contents?: GeminiContent[];

package/dist/utils/anthropic.cjs

@@ -373,16 +373,221 @@ function getAnthropicAPI(config) {
                 return undefined;
         }
     }
+    const anthropicContentConverter = {
+        providerName: "anthropic",
+        fromStandardTextBlock(block) {
+            return {
+                type: "text",
+                text: block.text,
+                ...("cache_control" in (block.metadata ?? {})
+                    ? {
+                        cache_control: block.metadata
+                            .cache_control,
+                    }
+                    : {}),
+            };
+        },
+        fromStandardImageBlock(block) {
+            if (block.source_type === "url") {
+                const data = (0, messages_1.parseBase64DataUrl)({
+                    dataUrl: block.url,
+                    asTypedArray: false,
+                });
+                if (data) {
+                    return {
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            data: data.data,
+                            media_type: data.mime_type,
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? { cache_control: block.metadata.cache_control }
+                            : {}),
+                    };
+                }
+                else {
+                    return {
+                        type: "image",
+                        source: {
+                            type: "url",
+                            url: block.url,
+                            media_type: block.mime_type ?? "",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? { cache_control: block.metadata.cache_control }
+                            : {}),
+                    };
+                }
+            }
+            else {
+                if (block.source_type === "base64") {
+                    return {
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            data: block.data,
+                            media_type: block.mime_type ?? "",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? { cache_control: block.metadata.cache_control }
+                            : {}),
+                    };
+                }
+                else {
+                    throw new Error(`Unsupported image source type: ${block.source_type}`);
+                }
+            }
+        },
+        fromStandardFileBlock(block) {
+            const mime_type = (block.mime_type ?? "").split(";")[0];
+            if (block.source_type === "url") {
+                if (mime_type === "application/pdf" || mime_type === "") {
+                    return {
+                        type: "document",
+                        source: {
+                            type: "url",
+                            url: block.url,
+                            media_type: block.mime_type ?? "",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? {
+                                cache_control: block.metadata
+                                    .cache_control,
+                            }
+                            : {}),
+                        ...("citations" in (block.metadata ?? {})
+                            ? {
+                                citations: block.metadata.citations,
+                            }
+                            : {}),
+                        ...("context" in (block.metadata ?? {})
+                            ? { context: block.metadata.context }
+                            : {}),
+                        ...(block.metadata?.title ||
+                            block.metadata?.filename ||
+                            block.metadata?.name
+                            ? {
+                                title: (block.metadata?.title ||
+                                    block.metadata?.filename ||
+                                    block.metadata?.name),
+                            }
+                            : {}),
+                    };
+                }
+                throw new Error(`Unsupported file mime type for file url source: ${block.mime_type}`);
+            }
+            else if (block.source_type === "text") {
+                if (mime_type === "text/plain" || mime_type === "") {
+                    return {
+                        type: "document",
+                        source: {
+                            type: "text",
+                            data: block.text,
+                            media_type: block.mime_type ?? "",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? {
+                                cache_control: block.metadata
+                                    .cache_control,
+                            }
+                            : {}),
+                        ...("citations" in (block.metadata ?? {})
+                            ? {
+                                citations: block.metadata.citations,
+                            }
+                            : {}),
+                        ...("context" in (block.metadata ?? {})
+                            ? { context: block.metadata.context }
+                            : {}),
+                        ...("title" in (block.metadata ?? {})
+                            ? { title: block.metadata.title }
+                            : {}),
+                    };
+                }
+                else {
+                    throw new Error(`Unsupported file mime type for file text source: ${block.mime_type}`);
+                }
+            }
+            else if (block.source_type === "base64") {
+                if (mime_type === "application/pdf" || mime_type === "") {
+                    return {
+                        type: "document",
+                        source: {
+                            type: "base64",
+                            data: block.data,
+                            media_type: "application/pdf",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? {
+                                cache_control: block.metadata
+                                    .cache_control,
+                            }
+                            : {}),
+                        ...("citations" in (block.metadata ?? {})
+                            ? {
+                                citations: block.metadata.citations,
+                            }
+                            : {}),
+                        ...("context" in (block.metadata ?? {})
+                            ? { context: block.metadata.context }
+                            : {}),
+                        ...("title" in (block.metadata ?? {})
+                            ? { title: block.metadata.title }
+                            : {}),
+                    };
+                }
+                else if (["image/jpeg", "image/png", "image/gif", "image/webp"].includes(mime_type)) {
+                    return {
+                        type: "document",
+                        source: {
+                            type: "content",
+                            content: [
+                                {
+                                    type: "image",
+                                    source: {
+                                        type: "base64",
+                                        data: block.data,
+                                        media_type: mime_type,
+                                    },
+                                },
+                            ],
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? {
+                                cache_control: block.metadata
+                                    .cache_control,
+                            }
+                            : {}),
+                        ...("citations" in (block.metadata ?? {})
+                            ? {
+                                citations: block.metadata.citations,
+                            }
+                            : {}),
+                        ...("context" in (block.metadata ?? {})
+                            ? { context: block.metadata.context }
+                            : {}),
+                        ...("title" in (block.metadata ?? {})
+                            ? { title: block.metadata.title }
+                            : {}),
+                    };
+                }
+                else {
+                    throw new Error(`Unsupported file mime type for file base64 source: ${block.mime_type}`);
+                }
+            }
+            else {
+                throw new Error(`Unsupported file source type: ${block.source_type}`);
+            }
+        },
+    };
     function contentToAnthropicContent(content) {
-        const ret = [];
         const ca = typeof content === "string" ? [{ type: "text", text: content }] : content;
-        ca.forEach((complex) => {
-            const ac = contentComplexToAnthropicContent(complex);
-            if (ac) {
-                ret.push(ac);
-            }
-        });
-        return ret;
+        return ca
+            .map((complex) => (0, messages_1.isDataContentBlock)(complex)
+            ? (0, messages_1.convertToProviderContentBlock)(complex, anthropicContentConverter)
+            : contentComplexToAnthropicContent(complex))
+            .filter(Boolean);
     }
     function toolCallToAnthropicContent(toolCall) {
         return {
@@ -439,6 +644,9 @@ function getAnthropicAPI(config) {
                 return aiMessageToAnthropicMessage(base);
             case "tool":
                 return toolMessageToAnthropicMessage(base);
+            case "system":
+                //  System messages are handled in formatSystem()
+                return undefined;
             default:
                 console.warn(`Unknown BaseMessage type: ${type}`, base);
                 return undefined;

package/dist/utils/anthropic.js

@@ -1,5 +1,5 @@
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
-import { AIMessageChunk, } from "@langchain/core/messages";
+import { AIMessageChunk, isDataContentBlock, convertToProviderContentBlock, parseBase64DataUrl, } from "@langchain/core/messages";
 export function getAnthropicAPI(config) {
     function partToString(part) {
         return "text" in part ? part.text : "";
@@ -370,16 +370,221 @@ export function getAnthropicAPI(config) {
                 return undefined;
         }
     }
+    const anthropicContentConverter = {
+        providerName: "anthropic",
+        fromStandardTextBlock(block) {
+            return {
+                type: "text",
+                text: block.text,
+                ...("cache_control" in (block.metadata ?? {})
+                    ? {
+                        cache_control: block.metadata
+                            .cache_control,
+                    }
+                    : {}),
+            };
+        },
+        fromStandardImageBlock(block) {
+            if (block.source_type === "url") {
+                const data = parseBase64DataUrl({
+                    dataUrl: block.url,
+                    asTypedArray: false,
+                });
+                if (data) {
+                    return {
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            data: data.data,
+                            media_type: data.mime_type,
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? { cache_control: block.metadata.cache_control }
+                            : {}),
+                    };
+                }
+                else {
+                    return {
+                        type: "image",
+                        source: {
+                            type: "url",
+                            url: block.url,
+                            media_type: block.mime_type ?? "",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? { cache_control: block.metadata.cache_control }
+                            : {}),
+                    };
+                }
+            }
+            else {
+                if (block.source_type === "base64") {
+                    return {
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            data: block.data,
+                            media_type: block.mime_type ?? "",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? { cache_control: block.metadata.cache_control }
+                            : {}),
+                    };
+                }
+                else {
+                    throw new Error(`Unsupported image source type: ${block.source_type}`);
+                }
+            }
+        },
+        fromStandardFileBlock(block) {
+            const mime_type = (block.mime_type ?? "").split(";")[0];
+            if (block.source_type === "url") {
+                if (mime_type === "application/pdf" || mime_type === "") {
+                    return {
+                        type: "document",
+                        source: {
+                            type: "url",
+                            url: block.url,
+                            media_type: block.mime_type ?? "",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? {
+                                cache_control: block.metadata
+                                    .cache_control,
+                            }
+                            : {}),
+                        ...("citations" in (block.metadata ?? {})
+                            ? {
+                                citations: block.metadata.citations,
+                            }
+                            : {}),
+                        ...("context" in (block.metadata ?? {})
+                            ? { context: block.metadata.context }
+                            : {}),
+                        ...(block.metadata?.title ||
+                            block.metadata?.filename ||
+                            block.metadata?.name
+                            ? {
+                                title: (block.metadata?.title ||
+                                    block.metadata?.filename ||
+                                    block.metadata?.name),
+                            }
+                            : {}),
+                    };
+                }
+                throw new Error(`Unsupported file mime type for file url source: ${block.mime_type}`);
+            }
+            else if (block.source_type === "text") {
+                if (mime_type === "text/plain" || mime_type === "") {
+                    return {
+                        type: "document",
+                        source: {
+                            type: "text",
+                            data: block.text,
+                            media_type: block.mime_type ?? "",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? {
+                                cache_control: block.metadata
+                                    .cache_control,
+                            }
+                            : {}),
+                        ...("citations" in (block.metadata ?? {})
+                            ? {
+                                citations: block.metadata.citations,
+                            }
+                            : {}),
+                        ...("context" in (block.metadata ?? {})
+                            ? { context: block.metadata.context }
+                            : {}),
+                        ...("title" in (block.metadata ?? {})
+                            ? { title: block.metadata.title }
+                            : {}),
+                    };
+                }
+                else {
+                    throw new Error(`Unsupported file mime type for file text source: ${block.mime_type}`);
+                }
+            }
+            else if (block.source_type === "base64") {
+                if (mime_type === "application/pdf" || mime_type === "") {
+                    return {
+                        type: "document",
+                        source: {
+                            type: "base64",
+                            data: block.data,
+                            media_type: "application/pdf",
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? {
+                                cache_control: block.metadata
+                                    .cache_control,
+                            }
+                            : {}),
+                        ...("citations" in (block.metadata ?? {})
+                            ? {
+                                citations: block.metadata.citations,
+                            }
+                            : {}),
+                        ...("context" in (block.metadata ?? {})
+                            ? { context: block.metadata.context }
+                            : {}),
+                        ...("title" in (block.metadata ?? {})
+                            ? { title: block.metadata.title }
+                            : {}),
+                    };
+                }
+                else if (["image/jpeg", "image/png", "image/gif", "image/webp"].includes(mime_type)) {
+                    return {
+                        type: "document",
+                        source: {
+                            type: "content",
+                            content: [
+                                {
+                                    type: "image",
+                                    source: {
+                                        type: "base64",
+                                        data: block.data,
+                                        media_type: mime_type,
+                                    },
+                                },
+                            ],
+                        },
+                        ...("cache_control" in (block.metadata ?? {})
+                            ? {
+                                cache_control: block.metadata
+                                    .cache_control,
+                            }
+                            : {}),
+                        ...("citations" in (block.metadata ?? {})
+                            ? {
+                                citations: block.metadata.citations,
+                            }
+                            : {}),
+                        ...("context" in (block.metadata ?? {})
+                            ? { context: block.metadata.context }
+                            : {}),
+                        ...("title" in (block.metadata ?? {})
+                            ? { title: block.metadata.title }
+                            : {}),
+                    };
+                }
+                else {
+                    throw new Error(`Unsupported file mime type for file base64 source: ${block.mime_type}`);
+                }
+            }
+            else {
+                throw new Error(`Unsupported file source type: ${block.source_type}`);
+            }
+        },
+    };
     function contentToAnthropicContent(content) {
-        const ret = [];
         const ca = typeof content === "string" ? [{ type: "text", text: content }] : content;
-        ca.forEach((complex) => {
-            const ac = contentComplexToAnthropicContent(complex);
-            if (ac) {
-                ret.push(ac);
-            }
-        });
-        return ret;
+        return ca
+            .map((complex) => isDataContentBlock(complex)
+            ? convertToProviderContentBlock(complex, anthropicContentConverter)
+            : contentComplexToAnthropicContent(complex))
+            .filter(Boolean);
     }
     function toolCallToAnthropicContent(toolCall) {
         return {
@@ -436,6 +641,9 @@ export function getAnthropicAPI(config) {
                 return aiMessageToAnthropicMessage(base);
             case "tool":
                 return toolMessageToAnthropicMessage(base);
+            case "system":
+                //  System messages are handled in formatSystem()
+                return undefined;
             default:
                 console.warn(`Unknown BaseMessage type: ${type}`, base);
                 return undefined;

package/dist/utils/common.cjs

@@ -69,7 +69,7 @@ function convertToGeminiTools(tools) {
                 geminiTools[functionDeclarationsIndex].functionDeclarations.push(...funcs);
             }
             else if ((0, function_calling_1.isLangChainTool)(tool)) {
-                const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
+                const jsonSchema = (0, zod_to_gemini_parameters_js_1.schemaToGeminiParameters)(tool.schema);
                 geminiTools[functionDeclarationsIndex].functionDeclarations.push({
                     name: tool.name,
                     description: tool.description ?? `A function available to call.`,
@@ -91,6 +91,22 @@ function convertToGeminiTools(tools) {
     return geminiTools;
 }
 exports.convertToGeminiTools = convertToGeminiTools;
+function reasoningEffortToReasoningTokens(_modelName, effort) {
+    if (effort === undefined) {
+        return undefined;
+    }
+    const maxEffort = 24 * 1024; // Max for Gemini 2.5 Flash
+    switch (effort) {
+        case "low":
+            return maxEffort / 3;
+        case "medium":
+            return (2 * maxEffort) / 3;
+        case "high":
+            return maxEffort;
+        default:
+            return undefined;
+    }
+}
 function copyAIModelParamsInto(params, options, target) {
     const ret = target || {};
     const model = options?.model ?? params?.model ?? target.model;
@@ -103,6 +119,16 @@ function copyAIModelParamsInto(params, options, target) {
         options?.maxOutputTokens ??
             params?.maxOutputTokens ??
             target.maxOutputTokens;
+    ret.maxReasoningTokens =
+        options?.maxReasoningTokens ??
+            params?.maxReasoningTokens ??
+            target?.maxReasoningTokens ??
+            options?.thinkingBudget ??
+            params?.thinkingBudget ??
+            target?.thinkingBudget ??
+            reasoningEffortToReasoningTokens(ret.modelName, params?.reasoningEffort) ??
+            reasoningEffortToReasoningTokens(ret.modelName, target?.reasoningEffort) ??
+            reasoningEffortToReasoningTokens(ret.modelName, options?.reasoningEffort);
     ret.topP = options?.topP ?? params?.topP ?? target.topP;
     ret.topK = options?.topK ?? params?.topK ?? target.topK;
     ret.presencePenalty =

package/dist/utils/common.js

@@ -2,7 +2,7 @@ import { isOpenAITool } from "@langchain/core/language_models/base";
 import { isLangChainTool } from "@langchain/core/utils/function_calling";
 import { isModelGemini, isModelGemma, validateGeminiParams } from "./gemini.js";
 import { GeminiToolAttributes, } from "../types.js";
-import { jsonSchemaToGeminiParameters, zodToGeminiParameters, } from "./zod_to_gemini_parameters.js";
+import { jsonSchemaToGeminiParameters, schemaToGeminiParameters, } from "./zod_to_gemini_parameters.js";
 import { isModelClaude, validateClaudeParams } from "./anthropic.js";
 export function copyAIModelParams(params, options) {
     return copyAIModelParamsInto(params, options, {});
@@ -65,7 +65,7 @@ export function convertToGeminiTools(tools) {
                 geminiTools[functionDeclarationsIndex].functionDeclarations.push(...funcs);
             }
             else if (isLangChainTool(tool)) {
-                const jsonSchema = zodToGeminiParameters(tool.schema);
+                const jsonSchema = schemaToGeminiParameters(tool.schema);
                 geminiTools[functionDeclarationsIndex].functionDeclarations.push({
                     name: tool.name,
                     description: tool.description ?? `A function available to call.`,
@@ -86,6 +86,22 @@ export function convertToGeminiTools(tools) {
     });
     return geminiTools;
 }
+function reasoningEffortToReasoningTokens(_modelName, effort) {
+    if (effort === undefined) {
+        return undefined;
+    }
+    const maxEffort = 24 * 1024; // Max for Gemini 2.5 Flash
+    switch (effort) {
+        case "low":
+            return maxEffort / 3;
+        case "medium":
+            return (2 * maxEffort) / 3;
+        case "high":
+            return maxEffort;
+        default:
+            return undefined;
+    }
+}
 export function copyAIModelParamsInto(params, options, target) {
     const ret = target || {};
     const model = options?.model ?? params?.model ?? target.model;
@@ -98,6 +114,16 @@ export function copyAIModelParamsInto(params, options, target) {
         options?.maxOutputTokens ??
             params?.maxOutputTokens ??
             target.maxOutputTokens;
+    ret.maxReasoningTokens =
+        options?.maxReasoningTokens ??
+            params?.maxReasoningTokens ??
+            target?.maxReasoningTokens ??
+            options?.thinkingBudget ??
+            params?.thinkingBudget ??
+            target?.thinkingBudget ??
+            reasoningEffortToReasoningTokens(ret.modelName, params?.reasoningEffort) ??
+            reasoningEffortToReasoningTokens(ret.modelName, target?.reasoningEffort) ??
+            reasoningEffortToReasoningTokens(ret.modelName, options?.reasoningEffort);
     ret.topP = options?.topP ?? params?.topP ?? target.topP;
     ret.topK = options?.topK ?? params?.topK ?? target.topK;
     ret.presencePenalty =

package/dist/utils/gemini.cjs

@@ -198,6 +198,109 @@ function getGeminiAPI(config) {
         }
         throw new Error(`Invalid media content: ${JSON.stringify(content, null, 1)}`);
     }
+    const standardContentBlockConverter = {
+        providerName: "Google Gemini",
+        fromStandardTextBlock(block) {
+            return {
+                text: block.text,
+            };
+        },
+        fromStandardImageBlock(block) {
+            if (block.source_type === "url") {
+                const data = (0, messages_1.parseBase64DataUrl)({ dataUrl: block.url });
+                if (data) {
+                    return {
+                        inlineData: {
+                            mimeType: data.mime_type,
+                            data: data.data,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        fileData: {
+                            mimeType: block.mime_type ?? "",
+                            fileUri: block.url,
+                        },
+                    };
+                }
+            }
+            if (block.source_type === "base64") {
+                return {
+                    inlineData: {
+                        mimeType: block.mime_type ?? "",
+                        data: block.data,
+                    },
+                };
+            }
+            throw new Error(`Unsupported source type: ${block.source_type}`);
+        },
+        fromStandardAudioBlock(block) {
+            if (block.source_type === "url") {
+                const data = (0, messages_1.parseBase64DataUrl)({ dataUrl: block.url });
+                if (data) {
+                    return {
+                        inlineData: {
+                            mimeType: data.mime_type,
+                            data: data.data,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        fileData: {
+                            mimeType: block.mime_type ?? "",
+                            fileUri: block.url,
+                        },
+                    };
+                }
+            }
+            if (block.source_type === "base64") {
+                return {
+                    inlineData: {
+                        mimeType: block.mime_type ?? "",
+                        data: block.data,
+                    },
+                };
+            }
+            throw new Error(`Unsupported source type: ${block.source_type}`);
+        },
+        fromStandardFileBlock(block) {
+            if (block.source_type === "text") {
+                return {
+                    text: block.text,
+                };
+            }
+            if (block.source_type === "url") {
+                const data = (0, messages_1.parseBase64DataUrl)({ dataUrl: block.url });
+                if (data) {
+                    return {
+                        inlineData: {
+                            mimeType: data.mime_type,
+                            data: data.data,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        fileData: {
+                            mimeType: block.mime_type ?? "",
+                            fileUri: block.url,
+                        },
+                    };
+                }
+            }
+            if (block.source_type === "base64") {
+                return {
+                    inlineData: {
+                        mimeType: block.mime_type ?? "",
+                        data: block.data,
+                    },
+                };
+            }
+            throw new Error(`Unsupported source type: ${block.source_type}`);
+        },
+    };
     async function messageContentComplexToPart(content) {
         switch (content.type) {
             case "text":
@@ -219,7 +322,9 @@ function getGeminiAPI(config) {
         throw new Error(`Cannot coerce "${content.type}" message part into a string.`);
     }
     async function messageContentComplexToParts(content) {
-        const contents = content.map(messageContentComplexToPart);
+        const contents = content.map((m) => (0, messages_1.isDataContentBlock)(m)
+            ? (0, messages_1.convertToProviderContentBlock)(m, standardContentBlockConverter)
+            : messageContentComplexToPart(m));
         return Promise.all(contents);
     }
     async function messageContentToParts(content) {
@@ -951,6 +1056,13 @@ function getGeminiAPI(config) {
                 ret.logprobs = parameters.topLogprobs;
             }
         }
+        // Add thinking configuration if explicitly set
+        if (typeof parameters.maxReasoningTokens !== "undefined") {
+            ret.thinkingConfig = {
+                thinkingBudget: parameters.maxReasoningTokens,
+                includeThoughts: true,
+            };
+        }
         // Remove any undefined properties, so we don't send them
         let attribute;
         for (attribute in ret) {
@@ -994,7 +1106,7 @@ function getGeminiAPI(config) {
         }
     }
     function structuredToolToFunctionDeclaration(tool) {
-        const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
+        const jsonSchema = (0, zod_to_gemini_parameters_js_1.schemaToGeminiParameters)(tool.schema);
         return {
             name: tool.name,
             description: tool.description ?? `A function available to call.`,
@@ -1113,6 +1225,16 @@ function validateGeminiParams(params) {
     if (params.maxOutputTokens && params.maxOutputTokens < 0) {
         throw new Error("`maxOutputTokens` must be a positive integer");
     }
+    if (typeof params.maxReasoningTokens !== "undefined") {
+        if (params.maxReasoningTokens < 0) {
+            throw new Error("`maxReasoningTokens` must be non-negative integer");
+        }
+        if (typeof params.maxOutputTokens !== "undefined") {
+            if (params.maxReasoningTokens >= params.maxOutputTokens) {
+                throw new Error("`maxOutputTokens` must be greater than `maxReasoningTokens`");
+            }
+        }
+    }
     if (params.temperature &&
         (params.temperature < 0 || params.temperature > 2)) {
         throw new Error("`temperature` must be in the range of [0.0,2.0]");

package/dist/utils/gemini.js

@@ -1,11 +1,11 @@
 import { v4 as uuidv4 } from "uuid";
-import { AIMessage, AIMessageChunk, isAIMessage, } from "@langchain/core/messages";
+import { AIMessage, AIMessageChunk, isAIMessage, parseBase64DataUrl, isDataContentBlock, convertToProviderContentBlock, } from "@langchain/core/messages";
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
 import { isLangChainTool } from "@langchain/core/utils/function_calling";
 import { concat } from "@langchain/core/utils/stream";
 import { GoogleAISafetyError } from "./safety.js";
 import { GeminiSearchToolAttributes, } from "../types.js";
-import { zodToGeminiParameters } from "./zod_to_gemini_parameters.js";
+import { schemaToGeminiParameters } from "./zod_to_gemini_parameters.js";
 export class DefaultGeminiSafetyHandler {
     constructor(settings) {
         Object.defineProperty(this, "errorFinish", {
@@ -193,6 +193,109 @@ export function getGeminiAPI(config) {
         }
         throw new Error(`Invalid media content: ${JSON.stringify(content, null, 1)}`);
     }
+    const standardContentBlockConverter = {
+        providerName: "Google Gemini",
+        fromStandardTextBlock(block) {
+            return {
+                text: block.text,
+            };
+        },
+        fromStandardImageBlock(block) {
+            if (block.source_type === "url") {
+                const data = parseBase64DataUrl({ dataUrl: block.url });
+                if (data) {
+                    return {
+                        inlineData: {
+                            mimeType: data.mime_type,
+                            data: data.data,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        fileData: {
+                            mimeType: block.mime_type ?? "",
+                            fileUri: block.url,
+                        },
+                    };
+                }
+            }
+            if (block.source_type === "base64") {
+                return {
+                    inlineData: {
+                        mimeType: block.mime_type ?? "",
+                        data: block.data,
+                    },
+                };
+            }
+            throw new Error(`Unsupported source type: ${block.source_type}`);
+        },
+        fromStandardAudioBlock(block) {
+            if (block.source_type === "url") {
+                const data = parseBase64DataUrl({ dataUrl: block.url });
+                if (data) {
+                    return {
+                        inlineData: {
+                            mimeType: data.mime_type,
+                            data: data.data,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        fileData: {
+                            mimeType: block.mime_type ?? "",
+                            fileUri: block.url,
+                        },
+                    };
+                }
+            }
+            if (block.source_type === "base64") {
+                return {
+                    inlineData: {
+                        mimeType: block.mime_type ?? "",
+                        data: block.data,
+                    },
+                };
+            }
+            throw new Error(`Unsupported source type: ${block.source_type}`);
+        },
+        fromStandardFileBlock(block) {
+            if (block.source_type === "text") {
+                return {
+                    text: block.text,
+                };
+            }
+            if (block.source_type === "url") {
+                const data = parseBase64DataUrl({ dataUrl: block.url });
+                if (data) {
+                    return {
+                        inlineData: {
+                            mimeType: data.mime_type,
+                            data: data.data,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        fileData: {
+                            mimeType: block.mime_type ?? "",
+                            fileUri: block.url,
+                        },
+                    };
+                }
+            }
+            if (block.source_type === "base64") {
+                return {
+                    inlineData: {
+                        mimeType: block.mime_type ?? "",
+                        data: block.data,
+                    },
+                };
+            }
+            throw new Error(`Unsupported source type: ${block.source_type}`);
+        },
+    };
     async function messageContentComplexToPart(content) {
         switch (content.type) {
             case "text":
@@ -214,7 +317,9 @@ export function getGeminiAPI(config) {
         throw new Error(`Cannot coerce "${content.type}" message part into a string.`);
     }
     async function messageContentComplexToParts(content) {
-        const contents = content.map(messageContentComplexToPart);
+        const contents = content.map((m) => isDataContentBlock(m)
+            ? convertToProviderContentBlock(m, standardContentBlockConverter)
+            : messageContentComplexToPart(m));
         return Promise.all(contents);
     }
     async function messageContentToParts(content) {
@@ -946,6 +1051,13 @@ export function getGeminiAPI(config) {
                 ret.logprobs = parameters.topLogprobs;
             }
         }
+        // Add thinking configuration if explicitly set
+        if (typeof parameters.maxReasoningTokens !== "undefined") {
+            ret.thinkingConfig = {
+                thinkingBudget: parameters.maxReasoningTokens,
+                includeThoughts: true,
+            };
+        }
         // Remove any undefined properties, so we don't send them
         let attribute;
         for (attribute in ret) {
@@ -989,7 +1101,7 @@ export function getGeminiAPI(config) {
         }
     }
     function structuredToolToFunctionDeclaration(tool) {
-        const jsonSchema = zodToGeminiParameters(tool.schema);
+        const jsonSchema = schemaToGeminiParameters(tool.schema);
         return {
             name: tool.name,
             description: tool.description ?? `A function available to call.`,
@@ -1107,6 +1219,16 @@ export function validateGeminiParams(params) {
     if (params.maxOutputTokens && params.maxOutputTokens < 0) {
         throw new Error("`maxOutputTokens` must be a positive integer");
     }
+    if (typeof params.maxReasoningTokens !== "undefined") {
+        if (params.maxReasoningTokens < 0) {
+            throw new Error("`maxReasoningTokens` must be non-negative integer");
+        }
+        if (typeof params.maxOutputTokens !== "undefined") {
+            if (params.maxReasoningTokens >= params.maxOutputTokens) {
+                throw new Error("`maxOutputTokens` must be greater than `maxReasoningTokens`");
+            }
+        }
+    }
     if (params.temperature &&
         (params.temperature < 0 || params.temperature > 2)) {
         throw new Error("`temperature` must be in the range of [0.0,2.0]");

package/dist/utils/zod_to_gemini_parameters.cjs

@@ -1,7 +1,8 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-unused-vars */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonSchemaToGeminiParameters = exports.zodToGeminiParameters = exports.removeAdditionalProperties = void 0;
+exports.jsonSchemaToGeminiParameters = exports.schemaToGeminiParameters = exports.removeAdditionalProperties = void 0;
+const types_1 = require("@langchain/core/utils/types");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 function removeAdditionalProperties(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -26,17 +27,14 @@ obj) {
     return obj;
 }
 exports.removeAdditionalProperties = removeAdditionalProperties;
-function zodToGeminiParameters(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-zodObj) {
+function schemaToGeminiParameters(schema) {
     // Gemini doesn't accept either the $schema or additionalProperties
     // attributes, so we need to explicitly remove them.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const jsonSchema = removeAdditionalProperties((0, zod_to_json_schema_1.zodToJsonSchema)(zodObj));
+    const jsonSchema = removeAdditionalProperties((0, types_1.isZodSchema)(schema) ? (0, zod_to_json_schema_1.zodToJsonSchema)(schema) : schema);
     const { $schema, ...rest } = jsonSchema;
     return rest;
 }
-exports.zodToGeminiParameters = zodToGeminiParameters;
+exports.schemaToGeminiParameters = schemaToGeminiParameters;
 function jsonSchemaToGeminiParameters(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 schema) {

package/dist/utils/zod_to_gemini_parameters.d.ts

@@ -1,5 +1,6 @@
 import type { z } from "zod";
+import { type JsonSchema7Type } from "zod-to-json-schema";
 import { GeminiFunctionSchema, GeminiJsonSchema } from "../types.js";
 export declare function removeAdditionalProperties(obj: Record<string, any>): GeminiJsonSchema;
-export declare function zodToGeminiParameters(zodObj: z.ZodType<any>): GeminiFunctionSchema;
+export declare function schemaToGeminiParameters<RunOutput extends Record<string, any> = Record<string, any>>(schema: z.ZodType<RunOutput> | z.ZodEffects<z.ZodType<RunOutput>> | JsonSchema7Type): GeminiFunctionSchema;
 export declare function jsonSchemaToGeminiParameters(schema: Record<string, any>): GeminiFunctionSchema;

package/dist/utils/zod_to_gemini_parameters.js

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
+import { isZodSchema } from "@langchain/core/utils/types";
 import { zodToJsonSchema } from "zod-to-json-schema";
 export function removeAdditionalProperties(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -22,13 +23,10 @@ obj) {
     }
     return obj;
 }
-export function zodToGeminiParameters(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-zodObj) {
+export function schemaToGeminiParameters(schema) {
     // Gemini doesn't accept either the $schema or additionalProperties
     // attributes, so we need to explicitly remove them.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const jsonSchema = removeAdditionalProperties(zodToJsonSchema(zodObj));
+    const jsonSchema = removeAdditionalProperties(isZodSchema(schema) ? zodToJsonSchema(schema) : schema);
     const { $schema, ...rest } = jsonSchema;
     return rest;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-common",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Core types and classes for Google services.",
   "type": "module",
   "engines": {
@@ -36,11 +36,11 @@
     "zod-to-json-schema": "^3.22.4"
   },
   "peerDependencies": {
-    "@langchain/core": ">=0.2.21 <0.4.0"
+    "@langchain/core": ">=0.3.48 <0.4.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
-    "@langchain/core": "workspace:*",
+    "@langchain/core": "0.3.48",
     "@langchain/scripts": ">=0.1.0 <0.2.0",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
@@ -58,7 +58,7 @@
     "jest": "^29.5.0",
     "jest-environment-node": "^29.6.4",
     "prettier": "^2.8.3",
-    "release-it": "^17.6.0",
+    "release-it": "^18.1.2",
     "rollup": "^4.5.2",
     "ts-jest": "^29.1.0",
     "typescript": "<5.2.0",
@@ -138,4 +138,4 @@
     "experimental/utils/media_core.d.ts",
     "experimental/utils/media_core.d.cts"
   ]
-}
+}