@juspay/neurolink 9.41.0 → 9.42.0

package/dist/lib/observability/otelBridge.d.ts

@@ -2,7 +2,7 @@
  * OpenTelemetry Bridge
  * Bidirectional context propagation between NeuroLink and OpenTelemetry
  */
-import { type SpanContext } from "@opentelemetry/api";
+import { type Context, type SpanContext } from "@opentelemetry/api";
 import type { SpanData } from "./types/spanTypes.js";
 import { type SpanType } from "./types/spanTypes.js";
 /**
@@ -18,7 +18,7 @@ export declare class OtelBridge {
     /**
      * Inject trace context into outgoing request headers
      */
-    injectContext(headers: Record<string, string>): Record<string, string>;
+    injectContext(headers: Record<string, string>, otelContext?: Context): Record<string, string>;
     /**
      * Create a NeuroLink span from OpenTelemetry context
      */

package/dist/lib/observability/otelBridge.js

@@ -15,15 +15,24 @@ export class OtelBridge {
      * Extract trace context from incoming request headers
      */
     extractContext(headers) {
-        const extractedContext = propagation.extract(context.active(), headers);
+        // Normalize traceparent: OTel HTTP auto-instrumentation may inject a second traceparent
+        // on top of the SDK's manually injected one, producing "val1, val2". The W3C spec rejects
+        // multiple values, causing extraction to silently return null. Take the first value only.
+        const normalizedHeaders = { ...headers };
+        if (typeof normalizedHeaders["traceparent"] === "string" &&
+            normalizedHeaders["traceparent"].includes(", ")) {
+            normalizedHeaders["traceparent"] =
+                normalizedHeaders["traceparent"].split(", ")[0];
+        }
+        const extractedContext = propagation.extract(context.active(), normalizedHeaders);
         const spanContext = trace.getSpanContext(extractedContext);
         return spanContext ?? null;
     }
     /**
      * Inject trace context into outgoing request headers
      */
-    injectContext(headers) {
-        propagation.inject(context.active(), headers);
+    injectContext(headers, otelContext = context.active()) {
+        propagation.inject(otelContext, headers);
         return headers;
     }
     /**

package/dist/lib/providers/amazonBedrock.js

@@ -1002,8 +1002,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                             });
                             if (firstStopReason === "tool_use") {
                                 const toolNames = firstMessageContent
-                                    .filter((b) => b.toolUse?.name)
-                                    .map((b) => b.toolUse.name)
+                                    .flatMap((b) => (b.toolUse?.name ? [b.toolUse.name] : []))
                                     .join(", ");
                                 streamSpan.addEvent("stream.tool_use", {
                                     iteration: 0,
@@ -1029,8 +1028,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                             });
                             if (stopReason === "tool_use") {
                                 const toolNames = assistantMessage.content
-                                    .filter((b) => b.toolUse?.name)
-                                    .map((b) => b.toolUse.name)
+                                    .flatMap((b) => (b.toolUse?.name ? [b.toolUse.name] : []))
                                     .join(", ");
                                 streamSpan.addEvent("stream.tool_use", {
                                     iteration,

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

@@ -1,17 +1,21 @@
 import { type LanguageModel } from "ai";
 import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { TextGenerationOptions, EnhancedGenerateResult } from "../types/generateTypes.js";
+import type { EnhancedGenerateResult, TextGenerationOptions } from "../types/generateTypes.js";
+import type { AnthropicProviderConfig } from "../types/providers.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { AnthropicAuthMethod, AnthropicResponseMetadata, ClaudeSubscriptionTier, ClaudeUsageInfo } from "../types/subscriptionTypes.js";
 import type { ValidationSchema } from "../types/typeAliases.js";
-import type { ClaudeSubscriptionTier, AnthropicAuthMethod, AnthropicResponseMetadata, ClaudeUsageInfo } from "../types/subscriptionTypes.js";
-import type { AnthropicProviderConfig } from "../types/providers.js";
 /**
  * Beta headers for Claude Code integration.
  * These enable experimental features:
  * - claude-code-20250219: Claude Code specific features
- * - interleaved-thinking-2025-05-14: Interleaved thinking mode
  * - fine-grained-tool-streaming-2025-05-14: Fine-grained tool streaming
+ *
+ * Note: interleaved-thinking-2025-05-14 was removed — it was claude-3-7-sonnet
+ * specific and causes invalid_request_error (HTTP 400) on claude-4 models
+ * (claude-opus-4-6, claude-sonnet-4-6) which handle thinking via the
+ * `thinking` request body parameter instead.
  */
 declare const ANTHROPIC_BETA_HEADERS: {
     "anthropic-beta": string;
@@ -140,6 +144,6 @@ export declare class AnthropicProvider extends BaseProvider {
     isAvailable(): Promise<boolean>;
     getModel(): LanguageModel;
 }
-export { ModelAccessError, isModelAvailableForTier, getRecommendedModelForTier, getModelCapabilities, } from "../models/anthropicModels.js";
+export { getModelCapabilities, getRecommendedModelForTier, isModelAvailableForTier, ModelAccessError, } from "../models/anthropicModels.js";
 export { ANTHROPIC_BETA_HEADERS };
 export default AnthropicProvider;

package/dist/lib/providers/anthropic.js

@@ -1,34 +1,37 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { stepCountIs, streamText } from "ai";
-import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
-import { AnthropicModels } from "../constants/enums.js";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { ANTHROPIC_TOKEN_URL, CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_CLIENT_ID, } from "../auth/anthropicOAuth.js";
+import { AnthropicModels, TOKEN_EXPIRY_BUFFER_MS, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { getModelCapabilities, getRecommendedModelForTier, isModelAvailableForTier, } from "../models/anthropicModels.js";
+import { createOAuthFetch } from "../proxy/oauthFetch.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { logger } from "../utils/logger.js";
 import { calculateCost } from "../utils/pricing.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { isModelAvailableForTier, getRecommendedModelForTier, getModelCapabilities, } from "../models/anthropicModels.js";
-import { CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_CLIENT_ID, ANTHROPIC_TOKEN_URL, } from "../auth/anthropicOAuth.js";
-import { createOAuthFetch } from "../proxy/oauthFetch.js";
-import { homedir } from "os";
-import { readFileSync, existsSync, writeFileSync, mkdirSync, renameSync, } from "fs";
-import { join } from "path";
-import { TOKEN_EXPIRY_BUFFER_MS } from "../constants/enums.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { getModelId } from "./providerTypeUtils.js";
 /**
  * Beta headers for Claude Code integration.
  * These enable experimental features:
  * - claude-code-20250219: Claude Code specific features
- * - interleaved-thinking-2025-05-14: Interleaved thinking mode
  * - fine-grained-tool-streaming-2025-05-14: Fine-grained tool streaming
+ *
+ * Note: interleaved-thinking-2025-05-14 was removed — it was claude-3-7-sonnet
+ * specific and causes invalid_request_error (HTTP 400) on claude-4 models
+ * (claude-opus-4-6, claude-sonnet-4-6) which handle thinking via the
+ * `thinking` request body parameter instead.
  */
 const ANTHROPIC_BETA_HEADERS = {
     "anthropic-beta": [
         "claude-code-20250219",
-        "interleaved-thinking-2025-05-14",
         "fine-grained-tool-streaming-2025-05-14",
     ].join(","),
 };
@@ -155,7 +158,9 @@ const detectAuthMethod = (oauthToken) => {
         logger.warn("[detectAuthMethod] ANTHROPIC_AUTH_METHOD=oauth but no OAuth token found; falling through to auto-detection");
     }
     else if (explicit) {
-        logger.warn("[detectAuthMethod] Unrecognized ANTHROPIC_AUTH_METHOD value; falling through to auto-detection", { value: explicit });
+        logger.warn("[detectAuthMethod] Unrecognized ANTHROPIC_AUTH_METHOD value; falling through to auto-detection", {
+            value: explicit,
+        });
     }
     // Auto-detect: OAuth takes precedence if available
     const method = oauthToken ? "oauth" : "api_key";
@@ -762,7 +767,7 @@ export class AnthropicProvider extends BaseProvider {
                     maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
                     tools,
                     stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
-                    toolChoice: shouldUseTools ? "auto" : "none",
+                    toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
@@ -857,7 +862,7 @@ export class AnthropicProvider extends BaseProvider {
     }
 }
 // Re-export types and utilities for convenience
-export { ModelAccessError, isModelAvailableForTier, getRecommendedModelForTier, getModelCapabilities, } from "../models/anthropicModels.js";
+export { getModelCapabilities, getRecommendedModelForTier, isModelAvailableForTier, ModelAccessError, } from "../models/anthropicModels.js";
 // Export beta headers constant for external use
 export { ANTHROPIC_BETA_HEADERS };
 export default AnthropicProvider;

package/dist/lib/providers/anthropicBaseProvider.d.ts

@@ -1,8 +1,8 @@
-import type { ZodType } from "zod";
 import { type LanguageModel, type Schema } from "ai";
-import { AIProviderName } from "../constants/enums.js";
-import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { ZodType } from "zod";
+import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 /**
  * Anthropic provider implementation using BaseProvider pattern
  * Migrated from direct API calls to Vercel AI SDK (@ai-sdk/anthropic)

package/dist/lib/providers/anthropicBaseProvider.js

@@ -1,13 +1,14 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { NoOutputGeneratedError, streamText, } from "ai";
-import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
-import { AIProviderName, AnthropicModels } from "../constants/enums.js";
+import { AnthropicModels } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { logger } from "../utils/logger.js";
 import { calculateCost } from "../utils/pricing.js";
+import { createAnthropicBaseConfig, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { validateApiKey, createAnthropicBaseConfig, } from "../utils/providerConfig.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { getModelId } from "./providerTypeUtils.js";
 const streamTracer = trace.getTracer("neurolink.provider.anthropic");
 /**
@@ -90,7 +91,7 @@ export class AnthropicProviderV2 extends BaseProvider {
                     maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
                     maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
                     tools,
-                    toolChoice: shouldUseTools ? "auto" : "none",
+                    toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {

package/dist/lib/providers/azureOpenai.d.ts

@@ -1,6 +1,6 @@
 import { type LanguageModel } from "ai";
+import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { AIProviderName } from "../constants/enums.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 export declare class AzureOpenAIProvider extends BaseProvider {
     private apiKey;

package/dist/lib/providers/azureOpenai.js

@@ -1,12 +1,13 @@
 import { createAzure } from "@ai-sdk/azure";
 import { stepCountIs, streamText } from "ai";
+import { APIVersions } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { AIProviderName, APIVersions } from "../constants/enums.js";
-import { validateApiKey, createAzureAPIKeyConfig, createAzureEndpointConfig, } from "../utils/providerConfig.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { logger } from "../utils/logger.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { logger } from "../utils/logger.js";
+import { createAzureAPIKeyConfig, createAzureEndpointConfig, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 export class AzureOpenAIProvider extends BaseProvider {
     apiKey;
     resourceName;
@@ -108,7 +109,7 @@ export class AzureOpenAIProvider extends BaseProvider {
                     ? { temperature: options.temperature }
                     : {}),
                 tools,
-                toolChoice: shouldUseTools ? "auto" : "none",
+                toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                 stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),

package/dist/lib/providers/googleAiStudio.js

@@ -11,6 +11,7 @@ import { logger } from "../utils/logger.js";
 import { isGemini3Model } from "../utils/modelDetection.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
@@ -473,6 +474,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
+            const collectedToolCalls = [];
+            const collectedToolResults = [];
             const result = await streamText({
                 model,
                 messages: messages,
@@ -480,7 +483,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools,
                 stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
-                toolChoice: shouldUseTools ? "auto" : "none",
+                toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 // Gemini 3: use thinkingLevel via providerOptions
@@ -502,6 +505,28 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     },
                 }),
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    for (const toolCall of toolCalls) {
+                        collectedToolCalls.push({
+                            toolCallId: toolCall.toolCallId,
+                            toolName: toolCall.toolName,
+                            args: toolCall.args ??
+                                toolCall.input ??
+                                toolCall
+                                    .parameters ??
+                                {},
+                        });
+                    }
+                    for (const toolResult of toolResults) {
+                        const rawToolResult = toolResult;
+                        collectedToolResults.push({
+                            toolName: toolResult.toolName,
+                            status: rawToolResult.error ? "failure" : "success",
+                            output: (rawToolResult.output ??
+                                rawToolResult.result) ?? undefined,
+                            error: rawToolResult.error,
+                            id: rawToolResult.toolCallId ?? toolResult.toolName,
+                        });
+                    }
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[GoogleAiStudioProvider] Failed to store tool executions", {
                             provider: this.providerName,
@@ -530,6 +555,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
+                ...(shouldUseTools && {
+                    toolCalls: collectedToolCalls,
+                    toolResults: collectedToolResults,
+                }),
                 analytics: analyticsPromise,
                 metadata: {
                     startTime,

package/dist/lib/providers/googleVertex.js

@@ -22,6 +22,7 @@ import { createGoogleAuthConfig, createVertexProjectConfig, validateApiKey, } fr
 import { convertZodToJsonSchema, inlineJsonSchema, } from "../utils/schemaConversion.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 import { getModelId } from "./providerTypeUtils.js";
 // Import proper types for multimodal message handling
@@ -856,6 +857,8 @@ export class GoogleVertexProvider extends BaseProvider {
             const maxTokens = shouldSetMaxTokens
                 ? options.maxTokens // No default limit
                 : undefined;
+            const collectedToolCalls = [];
+            const collectedToolResults = [];
             // Build complete stream options with proper typing
             let streamOptions = {
                 model: model,
@@ -867,7 +870,7 @@ export class GoogleVertexProvider extends BaseProvider {
                     tools &&
                     Object.keys(tools).length > 0 && {
                     tools,
-                    toolChoice: "auto",
+                    toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
@@ -911,6 +914,28 @@ export class GoogleVertexProvider extends BaseProvider {
                 },
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     logger.info("Tool execution completed", { toolResults, toolCalls });
+                    for (const toolCall of toolCalls) {
+                        collectedToolCalls.push({
+                            toolCallId: toolCall.toolCallId,
+                            toolName: toolCall.toolName,
+                            args: toolCall.args ??
+                                toolCall.input ??
+                                toolCall
+                                    .parameters ??
+                                {},
+                        });
+                    }
+                    for (const toolResult of toolResults) {
+                        const rawToolResult = toolResult;
+                        collectedToolResults.push({
+                            toolName: toolResult.toolName,
+                            status: rawToolResult.error ? "failure" : "success",
+                            output: (rawToolResult.output ??
+                                rawToolResult.result) ?? undefined,
+                            error: rawToolResult.error,
+                            id: rawToolResult.toolCallId ?? toolResult.toolName,
+                        });
+                    }
                     // Handle tool execution storage
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[GoogleVertexProvider] Failed to store tool executions", {
@@ -1011,16 +1036,13 @@ export class GoogleVertexProvider extends BaseProvider {
                 .finally(() => timeoutController?.cleanup());
             // Transform string stream to content object stream using BaseProvider method
             const transformedStream = this.createTextStream(result);
-            // Track tool calls and results for streaming
-            const toolCalls = [];
-            const toolResults = [];
             return {
                 stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 ...(shouldUseTools && {
-                    toolCalls,
-                    toolResults,
+                    toolCalls: collectedToolCalls,
+                    toolResults: collectedToolResults,
                 }),
             };
         }

package/dist/lib/providers/huggingFace.d.ts

@@ -1,8 +1,8 @@
+import { type LanguageModel, type Schema } from "ai";
 import type { ZodType } from "zod";
-import { type Schema, type LanguageModel } from "ai";
-import { AIProviderName } from "../constants/enums.js";
-import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 /**
  * HuggingFace Provider - BaseProvider Implementation
  * Using AI SDK with HuggingFace's OpenAI-compatible endpoint

package/dist/lib/providers/huggingFace.js

@@ -1,12 +1,12 @@
 import { createOpenAI } from "@ai-sdk/openai";
 import { NoOutputGeneratedError, stepCountIs, streamText, } from "ai";
-import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { logger } from "../utils/logger.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { validateApiKey, createHuggingFaceConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { logger } from "../utils/logger.js";
+import { createHuggingFaceConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 // Configuration helpers - now using consolidated utility
 const getHuggingFaceApiKey = () => {
     return validateApiKey(createHuggingFaceConfig());
@@ -136,9 +136,7 @@ export class HuggingFaceProvider extends BaseProvider {
                 tools: (shouldUseTools
                     ? streamOptions.tools || allTools
                     : {}),
-                toolChoice: (shouldUseTools
-                    ? streamOptions.toolChoice || "auto"
-                    : "none"),
+                toolChoice: resolveToolChoice(options, (shouldUseTools ? streamOptions.tools || allTools : {}), shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
@@ -203,7 +201,7 @@ export class HuggingFaceProvider extends BaseProvider {
             prompt: options.input.text,
             system: enhancedSystemPrompt,
             tools: formattedTools,
-            toolChoice: formattedTools ? "auto" : undefined,
+            toolChoice: formattedTools ? (options.toolChoice ?? "auto") : undefined,
         };
     }
     /**

package/dist/lib/providers/litellm.js

@@ -1,6 +1,6 @@
 import { createOpenAI } from "@ai-sdk/openai";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
-import { NoOutputGeneratedError, Output, streamText, } from "ai";
+import { NoOutputGeneratedError, Output, streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
@@ -10,7 +10,8 @@ import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { calculateCost } from "../utils/pricing.js";
 import { getProviderModel } from "../utils/providerConfig.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { getModelId } from "./providerTypeUtils.js";
 const streamTracer = trace.getTracer("neurolink.provider.litellm");
 // Configuration helpers
@@ -59,7 +60,7 @@ export class LiteLLMProvider extends BaseProvider {
             apiKey: config.apiKey,
             fetch: createProxyFetch(),
         });
-        this.model = customOpenAI(this.modelName || getDefaultLiteLLMModel());
+        this.model = customOpenAI.chat(this.modelName || getDefaultLiteLLMModel());
         logger.debug("LiteLLM Provider initialized", {
             modelName: this.modelName,
             provider: this.providerName,
@@ -85,18 +86,15 @@ export class LiteLLMProvider extends BaseProvider {
         // Check for timeout by error name and message as fallback
         const errorRecord = error;
         if (errorRecord?.name === "TimeoutError" ||
-            (typeof errorRecord?.message === "string" &&
-                errorRecord.message.toLowerCase().includes("timeout"))) {
+            (typeof errorRecord?.message === "string" && errorRecord.message.toLowerCase().includes("timeout"))) {
             return new NetworkError(`Request timed out: ${errorRecord?.message || "Unknown timeout"}`, this.providerName);
         }
         if (typeof errorRecord?.message === "string") {
-            if (errorRecord.message.includes("ECONNREFUSED") ||
-                errorRecord.message.includes("Failed to fetch")) {
+            if (errorRecord.message.includes("ECONNREFUSED") || errorRecord.message.includes("Failed to fetch")) {
                 return new NetworkError("LiteLLM proxy server not available. Please start the LiteLLM proxy server at " +
                     `${process.env.LITELLM_BASE_URL || "http://localhost:4000"}`, this.providerName);
             }
-            if (errorRecord.message.includes("API_KEY_INVALID") ||
-                errorRecord.message.includes("Invalid API key")) {
+            if (errorRecord.message.includes("API_KEY_INVALID") || errorRecord.message.includes("Invalid API key")) {
                 return new AuthenticationError("Invalid LiteLLM configuration. Please check your LITELLM_API_KEY environment variable.", this.providerName);
             }
             if (errorRecord.message.toLowerCase().includes("rate limit")) {
@@ -133,9 +131,7 @@ export class LiteLLMProvider extends BaseProvider {
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
             // Get tools - options.tools is pre-merged by BaseProvider.stream()
             const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools
-                ? options.tools || (await this.getAllTools())
-                : {};
+            const tools = shouldUseTools ? options.tools || (await this.getAllTools()) : {};
             logger.debug(`LiteLLM: Tools for streaming`, {
                 shouldUseTools,
                 toolCount: Object.keys(tools).length,
@@ -160,7 +156,7 @@ export class LiteLLMProvider extends BaseProvider {
                 ...(shouldUseTools &&
                     Object.keys(tools).length > 0 && {
                     tools,
-                    toolChoice: "auto",
+                    toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
@@ -186,6 +182,26 @@ export class LiteLLMProvider extends BaseProvider {
                 },
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     logger.info("Tool execution completed", { toolResults, toolCalls });
+                    for (const toolCall of toolCalls) {
+                        collectedToolCalls.push({
+                            toolCallId: toolCall.toolCallId,
+                            toolName: toolCall.toolName,
+                            args: toolCall.args ??
+                                toolCall.input ??
+                                toolCall.parameters ??
+                                {},
+                        });
+                    }
+                    for (const toolResult of toolResults) {
+                        const rawToolResult = toolResult;
+                        collectedToolResults.push({
+                            toolName: toolResult.toolName,
+                            status: rawToolResult.error ? "failure" : "success",
+                            output: (rawToolResult.output ?? rawToolResult.result) ?? undefined,
+                            error: rawToolResult.error,
+                            id: rawToolResult.toolCallId ?? toolResult.toolName,
+                        });
+                    }
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[LiteLLMProvider] Failed to store tool executions", {
                             provider: this.providerName,
@@ -219,15 +235,15 @@ export class LiteLLMProvider extends BaseProvider {
                 },
             });
             let result;
+            const collectedToolCalls = [];
+            const collectedToolResults = [];
             try {
                 result = streamText(streamOptions);
             }
             catch (streamError) {
                 streamSpan.setStatus({
                     code: SpanStatusCode.ERROR,
-                    message: streamError instanceof Error
-                        ? streamError.message
-                        : String(streamError),
+                    message: streamError instanceof Error ? streamError.message : String(streamError),
                 });
                 streamSpan.end();
                 throw streamError;
@@ -294,9 +310,7 @@ export class LiteLLMProvider extends BaseProvider {
                                     yield { content: textDelta };
                                 }
                             }
-                            else if ("type" in chunk &&
-                                chunk.type === "tool-call" &&
-                                "toolCallId" in chunk) {
+                            else if ("type" in chunk && chunk.type === "tool-call" && "toolCallId" in chunk) {
                                 // Tool call event - log for debugging
                                 const toolCallId = String(chunk.toolCallId);
                                 const toolName = "toolName" in chunk ? String(chunk.toolName) : "unknown";
@@ -323,14 +337,17 @@ export class LiteLLMProvider extends BaseProvider {
             })();
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
-                requestId: options.requestId ??
-                    `litellm-stream-${Date.now()}`,
+                requestId: options.requestId ?? `litellm-stream-${Date.now()}`,
                 streamingMode: true,
             });
             return {
                 stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
+                ...(shouldUseTools && {
+                    toolCalls: collectedToolCalls,
+                    toolResults: collectedToolResults,
+                }),
                 analytics: analyticsPromise,
                 metadata: {
                     startTime,
@@ -351,9 +368,7 @@ export class LiteLLMProvider extends BaseProvider {
         const { embed: aiEmbed } = await import("ai");
         const { createOpenAI } = await import("@ai-sdk/openai");
         const config = getLiteLLMConfig();
-        const embeddingModelName = modelName ||
-            process.env.LITELLM_EMBEDDING_MODEL ||
-            "gemini-embedding-001";
+        const embeddingModelName = modelName || process.env.LITELLM_EMBEDDING_MODEL || "gemini-embedding-001";
         const customOpenAI = createOpenAI({
             baseURL: config.baseURL,
             apiKey: config.apiKey,
@@ -371,9 +386,7 @@ export class LiteLLMProvider extends BaseProvider {
         const { embedMany: aiEmbedMany } = await import("ai");
         const { createOpenAI } = await import("@ai-sdk/openai");
         const config = getLiteLLMConfig();
-        const embeddingModelName = modelName ||
-            process.env.LITELLM_EMBEDDING_MODEL ||
-            "gemini-embedding-001";
+        const embeddingModelName = modelName || process.env.LITELLM_EMBEDDING_MODEL || "gemini-embedding-001";
         const customOpenAI = createOpenAI({
             baseURL: config.baseURL,
             apiKey: config.apiKey,
@@ -392,8 +405,7 @@ export class LiteLLMProvider extends BaseProvider {
         const now = Date.now();
         // Check if cached models are still valid
         if (LiteLLMProvider.modelsCache.length > 0 &&
-            now - LiteLLMProvider.modelsCacheTime <
-                LiteLLMProvider.MODELS_CACHE_DURATION) {
+            now - LiteLLMProvider.modelsCacheTime < LiteLLMProvider.MODELS_CACHE_DURATION) {
             logger.debug(`[${functionTag}] Using cached models`, {
                 cacheAge: Math.round((now - LiteLLMProvider.modelsCacheTime) / 1000),
                 modelCount: LiteLLMProvider.modelsCache.length,

package/dist/lib/providers/mistral.js

@@ -7,6 +7,7 @@ import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { logger } from "../utils/logger.js";
 import { createMistralConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
 // Configuration helpers - now using consolidated utility
 const getMistralApiKey = () => {
@@ -63,7 +64,7 @@ export class MistralProvider extends BaseProvider {
                 maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools,
                 stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
-                toolChoice: shouldUseTools ? "auto" : "none",
+                toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {