@juspay/neurolink 9.64.0 → 9.65.0

package/dist/providers/fireworks.js

@@ -0,0 +1,163 @@
+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;

package/dist/providers/googleAiStudio.js

@@ -2,7 +2,7 @@ import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enum
 import { BaseProvider } from "../core/baseProvider.js";
 import { IMAGE_GENERATION_MODELS } 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";
@@ -480,7 +480,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: {
@@ -520,12 +520,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),
@@ -624,7 +626,7 @@ 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 functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { abortSignal: composedSignal, originalNameMap });
                                 // 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
@@ -693,7 +695,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
             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
@@ -742,6 +744,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 || {};
@@ -749,6 +752,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),
@@ -817,7 +821,11 @@ 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 functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, {
+                            toolExecutions,
+                            abortSignal: composedSignal,
+                            originalNameMap,
+                        });
                         // 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
@@ -885,6 +893,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,
@@ -939,7 +954,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;
         }
@@ -962,6 +993,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/providers/googleNativeGemini3.d.ts

@@ -10,6 +10,19 @@
  */
 import { type Tool } from "ai";
 import type { ThinkingConfig, CollectedChunkResult, 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