@juspay/neurolink 12.14.1 → 12.14.3

package/dist/neurolink.js

@@ -4159,6 +4159,22 @@ Current user's request: ${currentInput}`;
             middleware: options.middleware,
             conversationMessages: options.conversationMessages,
             credentials: options.credentials,
+            // Extended thinking. Every provider gates it on `thinkingConfig`, so
+            // omitting the field here meant it never reached one: the request went
+            // out with no thinking block and the result carried no reasoning, with
+            // nothing raised to say the option had been discarded. This is the same
+            // failure the note above records for `disableInternalFallback` — an
+            // allowlist that silently swallows a documented option.
+            //
+            // `thinkingConfig` is the only one of the documented thinking options
+            // that `GenerateOptions` actually declares. `thinking`, `thinkingBudget`
+            // and `thinkingLevel` are folded into a `thinkingConfig` only by the CLI,
+            // in `src/lib/utils/thinkingConfig.ts`; nothing on the SDK path does that
+            // merge. They exist solely on the internal `TextGenerationOptions`, so no
+            // caller can pass them through
+            // generate() today. Declaring them is a public-type decision and is
+            // deliberately left out of this fix.
+            thinkingConfig: options.thinkingConfig,
             // Lifecycle callbacks must reach the provider so non-AI-SDK paths
             // (Vertex's native @google/genai, native Bedrock, Ollama, etc.) can
             // invoke them directly. Pipeline A also still receives them via the

package/dist/providers/anthropic/client.js

@@ -292,6 +292,12 @@ const messagesToAnthropic = (msgs) => {
             }
             case "assistant": {
                 const blocks = [];
+                // Extended thinking must come back byte-identical — signature
+                // included — or Anthropic rejects the turn, and the loop replays this
+                // message on every tool step. Blocks are emitted in content order
+                // rather than hoisted: `interleaved-thinking-2025-05-14` (requested in
+                // the beta header) lets thinking appear between tool calls, so
+                // reordering would corrupt the chain it validates.
                 for (const part of partsOf(msg.content)) {
                     if (typeof part === "string") {
                         if (part.length > 0) {
@@ -300,6 +306,29 @@ const messagesToAnthropic = (msgs) => {
                         continue;
                     }
                     const p = part;
+                    if (p?.type === "reasoning") {
+                        const meta = p.providerOptions?.anthropic;
+                        const redacted = meta?.redactedData;
+                        if (typeof redacted === "string" && redacted.length > 0) {
+                            blocks.push({ type: "redacted_thinking", data: redacted });
+                            continue;
+                        }
+                        const signature = meta?.signature;
+                        // Both halves required, matching loopAdapter's check on the
+                        // streaming path: Anthropic rejects a thinking block that is
+                        // unsigned, and equally one whose text is empty. Reasoning from a
+                        // provider that never produced a signature (a reasoner model's
+                        // plain text) is not an Anthropic thinking block at all, and an
+                        // empty one carries nothing worth replaying — either way, dropping
+                        // it beats sending a block that will be refused.
+                        if (typeof signature === "string" &&
+                            signature.length > 0 &&
+                            typeof p.text === "string" &&
+                            p.text.length > 0) {
+                            blocks.push({ type: "thinking", thinking: p.text, signature });
+                        }
+                        continue;
+                    }
                     if (p?.type === "text" && typeof p.text === "string") {
                         if (p.text.length > 0) {
                             const cc = cacheControlOf(p);
@@ -1118,15 +1147,28 @@ export class AnthropicProvider extends BaseProvider {
                         ? { topP: options.topP }
                         : {}),
                 }, "anthropic.doGenerate");
+                // Dropping a caller's explicit sampling parameters is exactly the
+                // kind of silent discard this change fixes elsewhere, so say so.
+                if (thinking &&
+                    (samplingParams.temperature !== undefined ||
+                        samplingParams.topP !== undefined)) {
+                    logger.debug("[anthropic] extended thinking is enabled, so temperature/top_p are omitted — Anthropic rejects any temperature but 1 while thinking is set");
+                }
                 const params = {
                     model: modelId,
                     messages: cachedMessages,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxOutputTokens),
                     ...(system ? { system } : {}),
-                    ...(samplingParams.temperature !== undefined
+                    // Extended thinking fixes sampling: Anthropic rejects any
+                    // temperature but 1 while `thinking` is set, and does not honour
+                    // top_p there. The CLI always sends a default temperature, so
+                    // forwarding it alongside thinking turns a call that used to work
+                    // into a 400. Drop the sampling knobs for exactly those turns and
+                    // let Anthropic's thinking defaults stand.
+                    ...(!thinking && samplingParams.temperature !== undefined
                         ? { temperature: samplingParams.temperature }
                         : {}),
-                    ...(samplingParams.topP !== undefined
+                    ...(!thinking && samplingParams.topP !== undefined
                         ? { top_p: samplingParams.topP }
                         : {}),
                     ...(options.stopSequences && options.stopSequences.length > 0
@@ -1187,7 +1229,29 @@ export class AnthropicProvider extends BaseProvider {
                 let jsonToolAnswered = false;
                 for (const block of response.content) {
                     if (block.type === "thinking") {
-                        content.push({ type: "reasoning", text: block.thinking });
+                        // The signature rides along in providerOptions because Anthropic
+                        // rejects a replayed thinking block without it, and the tool loop
+                        // pushes this part straight back into the conversation.
+                        content.push({
+                            type: "reasoning",
+                            text: block.thinking,
+                            providerOptions: {
+                                anthropic: { signature: block.signature },
+                            },
+                        });
+                    }
+                    else if (block.type === "redacted_thinking") {
+                        // Encrypted reasoning: no readable text, but it must still be
+                        // replayed verbatim or the turn is rejected.
+                        content.push({
+                            type: "reasoning",
+                            text: "",
+                            providerOptions: {
+                                anthropic: {
+                                    redactedData: block.data,
+                                },
+                            },
+                        });
                     }
                     else if (block.type === "text") {
                         // In forced-json mode the payload arrives via the tool input, not
@@ -1824,6 +1888,9 @@ export class AnthropicProvider extends BaseProvider {
                 const streamSamplingParams = resolveSamplingParams("anthropic", modelId, options.temperature !== undefined && options.temperature !== null
                     ? { temperature: options.temperature }
                     : {}, "anthropic.executeStream");
+                if (thinking && streamSamplingParams.temperature !== undefined) {
+                    logger.debug("[anthropic] extended thinking is enabled, so temperature is omitted on the stream path — Anthropic rejects any temperature but 1 while thinking is set");
+                }
                 return {
                     model: modelId,
                     messages: cachedConversation,
@@ -1833,7 +1900,9 @@ export class AnthropicProvider extends BaseProvider {
                     // the adapter immediately overwrites — and forced this whole params
                     // object into the streaming variant for a field it does not own.
                     ...(payload.system ? { system: payload.system } : {}),
-                    ...(streamSamplingParams.temperature !== undefined
+                    // Same constraint on the streaming path: a temperature alongside
+                    // `thinking` is rejected outright.
+                    ...(!thinking && streamSamplingParams.temperature !== undefined
                         ? { temperature: streamSamplingParams.temperature }
                         : {}),
                     ...(cachedTools && cachedTools.length > 0

package/dist/providers/openaiChatCompletionsClient.js

@@ -387,6 +387,118 @@ export const v3ToolChoiceToOpenAI = (choice, toolNameToWire) => {
             };
     }
 };
+/**
+ * OpenAI's strict structured-output mode rejects a schema unless every object
+ * node carries `additionalProperties: false` AND lists every one of its
+ * properties in `required` — recursively, including through array `items`.
+ * A plain JSON Schema satisfies neither, so sending one with `strict: true`
+ * fails the request outright rather than degrading.
+ *
+ * Adding `additionalProperties: false` is safe: it forbids keys the caller
+ * never asked for, which strict mode would forbid anyway. Filling in
+ * `required` is NOT safe — it would silently make the caller's optional
+ * fields mandatory. So when a schema still has optional properties after
+ * normalisation, the request drops to `strict: false`, which OpenAI accepts
+ * and which honours optionality. Callers whose schemas are already strict-
+ * compatible keep the stronger guarantee.
+ */
+// `properties` and `$defs` are MAPS of schemas, not schemas — recursing into
+// them as if they were nodes silently skips every child, which is exactly the
+// bug that let a nested object through without `additionalProperties: false`.
+const SCHEMA_MAPS = [
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+];
+const SCHEMA_NODES = [
+    "items",
+    "prefixItems",
+    "anyOf",
+    "oneOf",
+    "allOf",
+    "not",
+    "then",
+    "else",
+];
+// OpenAI's strict mode does not accept these composition keywords. A schema
+// carrying one cannot be sent with `strict: true` at all, so it is not merely
+// "not yet normalised" — it must drop to non-strict, where the schema is
+// honoured as written.
+const STRICT_UNSUPPORTED = ["allOf", "not", "if", "then", "else"];
+const mapValues = (obj, fn) => Object.fromEntries(Object.entries((obj ?? {})).map(([k, v]) => [
+    k,
+    fn(v),
+]));
+const withClosedObjects = (node) => {
+    if (Array.isArray(node)) {
+        return node.map(withClosedObjects);
+    }
+    if (!node || typeof node !== "object") {
+        return node;
+    }
+    const next = {
+        ...node,
+    };
+    for (const key of SCHEMA_MAPS) {
+        if (key in next) {
+            next[key] = mapValues(next[key], withClosedObjects);
+        }
+    }
+    for (const key of SCHEMA_NODES) {
+        if (key in next) {
+            next[key] = withClosedObjects(next[key]);
+        }
+    }
+    // A schema-valued `additionalProperties` is itself a schema (the index/value
+    // pattern) and its nested objects need closing too. A boolean one is a flag
+    // and must be left exactly as the caller wrote it.
+    if (next.additionalProperties &&
+        typeof next.additionalProperties === "object") {
+        next.additionalProperties = withClosedObjects(next.additionalProperties);
+    }
+    else if (next.type === "object" && !("additionalProperties" in next)) {
+        // Closed whether or not it declares `properties`: strict mode requires the
+        // key on EVERY object, including an empty one.
+        next.additionalProperties = false;
+    }
+    return next;
+};
+/**
+ * True when the schema can legally be sent with `strict: true`: every object
+ * node lists all of its properties as required, every object is closed, and
+ * no composition keyword OpenAI rejects appears anywhere.
+ *
+ * Deliberately conservative — a false negative costs only the stronger
+ * guarantee, while a false positive costs the whole request.
+ */
+const satisfiesStrictRequired = (node) => {
+    if (Array.isArray(node)) {
+        return node.every(satisfiesStrictRequired);
+    }
+    if (!node || typeof node !== "object") {
+        return true;
+    }
+    const rec = node;
+    if (STRICT_UNSUPPORTED.some((k) => k in rec)) {
+        return false;
+    }
+    if (rec.type === "object") {
+        if (rec.additionalProperties !== false) {
+            return false;
+        }
+        const names = Object.keys((rec.properties ?? {}));
+        const required = Array.isArray(rec.required)
+            ? rec.required
+            : [];
+        if (names.some((n) => !required.includes(n))) {
+            return false;
+        }
+    }
+    const mapsOk = SCHEMA_MAPS.filter((k) => k in rec).every((k) => Object.values((rec[k] ?? {})).every(satisfiesStrictRequired));
+    const nodesOk = SCHEMA_NODES.filter((k) => k in rec).every((k) => satisfiesStrictRequired(rec[k]));
+    return mapsOk && nodesOk;
+};
 export const v3ResponseFormatToOpenAI = (rf) => {
     if (rf.type === "text") {
         return { type: "text" };
@@ -394,13 +506,38 @@ export const v3ResponseFormatToOpenAI = (rf) => {
     if (!rf.schema) {
         return { type: "json_object" };
     }
+    // Mutate as little as possible, in this order:
+    //
+    //   1. already strict-legal  -> send it UNTOUCHED with strict: true
+    //   2. legal once closed     -> send the closed copy with strict: true
+    //   3. neither               -> send it UNTOUCHED with strict: false
+    //
+    // Case 3 is why closure is not applied unconditionally. Non-strict mode
+    // honours the schema exactly as written, so injecting
+    // `additionalProperties: false` there would silently change the caller's
+    // contract — and for a composition it can make the schema unsatisfiable:
+    // closing two `allOf` members that declare different properties leaves no
+    // object able to satisfy both. Leaving case 3 untouched also means
+    // non-OpenAI endpoints in this family, which may not implement OpenAI's
+    // strict contract at all, see exactly the schema the caller wrote.
+    //
+    // Case 1 matters for parity: a Zod schema whose properties are all required
+    // already converts to a strict-legal shape, so it goes out byte-identical to
+    // what it did before this change.
+    const original = rf.schema;
+    const closed = withClosedObjects(original);
+    const schema = satisfiesStrictRequired(original)
+        ? original
+        : satisfiesStrictRequired(closed)
+            ? closed
+            : original;
     return {
         type: "json_schema",
         json_schema: {
             name: rf.name ?? "response",
-            schema: rf.schema,
+            schema: schema,
             ...(rf.description ? { description: rf.description } : {}),
-            strict: true,
+            strict: satisfiesStrictRequired(schema),
         },
     };
 };

package/dist/types/aiCompat.d.ts

@@ -275,6 +275,7 @@ export type LanguageModelV3Content = {
 } | {
     type: "reasoning";
     text: string;
+    providerOptions?: Record<string, Record<string, unknown>>;
 } | {
     type: "file";
     data: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.14.1",
+  "version": "12.14.3",
   "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": {
@@ -110,6 +110,7 @@
     "test:new-providers": "pnpm exec tsx test/continuous-test-suite-new-providers.ts",
     "test:matrix": "pnpm exec tsx test/continuous-test-suite-provider-matrix.ts",
     "test:matrix:cli": "pnpm exec tsx test/continuous-test-suite-provider-matrix-cli.ts",
+    "test:thinking-config": "pnpm exec tsx test/continuous-test-suite-sdk-thinking-config.ts",
     "test:mcp:spans": "pnpm exec tsx test/continuous-test-suite-mcp-spans.ts",
     "test:mcp:infra": "pnpm exec tsx test/continuous-test-suite-mcp-infra.ts",
     "test:vendor-recovery": "pnpm exec tsx test/continuous-test-suite-native-vendor-recovery.ts",
@@ -179,10 +180,10 @@
     "docs:validate": "tsx tools/content/documentationSync.ts --validate",
     "docs:generate": "pnpm run docs:validate",
     "// Documentation (Docusaurus)": "",
-    "docs:start": "pnpm --filter ./docs-site start",
-    "docs:build": "pnpm --filter ./docs-site build",
-    "docs:serve": "pnpm --filter ./docs-site serve",
-    "docs:clear": "pnpm --filter ./docs-site clear",
+    "docs:start": "pnpm --dir docs-site start",
+    "docs:build": "pnpm --dir docs-site build",
+    "docs:serve": "pnpm --dir docs-site serve",
+    "docs:clear": "pnpm --dir docs-site clear",
     "// Proxy Observability (Local OpenObserve)": "",
     "proxy:observability:setup": "bash scripts/observability/manage-local-openobserve.sh setup",
     "proxy:observability:up": "bash scripts/observability/manage-local-openobserve.sh up",