@juspay/neurolink 12.11.3 → 12.12.1

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -19,10 +19,7 @@
  */
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { LanguageModel, OpenAICompatBuildBodyArgs, OpenAICompatChatMessage, OpenAICompatChatRequest, OpenAICompatChatTool, OpenAICompatResponseFormat, OpenAICompatStreamLifecycleListeners, Schema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
-/**
- * Abstract HTTP+SSE provider for OpenAI chat-completions-shaped endpoints.
- */
+import type { LanguageModel, OpenAICompatBuildBodyArgs, OpenAICompatChatMessage, OpenAICompatChatRequest, OpenAICompatChatTool, OpenAICompatResponseFormat, OpenAICompatStreamLifecycleListeners, Schema, EnhancedGenerateResult, TextGenerationOptions, ValidationSchema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
 export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider {
     protected config: {
         baseURL: string;
@@ -227,6 +224,26 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
      * streamText, no AI SDK orchestrator. Tool calls, multi-step loops,
      * telemetry, abort handling all inline.
      */
+    /**
+     * Native non-streaming generate.
+     *
+     * Drives the SAME `doGenerate` the ai loop drove — `buildDelegatingModel`'s,
+     * reached through `getAISDKModel()` — and supplies only the multi-step tool
+     * iteration around it. That matters: `doGenerate` is where the JSON-versus-SSE
+     * wire choice lives (`useStreamingWireForGenerate()`, false by default), along
+     * with the 400 retry, the context-overflow refit and the invalid-model
+     * fallback. An earlier attempt ran generate through the STREAMING loop
+     * instead and silently began sending `stream: true` on a path that had always
+     * sent plain JSON; ten providers returned empty content against a
+     * non-streaming body and a stream-rejecting backend failed outright. Loop
+     * around doGenerate, never around streamOneStep.
+     *
+     * Tool turns are appended in the message-builder shape, which
+     * `messageBuilderToOpenAI` already round-trips: an assistant message carrying
+     * `tool-call` parts, then one `tool` message of `tool-result` parts.
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
+    private executeNativeGenerate;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     private runStreamLoop;
     private streamOneStep;

package/dist/providers/openaiChatCompletionsBase.js

@@ -32,9 +32,15 @@ import { NoOutputGeneratedError } from "../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals, } from "../utils/timeout.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
+import { resolveRequestKind } from "../core/resolveRequestKind.js";
+import { appendJsonSchemaInstruction, hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
+import { resolveToolExecutionRecords } from "../core/toolExecutionRecorder.js";
+import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
+import { coerceJsonToSchema, schemaAccepts } from "../utils/json/coerce.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
 import { withProviderRetry } from "../utils/providerRetry.js";
+import { isSchemaComplexityError, isToolsSchemaConflictError, } from "../core/modules/structuredOutputPolicy.js";
 import { resolveDeferredTool } from "../tools/toolDiscovery.js";
 import { buildAPIError, buildBody, buildToolsForOpenAI, buildWireToolNameMaps, createDeferredAnalytics, ensureJsonWordInBody, estimateWireTokens, mapNeuroLinkToolChoice, mergeUsage, messageBuilderToOpenAI, parseSSEStream, stringifyToolOutput, stripTrailingSlash, v3ResponseFormatToOpenAI, v3ToolChoiceToOpenAI, v3ToolsToOpenAI, } from "./openaiChatCompletionsClient.js";
 import { createStreamChannel } from "../core/streamChannel.js";
@@ -47,6 +53,19 @@ const WINDOW_FIT_MARGIN_TOKENS = 512;
 /**
  * Abstract HTTP+SSE provider for OpenAI chat-completions-shaped endpoints.
  */
+/**
+ * Did the model's text yield an object the caller's schema accepts?
+ *
+ * This is the trigger for the prompt-side structured-output fallback. It asks
+ * the question the ai-package's structured-output parser used to ask by
+ * throwing: did the native `response_format` attempt actually produce the
+ * object. A schema we cannot validate with accepts everything, so an unknown
+ * schema never forces a pointless second request.
+ */
+const yieldsSchemaValidObject = (text, schema) => {
+    const coerced = coerceJsonToSchema(text, schema);
+    return coerced !== null && schemaAccepts(schema, coerced.structuredData);
+};
 export class OpenAIChatCompletionsProvider extends BaseProvider {
     config;
     resolvedModel;
@@ -707,6 +726,207 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
      * streamText, no AI SDK orchestrator. Tool calls, multi-step loops,
      * telemetry, abort handling all inline.
      */
+    /**
+     * Native non-streaming generate.
+     *
+     * Drives the SAME `doGenerate` the ai loop drove — `buildDelegatingModel`'s,
+     * reached through `getAISDKModel()` — and supplies only the multi-step tool
+     * iteration around it. That matters: `doGenerate` is where the JSON-versus-SSE
+     * wire choice lives (`useStreamingWireForGenerate()`, false by default), along
+     * with the 400 retry, the context-overflow refit and the invalid-model
+     * fallback. An earlier attempt ran generate through the STREAMING loop
+     * instead and silently began sending `stream: true` on a path that had always
+     * sent plain JSON; ten providers returned empty content against a
+     * non-streaming body and a stream-rejecting backend failed outright. Loop
+     * around doGenerate, never around streamOneStep.
+     *
+     * Tool turns are appended in the message-builder shape, which
+     * `messageBuilderToOpenAI` already round-trips: an assistant message carrying
+     * `tool-call` parts, then one `tool` message of `tool-result` parts.
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        await this.ensureModelLimits();
+        const options = this.normalizeTextOptions(optionsOrPrompt);
+        if (resolveRequestKind(options, this.modelName) !== "text") {
+            return super.generate(options, analysisSchema);
+        }
+        this.validateOptions(options);
+        const mergedTools = await this.getToolsForStream(options);
+        // Reuse BaseProvider's invalid-model fallback. Overriding generate() skips
+        // it otherwise, and a retired default stops degrading to the next live
+        // model in the catalog entry.
+        const callerOwnsFallback = "disableInternalFallback" in options &&
+            options.disableInternalFallback === true;
+        // The native loop bypasses BaseProvider.executeGeneration, so the turn
+        // budget has to be composed here or it stops existing for this provider.
+        return this.runGenerateWithModelFallback(() => this.withTurnTimeout({ ...options, tools: mergedTools }, this.getDescriptorGenerateMs(), (timedOptions) => this.executeNativeGenerate(timedOptions)), callerOwnsFallback);
+    }
+    async executeNativeGenerate(options) {
+        const startTime = Date.now();
+        const modelId = await this.resolveModelName();
+        // Middleware must wrap the model here. The native loop bypasses
+        // BaseProvider.executeGeneration, and with it the only place middleware was
+        // ever applied — a probe showed a caller's wrapGenerate running zero times
+        // on every native provider while their onFinish still fired, because
+        // onFinish had been special-cased and nothing else had.
+        const model = await this.getAISDKModelWithMiddleware(options);
+        // Runtime guard rather than an assertion: `LanguageModel` is a union that
+        // includes a bare string id, and a double assertion through unknown is
+        // banned by Critical Rule 14.
+        if (!hasNativeDoGenerate(model)) {
+            throw this.handleProviderError(new Error(`${this.providerName}: model handle exposes no doGenerate()`));
+        }
+        const doGenerate = model.doGenerate.bind(model);
+        const shouldUseTools = !options.disableTools && this.supportsTools();
+        const toolsRecord = shouldUseTools
+            ? options.tools || (await this.getAllTools())
+            : {};
+        // v3 tool shape — the same one doGenerate already converts internally.
+        const v3Tools = shouldUseTools
+            ? Object.entries(toolsRecord).map(([name, t]) => {
+                const tool = t;
+                return {
+                    type: "function",
+                    name,
+                    description: tool.description ?? "",
+                    inputSchema: (tool.inputSchema
+                        ? convertZodToJsonSchema(tool.inputSchema)
+                        : { type: "object", properties: {} }),
+                };
+            })
+            : undefined;
+        const hasTools = !!v3Tools && v3Tools.length > 0;
+        // Structured output rides response_format, which is what Output.object did
+        // on the ai path. Suppressed where the provider says the combination with
+        // tools is rejected.
+        const responseFormat = options.schema && !(hasTools && this.suppressResponseFormatWithTools())
+            ? {
+                type: "json",
+                schema: convertZodToJsonSchema(options.schema),
+            }
+            : undefined;
+        const conversation = (await this.buildMessagesForStream(options));
+        const toolExecutionSummaries = [];
+        const runLoop = (conv, format) => runNativeGenerateLoop({
+            doGenerate,
+            conversation: conv,
+            ...(v3Tools ? { tools: v3Tools } : {}),
+            toolsRecord,
+            ...(hasTools && options.toolChoice
+                ? { toolChoice: resolveToolChoice(options, toolsRecord, true) }
+                : {}),
+            // The per-call `timeout` keeps its per-MODEL-CALL meaning once
+            // `turnTimeoutMs` owns the whole-turn deadline, and it reaches the
+            // model layer only through this channel. Without it each step fell
+            // back to the provider default, so a caller asking for a short
+            // per-call timeout got the default on every request.
+            ...(typeof options.timeout === "number"
+                ? {
+                    providerOptions: {
+                        neurolink: { timeoutMs: options.timeout },
+                    },
+                }
+                : {}),
+            ...(format ? { responseFormat: format } : {}),
+            maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+            ...(options.maxTokens ? { maxOutputTokens: options.maxTokens } : {}),
+            ...(options.temperature !== undefined
+                ? { temperature: options.temperature }
+                : {}),
+            ...(options.abortSignal ? { abortSignal: options.abortSignal } : {}),
+            ...(options.toolTimeoutMs !== undefined
+                ? { toolTimeoutMs: options.toolTimeoutMs }
+                : {}),
+            // withProviderRetry + handleProviderError are what the ai loop
+            // supplied around each call: without them a 429 surfaces as a raw
+            // upstream string instead of a RateLimitError, and a throttle is
+            // never retried.
+            runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, `${this.providerName} generate`).catch((err) => {
+                throw this.handleProviderError(err);
+            }),
+        }, toolExecutionSummaries);
+        // Structured output rides `response_format` first. When a vendor rejects
+        // that outright — a tools/JSON-mode conflict, or a schema its constrained
+        // decoder will not accept — the recovery is to ask for the same object in
+        // words instead: drop `response_format` and spell the JSON Schema into the
+        // system prompt, letting coerceJsonToSchema recover the object from text.
+        //
+        // Ported from GenerationHandler's `promptJsonInstruction` fallback, which
+        // runs this on the ai-package path. That path is unreachable for every
+        // provider driven by this loop — GMI Cloud's MiniMax endpoint, the one it
+        // was written for, is a Tier-2 catalog provider on this very base class —
+        // so without this the recovery would simply not happen for it.
+        let loop;
+        try {
+            loop = await runLoop(conversation, responseFormat);
+        }
+        catch (error) {
+            const recoverable = responseFormat !== undefined &&
+                (isToolsSchemaConflictError(error) || isSchemaComplexityError(error));
+            if (!recoverable) {
+                throw error;
+            }
+            logger.warn(`[${this.providerName}] provider rejected response_format — retrying with the schema in the system prompt`, { provider: this.providerName, model: modelId });
+            loop = await runLoop(appendJsonSchemaInstruction(conversation, responseFormat.schema), undefined);
+        }
+        // The vendor can also IGNORE `response_format` and answer in prose without
+        // erroring at all — GMI Cloud's MiniMax endpoint does exactly that, and it
+        // is the case the fallback was written for. On the ai-package path the
+        // structured-output parser threw on the unparseable answer, so the catch
+        // above was reached; the native loop has no such parser, so the silent
+        // case sailed through and handed the caller prose. Same recovery, keyed on
+        // the result rather than on an exception.
+        if (responseFormat !== undefined &&
+            options.schema !== undefined &&
+            !yieldsSchemaValidObject(loop.text, options.schema)) {
+            logger.warn(`[${this.providerName}] response_format did not yield a schema-valid object — retrying with the schema in the system prompt`, { provider: this.providerName, model: modelId });
+            loop = await runLoop(appendJsonSchemaInstruction(conversation, responseFormat.schema), undefined);
+        }
+        const { text, finishReason, toolsUsed } = loop;
+        const inputTokens = loop.inputTokens;
+        const outputTokens = loop.outputTokens;
+        // stopReason / stepsUsed parity with the other native loops (Vertex
+        // Gemini / Claude / Bedrock) and with the ai-package path this replaced.
+        // Without them a consumer cannot tell a completed turn from one the step
+        // cap truncated: the turn that ends on a `tool-calls` finish with the
+        // budget spent is exactly the case the caller configured `maxSteps` to
+        // bound, and reporting it as a plain completion hides that.
+        const stepsUsed = loop.steps;
+        const stopReason = stepsUsed >= (options.maxSteps || DEFAULT_MAX_STEPS) &&
+            finishReason === "tool-calls"
+            ? "step-cap"
+            : finishReason === "error"
+                ? "provider-error"
+                : "completed";
+        const enhanced = {
+            content: text,
+            provider: this.providerName,
+            model: modelId,
+            finishReason,
+            stopReason,
+            stepsUsed,
+            usage: {
+                input: inputTokens,
+                output: outputTokens,
+                total: inputTokens + outputTokens,
+                // doGenerate reads prompt_tokens_details.cached_tokens, and the loop
+                // carries the counters out; discarding them here billed cached input
+                // at the full rate in calculateCost and made cache effectiveness
+                // invisible. Anthropic's native path already forwards both.
+                ...(loop.cacheReadTokens
+                    ? { cacheReadTokens: loop.cacheReadTokens }
+                    : {}),
+                ...(loop.cacheWriteTokens
+                    ? { cacheCreationTokens: loop.cacheWriteTokens }
+                    : {}),
+            },
+            responseTime: Date.now() - startTime,
+            toolsUsed,
+            toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
+            enhancedWithTools: toolsUsed.length > 0,
+        };
+        return this.finalizeNativeGenerate(enhanced, options, startTime);
+    }
     async executeStream(options, _analysisSchema) {
         this.validateStreamOptions(options);
         const startTime = Date.now();

package/dist/providers/providerTypeUtils.d.ts

@@ -1,6 +1,5 @@
 import type { StreamTextResult } from "../types/index.js";
 import type { LanguageModel } from "../types/index.js";
-import type { streamText } from "../utils/generation.js";
 /**
  * Extract the model identifier from a LanguageModel value.
  *
@@ -20,4 +19,4 @@ export declare function getModelId(model: LanguageModel, fallback?: string): str
  * `toolResults`, `toolCalls`) exists on the SDK result with compatible types.
  * This function performs the structural down-cast without `as any`.
  */
-export declare function toAnalyticsStreamResult(result: ReturnType<typeof streamText>): StreamTextResult;
+export declare function toAnalyticsStreamResult(result: StreamTextResult | Record<string, unknown>): StreamTextResult;

package/dist/providers/providerTypeUtils.js

@@ -32,7 +32,11 @@ export function getModelId(model, fallback = "unknown") {
  * `toolResults`, `toolCalls`) exists on the SDK result with compatible types.
  * This function performs the structural down-cast without `as any`.
  */
-export function toAnalyticsStreamResult(result) {
+export function toAnalyticsStreamResult(
+// Was `ReturnType<typeof streamText>`. Nothing calls streamText any more —
+// every streaming path is native — so the parameter is the structural
+// superset this narrows FROM, stated directly.
+result) {
     // The AI SDK v6 result is a structural superset of our StreamTextResult.
     // Both use PromiseLike for async fields and compatible usage shapes
     // (extractTokenUsage handles both v4 and v6 field names).