@juspay/neurolink 9.64.0 → 9.65.1

package/dist/lib/providers/fireworks.js

@@ -0,0 +1,164 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { stepCountIs, streamText } from "ai";
+import { FireworksModels } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { isNeuroLink } from "../neurolink.js";
+import { createLoggingFetch } from "../utils/loggingFetch.js";
+import { tracers, ATTR, withClientStreamSpan } from "../telemetry/index.js";
+import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
+import { logger } from "../utils/logger.js";
+import { createFireworksConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
+import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
+const FIREWORKS_DEFAULT_BASE_URL = "https://api.fireworks.ai/inference/v1";
+const getFireworksApiKey = () => validateApiKey(createFireworksConfig());
+const getDefaultFireworksModel = () => getProviderModel("FIREWORKS_MODEL", FireworksModels.DEEPSEEK_V4_PRO);
+/**
+ * Fireworks AI Provider
+ *
+ * Hosted open-model serving at api.fireworks.ai/inference/v1
+ * (OpenAI-compatible). Best for low-latency at scale on Llama / Mixtral /
+ * Qwen / DeepSeek.
+ *
+ * @see https://docs.fireworks.ai/api-reference/introduction
+ */
+export class FireworksProvider extends BaseProvider {
+    model;
+    apiKey;
+    baseURL;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
+        super(modelName, "fireworks", validatedNeurolink);
+        const overrideApiKey = credentials?.apiKey?.trim();
+        this.apiKey =
+            overrideApiKey && overrideApiKey.length > 0
+                ? overrideApiKey
+                : getFireworksApiKey();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.FIREWORKS_BASE_URL ??
+                FIREWORKS_DEFAULT_BASE_URL;
+        const fireworks = createOpenAI({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            fetch: createLoggingFetch("fireworks"),
+        });
+        this.model = fireworks.chat(this.modelName);
+        logger.debug("Fireworks Provider initialized", {
+            modelName: this.modelName,
+            providerName: this.providerName,
+            baseURL: this.baseURL,
+        });
+    }
+    async executeStream(options, _analysisSchema) {
+        return withClientStreamSpan({
+            name: "neurolink.provider.stream",
+            tracer: tracers.provider,
+            attributes: {
+                [ATTR.GEN_AI_SYSTEM]: "fireworks",
+                [ATTR.GEN_AI_MODEL]: this.modelName,
+                [ATTR.GEN_AI_OPERATION]: "stream",
+                [ATTR.NL_STREAM_MODE]: true,
+            },
+        }, async () => this.executeStreamInner(options), (r) => r.stream, (r, wrapped) => ({ ...r, stream: wrapped }));
+    }
+    async executeStreamInner(options) {
+        this.validateStreamOptions(options);
+        const startTime = Date.now();
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        try {
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
+            const messages = await this.buildMessagesForStream(options);
+            const model = await this.getAISDKModelWithMiddleware(options);
+            const result = await streamText({
+                model,
+                messages,
+                temperature: options.temperature,
+                maxOutputTokens: options.maxTokens,
+                tools,
+                stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
+                toolChoice: resolveToolChoice(options, tools, shouldUseTools),
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
+                        logger.warn("[FireworksProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
+            });
+            timeoutController?.cleanup();
+            const transformedStream = this.createTextStream(result);
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
+                requestId: `fireworks-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream,
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: { startTime, streamId: `fireworks-${Date.now()}` },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultFireworksModel();
+    }
+    getAISDKModel() {
+        return this.model;
+    }
+    formatProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new NetworkError(`Request timed out: ${error.message}`, "fireworks");
+        }
+        const errorRecord = error;
+        const message = typeof errorRecord?.message === "string"
+            ? errorRecord.message
+            : "Unknown error";
+        if (message.includes("Invalid API key") ||
+            message.includes("Authentication") ||
+            message.includes("401")) {
+            return new AuthenticationError("Invalid Fireworks API key. Get one at https://fireworks.ai/account/api-keys", "fireworks");
+        }
+        if (message.includes("rate limit") || message.includes("429")) {
+            return new RateLimitError("Fireworks rate limit exceeded. Back off and retry.", "fireworks");
+        }
+        if (message.includes("model_not_found") || message.includes("404")) {
+            return new InvalidModelError(`Fireworks model '${this.modelName}' not found. Browse https://fireworks.ai/models`, "fireworks");
+        }
+        return new ProviderError(`Fireworks error: ${message}`, "fireworks");
+    }
+    async validateConfiguration() {
+        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+    }
+    getConfiguration() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+            defaultModel: getDefaultFireworksModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default FireworksProvider;
+//# sourceMappingURL=fireworks.js.map

package/dist/lib/providers/googleAiStudio.js

@@ -1,15 +1,17 @@
 import {} from "ai";
 import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { IMAGE_GENERATION_MODELS } from "../core/constants.js";
+import { IMAGE_GENERATION_MODELS, TOOL_STORAGE_TIMEOUT_MS, } from "../core/constants.js";
 import { processUnifiedFilesArray } from "../utils/messageBuilder.js";
-import { ATTR, tracers, withClientSpan } from "../telemetry/index.js";
+import { ATTR, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../telemetry/index.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { withTimeout } from "../utils/async/index.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
-import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, } from "./googleNativeGemini3.js";
+import { transformToolExecutions } from "../utils/transformationUtils.js";
+import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, } from "./googleNativeGemini3.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
@@ -481,7 +483,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
      */
     async executeNativeGemini3Stream(options) {
         const modelName = options.model || this.modelName;
-        return withClientSpan({
+        return withClientStreamSpan({
             name: "neurolink.provider.stream",
             tracer: tracers.provider,
             attributes: {
@@ -521,12 +523,14 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 // Convert tools
                 let toolsConfig;
                 let executeMap = new Map();
+                let originalNameMap = new Map();
                 if (options.tools &&
                     Object.keys(options.tools).length > 0 &&
                     !options.disableTools) {
                     const result = buildNativeToolDeclarations(options.tools);
                     toolsConfig = result.toolsConfig;
                     executeMap = result.executeMap;
+                    originalNameMap = result.originalNameMap;
                     logger.debug("[GoogleAIStudio] Converted tools for native SDK", {
                         toolCount: toolsConfig[0].functionDeclarations.length,
                         toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
@@ -555,6 +559,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 const channel = createTextChannel();
                 // Shared mutable state updated by the background agentic loop.
                 const allToolCalls = [];
+                // Mirror the Vertex Gemini stream path: track tool executions so
+                // the storage hook can persist real outputs and StreamResult can
+                // surface toolsUsed/toolExecutions for tool-bearing turns.
+                const toolExecutions = [];
                 // analyticsResolvers lets the background loop settle the analytics
                 // promise once token counts are known (after the loop completes).
                 let analyticsResolve;
@@ -625,7 +633,40 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                 logger.debug(`[GoogleAIStudio] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
                                 // Add model response with ALL parts (including thoughtSignature) to history
                                 pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
-                                const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { abortSignal: composedSignal });
+                                const toolCallsBefore = allToolCalls.length;
+                                const toolExecsBefore = toolExecutions.length;
+                                const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, {
+                                    abortSignal: composedSignal,
+                                    originalNameMap,
+                                    toolExecutions,
+                                });
+                                // Persist this step's tool calls/results into conversation
+                                // memory. Without this, tool_call / tool_result rows never
+                                // reach Redis and the chat-history UI loses every tool
+                                // invocation.
+                                const stepToolCalls = allToolCalls.slice(toolCallsBefore);
+                                const stepToolExecs = toolExecutions.slice(toolExecsBefore);
+                                if (stepToolCalls.length > 0 || stepToolExecs.length > 0) {
+                                    const stepThoughtSig = extractThoughtSignature(chunkResult.rawResponseParts);
+                                    withTimeout(this.handleToolExecutionStorage(stepToolCalls.map((tc, i) => ({
+                                        toolName: tc.toolName,
+                                        args: tc.args,
+                                        ...(i === 0 && stepThoughtSig
+                                            ? { thoughtSignature: stepThoughtSig }
+                                            : {}),
+                                        stepIndex: step,
+                                    })), stepToolExecs.map((te) => ({
+                                        toolName: te.name,
+                                        output: te.output,
+                                        stepIndex: step,
+                                    })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
+                                        logger.warn("[GoogleAIStudio] Failed to store native tool executions", {
+                                            error: error instanceof Error
+                                                ? error.message
+                                                : String(error),
+                                        });
+                                    });
+                                }
                                 // Add function responses to history — the @google/genai SDK
                                 // only accepts "user" and "model" as valid roles in contents.
                                 // Function/tool responses must use role: "user" (matching the
@@ -682,7 +723,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 // Suppress unhandled-rejection warnings on loopPromise — errors are
                 // forwarded to the channel and will surface when the caller iterates.
                 loopPromise.catch(() => undefined);
-                return {
+                const result = {
                     stream: channel.iterable,
                     provider: this.providerName,
                     model: modelName,
@@ -690,11 +731,25 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     analytics: analyticsPromise,
                     metadata,
                 };
+                // Surface tools-used + executions via getters so they resolve at
+                // access time, after the background loop has populated the live
+                // arrays. Same lazy pattern used for `structuredOutput` elsewhere.
+                Object.defineProperty(result, "toolsUsed", {
+                    enumerable: true,
+                    configurable: true,
+                    get: () => allToolCalls.map((tc) => tc.toolName),
+                });
+                Object.defineProperty(result, "toolExecutions", {
+                    enumerable: true,
+                    configurable: true,
+                    get: () => transformToolExecutions(toolExecutions),
+                });
+                return result;
             }
             finally {
                 // Timeout controller cleanup is managed inside the background loop
             }
-        });
+        }, (r) => r.stream, (r, wrapped) => ({ ...r, stream: wrapped }));
     }
     /**
      * Execute generate using native @google/genai SDK for Gemini 3 models
@@ -743,6 +798,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 // Convert tools (a0269210: trust options.tools — already merged + filtered upstream)
                 let toolsConfig;
                 let executeMap = new Map();
+                let originalNameMap = new Map();
                 const shouldUseTools = !options.disableTools;
                 if (shouldUseTools) {
                     const tools = options.tools || {};
@@ -750,6 +806,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         const result = buildNativeToolDeclarations(tools);
                         toolsConfig = result.toolsConfig;
                         executeMap = result.executeMap;
+                        originalNameMap = result.originalNameMap;
                         logger.debug("[GoogleAIStudio] Converted tools for native SDK generate", {
                             toolCount: toolsConfig[0].functionDeclarations.length,
                             toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
@@ -818,7 +875,35 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         // Add model response with ALL parts (including thoughtSignature) to history
                         // This is critical for Gemini 3 - it requires thought signatures in subsequent turns
                         pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
-                        const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { toolExecutions, abortSignal: composedSignal });
+                        const toolCallsBefore = allToolCalls.length;
+                        const toolExecsBefore = toolExecutions.length;
+                        const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, {
+                            toolExecutions,
+                            abortSignal: composedSignal,
+                            originalNameMap,
+                        });
+                        // Persist this step's tool calls/results into conversation memory.
+                        const stepToolCalls = allToolCalls.slice(toolCallsBefore);
+                        const stepToolExecs = toolExecutions.slice(toolExecsBefore);
+                        if (stepToolCalls.length > 0 || stepToolExecs.length > 0) {
+                            const stepThoughtSig = extractThoughtSignature(chunkResult.rawResponseParts);
+                            withTimeout(this.handleToolExecutionStorage(stepToolCalls.map((tc, i) => ({
+                                toolName: tc.toolName,
+                                args: tc.args,
+                                ...(i === 0 && stepThoughtSig
+                                    ? { thoughtSignature: stepThoughtSig }
+                                    : {}),
+                                stepIndex: step,
+                            })), stepToolExecs.map((te) => ({
+                                toolName: te.name,
+                                output: te.output,
+                                stepIndex: step,
+                            })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
+                                logger.warn("[GoogleAIStudio] Failed to store native generate tool executions", {
+                                    error: error instanceof Error ? error.message : String(error),
+                                });
+                            });
+                        }
                         // Add function responses to history — the @google/genai SDK
                         // only accepts "user" and "model" as valid roles in contents.
                         // Function/tool responses must use role: "user" (matching the
@@ -854,7 +939,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     },
                     responseTime,
                     toolsUsed: allToolCalls.map((tc) => tc.toolName),
-                    toolExecutions: toolExecutions,
+                    toolExecutions: transformToolExecutions(toolExecutions),
                     enhancedWithTools: allToolCalls.length > 0,
                 };
                 return this.enhanceResult(baseResult, options, startTime);
@@ -886,6 +971,13 @@ export class GoogleAIStudioProvider extends BaseProvider {
             logger.info("[GoogleAIStudio] Routing image generation model to executeImageGeneration", { model: modelName });
             return this.executeImageGeneration(options);
         }
+        // TTS direct-synthesis mode: synthesise the input text directly (no LLM
+        // call). BaseProvider.runGenerateInActiveContext does the same dispatch
+        // — replicated here because AI Studio's override bypasses that path.
+        if (options.tts?.enabled && !options.tts?.useAiResponse) {
+            logger.info("[GoogleAIStudio] Routing TTS direct-synthesis to handleDirectTTSSynthesis", { model: modelName });
+            return this.handleDirectTTSSynthesis(options, Date.now());
+        }
         // Process the unified `input.files` array before routing to the
         // native SDK. BaseProvider.generate() runs this preprocessing via
         // buildMultimodalMessagesArray, but AI Studio's override skips it,
@@ -940,7 +1032,23 @@ export class GoogleAIStudioProvider extends BaseProvider {
             mergedOptions.prompt ||
             "";
         try {
-            const result = await this.executeNativeGemini3Generate(mergedOptions);
+            // Wrap in `neurolink.executeGeneration` so the observability span
+            // chain (Test: Generate Span Chain) sees a third inner span on the
+            // native @google/genai path — Pipeline A providers get this from
+            // GenerationHandler.executeGeneration; the native path bypasses
+            // GenerationHandler so we add the span here.
+            let result = await withSpan({
+                name: "neurolink.executeGeneration",
+                tracer: tracers.provider,
+                attributes: {
+                    [ATTR.GEN_AI_SYSTEM]: this.providerName,
+                    [ATTR.GEN_AI_MODEL]: modelName,
+                    "neurolink.path": "native.google-genai",
+                },
+            }, async () => this.executeNativeGemini3Generate(mergedOptions));
+            // Pipe through TTS-of-AI-response when caller asks for it. No-op when
+            // tts is disabled or useAiResponse is false.
+            result = await this.synthesizeAIResponseIfNeeded(result, options);
             this.emitPipelineBGenerationEvent(modelName, result, generateStartTime, true, undefined, inputPrompt);
             return result;
         }
@@ -963,6 +1071,14 @@ export class GoogleAIStudioProvider extends BaseProvider {
         const usage = result?.usage && typeof result.usage === "object"
             ? result.usage
             : { input: 0, output: 0, total: 0 };
+        // Mark on the result so the SDK-level runStandardGenerateRequest knows
+        // this provider already emitted `generation:end` itself and skips its
+        // own duplicate emission. Without this flag the public event listener
+        // (and the observability test) would see two events per generate call.
+        if (result && typeof result === "object") {
+            result._generationEndEmitted =
+                true;
+        }
         emitter.emit("generation:end", {
             provider: this.providerName,
             responseTime: Date.now() - startTime,

package/dist/lib/providers/googleNativeGemini3.d.ts

@@ -9,7 +9,20 @@
  * providers so they can share a single implementation.
  */
 import { type Tool } from "ai";
-import type { ThinkingConfig, CollectedChunkResult, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel, VertexNativePart, GeminiMultimodalInput } from "../types/index.js";
+import type { ThinkingConfig, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel, VertexNativePart, GeminiMultimodalInput } from "../types/index.js";
+export declare function sanitizeForGoogleFunctionName(name: string): string;
+/**
+ * Resolve a sanitized Gemini tool name to one that is both unique within
+ * the current request and at most 128 characters. When the candidate
+ * collides with an already-used name we append `_2`, `_3`, … — but
+ * reserve room for the suffix by truncating the base first so the
+ * resolved name never exceeds Google's `function_declarations[].name`
+ * limit.
+ *
+ * @param base       The already-sanitized candidate name.
+ * @param isTaken    Predicate that returns true if `name` is already used.
+ */
+export declare function resolveUniqueGoogleFunctionName(base: string, isTaken: (name: string) => boolean): string;
 /**
  * Sanitize a JSON Schema for Gemini's proto-based API.
  *
@@ -35,6 +48,12 @@ export declare function sanitizeSchemaForGemini(schema: Record<string, unknown>)
 export declare function sanitizeToolsForGemini(tools: Record<string, Tool>): {
     tools: Record<string, Tool>;
     dropped: string[];
+    /**
+     * Reverse map: Google-safe sanitized name → original consumer-supplied
+     * name. Lets the calling layer translate tool-call results back so the
+     * sanitization stays transport-only (see CodeRabbit thread, PR #1006).
+     */
+    originalNameMap: Map<string, string>;
 };
 export declare function normalizeToolsForJsonSchemaProvider(tools: Record<string, Tool>): {
     tools: Record<string, Tool>;
@@ -128,7 +147,10 @@ export declare function extractTextFromParts(rawResponseParts: unknown[]): strin
  * @param executeMap - Map of tool name to execute function
  * @param failedTools - Mutable map tracking per-tool failure counts
  * @param allToolCalls - Mutable array accumulating all tool call records
- * @param options - Optional settings for execution tracking and cancellation
+ * @param options - Optional settings for execution tracking and cancellation,
+ *                  plus an `originalNameMap` (Google-safe → consumer-supplied
+ *                  identifier) so the sanitization stays transport-only and
+ *                  consumers see the names they registered.
  * @returns Array of function responses for conversation history
  */
 export declare function executeNativeToolCalls(logLabel: string, stepFunctionCalls: NativeFunctionCall[], executeMap: Map<string, Tool["execute"]>, failedTools: Map<string, {
@@ -144,6 +166,7 @@ export declare function executeNativeToolCalls(logLabel: string, stepFunctionCal
         output: unknown;
     }>;
     abortSignal?: AbortSignal;
+    originalNameMap?: Map<string, string>;
 }): Promise<NativeFunctionResponse[]>;
 /**
  * Handle maxSteps termination by producing a final text when the model
@@ -195,10 +218,7 @@ export declare function buildGeminiResponseSchema(schema: unknown): Record<strin
 export declare function prependConversationMessages(contents: Array<{
     role: string;
     parts: unknown[];
-}>, conversationMessages?: Array<{
-    role: string;
-    content: string;
-}>): void;
+}>, conversationMessages?: Array<ChatMessage | MinimalChatMessage>): void;
 /**
  * Build the `parts` array for the current user turn of a Gemini native
  * `generateContent` request, including inline image + PDF blobs.