@juspay/neurolink 9.68.12 → 9.68.14

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

@@ -1,29 +1,47 @@
 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, OpenAICompatResponseFormat } from "../types/index.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
- * DeepSeek Provider
- * OpenAI-compatible chat completions; supports deepseek-chat (V3) and
- * deepseek-reasoner (R1, exposes reasoning_content).
+ * DeepSeek Provider — direct HTTP, no AI SDK.
+ *
+ * OpenAI-compatible chat completions at api.deepseek.com (deepseek-chat /
+ * deepseek-reasoner). All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`; this class declares configuration and
+ * provider-specific quirks:
+ *
+ *   1. Structured-output downgrade — DeepSeek rejects `response_format:
+ *      { type: "json_schema" }` ("This response_format type is unavailable
+ *      now"), so `adjustResponseFormat` downgrades it to `json_object` —
+ *      matching the `supportsStructuredOutputs: false` behaviour of the
+ *      `@ai-sdk/openai-compatible` path this migration replaced. The base
+ *      client injects the literal "json" word the API requires for that mode.
+ *
+ *   2. Reasoning support — the opt-in `thinking` request param (non-reasoner
+ *      chat models) and `reasoning_content` surfacing (deepseek-reasoner / R1)
+ *      both require plumbing the thinking signal and the reasoning delta
+ *      through the native base client. That plumbing isn't in place yet, so
+ *      neither is wired here; it is tracked as a base-client follow-up. All
+ *      other behavior is preserved.
+ *
+ * @see https://api-docs.deepseek.com
  */
-export declare class DeepSeekProvider extends BaseProvider {
-    private model;
-    private apiKey;
-    private baseURL;
+export declare class DeepSeekProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["deepseek"]);
-    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
-    private executeStreamInner;
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
-    protected getAISDKModel(): LanguageModel;
     protected formatProviderError(error: unknown): Error;
-    validateConfiguration(): Promise<boolean>;
-    getConfiguration(): {
-        provider: AIProviderName;
-        model: string;
-        defaultModel: string;
-        baseURL: string;
-    };
+    protected getFallbackModelName(): string;
+    protected getFallbackModels(): string[];
+    /**
+     * DeepSeek's /chat/completions rejects `response_format: { type:
+     * "json_schema" }` outright ("This response_format type is unavailable
+     * now"). The `@ai-sdk/openai-compatible` provider this migration replaced
+     * ran with `supportsStructuredOutputs: false`, which downgraded structured-
+     * output requests to `{ type: "json_object" }`. Replicate that downgrade so
+     * `generate({ schema })` keeps working. (DeepSeek's json_object mode also
+     * requires the word "json" somewhere in the messages; the base client's
+     * `ensureJsonWordInBody` injects a minimal instruction when the prompt
+     * lacks it.)
+     */
+    protected adjustResponseFormat(rf: OpenAICompatResponseFormat | undefined, _modelId: string): OpenAICompatResponseFormat | undefined;
 }
-export default DeepSeekProvider;

package/dist/lib/providers/deepseek.js

@@ -1,50 +1,10 @@
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { DeepSeekModels } 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 { createProxyFetch, maskProxyUrl } from "../proxy/proxyFetch.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 { createDeepSeekConfig, 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";
-const makeLoggingFetch = (provider) => {
-    const base = createProxyFetch();
-    return (async (input, init) => {
-        const url = typeof input === "string"
-            ? input
-            : input instanceof URL
-                ? input.toString()
-                : input.url;
-        const reqSize = init?.body && typeof init.body === "string" ? init.body.length : 0;
-        const response = await base(input, init);
-        if (!response.ok) {
-            // Don't fall back to the raw URL — that would defeat the redaction.
-            const safeUrl = maskProxyUrl(url) ?? "<redacted>";
-            if (process.env.NEUROLINK_DEBUG_HTTP === "1") {
-                const clone = response.clone();
-                const body = await clone.text().catch(() => "<unreadable>");
-                logger.warn(`[${provider}] upstream ${response.status}`, {
-                    url: safeUrl,
-                    body: body.slice(0, 800),
-                    reqSize,
-                });
-            }
-            else {
-                logger.warn(`[${provider}] upstream ${response.status} url=${safeUrl} reqSize=${reqSize}`);
-            }
-        }
-        return response;
-    });
-};
-const DEEPSEEK_DEFAULT_BASE_URL = "https://api.deepseek.com";
+import { TimeoutError } from "../utils/timeout.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
+const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
 const getDeepSeekApiKey = () => {
     return validateApiKey(createDeepSeekConfig());
 };
@@ -52,184 +12,61 @@ const getDefaultDeepSeekModel = () => {
     return getProviderModel("DEEPSEEK_MODEL", DeepSeekModels.DEEPSEEK_CHAT);
 };
 /**
- * DeepSeek Provider
- * OpenAI-compatible chat completions; supports deepseek-chat (V3) and
- * deepseek-reasoner (R1, exposes reasoning_content).
+ * DeepSeek Provider — direct HTTP, no AI SDK.
+ *
+ * OpenAI-compatible chat completions at api.deepseek.com (deepseek-chat /
+ * deepseek-reasoner). All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`; this class declares configuration and
+ * provider-specific quirks:
+ *
+ *   1. Structured-output downgrade — DeepSeek rejects `response_format:
+ *      { type: "json_schema" }` ("This response_format type is unavailable
+ *      now"), so `adjustResponseFormat` downgrades it to `json_object` —
+ *      matching the `supportsStructuredOutputs: false` behaviour of the
+ *      `@ai-sdk/openai-compatible` path this migration replaced. The base
+ *      client injects the literal "json" word the API requires for that mode.
+ *
+ *   2. Reasoning support — the opt-in `thinking` request param (non-reasoner
+ *      chat models) and `reasoning_content` surfacing (deepseek-reasoner / R1)
+ *      both require plumbing the thinking signal and the reasoning delta
+ *      through the native base client. That plumbing isn't in place yet, so
+ *      neither is wired here; it is tracked as a base-client follow-up. All
+ *      other behavior is preserved.
+ *
+ * @see https://api-docs.deepseek.com
  */
-export class DeepSeekProvider extends BaseProvider {
-    model;
-    apiKey;
-    baseURL;
+export class DeepSeekProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName, sdk, _region, credentials) {
-        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
-        super(modelName, "deepseek", validatedNeurolink);
         // Trim the override before applying precedence. A blank/whitespace
-        // `credentials.apiKey` should NOT bypass `getDeepSeekApiKey()` — that
-        // would build a client with an unusable bearer token and fail at request
-        // time with a confusing 401 instead of at construction time.
+        // `credentials.apiKey` must NOT bypass `getDeepSeekApiKey()` — that
+        // would build a client with an unusable bearer token and fail at
+        // request time with a confusing 401 instead of at construction time.
         const overrideApiKey = credentials?.apiKey?.trim();
-        this.apiKey =
-            overrideApiKey && overrideApiKey.length > 0
-                ? overrideApiKey
-                : getDeepSeekApiKey();
-        this.baseURL =
-            credentials?.baseURL ??
-                process.env.DEEPSEEK_BASE_URL ??
-                DEEPSEEK_DEFAULT_BASE_URL;
-        // We deliberately use `@ai-sdk/openai-compatible` rather than
-        // `@ai-sdk/openai`. Two upstream behaviors of `@ai-sdk/openai` break us:
-        //   1. It always sends `response_format: { type: "json_schema" }` when a
-        //      schema is provided. DeepSeek's API rejects that with the literal
-        //      message "This response_format type is unavailable now".
-        //   2. It does not parse the `reasoning_content` field that
-        //      `deepseek-reasoner` emits, so chain-of-thought is silently dropped.
-        // `@ai-sdk/openai-compatible` honors `supportsStructuredOutputs: false`
-        // (falls back to `{ type: "json_object" }` and injects the schema into
-        // the prompt) and parses both `choice.message.reasoning_content` and
-        // `delta.reasoning_content` into the SDK-standard `reasoning` part.
-        const deepseek = createOpenAICompatible({
-            name: "deepseek",
-            apiKey: this.apiKey,
-            baseURL: this.baseURL,
-            fetch: makeLoggingFetch("deepseek"),
-            supportsStructuredOutputs: false,
-            includeUsage: true,
-            // DeepSeek's `response_format: { type: "json_object" }` requires the
-            // prompt to literally contain the word "json" — otherwise the API
-            // rejects with: "Prompt must contain the word 'json' in some form to
-            // use 'response_format' of type 'json_object'." The OpenAI-compatible
-            // SDK fallback path (used because supportsStructuredOutputs is false)
-            // does not inject this guidance itself, so we prepend a system
-            // message when it's missing. No-op for non-JSON requests.
-            transformRequestBody: (body) => {
-                const rf = body
-                    .response_format;
-                if (rf?.type !== "json_object") {
-                    return body;
-                }
-                const messages = body
-                    .messages;
-                if (!Array.isArray(messages)) {
-                    return body;
-                }
-                const containsJsonWord = messages.some((m) => {
-                    const c = m?.content;
-                    if (typeof c === "string") {
-                        return /\bjson\b/i.test(c);
-                    }
-                    if (Array.isArray(c)) {
-                        return c.some((part) => typeof part?.text === "string" &&
-                            /\bjson\b/i.test(part.text));
-                    }
-                    return false;
-                });
-                if (containsJsonWord) {
-                    return body;
-                }
-                return {
-                    ...body,
-                    messages: [
-                        {
-                            role: "system",
-                            content: "Respond with valid JSON that satisfies the requested schema. Output JSON only — no prose, no markdown fencing.",
-                        },
-                        ...messages,
-                    ],
-                };
-            },
-        });
-        this.model = deepseek.chatModel(this.modelName);
+        const apiKey = overrideApiKey && overrideApiKey.length > 0
+            ? overrideApiKey
+            : getDeepSeekApiKey();
+        // Treat blank/whitespace overrides as unset so an empty
+        // `credentials.baseURL` or `DEEPSEEK_BASE_URL=` cannot silently override
+        // the default with "" (mirrors the apiKey precedence above).
+        const baseURL = credentials?.baseURL?.trim() ||
+            process.env.DEEPSEEK_BASE_URL?.trim() ||
+            DEEPSEEK_BASE_URL;
+        super("deepseek", modelName, sdk, { baseURL, apiKey });
         logger.debug("DeepSeek 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]: "deepseek",
-                [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 isReasoner = this.modelName === DeepSeekModels.DEEPSEEK_REASONER;
-            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),
-                // DeepSeek's `thinking` mode is opt-in for chat models — only enable
-                // when the caller explicitly asks for it via `thinkingConfig.enabled`.
-                // Forcing it on every chat call would trigger extended reasoning for
-                // simple prompts (and ignore reasoner models which control it natively).
-                providerOptions: !isReasoner && options.thinkingConfig?.enabled
-                    ? {
-                        openai: {
-                            thinking: { type: "enabled" },
-                        },
-                    }
-                    : undefined,
-                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("[DeepSeekProvider] 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: `deepseek-stream-${Date.now()}`,
-                streamingMode: true,
-            });
-            return {
-                stream: transformedStream,
-                provider: this.providerName,
-                model: this.modelName,
-                analytics: analyticsPromise,
-                metadata: { startTime, streamId: `deepseek-${Date.now()}` },
-            };
-        }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
-    }
+    // ===========================================================================
+    // Abstract hooks (required)
+    // ===========================================================================
     getProviderName() {
-        return this.providerName;
+        return "deepseek";
     }
     getDefaultModel() {
         return getDefaultDeepSeekModel();
     }
-    getAISDKModel() {
-        return this.model;
-    }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
             return new NetworkError(`Request timed out: ${error.message}`, "deepseek");
@@ -256,17 +93,31 @@ export class DeepSeekProvider extends BaseProvider {
         }
         return new ProviderError(`DeepSeek error: ${message}`, "deepseek");
     }
-    async validateConfiguration() {
-        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+    // ===========================================================================
+    // Optional hooks — provider-specific quirks
+    // ===========================================================================
+    getFallbackModelName() {
+        return DeepSeekModels.DEEPSEEK_CHAT;
     }
-    getConfiguration() {
-        return {
-            provider: this.providerName,
-            model: this.modelName,
-            defaultModel: getDefaultDeepSeekModel(),
-            baseURL: this.baseURL,
-        };
+    getFallbackModels() {
+        return [DeepSeekModels.DEEPSEEK_CHAT, DeepSeekModels.DEEPSEEK_REASONER];
+    }
+    /**
+     * DeepSeek's /chat/completions rejects `response_format: { type:
+     * "json_schema" }` outright ("This response_format type is unavailable
+     * now"). The `@ai-sdk/openai-compatible` provider this migration replaced
+     * ran with `supportsStructuredOutputs: false`, which downgraded structured-
+     * output requests to `{ type: "json_object" }`. Replicate that downgrade so
+     * `generate({ schema })` keeps working. (DeepSeek's json_object mode also
+     * requires the word "json" somewhere in the messages; the base client's
+     * `ensureJsonWordInBody` injects a minimal instruction when the prompt
+     * lacks it.)
+     */
+    adjustResponseFormat(rf, _modelId) {
+        if (rf?.type === "json_schema") {
+            return { type: "json_object" };
+        }
+        return rf;
     }
 }
-export default DeepSeekProvider;
 //# sourceMappingURL=deepseek.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;