@juspay/neurolink 9.67.1 → 9.67.2

package/dist/lib/providers/openaiCompatible.js

@@ -1,4 +1,3 @@
-import { createParser } from "eventsource-parser";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
@@ -7,11 +6,11 @@ import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, Ra
 import { logger } from "../utils/logger.js";
 import { NoOutputGeneratedError } from "../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
-import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../utils/timeout.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
+import { buildAPIError, buildBody, buildToolsForOpenAI, createChunkQueue, createDeferredAnalytics, mapNeuroLinkToolChoice, mergeUsage, messageBuilderToOpenAI, parseSSEStream, stringifyToolOutput, stripTrailingSlash, v3ResponseFormatToOpenAI, v3ToolChoiceToOpenAI, v3ToolsToOpenAI, } from "./openaiChatCompletionsClient.js";
 const FALLBACK_OPENAI_COMPATIBLE_MODEL = "gpt-3.5-turbo";
 const getOpenAICompatibleConfig = () => {
     const baseURL = process.env.OPENAI_COMPATIBLE_BASE_URL;
@@ -32,468 +31,12 @@ const getDefaultOpenAICompatibleModel = () => {
 // =============================================================================
 // Direct HTTP client for OpenAI chat-completions.
 //
-// Replaces both @ai-sdk/openai (the OpenAI wrapper) and streamText (the
-// orchestration). Tool execution, multi-step looping, and SSE parsing are
-// all inlined below. Nothing in this module imports from "ai" or
-// "@ai-sdk/provider" — the openai-compatible path is a clean cut.
+// Wire-format converters, SSE parser, request builder, and error builder all
+// live in ./openaiChatCompletionsClient.ts so providers that share the OpenAI
+// chat-completions shape (litellm, etc.) can reuse them without duplication.
+// Nothing in this module imports from "ai" or "@ai-sdk/provider" — the
+// openai-compatible path is a clean cut.
 // =============================================================================
-const stripTrailingSlash = (s) => s.replace(/\/+$/, "");
-const messageBuilderToOpenAI = (messages) => {
-    const out = [];
-    for (const msg of messages) {
-        switch (msg.role) {
-            case "system":
-                out.push({
-                    role: "system",
-                    content: typeof msg.content === "string"
-                        ? msg.content
-                        : safeStringify(msg.content),
-                });
-                break;
-            case "user":
-                out.push({
-                    role: "user",
-                    content: convertContentForOpenAI(msg.content),
-                });
-                break;
-            case "assistant": {
-                const parts = Array.isArray(msg.content) ? msg.content : [msg.content];
-                const text = [];
-                const toolCalls = [];
-                for (const part of parts) {
-                    if (part && typeof part === "object") {
-                        const p = part;
-                        if (p.type === "text") {
-                            text.push({
-                                type: "text",
-                                text: part.text ?? "",
-                            });
-                        }
-                        else if (p.type === "tool-call") {
-                            const tc = part;
-                            toolCalls.push({
-                                id: tc.toolCallId ?? "",
-                                type: "function",
-                                function: {
-                                    name: tc.toolName ?? "",
-                                    arguments: stringifyToolInput(tc.input),
-                                },
-                            });
-                        }
-                    }
-                    else if (typeof part === "string") {
-                        text.push({ type: "text", text: part });
-                    }
-                }
-                const flat = text.length === 0
-                    ? null
-                    : text.length === 1 && text[0].type === "text"
-                        ? text[0].text
-                        : text;
-                out.push({
-                    role: "assistant",
-                    content: flat,
-                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
-                });
-                break;
-            }
-            case "tool": {
-                // V3 tool messages carry `{ toolCallId, output }` per content[] entry,
-                // not at the top-level. Emit one OpenAI `role: "tool"` message per
-                // tool-result part so the model can correlate by tool_call_id.
-                if (Array.isArray(msg.content)) {
-                    for (const part of msg.content) {
-                        if (!part || typeof part !== "object") {
-                            continue;
-                        }
-                        const p = part;
-                        if (p.type === "tool-result") {
-                            out.push({
-                                role: "tool",
-                                tool_call_id: p.toolCallId ?? "",
-                                content: stringifyToolOutput(p.output),
-                            });
-                        }
-                    }
-                }
-                else if (typeof msg.content === "string") {
-                    // Legacy / flat-string callers (not V3): forward as-is.
-                    out.push({
-                        role: "tool",
-                        tool_call_id: msg.toolCallId ?? "",
-                        content: msg.content,
-                    });
-                }
-                break;
-            }
-        }
-    }
-    return out;
-};
-const convertContentForOpenAI = (content) => {
-    if (typeof content === "string") {
-        return content;
-    }
-    if (!Array.isArray(content)) {
-        return safeStringify(content);
-    }
-    const out = [];
-    for (const part of content) {
-        if (typeof part === "string") {
-            out.push({ type: "text", text: part });
-            continue;
-        }
-        if (!part || typeof part !== "object") {
-            continue;
-        }
-        const p = part;
-        if (p.type === "text") {
-            out.push({
-                type: "text",
-                text: part.text ?? "",
-            });
-        }
-        else if (p.type === "image" || p.type === "image_url") {
-            const data = part.image ??
-                part.data ??
-                part.url;
-            const url = imageDataToURL(data);
-            if (url) {
-                out.push({ type: "image_url", image_url: { url } });
-            }
-        }
-    }
-    if (out.length === 1 && out[0].type === "text") {
-        return out[0].text;
-    }
-    return out;
-};
-const imageDataToURL = (data) => {
-    if (typeof data === "string") {
-        if (data.startsWith("data:") || /^https?:\/\//i.test(data)) {
-            return data;
-        }
-        return `data:image/png;base64,${data}`;
-    }
-    if (data instanceof URL) {
-        return data.toString();
-    }
-    if (data instanceof Uint8Array) {
-        return `data:image/png;base64,${Buffer.from(data).toString("base64")}`;
-    }
-    return undefined;
-};
-const stringifyToolInput = (input) => {
-    if (typeof input === "string") {
-        return input;
-    }
-    try {
-        return JSON.stringify(input ?? {});
-    }
-    catch {
-        return "{}";
-    }
-};
-const safeStringify = (value) => {
-    try {
-        return JSON.stringify(value ?? "");
-    }
-    catch {
-        return String(value ?? "");
-    }
-};
-// V3 tool-result `output` is a tagged union ({type:"text"|"json"|...}).
-// Serialize each variant the way an OpenAI-compatible endpoint expects
-// to read it as the `content` of a `role: "tool"` message.
-const stringifyToolOutput = (output) => {
-    if (output === null || output === undefined) {
-        return "";
-    }
-    if (typeof output === "string") {
-        return output;
-    }
-    if (typeof output !== "object") {
-        return String(output);
-    }
-    const o = output;
-    switch (o.type) {
-        case "text":
-            return typeof o.value === "string" ? o.value : safeStringify(o.value);
-        case "json":
-            return safeStringify(o.value);
-        case "execution-denied":
-            return `Tool execution denied${o.reason ? `: ${o.reason}` : ""}`;
-        case "error-text":
-            return typeof o.value === "string" ? o.value : safeStringify(o.value);
-        case "error-json":
-            return safeStringify(o.value);
-        case "content":
-            if (Array.isArray(o.value)) {
-                return o.value
-                    .map((p) => {
-                    if (p &&
-                        typeof p === "object" &&
-                        p.type === "text") {
-                        return String(p.text ?? "");
-                    }
-                    return "";
-                })
-                    .filter((s) => s.length > 0)
-                    .join("\n");
-            }
-            return "";
-        default:
-            // Plain output object (not a V3 tagged union) — just stringify.
-            return safeStringify(output);
-    }
-};
-const buildToolsForOpenAI = (tools) => {
-    const entries = Object.entries(tools);
-    if (entries.length === 0) {
-        return undefined;
-    }
-    const out = [];
-    for (const [name, tool] of entries) {
-        const t = tool;
-        const rawSchema = t.inputSchema ?? t.parameters;
-        // tool.inputSchema may be a Zod schema, an AI SDK jsonSchema() wrapper,
-        // or plain JSON Schema — convertZodToJsonSchema normalizes all three.
-        // Sending raw Zod internals (with `_def`) gets rejected by most
-        // OpenAI-compatible endpoints.
-        const parameters = rawSchema
-            ? convertZodToJsonSchema(rawSchema)
-            : { type: "object", properties: {} };
-        out.push({
-            type: "function",
-            function: {
-                name,
-                ...(t.description ? { description: t.description } : {}),
-                parameters,
-            },
-        });
-    }
-    return out;
-};
-// V3 → OpenAI conversion helpers used by the non-streaming `doGenerate`
-// path that BaseProvider's `generate()` still drives via the AI SDK's
-// `generateText`. The streaming path doesn't need these — it consumes
-// NeuroLink-shaped options directly.
-const v3ToolsToOpenAI = (tools) => {
-    if (!tools || tools.length === 0) {
-        return undefined;
-    }
-    const out = [];
-    for (const t of tools) {
-        if (t.type === "function") {
-            out.push({
-                type: "function",
-                function: {
-                    name: t.name,
-                    ...(t.description ? { description: t.description } : {}),
-                    parameters: t.inputSchema,
-                    ...(t.strict !== undefined ? { strict: t.strict } : {}),
-                },
-            });
-        }
-        // provider-defined V3 tools are silently dropped here — they have no
-        // OpenAI chat-completions equivalent.
-    }
-    return out.length > 0 ? out : undefined;
-};
-const v3ToolChoiceToOpenAI = (choice) => {
-    switch (choice.type) {
-        case "auto":
-        case "none":
-        case "required":
-            return choice.type;
-        case "tool":
-            return { type: "function", function: { name: choice.toolName } };
-    }
-};
-const v3ResponseFormatToOpenAI = (rf) => {
-    if (rf.type === "text") {
-        return { type: "text" };
-    }
-    if (!rf.schema) {
-        return { type: "json_object" };
-    }
-    return {
-        type: "json_schema",
-        json_schema: {
-            name: rf.name ?? "response",
-            schema: rf.schema,
-            ...(rf.description ? { description: rf.description } : {}),
-            strict: true,
-        },
-    };
-};
-const mapNeuroLinkToolChoice = (choice) => {
-    if (!choice) {
-        return undefined;
-    }
-    if (choice === "auto" || choice === "none" || choice === "required") {
-        return choice;
-    }
-    if (typeof choice === "object" && choice !== null) {
-        const c = choice;
-        if (c.type === "tool" && c.toolName) {
-            return { type: "function", function: { name: c.toolName } };
-        }
-    }
-    return undefined;
-};
-const buildBody = (args) => {
-    const { modelId, messages, options, tools, toolChoice, streaming, responseFormat, } = args;
-    const body = {
-        model: modelId,
-        messages,
-        ...(streaming ? { stream: true } : {}),
-        ...(streaming ? { stream_options: { include_usage: true } } : {}),
-    };
-    if (options.maxTokens !== undefined && options.maxTokens !== null) {
-        body.max_tokens = options.maxTokens;
-    }
-    if (options.temperature !== undefined && options.temperature !== null) {
-        body.temperature = options.temperature;
-    }
-    if (options.topP !== undefined && options.topP !== null) {
-        body.top_p = options.topP;
-    }
-    if (options.presencePenalty !== undefined &&
-        options.presencePenalty !== null) {
-        body.presence_penalty = options.presencePenalty;
-    }
-    if (options.frequencyPenalty !== undefined &&
-        options.frequencyPenalty !== null) {
-        body.frequency_penalty = options.frequencyPenalty;
-    }
-    if (options.seed !== undefined && options.seed !== null) {
-        body.seed = options.seed;
-    }
-    if (options.stopSequences && options.stopSequences.length > 0) {
-        body.stop = options.stopSequences;
-    }
-    if (tools) {
-        body.tools = tools;
-    }
-    if (toolChoice !== undefined) {
-        body.tool_choice = toolChoice;
-    }
-    if (responseFormat) {
-        body.response_format = responseFormat;
-    }
-    return body;
-};
-const parseSSEStream = async (body, onTextDelta) => {
-    const result = {
-        text: "",
-        toolCalls: new Map(),
-        finishReason: null,
-        usage: undefined,
-    };
-    const decoder = new TextDecoder();
-    let parseErr;
-    const handleEvent = (msg) => {
-        const data = msg.data;
-        if (!data || data === "[DONE]") {
-            return;
-        }
-        let chunk;
-        try {
-            chunk = JSON.parse(data);
-        }
-        catch (err) {
-            parseErr = err instanceof Error ? err : new Error(String(err));
-            return;
-        }
-        if (chunk.usage) {
-            result.usage = chunk.usage;
-        }
-        const choice = chunk.choices?.[0];
-        if (!choice) {
-            return;
-        }
-        const delta = choice.delta;
-        if (delta?.content) {
-            result.text += delta.content;
-            onTextDelta(delta.content);
-        }
-        if (delta?.tool_calls) {
-            for (const tc of delta.tool_calls) {
-                let state = result.toolCalls.get(tc.index);
-                if (!state) {
-                    state = {
-                        id: tc.id ?? `call_${tc.index}_${Date.now()}`,
-                        name: tc.function?.name ?? "",
-                        argsBuffered: "",
-                    };
-                    result.toolCalls.set(tc.index, state);
-                }
-                else if (tc.id) {
-                    state.id = tc.id;
-                }
-                if (tc.function?.name) {
-                    state.name = tc.function.name;
-                }
-                if (tc.function?.arguments) {
-                    state.argsBuffered += tc.function.arguments;
-                }
-            }
-        }
-        if (choice.finish_reason) {
-            result.finishReason = choice.finish_reason;
-        }
-    };
-    const parser = createParser({ onEvent: handleEvent });
-    const reader = body.getReader();
-    try {
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            parser.feed(decoder.decode(value, { stream: true }));
-        }
-        parser.feed(decoder.decode());
-    }
-    finally {
-        reader.releaseLock();
-    }
-    if (parseErr) {
-        throw parseErr;
-    }
-    return result;
-};
-const buildAPIError = async (url, body, res) => {
-    let bodyText;
-    let parsed;
-    try {
-        bodyText = await res.text();
-        parsed = bodyText
-            ? JSON.parse(bodyText)
-            : undefined;
-    }
-    catch {
-        parsed = undefined;
-    }
-    const msg = parsed?.error?.message ??
-        `OpenAI-compatible request failed with status ${res.status}`;
-    const err = new Error(msg);
-    err.statusCode = res.status;
-    err.url = url;
-    // Redacted summary only — never attach raw prompts, tool definitions, or
-    // tool arguments to the thrown error. Anything serialized by upstream
-    // logging would leak them otherwise.
-    err.requestBody = {
-        model: body.model,
-        stream: body.stream === true,
-        tool_count: body.tools?.length ?? 0,
-    };
-    if (bodyText !== undefined) {
-        err.responseBody = bodyText;
-    }
-    return err;
-};
 // =============================================================================
 // Provider
 // =============================================================================
@@ -1186,57 +729,4 @@ export class OpenAICompatibleProvider extends BaseProvider {
         ];
     }
 }
-// Deferred-promise pair for `usage` and `finishReason` so the analytics
-// collector resolves with the actual aggregated values after the multi-step
-// loop ends, not the zeros they had at result-construction time.
-const createDeferredAnalytics = () => {
-    let resolveUsage = () => { };
-    const usagePromise = new Promise((r) => {
-        resolveUsage = r;
-    });
-    let resolveFinish = () => { };
-    const finishPromise = new Promise((r) => {
-        resolveFinish = r;
-    });
-    return { usagePromise, finishPromise, resolveUsage, resolveFinish };
-};
-// Single-producer / single-consumer chunk queue. The streaming loop pushes
-// `{content}` deltas as they arrive from SSE and a final `{done:true}` when
-// it finishes; the consumer's AsyncIterable pulls from `nextChunk()`.
-const createChunkQueue = () => {
-    const chunkQueue = [];
-    let pendingResolve;
-    const pushChunk = (c) => {
-        if (pendingResolve) {
-            const r = pendingResolve;
-            pendingResolve = undefined;
-            r(c);
-        }
-        else {
-            chunkQueue.push(c);
-        }
-    };
-    const nextChunk = () => new Promise((resolve) => {
-        if (chunkQueue.length > 0) {
-            resolve(chunkQueue.shift());
-        }
-        else {
-            pendingResolve = resolve;
-        }
-    });
-    return { pushChunk, nextChunk };
-};
-const mergeUsage = (a, b) => {
-    if (!a) {
-        return b;
-    }
-    if (!b) {
-        return a;
-    }
-    return {
-        prompt_tokens: (a.prompt_tokens ?? 0) + (b.prompt_tokens ?? 0),
-        completion_tokens: (a.completion_tokens ?? 0) + (b.completion_tokens ?? 0),
-        total_tokens: (a.total_tokens ?? 0) + (b.total_tokens ?? 0),
-    };
-};
 //# sourceMappingURL=openaiCompatible.js.map

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

@@ -903,6 +903,8 @@ export type AnthropicVertexSettings = {
     projectId: string;
     /** Google Cloud region for Anthropic models (e.g., 'us-east5') */
     region: string;
+    /** SDK request timeout in milliseconds */
+    timeout?: number;
 };
 /**
  * OpenAI-compatible models endpoint response structure

package/dist/providers/googleVertex.js

@@ -366,12 +366,13 @@ const createVertexSettings = async (region) => {
     return baseSettings;
 };
 // Create Anthropic-specific Vertex settings for native @anthropic-ai/vertex-sdk
-const createVertexAnthropicSettings = async (region) => {
+const createVertexAnthropicSettings = async (region, timeoutMs) => {
     const location = region || getVertexLocation();
     const project = getVertexProjectId();
     return {
         projectId: project,
         region: location,
+        ...(timeoutMs !== undefined && { timeout: timeoutMs }),
     };
 };
 // Helper function to determine if a model is an Anthropic model
@@ -2032,9 +2033,9 @@ export class GoogleVertexProvider extends BaseProvider {
     /**
      * Create native AnthropicVertex client for Claude models
      */
-    async createAnthropicVertexClient() {
+    async createAnthropicVertexClient(timeoutMs) {
         const mod = await getAnthropicVertexModule();
-        const settings = await createVertexAnthropicSettings(this.location);
+        const settings = await createVertexAnthropicSettings(this.location, timeoutMs);
         return new mod.AnthropicVertex(settings);
     }
     /**
@@ -2042,9 +2043,10 @@ export class GoogleVertexProvider extends BaseProvider {
      * This bypasses @ai-sdk/google-vertex completely and uses Anthropic's native SDK
      */
     async executeNativeAnthropicStream(options) {
-        const client = await this.createAnthropicVertexClient();
         const modelName = options.model || this.modelName || "claude-sonnet-4-5@20250929";
         const startTime = Date.now();
+        const streamTimeoutMs = parseTimeout(options.timeout) ?? 300_000;
+        const client = await this.createAnthropicVertexClient(streamTimeoutMs);
         logger.debug("[GoogleVertex] Using native @anthropic-ai/vertex-sdk for Claude stream", {
             model: modelName,
             project: this.projectId,
@@ -2336,7 +2338,6 @@ export class GoogleVertexProvider extends BaseProvider {
         // abort the stream after the configured timeout so a stalled
         // Vertex/Anthropic endpoint can't hang forever. options.timeout wins
         // if set; otherwise 5 min — generous for tool-heavy turns.
-        const streamTimeoutMs = parseTimeout(options.timeout) ?? 300_000;
         const streamTimeoutHandle = setTimeout(() => {
             logger.warn(`[GoogleVertex] Anthropic stream exceeded ${streamTimeoutMs}ms — aborting`);
             abortHandler();
@@ -2560,9 +2561,10 @@ export class GoogleVertexProvider extends BaseProvider {
      * Execute generate using native @anthropic-ai/vertex-sdk for Claude models on Vertex AI
      */
     async executeNativeAnthropicGenerate(options) {
-        const client = await this.createAnthropicVertexClient();
         const modelName = options.model || this.modelName || "claude-sonnet-4-5@20250929";
         const startTime = Date.now();
+        const generateTimeoutMs = parseTimeout(options.timeout) ?? 300_000;
+        const client = await this.createAnthropicVertexClient(generateTimeoutMs);
         logger.debug("[GoogleVertex] Using native @anthropic-ai/vertex-sdk for Claude generate", {
             model: modelName,
             project: this.projectId,
@@ -2826,7 +2828,6 @@ export class GoogleVertexProvider extends BaseProvider {
                 // Bound the SDK wait so a stalled Vertex/Anthropic call can't hang
                 // generate forever. options.timeout wins if set, otherwise default
                 // to 5 min — generous for tool-heavy turns.
-                const generateTimeoutMs = parseTimeout(options.timeout) ?? 300_000;
                 const response = await withTimeout(client.messages.create({
                     ...requestParams,
                     messages: currentMessages,