@juspay/neurolink 9.67.0 → 9.67.1

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

@@ -35,6 +35,7 @@ export * from "./middleware.js";
 export * from "./model.js";
 export * from "./multimodal.js";
 export * from "./observability.js";
+export * from "./openaiCompatible.js";
 export * from "./ppt.js";
 export * from "./processor.js";
 export * from "./providers.js";

package/dist/lib/types/index.js

@@ -36,6 +36,7 @@ export * from "./middleware.js";
 export * from "./model.js";
 export * from "./multimodal.js";
 export * from "./observability.js";
+export * from "./openaiCompatible.js";
 export * from "./ppt.js";
 export * from "./processor.js";
 export * from "./providers.js";

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

@@ -3,7 +3,7 @@ import type { EvaluationData, GetPromptFunction } from "./evaluation.js";
 import type { AuthenticatedUser, RouteDefinition, ServerContext } from "./server.js";
 import type { LanguageModelMiddleware as BaseLanguageModelMiddleware } from "ai";
 export type { LanguageModelMiddleware } from "ai";
-export type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3Message, LanguageModelV3StreamPart, LanguageModelV3ToolCall, LanguageModelV3ToolChoice, LanguageModelV3Source, LanguageModelV3Middleware, JSONSchema7, } from "@ai-sdk/provider";
+export type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3Message, LanguageModelV3Prompt, LanguageModelV3StreamPart, LanguageModelV3ToolCall, LanguageModelV3ToolChoice, LanguageModelV3Source, LanguageModelV3Middleware, JSONSchema7, } from "@ai-sdk/provider";
 import type { LanguageModelV3 } from "@ai-sdk/provider";
 export type LanguageModelV3GenerateResult = Awaited<ReturnType<LanguageModelV3["doGenerate"]>>;
 export type LanguageModelV3StreamResult = Awaited<ReturnType<LanguageModelV3["doStream"]>>;

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

@@ -0,0 +1,250 @@
+import type { NeuroLinkEvents, TypedEventEmitter } from "./common.js";
+import type { JSONSchema7 } from "./middleware.js";
+import type { LanguageModelV3, LanguageModelV3CallOptions } from "./middleware.js";
+import type { StreamOptions } from "./stream.js";
+import type { Tool } from "./tools.js";
+export type OpenAICompatChatRole = "system" | "user" | "assistant" | "tool";
+export type OpenAICompatTextContent = {
+    type: "text";
+    text: string;
+};
+export type OpenAICompatImageURLContent = {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: "auto" | "low" | "high";
+    };
+};
+export type OpenAICompatMessageContent = OpenAICompatTextContent | OpenAICompatImageURLContent;
+export type OpenAICompatToolCallWire = {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+export type OpenAICompatChatMessage = {
+    role: "system";
+    content: string | OpenAICompatMessageContent[];
+} | {
+    role: "user";
+    content: string | OpenAICompatMessageContent[];
+} | {
+    role: "assistant";
+    content?: string | OpenAICompatMessageContent[] | null;
+    tool_calls?: OpenAICompatToolCallWire[];
+} | {
+    role: "tool";
+    content: string;
+    tool_call_id: string;
+};
+export type OpenAICompatChatTool = {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters: JSONSchema7;
+        strict?: boolean;
+    };
+};
+export type OpenAICompatToolChoiceWire = "auto" | "none" | "required" | {
+    type: "function";
+    function: {
+        name: string;
+    };
+};
+export type OpenAICompatResponseFormat = {
+    type: "text";
+} | {
+    type: "json_object";
+} | {
+    type: "json_schema";
+    json_schema: {
+        name: string;
+        schema: JSONSchema7;
+        description?: string;
+        strict?: boolean;
+    };
+};
+export type OpenAICompatChatRequest = {
+    model: string;
+    messages: OpenAICompatChatMessage[];
+    stream?: boolean;
+    stream_options?: {
+        include_usage?: boolean;
+    };
+    max_tokens?: number;
+    max_completion_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    seed?: number;
+    stop?: string[];
+    tools?: OpenAICompatChatTool[];
+    tool_choice?: OpenAICompatToolChoiceWire;
+    response_format?: OpenAICompatResponseFormat;
+    parallel_tool_calls?: boolean;
+    user?: string;
+};
+export type OpenAICompatUsage = {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+    };
+    completion_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+};
+export type OpenAICompatChatChoiceMessage = {
+    role: "assistant";
+    content?: string | null;
+    tool_calls?: OpenAICompatToolCallWire[];
+    refusal?: string | null;
+};
+export type OpenAICompatChatChoice = {
+    index: number;
+    message: OpenAICompatChatChoiceMessage;
+    finish_reason: "stop" | "length" | "tool_calls" | "function_call" | "content_filter" | null;
+};
+export type OpenAICompatChatResponse = {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices: OpenAICompatChatChoice[];
+    usage?: OpenAICompatUsage;
+    system_fingerprint?: string;
+};
+export type OpenAICompatStreamDelta = {
+    role?: OpenAICompatChatRole;
+    content?: string | null;
+    tool_calls?: Array<{
+        index: number;
+        id?: string;
+        type?: "function";
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }>;
+    refusal?: string | null;
+};
+export type OpenAICompatStreamChunkChoice = {
+    index: number;
+    delta: OpenAICompatStreamDelta;
+    finish_reason: "stop" | "length" | "tool_calls" | "function_call" | "content_filter" | null;
+};
+export type OpenAICompatChatStreamChunk = {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices: OpenAICompatStreamChunkChoice[];
+    usage?: OpenAICompatUsage;
+};
+export type OpenAICompatErrorBody = {
+    error?: {
+        message?: string;
+        type?: string;
+        code?: string | number;
+        param?: string | null;
+    };
+};
+export type OpenAICompatConfig = {
+    provider: string;
+    modelId: string;
+    baseURL: string;
+    apiKey?: string;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    fetch?: typeof globalThis.fetch;
+};
+export type OpenAICompatToolWarning = NonNullable<Awaited<ReturnType<LanguageModelV3["doGenerate"]>>["warnings"]>[number];
+export type OpenAICompatV3Content = Awaited<ReturnType<LanguageModelV3["doGenerate"]>>["content"][number];
+export type OpenAICompatV3FinishReason = Awaited<ReturnType<LanguageModelV3["doGenerate"]>>["finishReason"];
+export type OpenAICompatV3Usage = Awaited<ReturnType<LanguageModelV3["doGenerate"]>>["usage"];
+export type OpenAICompatV3StreamPart = Awaited<ReturnType<LanguageModelV3["doStream"]>>["stream"] extends ReadableStream<infer P> ? P : never;
+export type OpenAICompatV3CallTools = NonNullable<LanguageModelV3CallOptions["tools"]>;
+export type OpenAICompatV3CallToolChoice = NonNullable<LanguageModelV3CallOptions["toolChoice"]>;
+export type OpenAICompatUserOrAssistantPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "file";
+    mediaType: string;
+    data: Uint8Array | string | URL;
+    filename?: string;
+};
+export type OpenAICompatMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: unknown;
+    toolCallId?: string;
+    toolName?: string;
+};
+export type OpenAICompatSSEResult = {
+    text: string;
+    toolCalls: Map<number, {
+        id: string;
+        name: string;
+        argsBuffered: string;
+    }>;
+    finishReason: "stop" | "length" | "tool_calls" | "function_call" | "content_filter" | null;
+    usage?: OpenAICompatUsage;
+};
+export type OpenAICompatStreamChunk = {
+    content: string;
+} | {
+    done: true;
+};
+export type ToolExecutionSummaryInternal = {
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    output?: unknown;
+    error?: string;
+    startTime: Date;
+    endTime: Date;
+};
+export type StreamLoopArgs = {
+    maxSteps: number;
+    modelId: string;
+    url: string;
+    apiKey: string;
+    fetchImpl: typeof fetch;
+    abortSignal: AbortSignal | undefined;
+    options: StreamOptions;
+    conversation: OpenAICompatChatMessage[];
+    openAITools: OpenAICompatChatTool[] | undefined;
+    openAIToolChoice: OpenAICompatToolChoiceWire | undefined;
+    toolsRecord: Record<string, Tool>;
+    emitter: TypedEventEmitter<NeuroLinkEvents> | undefined;
+    toolsUsed: string[];
+    toolExecutionSummaries: ToolExecutionSummaryInternal[];
+    pushChunk: (chunk: OpenAICompatStreamChunk) => void;
+    resolveUsage: (u: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    }) => void;
+    resolveFinish: (reason: string) => void;
+};
+export type OpenAICompatBuildBodyArgs = {
+    modelId: string;
+    messages: OpenAICompatChatMessage[];
+    options: {
+        maxTokens?: number | null;
+        temperature?: number | null;
+        topP?: number | null;
+        presencePenalty?: number | null;
+        frequencyPenalty?: number | null;
+        seed?: number | null;
+        stopSequences?: string[];
+    };
+    tools?: OpenAICompatChatTool[];
+    toolChoice?: OpenAICompatToolChoiceWire;
+    streaming: boolean;
+    responseFormat?: OpenAICompatResponseFormat;
+};

package/dist/lib/types/openaiCompatible.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=openaiCompatible.js.map

package/dist/providers/openaiCompatible.d.ts

@@ -1,16 +1,17 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
-import type { LanguageModel, Schema } from "../types/index.js";
+import type { LanguageModel, Schema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
 /**
- * OpenAI Compatible Provider - BaseProvider Implementation
- * Provides access to one of the OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)
+ * OpenAI Compatible Provider — direct HTTP, no AI SDK.
+ *
+ * Talks to any OpenAI chat-completions-shaped endpoint (LiteLLM, vLLM,
+ * OpenRouter, etc.). The entire request/stream/tool-loop is inline above;
+ * no `streamText`, no `LanguageModelV3`, no `@ai-sdk/openai`.
  */
 export declare class OpenAICompatibleProvider extends BaseProvider {
-    private model?;
     private config;
+    private resolvedModel?;
     private discoveredModel?;
-    private customOpenAI;
     constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: {
         apiKey?: string;
         baseURL?: string;
@@ -18,33 +19,59 @@ export declare class OpenAICompatibleProvider extends BaseProvider {
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
-     * Returns the Vercel AI SDK model instance for OpenAI Compatible endpoints
-     * Handles auto-discovery if no model was specified
+     * Abstract from BaseProvider — used by the parent's generate() path which
+     * still goes through `generateText`. Returns a thin LanguageModelV3-shaped
+     * object that delegates to the same HTTP helpers used by executeStream.
+     * Stays inside this file so no AI-SDK-named import is needed here.
      */
     protected getAISDKModel(): Promise<LanguageModel>;
-    protected formatProviderError(error: unknown): Error;
+    private resolveModelName;
     /**
-     * OpenAI Compatible endpoints support tools for compatible models
+     * Returns a minimal V3-shaped model. Only used by BaseProvider's
+     * `generate()` non-streaming path which still relies on the parent's
+     * `generateText`. The streaming path bypasses this entirely.
      */
+    private buildDelegatingModel;
+    protected formatProviderError(error: unknown): Error;
     supportsTools(): boolean;
     /**
-     * Provider-specific streaming implementation
-     * Note: This is only used when tools are disabled
+     * Streaming path — drives the OpenAI endpoint directly. No streamText,
+     * no AI SDK orchestrator. Tool calls, multi-step loops, telemetry,
+     * abort handling all inline.
      */
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     /**
-     * Get available models from OpenAI Compatible endpoint
+     * Multi-step streaming orchestrator. One iteration per model turn:
      *
-     * Fetches from the /v1/models endpoint to discover available models.
-     * This is useful for auto-discovery when no model is specified.
+     *   1. POST /chat/completions with stream:true
+     *   2. Parse SSE; push text deltas to the consumer queue
+     *   3. If the step emitted tool_calls → execute each, append to
+     *      conversation, loop again
+     *   4. Otherwise resolve the deferred analytics promises and exit
+     *
+     * Bounded by `args.maxSteps`. Any thrown error rejects loopPromise and
+     * is surfaced to the consumer via `await loopPromise` in the stream
+     * generator.
      */
-    getAvailableModels(): Promise<string[]>;
+    private runStreamLoop;
     /**
-     * Get the first available model for auto-selection
+     * One streaming round-trip: POST chat-completions, parse SSE, push text
+     * deltas to the consumer queue. Returns the accumulated SSE result so
+     * the caller can decide whether to run tools and re-stream.
      */
-    getFirstAvailableModel(): Promise<string>;
+    private streamOneStep;
     /**
-     * Fallback models when discovery fails
+     * Execute every tool_call collected from one streaming step:
+     *
+     *   - append an `assistant` turn carrying the tool_calls
+     *   - resolve each tool from the local registry and run it
+     *   - emit tool:start/tool:end events
+     *   - push per-execution summaries
+     *   - append a `tool` turn per result so the next step can see them
+     *   - mirror BaseProvider's tool-events + storage hooks
      */
+    private executeToolBatch;
+    getAvailableModels(): Promise<string[]>;
+    getFirstAvailableModel(): Promise<string>;
     private getFallbackModels;
 }