@juspay/neurolink 12.12.13 → 12.12.15

package/dist/core/baseProvider.js

@@ -1706,9 +1706,12 @@ export class BaseProvider {
             analytics: result.analytics,
             evaluation: result.evaluation,
             audio: result.audio,
-            // Forward reasoning fields populated by the native generate loop from
-            // vendor reasoning parts (DeepSeek `reasoning_content`, Anthropic
-            // thinking, Gemini thought parts, OpenAI o1).
+            // Forward reasoning fields. They are populated by the shared native
+            // generate loop, which serves the OpenAI-compatible, Anthropic and
+            // SageMaker providers (DeepSeek `reasoning_content`, gateway
+            // `reasoning`, Anthropic thinking, OpenAI o-series). Vertex and AI Studio
+            // override generate() and never reach that loop; they report a numeric
+            // `usage.reasoning` token count and leave this text field undefined.
             reasoning: result.reasoning,
             reasoningTokens: result.reasoningTokens,
         };

package/dist/core/nativeToolFormat.js

@@ -16,8 +16,9 @@ export function toNativeToolDeclarations(tools, format) {
         const input_schema = (rawSchema
             ? convertZodToJsonSchema(rawSchema)
             : { type: "object", properties: {} });
-        // Honor a cache breakpoint the caller set on this tool. The direct
-        // Anthropic path marks the last tool itself, on the assembled request.
+        // Honor a cache breakpoint the caller set on this tool. Closing the
+        // stable prefix is a separate step: both Anthropic paths call
+        // `withLastToolCacheBreakpoint` on the assembled array afterwards.
         const cc = cacheControlOf(tool);
         const declaration = {
             name,

package/dist/neurolink.js

@@ -4386,9 +4386,11 @@ Current user's request: ${currentInput}`;
             music: textResult.music,
             ppt: textResult.ppt,
             // Forward reasoning/reasoningTokens from the provider layer.
-            // The native generate loop extracts these from vendor reasoning
+            // The shared native generate loop extracts these from vendor reasoning
             // parts (DeepSeek's `reasoning_content`, Anthropic thinking blocks,
-            // Gemini thought parts, OpenAI o1) and they're declared on
+            // OpenAI o-series) for the providers that use it — OpenAI-compatible,
+            // Anthropic and SageMaker. Vertex and AI Studio override generate() and
+            // leave the text field undefined. They're declared on
             // `GenerateResult`, but the builder previously dropped them on the
             // floor — so callers asking for `result.reasoning` got `undefined`
             // even when the model emitted a chain-of-thought.

package/dist/providers/amazonSagemaker.js

@@ -139,7 +139,67 @@ export class AmazonSageMakerProvider extends BaseProvider {
         if (!hasNativeDoGenerate(model)) {
             throw this.handleProviderError(new Error("sagemaker: model handle exposes no doGenerate()"));
         }
-        const doGenerate = model.doGenerate.bind(model);
+        const doGenerate = async (call) => {
+            const format = call.responseFormat;
+            const result = await model.doGenerate({
+                ...call,
+                ...(call.maxOutputTokens !== undefined
+                    ? { maxTokens: call.maxOutputTokens }
+                    : {}),
+                ...(format?.type === "json"
+                    ? {
+                        responseFormat: format.schema
+                            ? {
+                                type: "json_schema",
+                                json_schema: { name: "response", schema: format.schema },
+                            }
+                            : { type: "json_object" },
+                    }
+                    : {}),
+            });
+            // SageMaker's low-level model retains its legacy result for streaming
+            // and direct consumers. The shared loop consumes V3 content and usage.
+            if (Array.isArray(result.content)) {
+                return result;
+            }
+            const content = [];
+            if (typeof result.text === "string" && result.text) {
+                content.push({ type: "text", text: result.text });
+            }
+            if (typeof result.reasoning === "string" && result.reasoning) {
+                content.push({ type: "reasoning", text: result.reasoning });
+            }
+            for (const call of Array.isArray(result.toolCalls)
+                ? result.toolCalls
+                : []) {
+                if (typeof call !== "object" || call === null) {
+                    continue;
+                }
+                const item = call;
+                const fn = item.function;
+                if (typeof item.id === "string" && typeof fn?.name === "string") {
+                    content.push({
+                        type: "tool-call",
+                        toolCallId: item.id,
+                        toolName: fn.name,
+                        input: fn.arguments ?? "{}",
+                    });
+                }
+            }
+            const usage = result.usage;
+            return {
+                ...result,
+                content,
+                usage: {
+                    inputTokens: {
+                        total: typeof usage?.inputTokens === "number" ? usage.inputTokens : 0,
+                    },
+                    outputTokens: {
+                        total: typeof usage?.outputTokens === "number" ? usage.outputTokens : 0,
+                    },
+                },
+            };
+        };
         const shouldUseTools = !options.disableTools && this.supportsTools();
         const toolsRecord = shouldUseTools
             ? options.tools || {}

package/dist/providers/anthropic/cacheControl.d.ts

@@ -1,9 +1,26 @@
 import type Anthropic from "@anthropic-ai/sdk";
 /**
- * Read an Anthropic cache breakpoint from a message/part/tool carrier.
- * MessageBuilder marks system messages with
- * `providerOptions.anthropic.cacheControl`; the Anthropic client marks the last
- * tool definition on the assembled request. This reader is what honors both.
+ * Default the tool cache boundary to the last tool, unless the caller chose one.
+ *
+ * Tool definitions sit between the system prompt and the conversation and
+ * rarely change, so with no breakpoint closing that prefix the whole tools
+ * block is re-billed as fresh input every turn.
+ *
+ * Call it after every tool mutation — including any appended `final_result`
+ * tool — and before counting markers for the remaining history budget.
+ * Explicit caller markers are preserved, including a non-last boundary.
+ * Both generate and stream apply the same default.
+ *
+ * Pure — returns a new array. A tool that already carries a breakpoint wins.
+ */
+export declare const withLastToolCacheBreakpoint: (tools: Anthropic.Messages.Tool[] | undefined) => Anthropic.Messages.Tool[] | undefined;
+/**
+ * Read an Anthropic cache breakpoint from a message/part/tool carrier that
+ * still carries `providerOptions.anthropic.cacheControl` — i.e. BEFORE
+ * conversion to the Anthropic wire shape. MessageBuilder marks system messages
+ * that way. Tools are marked after conversion, by
+ * `withLastToolCacheBreakpoint`, which reads the wire-shaped `cache_control`
+ * instead; do not use this reader on an assembled tool.
  *
  * Extracted from anthropic/client.ts so `src/lib/core/nativeToolFormat.ts`
  * can share it without importing the provider client (which would create a

package/dist/providers/anthropic/cacheControl.js

@@ -1,8 +1,41 @@
 /**
- * Read an Anthropic cache breakpoint from a message/part/tool carrier.
- * MessageBuilder marks system messages with
- * `providerOptions.anthropic.cacheControl`; the Anthropic client marks the last
- * tool definition on the assembled request. This reader is what honors both.
+ * Default the tool cache boundary to the last tool, unless the caller chose one.
+ *
+ * Tool definitions sit between the system prompt and the conversation and
+ * rarely change, so with no breakpoint closing that prefix the whole tools
+ * block is re-billed as fresh input every turn.
+ *
+ * Call it after every tool mutation — including any appended `final_result`
+ * tool — and before counting markers for the remaining history budget.
+ * Explicit caller markers are preserved, including a non-last boundary.
+ * Both generate and stream apply the same default.
+ *
+ * Pure — returns a new array. A tool that already carries a breakpoint wins.
+ */
+export const withLastToolCacheBreakpoint = (tools) => {
+    if (!tools || tools.length === 0) {
+        return tools;
+    }
+    // Read the ASSEMBLED wire field. An earlier version asked `cacheControlOf`,
+    // which looks at `providerOptions.anthropic.cacheControl` — a shape these
+    // tools no longer have by this point — so the check never fired and a
+    // caller-marked tool got a second, redundant marker.
+    if (tools.some((t) => t.cache_control !== undefined)) {
+        return [...tools];
+    }
+    const last = tools[tools.length - 1];
+    return [
+        ...tools.slice(0, -1),
+        { ...last, cache_control: { type: "ephemeral" } },
+    ];
+};
+/**
+ * Read an Anthropic cache breakpoint from a message/part/tool carrier that
+ * still carries `providerOptions.anthropic.cacheControl` — i.e. BEFORE
+ * conversion to the Anthropic wire shape. MessageBuilder marks system messages
+ * that way. Tools are marked after conversion, by
+ * `withLastToolCacheBreakpoint`, which reads the wire-shaped `cache_control`
+ * instead; do not use this reader on an assembled tool.
  *
  * Extracted from anthropic/client.ts so `src/lib/core/nativeToolFormat.ts`
  * can share it without importing the provider client (which would create a

package/dist/providers/anthropic/client.js

@@ -44,7 +44,7 @@ import { createDeferredAnalytics, stringifyToolInput, } from "../openaiChatCompl
 import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { ANTHROPIC_BETA_HEADERS } from "./constants.js";
-import { cacheControlOf } from "./cacheControl.js";
+import { cacheControlOf, withLastToolCacheBreakpoint } from "./cacheControl.js";
 import { appendFinalResultInstruction, appendFinalResultTool, FINAL_RESULT_TOOL_NAME, } from "./structuredOutput.js";
 // AnthropicProviderConfig is imported from types/providers.ts
 // Re-export for backward compatibility
@@ -1087,23 +1087,9 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 // Extended thinking passthrough (providerOptions.anthropic.thinking).
                 const thinking = options.providerOptions?.anthropic?.thinking;
-                // Close the stable prefix with a breakpoint on the LAST tool. Tool
-                // definitions sit between the system prompt and the conversation and
-                // rarely change, so without this the whole tools block is re-billed
-                // every turn. Applied after every tool mutation above (including the
-                // appended final_result tool) so the marker really is last, and before
-                // the count below so the history budget accounts for it. A caller that
-                // marked a tool itself wins.
-                if (tools && tools.length > 0) {
-                    const alreadyMarked = tools.some((t) => cacheControlOf(t));
-                    if (!alreadyMarked) {
-                        const last = tools[tools.length - 1];
-                        tools = [
-                            ...tools.slice(0, -1),
-                            { ...last, cache_control: { type: "ephemeral" } },
-                        ];
-                    }
-                }
+                // Close the stable prefix with a breakpoint on the last tool. The
+                // stream path does the same, just before its own marker count.
+                tools = withLastToolCacheBreakpoint(tools);
                 // Prompt-cache parity with the native Vertex+Claude path: upstream
                 // layers mark the stable prefix (system via MessageBuilder, and the
                 // last tool just above) — the growing conversation
@@ -1779,12 +1765,17 @@ export class AnthropicProvider extends BaseProvider {
                         }
                     }
                 }
+                // Close the stable prefix with a breakpoint on the last tool, exactly
+                // as the generate path does. This was missing: the marker was applied
+                // only in doGenerate, so a streaming turn re-billed the entire tools
+                // block every step and could not reuse the prefix generate() cached.
+                const cachedTools = withLastToolCacheBreakpoint(anthropicTools);
                 // Prompt-cache parity with the native Vertex+Claude path — rolling
                 // history breakpoints, re-applied per step so the stable prefix stays
                 // byte-identical while the breakpoint follows the growing tail.
                 const cacheMarkersUsed = countAnthropicCacheMarkers({
                     system: payload.system,
-                    tools: anthropicTools,
+                    tools: cachedTools,
                     messages: conversation,
                 });
                 const cachedConversation = applyAnthropicHistoryCacheBreakpoints(conversation, ANTHROPIC_MAX_CACHE_BREAKPOINTS - cacheMarkersUsed);
@@ -1803,8 +1794,8 @@ export class AnthropicProvider extends BaseProvider {
                     ...(streamSamplingParams.temperature !== undefined
                         ? { temperature: streamSamplingParams.temperature }
                         : {}),
-                    ...(anthropicTools && anthropicTools.length > 0
-                        ? { tools: anthropicTools }
+                    ...(cachedTools && cachedTools.length > 0
+                        ? { tools: cachedTools }
                         : {}),
                     ...(anthropicToolChoice ? { tool_choice: anthropicToolChoice } : {}),
                     ...(thinking ? { thinking } : {}),

package/dist/providers/sagemaker/language-model.js

@@ -399,8 +399,8 @@ export class SageMakerLanguageModel {
                 ...(options.maxTokens !== undefined
                     ? { max_new_tokens: options.maxTokens }
                     : {}),
-                temperature: options.temperature || 0.7,
-                top_p: options.topP || 0.9,
+                temperature: options.temperature ?? 0.7,
+                top_p: options.topP ?? 0.9,
                 stop: options.stopSequences || [],
             },
         };
@@ -582,9 +582,14 @@ export class SageMakerLanguageModel {
         // Handle response with tool calls
         if (responseBody.choices && Array.isArray(responseBody.choices)) {
             const choice = responseBody.choices[0];
-            if (choice?.message?.content) {
+            if (typeof choice?.message?.content === "string") {
                 return choice.message.content;
             }
+            // A tool-only assistant turn has no text. Serializing the entire
+            // endpoint response here would replay its envelope as assistant prose.
+            if (choice?.message?.tool_calls?.length) {
+                return "";
+            }
         }
         // Fallback: stringify the entire response
         return JSON.stringify(responseBody);

package/dist/types/service.d.ts

@@ -3,18 +3,6 @@
  * Service registry, dependency injection, and service management types
  */
 import type { UnknownRecord } from "./common.js";
-/**
- * Service factory function type
- */
-export type ServiceFactory<T = unknown> = () => T | Promise<T>;
-/**
- * Service registration configuration
- */
-export type ServiceRegistration<T = unknown> = {
-    factory: ServiceFactory<T>;
-    singleton: boolean;
-    instance?: T;
-};
 /**
  * Service definition with metadata and status
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.12.13",
+  "version": "12.12.15",
   "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": {