@juspay/neurolink 9.54.6 → 9.54.8

package/dist/providers/googleVertex.js

@@ -23,6 +23,7 @@ import { convertZodToJsonSchema, inlineJsonSchema, } from "../utils/schemaConver
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, normalizeToolsForJsonSchemaProvider, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 import { getModelId } from "./providerTypeUtils.js";
 // Import proper types for multimodal message handling
@@ -857,23 +858,19 @@ export class GoogleVertexProvider extends BaseProvider {
     async maybeExecuteNativeGemini3ToolStream(options, analysisSchema, modelName) {
         const wantsStructuredOutput = analysisSchema || options.output?.format === "json" || options.schema;
         const shouldUseTools = !options.disableTools && this.supportsTools() && !wantsStructuredOutput;
-        const optionTools = options.tools || {};
-        const sdkTools = shouldUseTools ? await this.getAllTools() : {};
-        const combinedToolCount = Object.keys(optionTools).length + Object.keys(sdkTools).length;
-        const hasTools = shouldUseTools && combinedToolCount > 0;
+        const tools = options.tools || {};
+        const hasTools = shouldUseTools && Object.keys(tools).length > 0;
         if (!isGemini3Model(modelName) || !hasTools) {
             return null;
         }
         const processedOptions = await this.processCSVFilesForNativeSDK(options);
         const mergedOptions = {
             ...processedOptions,
-            tools: { ...sdkTools, ...optionTools },
+            tools: tools,
         };
         logger.info("[GoogleVertex] Routing Gemini 3 to native SDK for tool calling", {
             model: modelName,
-            optionToolCount: Object.keys(optionTools).length,
-            sdkToolCount: Object.keys(sdkTools).length,
-            totalToolCount: combinedToolCount,
+            optionToolCount: Object.keys(tools).length,
         });
         return this.executeNativeGemini3Stream(mergedOptions);
     }
@@ -933,9 +930,8 @@ export class GoogleVertexProvider extends BaseProvider {
     }
     async resolveAISDKStreamTools(options, modelName, functionTag) {
         const shouldUseTools = !options.disableTools && this.supportsTools();
-        const baseStreamTools = shouldUseTools ? await this.getAllTools() : {};
         const rawTools = shouldUseTools
-            ? { ...baseStreamTools, ...(options.tools || {}) }
+            ? options.tools
             : {};
         const isAnthropic = isAnthropicModel(modelName);
         let tools;
@@ -963,8 +959,7 @@ export class GoogleVertexProvider extends BaseProvider {
         }
         logger.debug(`${functionTag}: Tools for streaming`, {
             shouldUseTools,
-            baseToolCount: Object.keys(baseStreamTools).length,
-            externalToolCount: Object.keys(options.tools || {}).length,
+            externalToolCount: Object.keys(options.tools ?? {}).length,
             toolCount: Object.keys(tools ?? {}).length,
             toolNames: Object.keys(tools ?? {}),
         });
@@ -972,7 +967,7 @@ export class GoogleVertexProvider extends BaseProvider {
             shouldUseTools,
             tools,
             isAnthropic,
-            baseToolCount: Object.keys(baseStreamTools).length,
+            baseToolCount: 0,
         };
     }
     buildAISDKStreamOptions(params) {
@@ -1075,6 +1070,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 id: toolResult.toolCallId ?? toolResult.toolName,
             });
         }
+        // Emit tool:end for each completed tool result so Pipeline B
+        // captures telemetry for AI-SDK-driven tool calls (gap S2).
+        emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
             logger.warn("[GoogleVertexProvider] Failed to store tool executions", {
                 provider: this.providerName,
@@ -1516,6 +1514,31 @@ export class GoogleVertexProvider extends BaseProvider {
                 requestDuration: responseTime,
                 timestamp: new Date().toISOString(),
             });
+            // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
+            // observation. The native @google/genai stream path on Vertex bypasses the
+            // Vercel AI SDK so experimental_telemetry is never injected; we emit manually.
+            const vertexStreamEmitter = this.neurolink?.getEventEmitter();
+            if (vertexStreamEmitter) {
+                vertexStreamEmitter.emit("generation:end", {
+                    provider: this.providerName,
+                    responseTime,
+                    timestamp: Date.now(),
+                    result: {
+                        content: "",
+                        usage: {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            total: totalInputTokens + totalOutputTokens,
+                        },
+                        model: params.modelName,
+                        provider: this.providerName,
+                        finishReason: step >= params.maxSteps && !completedWithFinalAnswer
+                            ? "max_steps"
+                            : "stop",
+                    },
+                    success: true,
+                });
+            }
             params.channel.close();
         }
         catch (error) {
@@ -1563,14 +1586,13 @@ export class GoogleVertexProvider extends BaseProvider {
                 logger.warn("[GoogleVertex] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request.");
                 shouldUseTools = false;
             }
-            const sdkTools = shouldUseTools ? await this.getAllTools() : {};
-            const combinedTools = shouldUseTools
-                ? { ...sdkTools, ...(options.tools || {}) }
+            const tools = shouldUseTools
+                ? (options.tools ?? {})
                 : {};
             let toolsConfig;
             let executeMap = new Map();
-            if (Object.keys(combinedTools).length > 0) {
-                const result = buildNativeToolDeclarations(combinedTools);
+            if (Object.keys(tools).length > 0) {
+                const result = buildNativeToolDeclarations(tools);
                 toolsConfig = result.toolsConfig;
                 executeMap = result.executeMap;
                 logger.debug("[GoogleVertex] Converted tools for native SDK generate", {
@@ -1661,6 +1683,29 @@ export class GoogleVertexProvider extends BaseProvider {
             span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
             span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
             span.setAttribute(ATTR.GEN_AI_FINISH_REASON, step >= maxSteps ? "max_steps" : "stop");
+            // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
+            // observation. The native @google/genai path on Vertex bypasses the Vercel
+            // AI SDK so experimental_telemetry is never injected; we emit manually.
+            const vertexGenerateEmitter = this.neurolink?.getEventEmitter();
+            if (vertexGenerateEmitter) {
+                vertexGenerateEmitter.emit("generation:end", {
+                    provider: this.providerName,
+                    responseTime,
+                    timestamp: Date.now(),
+                    result: {
+                        content: finalText,
+                        usage: {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            total: totalInputTokens + totalOutputTokens,
+                        },
+                        model: modelName,
+                        provider: this.providerName,
+                        finishReason: step >= maxSteps ? "max_steps" : "stop",
+                    },
+                    success: true,
+                });
+            }
             // Build EnhancedGenerateResult
             return {
                 content: finalText,
@@ -1760,24 +1805,18 @@ export class GoogleVertexProvider extends BaseProvider {
         const wantsStructuredOutput = options.output?.format === "json" || !!options.schema;
         // Check if we should use native SDK for Gemini 3 with tools
         const shouldUseTools = !options.disableTools && this.supportsTools() && !wantsStructuredOutput;
-        const sdkTools = shouldUseTools ? await this.getAllTools() : {};
-        const hasTools = shouldUseTools &&
-            (Object.keys(sdkTools).length > 0 ||
-                (options.tools && Object.keys(options.tools).length > 0));
+        const hasTools = shouldUseTools && options.tools && Object.keys(options.tools).length > 0;
         if (isGemini3Model(modelName) && hasTools && !wantsStructuredOutput) {
             // Process CSV files before routing to native SDK (bypasses normal message builder)
             const processedOptions = await this.processCSVFilesForNativeSDK(options);
             // Merge SDK tools into options for native SDK path
             const mergedOptions = {
                 ...processedOptions,
-                tools: { ...sdkTools, ...(processedOptions.tools || {}) },
+                tools: options.tools || {},
             };
             logger.info("[GoogleVertex] Routing Gemini 3 generate to native SDK for tool calling", {
                 model: modelName,
-                sdkToolCount: Object.keys(sdkTools).length,
-                optionToolCount: Object.keys(processedOptions.tools || {}).length,
-                totalToolCount: Object.keys(sdkTools).length +
-                    Object.keys(processedOptions.tools || {}).length,
+                totalToolCount: Object.keys(mergedOptions.tools ?? {}).length,
             });
             return this.executeNativeGemini3Generate(mergedOptions);
         }

package/dist/providers/huggingFace.js

@@ -3,6 +3,7 @@ import { NoOutputGeneratedError, stepCountIs, streamText, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { createHuggingFaceConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -141,6 +142,7 @@ export class HuggingFaceProvider extends BaseProvider {
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[HuggingFaceProvider] Failed to store tool executions", {
                             provider: this.providerName,

package/dist/providers/litellm.js

@@ -7,6 +7,7 @@ import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { isAbortError } from "../utils/errorHandling.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { calculateCost } from "../utils/pricing.js";
 import { getProviderModel } from "../utils/providerConfig.js";
@@ -190,6 +191,7 @@ export class LiteLLMProvider extends BaseProvider {
                     chunkCount++;
                 },
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     logger.info("Tool execution completed", { toolResults, toolCalls });
                     for (const toolCall of toolCalls) {
                         collectedToolCalls.push({

package/dist/providers/mistral.js

@@ -4,6 +4,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { createMistralConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -69,6 +70,7 @@ export class MistralProvider extends BaseProvider {
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[MistralProvider] Failed to store tool executions", {
                             provider: this.providerName,

package/dist/providers/ollama.js

@@ -9,6 +9,7 @@ import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { InvalidModelError, NetworkError, ProviderError, } from "../types/index.js";
 import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { TimeoutError } from "../utils/timeout.js";
 // Model version constants (configurable via environment)
 const DEFAULT_OLLAMA_MODEL = process.env.OLLAMA_MODEL || "llama3.1:8b";
@@ -743,13 +744,22 @@ export class OllamaProvider extends BaseProvider {
                     content: options.input.text,
                 });
             }
+            // Capture instance references before the stream for use in the finally block.
+            const ollamaNeurolink = this.neurolink;
+            const ollamaProviderName = this.providerName;
+            const ollamaModelName = this.modelName || FALLBACK_OLLAMA_MODEL;
             // Conversation loop for multi-step tool execution
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            let lastFinishReason;
+            let ollamaStreamErrored = false;
             const stream = new ReadableStream({
                 start: async (controller) => {
                     try {
                         while (iteration < maxIterations) {
                             logger.debug(`[OllamaProvider] Conversation iteration ${iteration + 1}/${maxIterations}`);
-                            // Make API request
+                            // Make API request — request usage in stream_options so
+                            // Pipeline B gets real token counts for Langfuse cost dashboards.
                             const response = await proxyFetch(`${this.baseUrl}/v1/chat/completions`, {
                                 method: "POST",
                                 headers: { "Content-Type": "application/json" },
@@ -759,6 +769,7 @@ export class OllamaProvider extends BaseProvider {
                                     tools: ollamaTools,
                                     tool_choice: "auto",
                                     stream: true,
+                                    stream_options: { include_usage: true },
                                     temperature: options.temperature,
                                     max_tokens: options.maxTokens,
                                 }),
@@ -768,7 +779,15 @@ export class OllamaProvider extends BaseProvider {
                                 throw this.handleProviderError(await createOllamaHttpError(response));
                             }
                             // Process response stream
-                            const { content, toolCalls, finishReason } = await this.processOllamaResponse(response, controller);
+                            const { content, toolCalls, finishReason, usage } = await this.processOllamaResponse(response, controller);
+                            // Accumulate usage across iterations for Pipeline B
+                            if (usage) {
+                                totalInputTokens += usage.input;
+                                totalOutputTokens += usage.output;
+                            }
+                            if (finishReason) {
+                                lastFinishReason = finishReason;
+                            }
                             // Add assistant message to history
                             const assistantMessage = {
                                 role: "assistant",
@@ -822,20 +841,53 @@ export class OllamaProvider extends BaseProvider {
                             }
                         }
                         if (iteration >= maxIterations) {
+                            ollamaStreamErrored = true;
                             controller.error(new Error(`Ollama conversation exceeded maximum iterations (${maxIterations})`));
                         }
                     }
                     catch (error) {
+                        ollamaStreamErrored = true;
                         controller.error(error);
                     }
                     finally {
-                        // Resolve analytics with final values now that the loop has completed.
-                        resolveAnalytics(createAnalytics(this.providerName, this.modelName || FALLBACK_OLLAMA_MODEL, { usage: { input: 0, output: 0, total: 0 } }, Date.now() - startTime, {
+                        // Resolve analytics with accumulated token counts so Pipeline A
+                        // and Pipeline B both get real usage data from Ollama.
+                        const aggregatedUsage = {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            total: totalInputTokens + totalOutputTokens,
+                        };
+                        resolveAnalytics(createAnalytics(this.providerName, this.modelName || FALLBACK_OLLAMA_MODEL, { usage: aggregatedUsage }, Date.now() - startTime, {
                             requestId: `ollama-stream-${Date.now()}`,
                             streamingMode: true,
                             iterations: iteration,
-                            note: "Token usage not available from Ollama streaming responses",
                         }));
+                        // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
+                        // observation. Ollama bypasses the Vercel AI SDK so
+                        // experimental_telemetry is never injected; we emit manually.
+                        const ollamaEmitter = ollamaNeurolink?.getEventEmitter();
+                        if (ollamaEmitter) {
+                            // Collect accumulated text from conversation history
+                            const accumulatedContent = conversationHistory
+                                .filter((m) => m.role === "assistant")
+                                .map((m) => m.content)
+                                .join("");
+                            ollamaEmitter.emit("generation:end", {
+                                provider: ollamaProviderName,
+                                responseTime: Date.now() - startTime,
+                                timestamp: Date.now(),
+                                result: {
+                                    content: accumulatedContent,
+                                    usage: aggregatedUsage,
+                                    model: ollamaModelName,
+                                    provider: ollamaProviderName,
+                                    finishReason: ollamaStreamErrored
+                                        ? "error"
+                                        : (lastFinishReason ?? "stop"),
+                                },
+                                success: !ollamaStreamErrored,
+                            });
+                        }
                     }
                 },
             });
@@ -1075,6 +1127,7 @@ export class OllamaProvider extends BaseProvider {
         let aggregatedContent = "";
         let aggregatedToolCalls = [];
         let finalFinishReason;
+        let finalUsage;
         try {
             while (true) {
                 const { done, value } = await reader.read();
@@ -1092,6 +1145,19 @@ export class OllamaProvider extends BaseProvider {
                         }
                         try {
                             const parsed = JSON.parse(dataLine);
+                            // OpenAI-compatible usage chunk (Ollama may include usage
+                            // in the final chunk when stream_options.include_usage is set,
+                            // or as a standalone chunk with empty choices).
+                            const parsedUsage = parsed.usage;
+                            if (parsedUsage) {
+                                const input = parsedUsage.prompt_tokens ?? 0;
+                                const output = parsedUsage.completion_tokens ?? 0;
+                                finalUsage = {
+                                    input,
+                                    output,
+                                    total: parsedUsage.total_tokens ?? input + output,
+                                };
+                            }
                             const processed = this.processOllamaStreamData(parsed);
                             if (!processed) {
                                 continue;
@@ -1129,6 +1195,7 @@ export class OllamaProvider extends BaseProvider {
             content: aggregatedContent || undefined,
             toolCalls: aggregatedToolCalls.length > 0 ? aggregatedToolCalls : undefined,
             finishReason: finalFinishReason,
+            usage: finalUsage,
         };
     }
     /**
@@ -1413,6 +1480,18 @@ export class OllamaProvider extends BaseProvider {
                 });
             }
         }
+        // Emit tool:end for each completed tool result so Pipeline B
+        // captures telemetry for Ollama-driven tool calls (gap S2).
+        emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResultsForStorage.map((tr) => {
+            const hasError = tr.result && typeof tr.result === "object" && "error" in tr.result;
+            return {
+                toolName: tr.toolName,
+                result: tr.result,
+                error: hasError
+                    ? String(tr.result.error)
+                    : undefined,
+            };
+        }));
         // Store tool executions (similar to Bedrock)
         this.handleToolExecutionStorage(toolCallsForStorage, toolResultsForStorage, options, new Date()).catch((error) => {
             logger.warn("[OllamaProvider] Failed to store tool executions", {

package/dist/providers/openAI.d.ts

@@ -42,6 +42,8 @@ export declare class OpenAIProvider extends BaseProvider {
      * Validate tool structure for OpenAI compatibility
      * More lenient validation to avoid filtering out valid tools
      */
+    /** Shared helper: mark a stream span as ERROR, record the exception, and end it. */
+    private endStreamSpanWithError;
     private isValidToolStructure;
     /**
      * Validate tool parameters for OpenAI compatibility

package/dist/providers/openAI.js

@@ -13,6 +13,7 @@ import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/
 import { isZodSchema } from "../utils/schemaConversion.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { getModelId } from "./providerTypeUtils.js";
 /**
  * Retrieve a tool's schema, handling both AI SDK v6 (`inputSchema`) and
@@ -154,6 +155,17 @@ export class OpenAIProvider extends BaseProvider {
      * Validate tool structure for OpenAI compatibility
      * More lenient validation to avoid filtering out valid tools
      */
+    /** Shared helper: mark a stream span as ERROR, record the exception, and end it. */
+    endStreamSpanWithError(span, error) {
+        span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: error instanceof Error ? error.message : String(error),
+        });
+        if (error instanceof Error) {
+            span.recordException(error);
+        }
+        span.end();
+    }
     isValidToolStructure(tool) {
         if (!tool || typeof tool !== "object") {
             return false;
@@ -337,6 +349,9 @@ export class OpenAIProvider extends BaseProvider {
                             toolResults,
                             toolCalls,
                         });
+                        // Emit tool:end for each completed tool result so Pipeline B
+                        // captures telemetry for AI-SDK-driven tool calls (gap S2).
+                        emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                         // Handle tool execution storage
                         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                             logger.warn("[OpenAIProvider] Failed to store tool executions", {
@@ -348,7 +363,7 @@ export class OpenAIProvider extends BaseProvider {
                 });
             }
             catch (streamError) {
-                streamSpan.end();
+                this.endStreamSpanWithError(streamSpan, streamError);
                 throw streamError;
             }
             // Collect token usage and finish reason asynchronously when the stream completes,
@@ -381,11 +396,7 @@ export class OpenAIProvider extends BaseProvider {
                 streamSpan.end();
             })
                 .catch((err) => {
-                streamSpan.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: err instanceof Error ? err.message : String(err),
-                });
-                streamSpan.end();
+                this.endStreamSpanWithError(streamSpan, err);
             });
             timeoutController?.cleanup();
             // Debug the actual result structure

package/dist/providers/openRouter.js

@@ -6,6 +6,7 @@ import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { isAbortError } from "../utils/errorHandling.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -273,6 +274,7 @@ export class OpenRouterProvider extends BaseProvider {
                     chunkCount++;
                 },
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     logger.info("Tool execution completed", {
                         toolCallCount: toolCalls?.length || 0,
                         toolResultCount: toolResults?.length || 0,

package/dist/providers/openaiCompatible.js

@@ -4,6 +4,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
@@ -197,6 +198,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: (event) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), event.toolResults);
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {
                             provider: this.providerName,

package/dist/providers/sagemaker/detection.d.ts

@@ -4,38 +4,7 @@
  * This module provides intelligent detection of SageMaker endpoint capabilities
  * including model type identification and streaming protocol support.
  */
-import type { SageMakerConfig, SageMakerModelConfig, StreamingCapability } from "../../types/index.js";
-/**
- * Model type detection result
- */
-type ModelDetectionResult = {
-    /** Primary model type */
-    type: StreamingCapability["modelType"];
-    /** Detection confidence (0-1) */
-    confidence: number;
-    /** Evidence used for detection */
-    evidence: string[];
-    /** Suggested configuration */
-    suggestedConfig?: Partial<SageMakerModelConfig>;
-};
-/**
- * Endpoint health and metadata information
- */
-type EndpointHealth = {
-    /** Health status */
-    status: "healthy" | "unhealthy" | "unknown";
-    /** Response time in milliseconds */
-    responseTime: number;
-    /** Endpoint metadata if available */
-    metadata?: Record<string, unknown>;
-    /** Model information if discoverable */
-    modelInfo?: {
-        name?: string;
-        version?: string;
-        framework?: string;
-        architecture?: string;
-    };
-};
+import type { EndpointHealth, ModelDetectionResult, SageMakerConfig, StreamingCapability } from "../../types/index.js";
 /**
  * SageMaker Model Detection and Capability Discovery Service
  */
@@ -150,4 +119,3 @@ export declare class SageMakerDetector {
  * Create a detector instance with configuration
  */
 export declare function createSageMakerDetector(config: SageMakerConfig): SageMakerDetector;
-export {};

package/dist/providers/sagemaker/diagnostics.d.ts

@@ -3,30 +3,7 @@
  *
  * Provides basic diagnostic functions for SageMaker configuration and connectivity.
  */
-/**
- * Simple diagnostic result interface
- */
-type DiagnosticResult = {
-    name: string;
-    category: "configuration" | "connectivity" | "streaming";
-    status: "pass" | "fail" | "warning";
-    message: string;
-    details?: string;
-    recommendation?: string;
-};
-/**
- * Diagnostic report interface
- */
-type DiagnosticReport = {
-    overallStatus: "healthy" | "issues" | "critical";
-    results: DiagnosticResult[];
-    summary: {
-        total: number;
-        passed: number;
-        failed: number;
-        warnings: number;
-    };
-};
+import type { DiagnosticReport } from "../../types/index.js";
 /**
  * Run quick diagnostics for SageMaker configuration
  */
@@ -35,4 +12,3 @@ export declare function runQuickDiagnostics(endpoint?: string): Promise<Diagnost
  * Format diagnostic report for console output
  */
 export declare function formatDiagnosticReport(report: DiagnosticReport): string;
-export {};

package/dist/providers/sagemaker/language-model.d.ts

@@ -4,7 +4,7 @@
  * This module implements the LanguageModel interface for Amazon SageMaker
  * integration with the Vercel AI SDK.
  */
-import type { SageMakerAsLanguageModel, SageMakerConfig, SageMakerModelConfig, ConnectivityResult } from "../../types/index.js";
+import type { ConnectivityResult, SageMakerAsLanguageModel, SageMakerConfig, SageMakerModelConfig } from "../../types/index.js";
 /**
  * SageMaker Language Model implementing LanguageModel interface
  *

package/dist/proxy/proxyConfig.js

@@ -136,6 +136,10 @@ function failOnUnresolvedAccountCredentials(obj) {
             "Set the required environment variables or provide defaults with ${VAR:-default}.");
     }
 }
+// ---------------------------------------------------------------------------
+// YAML parsing (dynamic import with fallback)
+// ---------------------------------------------------------------------------
+/** Shape of the dynamically-imported `js-yaml` module. */
 /**
  * Parse YAML content into a JS object.
  * Uses `js-yaml` if available (dynamic import), otherwise falls back to

package/dist/proxy/proxyEnv.d.ts

@@ -1,19 +1,3 @@
-type ProxyEnvSource = "cli" | "environment" | "default" | "none";
-type ProxyEnvResolution = {
-    path?: string;
-    source: ProxyEnvSource;
-    required: boolean;
-};
-type ProxyEnvLoadResult = {
-    loaded: boolean;
-    path?: string;
-    source: ProxyEnvSource;
-};
-type ProxyEnvOptions = {
-    explicitEnvFile?: string;
-    env?: NodeJS.ProcessEnv;
-    homeDir?: string;
-};
+import type { ProxyEnvLoadResult, ProxyEnvOptions, ProxyEnvResolution } from "../types/index.js";
 export declare function resolveProxyEnvFile(options?: ProxyEnvOptions): ProxyEnvResolution;
 export declare function loadProxyEnvFile(options?: ProxyEnvOptions): Promise<ProxyEnvLoadResult>;
-export {};