@juspay/neurolink 9.63.1 → 9.65.0

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.d.ts

@@ -41,7 +41,8 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     getProviderName(): AIProviderName;
     getDefaultModel(): string;
     /**
-     * 🔧 PHASE 2: Return AI SDK model instance for tool calling
+     * AI SDK model instance — no longer used.
+     * All models are routed through native @google/genai SDK directly.
      */
     getAISDKModel(): LanguageModel;
     protected formatProviderError(error: unknown): Error;
@@ -62,8 +63,8 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     private estimateTokenCount;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     /**
-     * Execute stream using native @google/genai SDK for Gemini 3 models
-     * This bypasses @ai-sdk/google to properly handle thought_signature
+     * Execute stream using native @google/genai SDK
+     * Uses @google/genai directly for all Gemini models (2.0, 2.5, 3.x)
      */
     private executeNativeGemini3Stream;
     /**
@@ -75,6 +76,13 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      * Override generate to route Gemini 3 models with tools to native SDK
      */
     generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
+    /**
+     * Emit `generation:end` so the Pipeline B observability listener creates
+     * a `model.generation` span for native Google AI Studio generate calls.
+     * Without this hand-off the native path silently disappears from
+     * Pipeline B exporters (Langfuse, custom OTEL collectors).
+     */
+    private emitPipelineBGenerationEvent;
     private executeAudioStreamViaGeminiLive;
     protected getDefaultEmbeddingModel(): string;
     /**