@langchain/google-common 0.2.4 → 0.2.6

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,

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

@@ -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,

package/dist/connection.cjs

@@ -114,17 +114,17 @@ class GoogleHostConnection extends GoogleConnection {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "apiVersion", {
+        Object.defineProperty(this, "_apiVersion", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "v1"
+            value: void 0
         });
         this.caller = caller;
         this.platformType = fields?.platformType;
         this._endpoint = fields?.endpoint;
         this._location = fields?.location;
-        this.apiVersion = fields?.apiVersion ?? this.apiVersion;
+        this._apiVersion = fields?.apiVersion;
         this.client = client;
     }
     get platform() {
@@ -133,6 +133,12 @@ class GoogleHostConnection extends GoogleConnection {
     get computedPlatformType() {
         return "gcp";
     }
+    get computedApiVersion() {
+        return "v1";
+    }
+    get apiVersion() {
+        return this._apiVersion ?? this.computedApiVersion;
+    }
     get location() {
         return this._location ?? this.computedLocation;
     }
@@ -238,6 +244,14 @@ class GoogleAIConnection extends GoogleHostConnection {
             return "gcp";
         }
     }
+    get computedApiVersion() {
+        switch (this.platform) {
+            case "gai":
+                return "v1beta";
+            default:
+                return "v1";
+        }
+    }
     get computedLocation() {
         switch (this.apiName) {
             case "google":

package/dist/connection.d.ts

@@ -25,10 +25,12 @@ export declare abstract class GoogleHostConnection<CallOptions extends AsyncCall
     platformType: GooglePlatformType | undefined;
     _endpoint: string | undefined;
     _location: string | undefined;
-    apiVersion: string;
+    _apiVersion: string | undefined;
     constructor(fields: GoogleConnectionParams<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming?: boolean);
     get platform(): GooglePlatformType;
     get computedPlatformType(): GooglePlatformType;
+    get computedApiVersion(): string;
+    get apiVersion(): string;
     get location(): string;
     get computedLocation(): string;
     get endpoint(): string;
@@ -52,6 +54,7 @@ export declare abstract class GoogleAIConnection<CallOptions extends AsyncCaller
     get api(): GoogleAIAPI;
     get isApiKey(): boolean;
     get computedPlatformType(): GooglePlatformType;
+    get computedApiVersion(): string;
     get computedLocation(): string;
     abstract buildUrlMethod(): Promise<string>;
     buildUrlGenerativeLanguage(): Promise<string>;

package/dist/connection.js

@@ -110,17 +110,17 @@ export class GoogleHostConnection extends GoogleConnection {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "apiVersion", {
+        Object.defineProperty(this, "_apiVersion", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "v1"
+            value: void 0
         });
         this.caller = caller;
         this.platformType = fields?.platformType;
         this._endpoint = fields?.endpoint;
         this._location = fields?.location;
-        this.apiVersion = fields?.apiVersion ?? this.apiVersion;
+        this._apiVersion = fields?.apiVersion;
         this.client = client;
     }
     get platform() {
@@ -129,6 +129,12 @@ export class GoogleHostConnection extends GoogleConnection {
     get computedPlatformType() {
         return "gcp";
     }
+    get computedApiVersion() {
+        return "v1";
+    }
+    get apiVersion() {
+        return this._apiVersion ?? this.computedApiVersion;
+    }
     get location() {
         return this._location ?? this.computedLocation;
     }
@@ -232,6 +238,14 @@ export class GoogleAIConnection extends GoogleHostConnection {
             return "gcp";
         }
     }
+    get computedApiVersion() {
+        switch (this.platform) {
+            case "gai":
+                return "v1beta";
+            default:
+                return "v1";
+        }
+    }
     get computedLocation() {
         switch (this.apiName) {
             case "google":

package/dist/experimental/media.cjs

@@ -328,14 +328,8 @@ class AIStudioMediaBlob extends media_core_js_1.MediaBlob {
 }
 exports.AIStudioMediaBlob = AIStudioMediaBlob;
 class AIStudioFileUploadConnection extends GoogleMultipartUploadConnection {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "apiVersion", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "v1beta"
-        });
+    get computedApiVersion() {
+        return "v1beta";
     }
     async buildUrl() {
         return `https://generativelanguage.googleapis.com/upload/${this.apiVersion}/files`;
@@ -357,15 +351,12 @@ class AIStudioFileDownloadConnection extends GoogleDownloadConnection {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "apiVersion", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "v1beta"
-        });
         this.method = fields.method;
         this.name = fields.name;
     }
+    get computedApiVersion() {
+        return "v1beta";
+    }
     buildMethod() {
         return this.method;
     }

package/dist/experimental/media.d.ts

@@ -166,7 +166,7 @@ export interface AIStudioFileConnectionParams {
 export interface AIStudioFileUploadConnectionParams<AuthOptions> extends GoogleUploadConnectionParams<AuthOptions>, AIStudioFileConnectionParams {
 }
 export declare class AIStudioFileUploadConnection<AuthOptions> extends GoogleMultipartUploadConnection<AsyncCallerCallOptions, AIStudioFileSaveResponse, AuthOptions> {
-    apiVersion: string;
+    get computedApiVersion(): string;
     buildUrl(): Promise<string>;
 }
 export interface AIStudioFileDownloadConnectionParams<AuthOptions> extends AIStudioFileConnectionParams, GoogleConnectionParams<AuthOptions> {
@@ -176,8 +176,8 @@ export interface AIStudioFileDownloadConnectionParams<AuthOptions> extends AIStu
 export declare class AIStudioFileDownloadConnection<ResponseType extends GoogleResponse, AuthOptions> extends GoogleDownloadConnection<AsyncCallerCallOptions, ResponseType, AuthOptions> {
     method: GoogleAbstractedClientOpsMethod;
     name: string;
-    apiVersion: string;
     constructor(fields: AIStudioFileDownloadConnectionParams<AuthOptions>, caller: AsyncCaller, client: GoogleAbstractedClient);
+    get computedApiVersion(): string;
     buildMethod(): GoogleAbstractedClientOpsMethod;
     buildUrl(): Promise<string>;
 }

package/dist/experimental/media.js

@@ -315,14 +315,8 @@ export class AIStudioMediaBlob extends MediaBlob {
     }
 }
 export class AIStudioFileUploadConnection extends GoogleMultipartUploadConnection {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "apiVersion", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "v1beta"
-        });
+    get computedApiVersion() {
+        return "v1beta";
     }
     async buildUrl() {
         return `https://generativelanguage.googleapis.com/upload/${this.apiVersion}/files`;
@@ -343,15 +337,12 @@ export class AIStudioFileDownloadConnection extends GoogleDownloadConnection {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "apiVersion", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "v1beta"
-        });
         this.method = fields.method;
         this.name = fields.name;
     }
+    get computedApiVersion() {
+        return "v1beta";
+    }
     buildMethod() {
         return this.method;
     }

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

@@ -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

@@ -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) {
@@ -546,12 +651,9 @@ function getGeminiAPI(config) {
         if (!data) {
             return {};
         }
-        return {
-            usage_metadata: {
-                prompt_token_count: data.usageMetadata?.promptTokenCount,
-                candidates_token_count: data.usageMetadata?.candidatesTokenCount,
-                total_token_count: data.usageMetadata?.totalTokenCount,
-            },
+        const finish_reason = data.candidates[0]?.finishReason;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ret = {
             safety_ratings: data.candidates[0]?.safetyRatings?.map((rating) => ({
                 category: rating.category,
                 probability: rating.probability,
@@ -561,11 +663,21 @@ function getGeminiAPI(config) {
             })),
             citation_metadata: data.candidates[0]?.citationMetadata,
             grounding_metadata: data.candidates[0]?.groundingMetadata,
-            finish_reason: data.candidates[0]?.finishReason,
+            finish_reason,
             finish_message: data.candidates[0]?.finishMessage,
             avgLogprobs: data.candidates[0]?.avgLogprobs,
             logprobs: candidateToLogprobs(data.candidates[0]),
         };
+        // Only add the usage_metadata on the last chunk
+        // sent while streaming (see issue 8102).
+        if (typeof finish_reason === "string") {
+            ret.usage_metadata = {
+                prompt_token_count: data.usageMetadata?.promptTokenCount,
+                candidates_token_count: data.usageMetadata?.candidatesTokenCount,
+                total_token_count: data.usageMetadata?.totalTokenCount,
+            };
+        }
+        return ret;
     }
     function responseToChatGeneration(response) {
         return new outputs_1.ChatGenerationChunk({
@@ -951,6 +1063,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) {
@@ -1113,6 +1232,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,5 +1,5 @@
 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";
@@ -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) {
@@ -541,12 +646,9 @@ export function getGeminiAPI(config) {
         if (!data) {
             return {};
         }
-        return {
-            usage_metadata: {
-                prompt_token_count: data.usageMetadata?.promptTokenCount,
-                candidates_token_count: data.usageMetadata?.candidatesTokenCount,
-                total_token_count: data.usageMetadata?.totalTokenCount,
-            },
+        const finish_reason = data.candidates[0]?.finishReason;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ret = {
             safety_ratings: data.candidates[0]?.safetyRatings?.map((rating) => ({
                 category: rating.category,
                 probability: rating.probability,
@@ -556,11 +658,21 @@ export function getGeminiAPI(config) {
             })),
             citation_metadata: data.candidates[0]?.citationMetadata,
             grounding_metadata: data.candidates[0]?.groundingMetadata,
-            finish_reason: data.candidates[0]?.finishReason,
+            finish_reason,
             finish_message: data.candidates[0]?.finishMessage,
             avgLogprobs: data.candidates[0]?.avgLogprobs,
             logprobs: candidateToLogprobs(data.candidates[0]),
         };
+        // Only add the usage_metadata on the last chunk
+        // sent while streaming (see issue 8102).
+        if (typeof finish_reason === "string") {
+            ret.usage_metadata = {
+                prompt_token_count: data.usageMetadata?.promptTokenCount,
+                candidates_token_count: data.usageMetadata?.candidatesTokenCount,
+                total_token_count: data.usageMetadata?.totalTokenCount,
+            };
+        }
+        return ret;
     }
     function responseToChatGeneration(response) {
         return new ChatGenerationChunk({
@@ -946,6 +1058,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) {
@@ -1107,6 +1226,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-common",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "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": "0.3.44",
+    "@langchain/core": "0.3.53",
     "@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",