@juspay/neurolink 12.12.13 → 12.12.14

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/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/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.14",
   "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": {