@juspay/neurolink 9.67.2 → 9.68.0

package/dist/providers/openaiChatCompletionsClient.js

@@ -318,6 +318,45 @@ export const mapNeuroLinkToolChoice = (choice) => {
     }
     return undefined;
 };
+// OpenAI-compatible endpoints (OpenAI, DeepSeek, …) reject
+// `response_format: { type: "json_object" }` unless the literal word "json"
+// appears somewhere in the messages. The `@ai-sdk/openai-compatible` wrapper
+// this client replaced injected that instruction for us; the native client
+// must do the same or json_object requests 400.
+export const messagesContainJsonWord = (messages) => 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;
+});
+// Prepends a minimal JSON-instruction system message to the FINAL wire body
+// when json_object mode is requested and its messages don't already mention
+// "json". Operates on the post-`adjustRequestBody` body so the guard reflects
+// whatever a subclass left on the wire (response_format/messages it may have
+// rewritten), not an intermediate state. No-op otherwise.
+export const ensureJsonWordInBody = (body) => body.response_format?.type === "json_object" &&
+    !messagesContainJsonWord(body.messages)
+    ? {
+        ...body,
+        messages: [
+            {
+                role: "system",
+                content: "Respond with valid JSON only — no prose, no markdown fencing.",
+            },
+            ...body.messages,
+        ],
+    }
+    : body;
+// Reasoning-class OpenAI models (o-series, gpt-5+) reject `max_tokens` and
+// require `max_completion_tokens`. The OpenAI + Azure providers use this to
+// rename the field on the wire body; third-party OpenAI-compatible endpoints
+// keep `max_tokens`, so it is opt-in per provider, never applied by default.
+export const requiresMaxCompletionTokens = (modelId) => /^(o\d|gpt-5)/i.test(modelId.replace(/^.*\//, ""));
 export const buildBody = (args) => {
     const { modelId, messages, options, tools, toolChoice, streaming, responseFormat, } = args;
     const body = {

package/dist/providers/openaiCompatible.d.ts

@@ -1,77 +1,21 @@
 import type { AIProviderName } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import type { LanguageModel, Schema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
  * 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`.
+ * OpenRouter, etc.). All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`. This class just declares config and
+ * provider-specific error mapping.
  */
-export declare class OpenAICompatibleProvider extends BaseProvider {
-    private config;
-    private resolvedModel?;
-    private discoveredModel?;
+export declare class OpenAICompatibleProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: {
         apiKey?: string;
         baseURL?: string;
     });
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
-    /**
-     * 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>;
-    private resolveModelName;
-    /**
-     * 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 getFallbackModelName(): string;
+    protected getFallbackModels(): string[];
     protected formatProviderError(error: unknown): Error;
-    supportsTools(): boolean;
-    /**
-     * 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>;
-    /**
-     * Multi-step streaming orchestrator. One iteration per model turn:
-     *
-     *   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.
-     */
-    private runStreamLoop;
-    /**
-     * 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.
-     */
-    private streamOneStep;
-    /**
-     * 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;
 }