@juspay/neurolink 9.68.13 → 9.68.15

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

@@ -1,33 +1,24 @@
 import type { AIProviderName } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import type { NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
-import type { LanguageModel } from "../types/index.js";
+import type { NeurolinkCredentials } from "../types/index.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
- * Groq Provider
+ * Groq Provider — direct HTTP, no AI SDK.
  *
  * Sub-100ms inference of Llama / Mistral / Gemma at api.groq.com/openai/v1
  * (OpenAI-compatible). Best for low-latency tier; trade-off vs other open
  * model hosts is throughput latency, not quality.
  *
+ * All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`; this class only declares configuration
+ * and provider-specific error mapping.
+ *
  * @see https://console.groq.com/docs/quickstart
  */
-export declare class GroqProvider extends BaseProvider {
-    private model;
-    private apiKey;
-    private baseURL;
+export declare class GroqProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["groq"]);
-    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
-    private executeStreamInner;
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
-    protected getAISDKModel(): LanguageModel;
+    protected getFallbackModelName(): string;
+    protected getFallbackModels(): string[];
     protected formatProviderError(error: unknown): Error;
-    validateConfiguration(): Promise<boolean>;
-    getConfiguration(): {
-        provider: AIProviderName;
-        model: string;
-        defaultModel: string;
-        baseURL: string;
-    };
 }
-export default GroqProvider;

package/dist/lib/providers/groq.js

@@ -1,144 +1,59 @@
-import { createOpenAI } from "@ai-sdk/openai";
 import { GroqModels } 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, ProviderError, RateLimitError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 import { createGroqConfig, 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";
-import { stepCountIs } from "../utils/tool.js";
-import { streamText } from "../utils/generation.js";
+import { TimeoutError } from "../utils/timeout.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 const GROQ_DEFAULT_BASE_URL = "https://api.groq.com/openai/v1";
 const getGroqApiKey = () => validateApiKey(createGroqConfig());
 const getDefaultGroqModel = () => getProviderModel("GROQ_MODEL", GroqModels.LLAMA_3_3_70B_VERSATILE);
 /**
- * Groq Provider
+ * Groq Provider — direct HTTP, no AI SDK.
  *
  * Sub-100ms inference of Llama / Mistral / Gemma at api.groq.com/openai/v1
  * (OpenAI-compatible). Best for low-latency tier; trade-off vs other open
  * model hosts is throughput latency, not quality.
  *
+ * All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`; this class only declares configuration
+ * and provider-specific error mapping.
+ *
  * @see https://console.groq.com/docs/quickstart
  */
-export class GroqProvider extends BaseProvider {
-    model;
-    apiKey;
-    baseURL;
+export class GroqProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName, sdk, _region, credentials) {
-        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
-        super(modelName, "groq", validatedNeurolink);
         const overrideApiKey = credentials?.apiKey?.trim();
-        this.apiKey =
-            overrideApiKey && overrideApiKey.length > 0
-                ? overrideApiKey
-                : getGroqApiKey();
-        this.baseURL =
-            credentials?.baseURL ??
-                process.env.GROQ_BASE_URL ??
-                GROQ_DEFAULT_BASE_URL;
-        const groq = createOpenAI({
-            apiKey: this.apiKey,
-            baseURL: this.baseURL,
-            fetch: createLoggingFetch("groq"),
-        });
-        this.model = groq.chat(this.modelName);
+        const apiKey = overrideApiKey && overrideApiKey.length > 0
+            ? overrideApiKey
+            : getGroqApiKey();
+        const baseURL = credentials?.baseURL?.trim() ||
+            process.env.GROQ_BASE_URL?.trim() ||
+            GROQ_DEFAULT_BASE_URL;
+        super("groq", modelName, sdk, { baseURL, apiKey });
         logger.debug("Groq Provider initialized", {
             modelName: this.modelName,
             providerName: this.providerName,
-            baseURL: this.baseURL,
+            baseURL: this.config.baseURL,
         });
     }
-    async executeStream(options, _analysisSchema) {
-        return withClientStreamSpan({
-            name: "neurolink.provider.stream",
-            tracer: tracers.provider,
-            attributes: {
-                [ATTR.GEN_AI_SYSTEM]: "groq",
-                [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);
-        // Resolve per-call credentials first, then fall back to instance-level.
-        const perCallCreds = options.credentials?.groq;
-        const effectiveApiKey = perCallCreds?.apiKey?.trim() || this.apiKey;
-        const effectiveBaseURL = perCallCreds?.baseURL || this.baseURL;
-        const startTime = Date.now();
-        const timeout = this.getTimeout(options);
-        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
-        try {
-            // Use the canonical BaseProvider helper: merges base tools (MCP/built-in)
-            // with user-provided tools (RAG, etc.) and applies per-call filtering.
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = await this.getToolsForStream(options);
-            const messages = await this.buildMessagesForStream(options);
-            // When per-call credentials differ from instance, build a fresh client.
-            const hasDifferentCreds = effectiveApiKey !== this.apiKey || effectiveBaseURL !== this.baseURL;
-            const model = hasDifferentCreds
-                ? createOpenAI({
-                    apiKey: effectiveApiKey,
-                    baseURL: effectiveBaseURL,
-                    fetch: createLoggingFetch("groq"),
-                }).chat(this.modelName)
-                : 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("[GroqProvider] 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: `groq-stream-${Date.now()}`,
-                streamingMode: true,
-            });
-            return {
-                stream: transformedStream,
-                provider: this.providerName,
-                model: this.modelName,
-                analytics: analyticsPromise,
-                metadata: { startTime, streamId: `groq-${Date.now()}` },
-            };
-        }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
-    }
     getProviderName() {
-        return this.providerName;
+        return "groq";
     }
     getDefaultModel() {
         return getDefaultGroqModel();
     }
-    getAISDKModel() {
-        return this.model;
+    getFallbackModelName() {
+        return GroqModels.LLAMA_3_1_8B_INSTANT;
+    }
+    getFallbackModels() {
+        return [
+            GroqModels.LLAMA_3_3_70B_VERSATILE,
+            GroqModels.LLAMA_3_1_8B_INSTANT,
+            GroqModels.GEMMA_2_9B_IT,
+            GroqModels.MIXTRAL_8X7B_32768,
+            GroqModels.LLAMA_3_2_90B_VISION_PREVIEW,
+            GroqModels.LLAMA_3_2_11B_VISION_PREVIEW,
+        ];
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
@@ -166,17 +81,5 @@ export class GroqProvider extends BaseProvider {
         }
         return new ProviderError(`Groq error: ${message}`, "groq");
     }
-    async validateConfiguration() {
-        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
-    }
-    getConfiguration() {
-        return {
-            provider: this.providerName,
-            model: this.modelName,
-            defaultModel: getDefaultGroqModel(),
-            baseURL: this.baseURL,
-        };
-    }
 }
-export default GroqProvider;
 //# sourceMappingURL=groq.js.map

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

@@ -1,78 +1,51 @@
-import { AIProviderName } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import type { NeuroLink } from "../neurolink.js";
-import type { EnhancedGenerateResult, TextGenerationOptions, ValidationSchema, StreamOptions, StreamResult } from "../types/index.js";
-import type { LanguageModel } from "../types/index.js";
+import type { AIProviderName } from "../constants/enums.js";
+import type { EnhancedGenerateResult, NeurolinkCredentials, OpenAICompatStreamLifecycleListeners, TextGenerationOptions } from "../types/index.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
- * OpenAI Provider v2 - BaseProvider Implementation
- * Migrated to use factory pattern with exact Google AI provider pattern
+ * OpenAI Provider — direct HTTP, no AI SDK.
+ *
+ * OpenAI chat completions at api.openai.com/v1. All request / stream /
+ * tool-loop orchestration lives in `OpenAIChatCompletionsProvider`; this
+ * class adds:
+ *   - OTel span wrap with cost (`onStreamStart`)
+ *   - Native `/v1/embeddings` (`embed` / `embedMany`)
+ *   - Image generation via `/v1/images/generations` (`executeImageGeneration`)
+ *   - OpenAI-specific error mapping (`formatProviderError`)
+ *
+ * @see https://platform.openai.com/docs/api-reference
  */
-export declare class OpenAIProvider extends BaseProvider {
-    private model;
-    private credentials?;
-    constructor(modelName?: string, neurolink?: NeuroLink, _region?: string, credentials?: {
-        apiKey?: string;
-        baseURL?: string;
-    });
+export declare class OpenAIProvider extends OpenAIChatCompletionsProvider {
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["openai"]);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    formatProviderError(error: unknown): Error;
     /**
-     * Check if this provider supports tool/function calling
+     * Wrap the stream in an OTel span to capture provider-level latency,
+     * token usage, finish reason, and cost. Mirrors the pre-migration
+     * `streamText`-span behaviour.
      */
-    supportsTools(): boolean;
-    getProviderName(): AIProviderName;
-    getDefaultModel(): string;
+    protected onStreamStart(modelId: string): OpenAICompatStreamLifecycleListeners | undefined;
     /**
-     * Get the default embedding model for OpenAI
-     * @returns The default OpenAI embedding model name
+     * Default embedding model, overridable via OPENAI_EMBEDDING_MODEL env var.
      */
     protected getDefaultEmbeddingModel(): string;
     /**
-     * Returns the Vercel AI SDK model instance for OpenAI
-     */
-    getAISDKModel(): LanguageModel;
-    /**
-     * OpenAI-specific tool validation and filtering
-     * Filters out tools that might cause streaming issues
-     */
-    private validateAndFilterToolsForOpenAI;
-    /**
-     * Validate Zod schema structure
-     */
-    private validateZodSchema;
-    /**
-     * Validate tool structure for OpenAI compatibility
-     * More lenient validation to avoid filtering out valid tools
-     */
-    /** Shared helper: mark a stream span as ERROR, record the exception, and end it. */
-    private endStreamSpanWithError;
-    private isValidToolStructure;
-    /**
-     * Validate tool parameters for OpenAI compatibility
-     * Ensures the tool has either valid Zod schema or valid JSON schema
-     */
-    private isValidToolParameters;
-    formatProviderError(error: unknown): Error;
-    /**
-     * executeGenerate method removed - generation is now handled by BaseProvider.
-     * For details on the changes and migration steps, refer to the BaseProvider documentation
-     * and the migration guide in the project repository.
-     */
-    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
-    private createOpenAITransformedStream;
-    private extractOpenAIChunkContent;
-    /**
-     * Generate embeddings for text using OpenAI text-embedding models
+     * Generate an embedding for a single text input via native /v1/embeddings.
+     *
      * @param text - The text to embed
      * @param modelName - The embedding model to use (default: text-embedding-3-small)
      * @returns Promise resolving to the embedding vector
      */
     embed(text: string, modelName?: string): Promise<number[]>;
     /**
-     * Generate embeddings for multiple texts in a single batch
+     * Generate embeddings for multiple texts in a single batch via native /v1/embeddings.
+     *
      * @param texts - The texts to embed
      * @param modelName - The embedding model to use (default: text-embedding-3-small)
      * @returns Promise resolving to an array of embedding vectors
      */
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
+    private callEmbeddings;
     /**
      * Image generation via the OpenAI Images API (`/v1/images/generations`).
      *
@@ -95,4 +68,3 @@ export declare class OpenAIProvider extends BaseProvider {
      */
     private aspectRatioToOpenAISize;
 }
-export default OpenAIProvider;