@aigne/gemini 0.14.16 → 1.74.0-beta

package/README.md

@@ -2,28 +2,28 @@
 
 <p align="center">
   <picture>
-    <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/logo-dark.svg" media="(prefers-color-scheme: dark)">
-    <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/logo.svg" media="(prefers-color-scheme: light)">
-    <img src="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/logo.svg" alt="AIGNE Logo" width="400" />
+    <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/logo-dark.svg" media="(prefers-color-scheme: dark)">
+    <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/logo.svg" media="(prefers-color-scheme: light)">
+    <img src="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/logo.svg" alt="AIGNE Logo" width="400" />
   </picture>
 </p>
 
-[![GitHub star chart](https://img.shields.io/github/stars/AIGNE-io/aigne-framework?style=flat-square)](https://star-history.com/#AIGNE-io/aigne-framework)
-[![Open Issues](https://img.shields.io/github/issues-raw/AIGNE-io/aigne-framework?style=flat-square)](https://github.com/AIGNE-io/aigne-framework/issues)
-[![codecov](https://codecov.io/gh/AIGNE-io/aigne-framework/graph/badge.svg?token=DO07834RQL)](https://codecov.io/gh/AIGNE-io/aigne-framework)
+[![GitHub star chart](https://img.shields.io/github/stars/ArcBlock/aigne-framework?style=flat-square)](https://star-history.com/#ArcBlock/aigne-framework)
+[![Open Issues](https://img.shields.io/github/issues-raw/ArcBlock/aigne-framework?style=flat-square)](https://github.com/ArcBlock/aigne-framework/issues)
+[![codecov](https://codecov.io/gh/ArcBlock/aigne-framework/graph/badge.svg?token=DO07834RQL)](https://codecov.io/gh/ArcBlock/aigne-framework)
 [![NPM Version](https://img.shields.io/npm/v/@aigne/gemini)](https://www.npmjs.com/package/@aigne/gemini)
-[![Elastic-2.0 licensed](https://img.shields.io/npm/l/@aigne/gemini)](https://github.com/AIGNE-io/aigne-framework/blob/main/LICENSE.md)
+[![Elastic-2.0 licensed](https://img.shields.io/npm/l/@aigne/gemini)](https://github.com/ArcBlock/aigne-framework/blob/main/LICENSE.md)
 
-AIGNE Gemini SDK for integrating with Google's Gemini AI models within the [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework).
+AIGNE Gemini SDK for integrating with Google's Gemini AI models within the [AIGNE Framework](https://github.com/ArcBlock/aigne-framework).
 
 ## Introduction
 
 `@aigne/gemini` provides a seamless integration between the AIGNE Framework and Google's Gemini language models and API. This package enables developers to easily leverage Gemini's advanced AI capabilities in their AIGNE applications, providing a consistent interface across the framework while taking advantage of Google's state-of-the-art multimodal models.
 
 <picture>
-  <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/assets/aigne-gemini-dark.png" media="(prefers-color-scheme: dark)">
-  <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/assets/aigne-gemini.png" media="(prefers-color-scheme: light)">
-  <img src="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/assets/aigne-gemini.png" alt="AIGNE Arch" />
+  <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/assets/aigne-gemini-dark.png" media="(prefers-color-scheme: dark)">
+  <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/assets/aigne-gemini.png" media="(prefers-color-scheme: light)">
+  <img src="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/assets/aigne-gemini.png" alt="AIGNE Arch" />
 </picture>
 
 ## Features

package/dist/gemini-chat-model.cjs

@@ -0,0 +1,435 @@
+let _aigne_core = require("@aigne/core");
+let _aigne_core_utils_logger = require("@aigne/core/utils/logger");
+let _aigne_core_utils_model_utils = require("@aigne/core/utils/model-utils");
+let _aigne_core_utils_type_utils = require("@aigne/core/utils/type-utils");
+let _aigne_utils_nodejs = require("@aigne/utils/nodejs");
+let _aigne_uuid = require("@aigne/uuid");
+let _google_genai = require("@google/genai");
+let yaml = require("yaml");
+let zod = require("zod");
+let zod_to_json_schema = require("zod-to-json-schema");
+
+//#region src/gemini-chat-model.ts
+const GEMINI_DEFAULT_CHAT_MODEL = "gemini-2.0-flash";
+const OUTPUT_FUNCTION_NAME = "output";
+const NEED_UPLOAD_MAX_FILE_SIZE_MB = 20;
+/**
+* Implementation of the ChatModel interface for Google's Gemini API
+*
+* @example
+* Here's how to create and use a Gemini chat model:
+* {@includeCode ../test/gemini-chat-model.test.ts#example-gemini-chat-model}
+*
+* @example
+* Here's an example with streaming response:
+* {@includeCode ../test/gemini-chat-model.test.ts#example-gemini-chat-model-streaming}
+*/
+var GeminiChatModel = class extends _aigne_core.ChatModel {
+	constructor(options) {
+		super({
+			...options,
+			model: options?.model || GEMINI_DEFAULT_CHAT_MODEL
+		});
+		this.options = options;
+	}
+	apiKeyEnvName = "GEMINI_API_KEY";
+	_googleClient;
+	get googleClient() {
+		if (this._googleClient) return this._googleClient;
+		const { apiKey } = this.credential;
+		if (!apiKey) throw new Error(`${this.name} requires an API key. Please provide it via \`options.apiKey\`, or set the \`${this.apiKeyEnvName}\` environment variable`);
+		this._googleClient ??= new _google_genai.GoogleGenAI({
+			apiKey,
+			...this.options?.clientOptions
+		});
+		return this._googleClient;
+	}
+	get credential() {
+		return {
+			apiKey: this.options?.apiKey || process.env[this.apiKeyEnvName] || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY,
+			model: this.options?.model || GEMINI_DEFAULT_CHAT_MODEL
+		};
+	}
+	get modelOptions() {
+		return this.options?.modelOptions;
+	}
+	async countTokens(input) {
+		const { model, ...request } = await this.getParameters(input);
+		const contents = [];
+		const { systemInstruction, tools } = request.config ?? {};
+		if (systemInstruction) contents.push(this.contentUnionToContent(systemInstruction));
+		if (tools?.length) contents.push({
+			role: "system",
+			parts: [{ text: JSON.stringify(tools) }]
+		});
+		contents.push(...[request.contents].flat().map(this.contentUnionToContent));
+		const tokens = (await this.googleClient.models.countTokens({
+			model,
+			contents
+		})).totalTokens;
+		if (!(0, _aigne_core_utils_type_utils.isNil)(tokens)) return tokens;
+		return super.countTokens(input);
+	}
+	contentUnionToContent(content) {
+		if (typeof content === "object" && "parts" in content) return {
+			role: "system",
+			parts: content.parts
+		};
+		else if (typeof content === "string") return {
+			role: "system",
+			parts: [{ text: content }]
+		};
+		else if (Array.isArray(content)) return {
+			role: "system",
+			parts: content.map((i) => typeof i === "string" ? { text: i } : i)
+		};
+		else return {
+			role: "system",
+			parts: [content]
+		};
+	}
+	process(input, options) {
+		return this.processInput(input, options);
+	}
+	thinkingBudgetModelMap = [
+		{
+			pattern: /gemini-2.5-flash-image-preview/,
+			support: false
+		},
+		{
+			pattern: /gemini-3(?!.*-image-)/,
+			support: true,
+			type: "level"
+		},
+		{
+			pattern: /gemini-2.5-pro/,
+			support: true,
+			min: 128,
+			max: 32768
+		},
+		{
+			pattern: /gemini-2.5-flash/,
+			support: true,
+			min: 0,
+			max: 24576
+		},
+		{
+			pattern: /2.5-flash-lite/,
+			support: true,
+			min: 512,
+			max: 24576
+		},
+		{
+			pattern: /.*/,
+			support: false
+		}
+	];
+	thinkingBudgetLevelMap = {
+		high: 1e5,
+		medium: 1e4,
+		low: 5e3,
+		minimal: 200
+	};
+	thinkingLevelMap = {
+		high: _google_genai.ThinkingLevel.HIGH,
+		medium: _google_genai.ThinkingLevel.HIGH,
+		low: _google_genai.ThinkingLevel.LOW,
+		minimal: _google_genai.ThinkingLevel.LOW
+	};
+	getThinkingBudget(model, effort) {
+		const m = this.thinkingBudgetModelMap.find((i) => i.pattern.test(model));
+		if (!m?.support) return { support: false };
+		if (m.type === "level") {
+			let level = _google_genai.ThinkingLevel.THINKING_LEVEL_UNSPECIFIED;
+			if (typeof effort === "string") level = this.thinkingLevelMap[effort];
+			else if (typeof effort === "number") level = effort >= this.thinkingBudgetLevelMap["medium"] ? _google_genai.ThinkingLevel.HIGH : _google_genai.ThinkingLevel.LOW;
+			return {
+				support: true,
+				level
+			};
+		}
+		let budget = typeof effort === "string" ? this.thinkingBudgetLevelMap[effort] || void 0 : effort;
+		if (typeof budget === "undefined") return { support: true };
+		if (typeof m.min === "number") budget = Math.max(m.min, budget);
+		if (typeof m.max === "number") budget = Math.min(m.max, budget);
+		return {
+			support: true,
+			budget
+		};
+	}
+	async getParameters(input) {
+		const { modelOptions = {} } = input;
+		const model = modelOptions.model || this.credential.model;
+		const { contents, config } = await this.buildContents(input);
+		const thinkingBudget = this.getThinkingBudget(model, modelOptions.reasoningEffort);
+		return {
+			model,
+			contents,
+			config: {
+				thinkingConfig: thinkingBudget.support ? {
+					includeThoughts: true,
+					thinkingBudget: thinkingBudget.budget,
+					thinkingLevel: thinkingBudget.level
+				} : void 0,
+				responseModalities: modelOptions.modalities,
+				temperature: modelOptions.temperature,
+				topP: modelOptions.topP,
+				frequencyPenalty: modelOptions.frequencyPenalty,
+				presencePenalty: modelOptions.presencePenalty,
+				...config,
+				...await this.buildConfig(input)
+			}
+		};
+	}
+	async *processInput(input, options) {
+		const parameters = await this.getParameters(input);
+		const response = await this.googleClient.models.generateContentStream(parameters);
+		let usage = {
+			inputTokens: 0,
+			outputTokens: 0
+		};
+		let responseModel;
+		const files = [];
+		const toolCalls = [];
+		let text = "";
+		let json;
+		for await (const chunk of response) {
+			if (!responseModel && chunk.modelVersion) {
+				responseModel = chunk.modelVersion;
+				yield { delta: { json: { model: responseModel } } };
+			}
+			for (const { content } of chunk.candidates ?? []) if (content?.parts) for (const part of content.parts) {
+				if (part.text) if (part.thought) yield { delta: { text: { thoughts: part.text } } };
+				else {
+					text += part.text;
+					if (input.responseFormat?.type !== "json_schema") yield { delta: { text: { text: part.text } } };
+				}
+				if (part.inlineData?.data) files.push({
+					type: "file",
+					data: part.inlineData.data,
+					filename: part.inlineData.displayName,
+					mimeType: part.inlineData.mimeType
+				});
+				if (part.functionCall?.name) if (part.functionCall.name === OUTPUT_FUNCTION_NAME) json = part.functionCall.args;
+				else {
+					const toolCall = {
+						id: part.functionCall.id || (0, _aigne_uuid.v7)(),
+						type: "function",
+						function: {
+							name: part.functionCall.name,
+							arguments: part.functionCall.args || {}
+						}
+					};
+					if (part.thoughtSignature && parameters.model.includes("gemini-3")) toolCall.metadata = { thoughtSignature: part.thoughtSignature };
+					toolCalls.push(toolCall);
+				}
+			}
+			if (chunk.usageMetadata) {
+				if (chunk.usageMetadata.promptTokenCount) usage.inputTokens = chunk.usageMetadata.promptTokenCount;
+				if (chunk.usageMetadata.candidatesTokenCount || chunk.usageMetadata.thoughtsTokenCount) usage.outputTokens = (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0);
+				if (chunk.usageMetadata.cachedContentTokenCount) usage.cacheReadInputTokens = chunk.usageMetadata.cachedContentTokenCount;
+			}
+		}
+		if (toolCalls.length) yield { delta: { json: { toolCalls } } };
+		if (input.responseFormat?.type === "json_schema") {
+			if (json) yield { delta: { json: { json } } };
+			else if (text) yield { delta: { json: { json: (0, _aigne_core.safeParseJSON)(text) } } };
+			else if (!toolCalls.length) throw new _aigne_core.StructuredOutputError("No JSON response from the model");
+		} else if (!toolCalls.length) {
+			if (!text && !files.length) {
+				_aigne_core_utils_logger.logger.warn("Empty response from Gemini, retrying with structured output mode");
+				try {
+					const outputSchema = zod.z.object({ output: zod.z.string().describe("The final answer from the model") });
+					const result = await (0, _aigne_core.agentProcessResultToObject)(await this.process({
+						...input,
+						responseFormat: {
+							type: "json_schema",
+							jsonSchema: {
+								name: "output",
+								schema: (0, zod_to_json_schema.zodToJsonSchema)(outputSchema)
+							}
+						}
+					}, options));
+					usage = (0, _aigne_core_utils_model_utils.mergeUsage)(usage, result.usage);
+					if (result.toolCalls?.length) {
+						toolCalls.push(...result.toolCalls);
+						yield { delta: { json: { toolCalls } } };
+					} else {
+						if (!result.json) throw new Error("Retrying with structured output mode got no json response");
+						const parsed = outputSchema.safeParse(result.json);
+						if (!parsed.success) throw new Error("Retrying with structured output mode got invalid json response");
+						text = parsed.data.output;
+						yield { delta: { text: { text } } };
+						_aigne_core_utils_logger.logger.warn("Empty response from Gemini, retried with structured output mode successfully");
+					}
+				} catch (error) {
+					_aigne_core_utils_logger.logger.error("Empty response from Gemini, retrying with structured output mode failed", error);
+					throw new _aigne_core.StructuredOutputError("No response from the model");
+				}
+			}
+		}
+		yield { delta: { json: {
+			usage,
+			files: files.length ? files : void 0,
+			modelOptions: { reasoningEffort: parameters.config?.thinkingConfig?.thinkingLevel || parameters.config?.thinkingConfig?.thinkingBudget }
+		} } };
+	}
+	async buildConfig(input) {
+		const config = {};
+		const { tools, toolConfig } = await this.buildTools(input);
+		config.tools = tools;
+		config.toolConfig = toolConfig;
+		if (input.responseFormat?.type === "json_schema") if (config.tools?.length) {
+			config.tools.push({ functionDeclarations: [{
+				name: OUTPUT_FUNCTION_NAME,
+				description: "Output the final response",
+				parametersJsonSchema: input.responseFormat.jsonSchema.schema
+			}] });
+			config.toolConfig = {
+				...config.toolConfig,
+				functionCallingConfig: { mode: _google_genai.FunctionCallingConfigMode.ANY }
+			};
+		} else {
+			config.responseJsonSchema = input.responseFormat.jsonSchema.schema;
+			config.responseMimeType = "application/json";
+		}
+		return config;
+	}
+	async buildTools(input) {
+		const tools = [];
+		for (const tool of input.tools ?? []) tools.push({ functionDeclarations: [{
+			name: tool.function.name,
+			description: tool.function.description,
+			parametersJsonSchema: tool.function.parameters
+		}] });
+		return {
+			tools,
+			toolConfig: { functionCallingConfig: !input.toolChoice ? void 0 : input.toolChoice === "auto" ? { mode: _google_genai.FunctionCallingConfigMode.AUTO } : input.toolChoice === "none" ? { mode: _google_genai.FunctionCallingConfigMode.NONE } : input.toolChoice === "required" ? { mode: _google_genai.FunctionCallingConfigMode.ANY } : {
+				mode: _google_genai.FunctionCallingConfigMode.ANY,
+				allowedFunctionNames: [input.toolChoice.function.name]
+			} }
+		};
+	}
+	async buildVideoContentParts(media) {
+		const { path: filePath, mimeType: fileMimeType } = await this.transformFileType("local", media);
+		if (filePath) {
+			if ((await _aigne_utils_nodejs.nodejs.fs.stat(filePath)).size / (1024 * 1024) > NEED_UPLOAD_MAX_FILE_SIZE_MB) {
+				let file = await this.googleClient.files.upload({
+					file: filePath,
+					config: { mimeType: fileMimeType }
+				});
+				while (file.state === "PROCESSING") {
+					await new Promise((resolve) => setTimeout(resolve, 1e3));
+					if (file.name) file = await this.googleClient.files.get({ name: file.name });
+				}
+				if (file.state !== "ACTIVE") throw new Error(`File ${file.name} failed to process: ${file.state}`);
+				if (file.uri && file.mimeType) {
+					const part = (0, _google_genai.createUserContent)([(0, _google_genai.createPartFromUri)(file.uri, file.mimeType), ""]).parts?.find((x) => x.fileData);
+					if (part) {
+						await _aigne_utils_nodejs.nodejs.fs.rm(filePath);
+						return part;
+					}
+				}
+			}
+		}
+	}
+	async buildContents(input) {
+		const result = { contents: [] };
+		const systemParts = [];
+		result.contents = (await Promise.all(input.messages.map(async (msg) => {
+			if (msg.role === "system") {
+				if (typeof msg.content === "string") systemParts.push({ text: msg.content });
+				else if (Array.isArray(msg.content)) systemParts.push(...msg.content.map((item) => {
+					if (item.type === "text") return { text: item.text };
+					throw new Error(`Unsupported content type: ${item.type}`);
+				}));
+				return;
+			}
+			const content = { role: msg.role === "agent" ? "model" : msg.role === "user" ? "user" : void 0 };
+			if (msg.toolCalls) content.parts = msg.toolCalls.map((call) => {
+				const part = { functionCall: {
+					id: call.id,
+					name: call.function.name,
+					args: call.function.arguments
+				} };
+				if (call.metadata?.thoughtSignature) part.thoughtSignature = call.metadata.thoughtSignature;
+				return part;
+			});
+			else if (msg.toolCallId) {
+				const call = input.messages.flatMap((i) => i.toolCalls).find((c) => c?.id === msg.toolCallId);
+				if (!call) throw new Error(`Tool call not found: ${msg.toolCallId}`);
+				if (!msg.content) throw new Error("Tool call must have content");
+				let toolResult;
+				{
+					let text;
+					if (typeof msg.content === "string") text = msg.content;
+					else if (msg.content?.length === 1) {
+						const first = msg.content[0];
+						if (first?.type === "text") text = first.text;
+					}
+					if (text) {
+						try {
+							const obj = (0, yaml.parse)(text);
+							if ((0, _aigne_core_utils_type_utils.isRecord)(obj)) toolResult = obj;
+						} catch {}
+						if (!toolResult) toolResult = { result: text };
+					}
+				}
+				const functionResponse = {
+					id: msg.toolCallId,
+					name: call.function.name
+				};
+				if (toolResult) functionResponse.response = toolResult;
+				else functionResponse.parts = await this.contentToParts(msg.content);
+				content.parts = [{ functionResponse }];
+			} else if (msg.content) content.parts = await this.contentToParts(msg.content);
+			return content;
+		}))).filter(_aigne_core_utils_type_utils.isNonNullable);
+		this.ensureMessagesHasUserMessage(systemParts, result.contents);
+		if (systemParts.length) {
+			result.config ??= {};
+			result.config.systemInstruction = systemParts;
+		}
+		return result;
+	}
+	async contentToParts(content) {
+		if (typeof content === "string") return [{ text: content }];
+		return Promise.all(content.map(async (item) => {
+			switch (item.type) {
+				case "text": return { text: item.text };
+				case "url": return { fileData: {
+					fileUri: item.url,
+					mimeType: item.mimeType
+				} };
+				case "file": {
+					const part = await this.buildVideoContentParts(item);
+					if (part) return part;
+					return { inlineData: {
+						data: item.data,
+						mimeType: item.mimeType
+					} };
+				}
+				case "local": throw new Error(`Unsupported local file: ${item.path}, it should be converted to base64 at ChatModel`);
+			}
+		}));
+	}
+	ensureMessagesHasUserMessage(systems, contents) {
+		if (!contents.length && systems.length) {
+			const system = systems.pop();
+			if (system) contents.push({
+				role: "user",
+				parts: [system]
+			});
+		}
+		if (contents[0]?.role === "model") {
+			const system = systems.pop();
+			if (system) contents.unshift({
+				role: "user",
+				parts: [system]
+			});
+		}
+	}
+};
+
+//#endregion
+exports.GeminiChatModel = GeminiChatModel;

package/dist/gemini-chat-model.d.cts

@@ -0,0 +1,123 @@
+import * as _aigne_core0 from "@aigne/core";
+import { AgentInvokeOptions, AgentProcessResult, ChatModel, ChatModelInput, ChatModelInputOptions, ChatModelOptions, ChatModelOutput } from "@aigne/core";
+import { PromiseOrValue } from "@aigne/core/utils/type-utils";
+import { GoogleGenAI, GoogleGenAIOptions, ThinkingLevel } from "@google/genai";
+
+//#region src/gemini-chat-model.d.ts
+interface GeminiChatModelOptions extends ChatModelOptions {
+  /**
+       * API key for Gemini API
+       *
+       * If not provided, will look for GEMINI_API_KEY or GOOGLE_API_KEY in environment variables
+       */
+  apiKey?: string;
+  /**
+       * Optional client options for the Gemini SDK
+       */
+  clientOptions?: Partial<GoogleGenAIOptions>;
+}
+/**
+ * Implementation of the ChatModel interface for Google's Gemini API
+ *
+ * @example
+ * Here's how to create and use a Gemini chat model:
+ * {@includeCode ../test/gemini-chat-model.test.ts#example-gemini-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../test/gemini-chat-model.test.ts#example-gemini-chat-model-streaming}
+ */
+declare class GeminiChatModel extends ChatModel {
+  options?: GeminiChatModelOptions | undefined;
+  constructor(options?: GeminiChatModelOptions | undefined);
+  protected apiKeyEnvName: string;
+  protected _googleClient?: GoogleGenAI;
+  get googleClient(): GoogleGenAI;
+  get credential(): {
+    apiKey: string | undefined;
+    model: string;
+  };
+  get modelOptions(): Partial<{
+    [x: string]: unknown;
+    model?: string | {
+      $get: string;
+    } | undefined;
+    temperature?: number | {
+      $get: string;
+    } | undefined;
+    topP?: number | {
+      $get: string;
+    } | undefined;
+    frequencyPenalty?: number | {
+      $get: string;
+    } | undefined;
+    presencePenalty?: number | {
+      $get: string;
+    } | undefined;
+    parallelToolCalls?: boolean | {
+      $get: string;
+    } | undefined;
+    modalities?: {
+      $get: string;
+    } | _aigne_core0.Modality[] | undefined;
+    preferInputFileType?: "url" | {
+      $get: string;
+    } | "file" | undefined;
+    reasoningEffort?: number | {
+      $get: string;
+    } | "minimal" | "low" | "medium" | "high" | undefined;
+    cacheConfig?: {
+      $get: string;
+    } | _aigne_core0.CacheConfig | undefined;
+  }> | undefined;
+  countTokens(input: ChatModelInput): Promise<number>;
+  private contentUnionToContent;
+  process(input: ChatModelInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+  protected thinkingBudgetModelMap: ({
+    pattern: RegExp;
+    support: boolean;
+    type?: undefined;
+    min?: undefined;
+    max?: undefined;
+  } | {
+    pattern: RegExp;
+    support: boolean;
+    type: string;
+    min?: undefined;
+    max?: undefined;
+  } | {
+    pattern: RegExp;
+    support: boolean;
+    min: number;
+    max: number;
+    type?: undefined;
+  })[];
+  protected thinkingBudgetLevelMap: {
+    high: number;
+    medium: number;
+    low: number;
+    minimal: number;
+  };
+  protected thinkingLevelMap: {
+    high: ThinkingLevel;
+    medium: ThinkingLevel;
+    low: ThinkingLevel;
+    minimal: ThinkingLevel;
+  };
+  protected getThinkingBudget(model: string, effort: ChatModelInputOptions["reasoningEffort"]): {
+    support: boolean;
+    budget?: number;
+    level?: ThinkingLevel;
+  };
+  private getParameters;
+  private processInput;
+  private buildConfig;
+  private buildTools;
+  private buildVideoContentParts;
+  private buildContents;
+  private contentToParts;
+  private ensureMessagesHasUserMessage;
+}
+//#endregion
+export { GeminiChatModel, GeminiChatModelOptions };
+//# sourceMappingURL=gemini-chat-model.d.cts.map

package/dist/gemini-chat-model.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini-chat-model.d.cts","names":[],"sources":["../src/gemini-chat-model.ts"],"mappings":";;;;;;UA+CiB,sBAAA,SAA+B,gBAAA;EAAA;;AAyBhD;;;EAzBgD,MAAA;EAAA;;AAyBhD;EAzBgD,aAAA,GAW9B,OAAA,CAAQ,kBAAA;AAAA;AAAA;;;;AAc1B;;;;;;;AAd0B,cAcb,eAAA,SAAwB,SAAA;EAAA,OAAA,GACG,sBAAA;EAAA,YAAA,OAAA,GAAA,sBAAA;EAAA,UAAA,aAAA;EAAA,UAAA,aAAA,GASZ,WAAA;EAAA,IAAA,aAAA,GAEV,WAAA;EAAA,IAAA,WAAA;IAAA,MAAA;IAAA,KAAA;EAAA;EAAA,IAAA,aAAA,GA+BA,OAAA;IAAA,CAAA,CAAA;IAAA,KAAA;MAAA,IAAA;IAAA;IAAA,WAAA;MAAA,IAAA;IAAA;IAAA,IAAA;MAAA,IAAA;IAAA;IAAA,gBAAA;MAAA,IAAA;IAAA;IAAA,eAAA;MAAA,IAAA;IAAA;IAAA,iBAAA;MAAA,IAAA;IAAA;IAAA,UAAA;MAAA,IAAA;IAAA,IA/BA,YAAA,CAAA,QAAA;IAAA,mBAAA;MAAA,IAAA;IAAA;IAAA,eAAA;MAAA,IAAA;IAAA;IAAA,WAAA;MAAA,IAAA;IAAA;;qBAmCkB,cAAA,GAAiB,OAAA;EAAA,QAAA,qBAAA;EAAA,QAAA,KAAA,EAwC1C,cAAA,EAAA,OAAA,EACE,kBAAA,GACR,cAAA,CAAe,kBAAA,CAAmB,eAAA;EAAA,UAAA,sBAAA;IAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAwD3B,qBAAA;IAAA,OAAA;IAAA,MAAA;IAAA,KAAA,GACsC,aAAA;EAAA;EAAA,QAAA,aAAA;EAAA,QAAA,YAAA;EAAA,QAAA,WAAA;EAAA,QAAA,UAAA;EAAA,QAAA,sBAAA;EAAA,QAAA,aAAA;EAAA,QAAA,cAAA;EAAA,QAAA,4BAAA;AAAA"}