@juspay/neurolink 12.12.0 → 12.12.1

package/dist/core/nativeGenerateLoop.js

@@ -13,6 +13,7 @@
  * share this: the v3 result shape (`content` parts, `finishReason`, `usage`) is
  * the same across Anthropic, the OpenAI-compatible family and SageMaker.
  */
+import { logger } from "../utils/logger.js";
 import { guardToolExecutor } from "./toolExecutionGuards.js";
 /**
  * Narrow a model handle to the delegating shape this loop drives.
@@ -104,10 +105,19 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
     let steps = 0;
     // One bounded recovery re-ask per turn; see the empty-tool-calls branch.
     let reasked = false;
+    // True only while the NEXT step is the recovery re-ask. `reasked` stays set
+    // for the rest of the turn, so it cannot distinguish "this step is the
+    // re-ask" from "the re-ask already happened" — and degrading a later,
+    // unrelated failure would swallow a real error.
+    let reaskPending = false;
+    // The turn as it stood before the re-ask. The re-ask is a bonus request on
+    // top of a call that already produced a result, so if it fails the honest
+    // answer is that result — not a thrown turn.
+    let preReask;
     const hasTools = Boolean(args.tools && args.tools.length > 0);
     for (let step = 0; step < args.maxSteps; step++) {
         steps = step + 1;
-        const res = await args.runStep(() => args.doGenerate({
+        const runThisStep = () => args.runStep(() => args.doGenerate({
             prompt: args.conversation,
             ...(args.tools && args.tools.length > 0 ? { tools: args.tools } : {}),
             // The v3 call option is an OBJECT — `{ type: "none" }`. Passing the
@@ -120,7 +130,9 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
                 : args.toolChoice !== undefined
                     ? { toolChoice: args.toolChoice }
                     : {}),
-            ...(args.responseFormat ? { responseFormat: args.responseFormat } : {}),
+            ...(args.responseFormat
+                ? { responseFormat: args.responseFormat }
+                : {}),
             ...(args.providerOptions
                 ? { providerOptions: args.providerOptions }
                 : {}),
@@ -132,6 +144,30 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
                 : {}),
             ...(args.abortSignal ? { abortSignal: args.abortSignal } : {}),
         }));
+        let res;
+        try {
+            res = await runThisStep();
+        }
+        catch (stepError) {
+            // Ported from GenerationHandler.recoverEmptyToolCallsFinish's catch: a
+            // failed re-ask hands back the turn that already succeeded rather than
+            // turning a degraded turn into a thrown one. The native port made the
+            // re-ask a `continue`, so the failure surfaced from the NEXT step's
+            // doGenerate and propagated instead.
+            if (reaskPending && preReask) {
+                logger.warn("toolChoice: none re-ask failed; returning the original result", {
+                    error: stepError instanceof Error
+                        ? stepError.message
+                        : String(stepError),
+                });
+                text = preReask.text;
+                finishReason = preReask.finishReason;
+                rawFinishReason = preReask.rawFinishReason;
+                break;
+            }
+            throw stepError;
+        }
+        reaskPending = false;
         const parts = asParts(res.content);
         // Each step REPLACES the text rather than appending: the final step's
         // answer is the turn's answer, matching what generateText reported.
@@ -177,6 +213,8 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
                 step + 1 < args.maxSteps;
             if (emptyToolCallsFinish) {
                 reasked = true;
+                reaskPending = true;
+                preReask = { text, finishReason, rawFinishReason };
                 args.conversation.push({ role: "assistant", content: parts });
                 continue;
             }

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -20,9 +20,6 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { LanguageModel, OpenAICompatBuildBodyArgs, OpenAICompatChatMessage, OpenAICompatChatRequest, OpenAICompatChatTool, OpenAICompatResponseFormat, OpenAICompatStreamLifecycleListeners, Schema, EnhancedGenerateResult, TextGenerationOptions, ValidationSchema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
-/**
- * Abstract HTTP+SSE provider for OpenAI chat-completions-shaped endpoints.
- */
 export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider {
     protected config: {
         baseURL: string;

package/dist/providers/openaiChatCompletionsBase.js

@@ -36,6 +36,7 @@ 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";
@@ -52,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;
@@ -855,14 +869,42 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.12.0",
+  "version": "12.12.1",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {