@juspay/neurolink 11.5.2 → 11.6.1

package/dist/core/baseProvider.d.ts

@@ -276,9 +276,43 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     protected getToolCallRepairFn(options?: StreamOptions | TextGenerationOptions): ToolCallRepairFunction<ToolSet> | undefined;
     /**
-     * Provider-specific streaming implementation (only used when tools are disabled)
-     */
-    protected abstract executeStream(options: StreamOptions, analysisSchema?: ValidationSchema): Promise<StreamResult>;
+     * Opt-in streaming hook. A provider that produces an async iterable of text
+     * chunks plus promises for how the turn ended implements this and gets a
+     * working `executeStream` for free.
+     *
+     * Deliberately optional rather than abstract: every provider that already
+     * overrides `executeStream` directly — the older and still perfectly valid
+     * pattern — never needs it.
+     *
+     * `finishReason` and `usage` are promises because both are only knowable
+     * once the underlying stream has finished. Resolve them when it does; the
+     * default `executeStream` chains off them rather than waiting for a
+     * consumer, so they must settle even if nobody drains the stream.
+     */
+    protected doStream?(options: StreamOptions): Promise<{
+        stream: AsyncIterable<{
+            content: string;
+        }>;
+        finishReason: Promise<string>;
+        usage: Promise<{
+            inputTokens: number;
+            outputTokens: number;
+        }>;
+        warnings?: string[];
+    }>;
+    /**
+     * Provider-specific streaming implementation (only used when tools are
+     * disabled).
+     *
+     * This used to be `protected abstract`, which meant a provider had exactly
+     * two options: write the whole adapter by hand, or not stream at all. The
+     * failure mode that produced was SageMaker's — a complete, working
+     * `doStream` sitting one property access away from an `executeStream` that
+     * unconditionally threw "not yet fully implemented". Providers that
+     * implement `doStream` now inherit a correct implementation, and providers
+     * that override this method are unaffected.
+     */
+    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     /**
      * Get the provider name
      */

package/dist/core/baseProvider.js

@@ -4,7 +4,9 @@ import { isImageGenerationModel } from "../core/constants.js";
 import { MiddlewareFactory } from "../middleware/factory.js";
 import { modelSupports } from "../models/modelRegistry.js";
 import { ATTR, tracers } from "../telemetry/index.js";
-import { isAbortError, NeuroLinkError } from "../utils/errorHandling.js";
+import { ERROR_CODES, isAbortError, NeuroLinkError, } from "../utils/errorHandling.js";
+import { createAnalytics as buildAnalytics } from "./analytics.js";
+import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { duckTypedStatusCode, extractRetryAfterMsFromError, } from "../utils/providerRetry.js";
 import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "../utils/lifecycleCallbacks.js";
 import { resolveLifecycleTimeoutMs } from "../utils/lifecycleTimeout.js";
@@ -1372,6 +1374,73 @@ export class BaseProvider {
             return createToolCallRepair()(...args);
         });
     }
+    /**
+     * Provider-specific streaming implementation (only used when tools are
+     * disabled).
+     *
+     * This used to be `protected abstract`, which meant a provider had exactly
+     * two options: write the whole adapter by hand, or not stream at all. The
+     * failure mode that produced was SageMaker's — a complete, working
+     * `doStream` sitting one property access away from an `executeStream` that
+     * unconditionally threw "not yet fully implemented". Providers that
+     * implement `doStream` now inherit a correct implementation, and providers
+     * that override this method are unaffected.
+     */
+    async executeStream(options, _analysisSchema) {
+        if (!this.doStream) {
+            throw new NeuroLinkError({
+                code: ERROR_CODES.INVALID_CONFIGURATION,
+                message: `${this.providerName} cannot stream: it neither implements doStream() nor overrides executeStream()`,
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.CRITICAL,
+                retriable: false,
+                context: { provider: this.providerName, model: this.modelName },
+            });
+        }
+        const startTime = Date.now();
+        const { stream, finishReason, usage, warnings } = await this.doStream(options);
+        if (warnings?.length) {
+            logger.warn(`[${this.providerName}] doStream reported warnings`, {
+                provider: this.providerName,
+                count: warnings.length,
+            });
+        }
+        // `metadata` is handed back by reference and filled in when the turn
+        // ends — the documented contract for background-loop streams, since a
+        // result-object spread would snapshot a top-level getter before the
+        // stream has produced anything.
+        const metadata = {
+            startTime,
+            streamId: `${this.providerName}-${startTime}`,
+        };
+        // Chained off the provider's own promises rather than off the consumer
+        // draining the stream. Binding analytics to a stream iterator's finally
+        // block means a caller that awaits analytics without iterating waits
+        // forever, because a generator body does not run until it is iterated.
+        const analytics = (async () => {
+            const [resolvedFinishReason, resolvedUsage] = await Promise.all([
+                finishReason,
+                usage,
+            ]);
+            metadata.finishReason = resolvedFinishReason;
+            metadata.rawFinishReason = resolvedFinishReason;
+            return buildAnalytics(this.providerName, this.modelName || this.getDefaultModel(), {
+                usage: {
+                    input: resolvedUsage.inputTokens,
+                    output: resolvedUsage.outputTokens,
+                    total: resolvedUsage.inputTokens + resolvedUsage.outputTokens,
+                },
+                stopReason: resolvedFinishReason,
+            }, Date.now() - startTime, { streamingMode: true });
+        })();
+        return {
+            stream,
+            model: this.modelName || this.getDefaultModel(),
+            provider: this.getProviderName(),
+            analytics,
+            metadata,
+        };
+    }
     /**
      * Get AI SDK model with middleware applied
      * This method wraps the base model with any configured middleware

package/dist/core/loopEngine.js

@@ -60,6 +60,8 @@ export function runAgenticLoop(adapter, initialConversation, options) {
         let conversation = initialConversation;
         let usage = { inputTokens: 0, outputTokens: 0 };
         let finalText = "";
+        // The most recent step's text, kept only for the step-cap case below.
+        let lastStepText = "";
         let rawStopReason;
         const allToolCalls = [];
         const allToolExecutions = [];
@@ -113,6 +115,7 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                 }
                 usage = sumUsage(usage, stepResult.usage);
                 rawStopReason = stepResult.rawStopReason;
+                lastStepText = stepResult.text || lastStepText;
                 if (adapter.isMalformedStep?.(stepResult) &&
                     !malformedRetryUsed &&
                     !internalAbort.signal.aborted) {
@@ -211,7 +214,14 @@ export function runAgenticLoop(adapter, initialConversation, options) {
             }
             const finishReason = adapter.mapFinishReason(rawStopReason, hadToolCallsAtCap);
             return {
-                text: finalText,
+                // `finalText` is only set by a step that asked for no tools, so a turn
+                // that runs out of steps mid-tool-call would otherwise return "" and
+                // throw away everything the model actually said. An empty result also
+                // reads as a failed generation to callers that retry on empty content,
+                // turning one capped turn into several. Fall back to the last step's
+                // text in that case only — when the loop ended normally, an empty
+                // final step genuinely means the model said nothing.
+                text: finalText || (hadToolCallsAtCap ? lastStepText : ""),
                 toolCalls: allToolCalls,
                 toolExecutions: allToolExecutions,
                 usage,

package/dist/lib/core/baseProvider.d.ts

@@ -276,9 +276,43 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     protected getToolCallRepairFn(options?: StreamOptions | TextGenerationOptions): ToolCallRepairFunction<ToolSet> | undefined;
     /**
-     * Provider-specific streaming implementation (only used when tools are disabled)
-     */
-    protected abstract executeStream(options: StreamOptions, analysisSchema?: ValidationSchema): Promise<StreamResult>;
+     * Opt-in streaming hook. A provider that produces an async iterable of text
+     * chunks plus promises for how the turn ended implements this and gets a
+     * working `executeStream` for free.
+     *
+     * Deliberately optional rather than abstract: every provider that already
+     * overrides `executeStream` directly — the older and still perfectly valid
+     * pattern — never needs it.
+     *
+     * `finishReason` and `usage` are promises because both are only knowable
+     * once the underlying stream has finished. Resolve them when it does; the
+     * default `executeStream` chains off them rather than waiting for a
+     * consumer, so they must settle even if nobody drains the stream.
+     */
+    protected doStream?(options: StreamOptions): Promise<{
+        stream: AsyncIterable<{
+            content: string;
+        }>;
+        finishReason: Promise<string>;
+        usage: Promise<{
+            inputTokens: number;
+            outputTokens: number;
+        }>;
+        warnings?: string[];
+    }>;
+    /**
+     * Provider-specific streaming implementation (only used when tools are
+     * disabled).
+     *
+     * This used to be `protected abstract`, which meant a provider had exactly
+     * two options: write the whole adapter by hand, or not stream at all. The
+     * failure mode that produced was SageMaker's — a complete, working
+     * `doStream` sitting one property access away from an `executeStream` that
+     * unconditionally threw "not yet fully implemented". Providers that
+     * implement `doStream` now inherit a correct implementation, and providers
+     * that override this method are unaffected.
+     */
+    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     /**
      * Get the provider name
      */

package/dist/lib/core/baseProvider.js

@@ -4,7 +4,9 @@ import { isImageGenerationModel } from "../core/constants.js";
 import { MiddlewareFactory } from "../middleware/factory.js";
 import { modelSupports } from "../models/modelRegistry.js";
 import { ATTR, tracers } from "../telemetry/index.js";
-import { isAbortError, NeuroLinkError } from "../utils/errorHandling.js";
+import { ERROR_CODES, isAbortError, NeuroLinkError, } from "../utils/errorHandling.js";
+import { createAnalytics as buildAnalytics } from "./analytics.js";
+import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { duckTypedStatusCode, extractRetryAfterMsFromError, } from "../utils/providerRetry.js";
 import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "../utils/lifecycleCallbacks.js";
 import { resolveLifecycleTimeoutMs } from "../utils/lifecycleTimeout.js";
@@ -1372,6 +1374,73 @@ export class BaseProvider {
             return createToolCallRepair()(...args);
         });
     }
+    /**
+     * Provider-specific streaming implementation (only used when tools are
+     * disabled).
+     *
+     * This used to be `protected abstract`, which meant a provider had exactly
+     * two options: write the whole adapter by hand, or not stream at all. The
+     * failure mode that produced was SageMaker's — a complete, working
+     * `doStream` sitting one property access away from an `executeStream` that
+     * unconditionally threw "not yet fully implemented". Providers that
+     * implement `doStream` now inherit a correct implementation, and providers
+     * that override this method are unaffected.
+     */
+    async executeStream(options, _analysisSchema) {
+        if (!this.doStream) {
+            throw new NeuroLinkError({
+                code: ERROR_CODES.INVALID_CONFIGURATION,
+                message: `${this.providerName} cannot stream: it neither implements doStream() nor overrides executeStream()`,
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.CRITICAL,
+                retriable: false,
+                context: { provider: this.providerName, model: this.modelName },
+            });
+        }
+        const startTime = Date.now();
+        const { stream, finishReason, usage, warnings } = await this.doStream(options);
+        if (warnings?.length) {
+            logger.warn(`[${this.providerName}] doStream reported warnings`, {
+                provider: this.providerName,
+                count: warnings.length,
+            });
+        }
+        // `metadata` is handed back by reference and filled in when the turn
+        // ends — the documented contract for background-loop streams, since a
+        // result-object spread would snapshot a top-level getter before the
+        // stream has produced anything.
+        const metadata = {
+            startTime,
+            streamId: `${this.providerName}-${startTime}`,
+        };
+        // Chained off the provider's own promises rather than off the consumer
+        // draining the stream. Binding analytics to a stream iterator's finally
+        // block means a caller that awaits analytics without iterating waits
+        // forever, because a generator body does not run until it is iterated.
+        const analytics = (async () => {
+            const [resolvedFinishReason, resolvedUsage] = await Promise.all([
+                finishReason,
+                usage,
+            ]);
+            metadata.finishReason = resolvedFinishReason;
+            metadata.rawFinishReason = resolvedFinishReason;
+            return buildAnalytics(this.providerName, this.modelName || this.getDefaultModel(), {
+                usage: {
+                    input: resolvedUsage.inputTokens,
+                    output: resolvedUsage.outputTokens,
+                    total: resolvedUsage.inputTokens + resolvedUsage.outputTokens,
+                },
+                stopReason: resolvedFinishReason,
+            }, Date.now() - startTime, { streamingMode: true });
+        })();
+        return {
+            stream,
+            model: this.modelName || this.getDefaultModel(),
+            provider: this.getProviderName(),
+            analytics,
+            metadata,
+        };
+    }
     /**
      * Get AI SDK model with middleware applied
      * This method wraps the base model with any configured middleware

package/dist/lib/core/loopEngine.js

@@ -60,6 +60,8 @@ export function runAgenticLoop(adapter, initialConversation, options) {
         let conversation = initialConversation;
         let usage = { inputTokens: 0, outputTokens: 0 };
         let finalText = "";
+        // The most recent step's text, kept only for the step-cap case below.
+        let lastStepText = "";
         let rawStopReason;
         const allToolCalls = [];
         const allToolExecutions = [];
@@ -113,6 +115,7 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                 }
                 usage = sumUsage(usage, stepResult.usage);
                 rawStopReason = stepResult.rawStopReason;
+                lastStepText = stepResult.text || lastStepText;
                 if (adapter.isMalformedStep?.(stepResult) &&
                     !malformedRetryUsed &&
                     !internalAbort.signal.aborted) {
@@ -211,7 +214,14 @@ export function runAgenticLoop(adapter, initialConversation, options) {
             }
             const finishReason = adapter.mapFinishReason(rawStopReason, hadToolCallsAtCap);
             return {
-                text: finalText,
+                // `finalText` is only set by a step that asked for no tools, so a turn
+                // that runs out of steps mid-tool-call would otherwise return "" and
+                // throw away everything the model actually said. An empty result also
+                // reads as a failed generation to callers that retry on empty content,
+                // turning one capped turn into several. Fall back to the last step's
+                // text in that case only — when the loop ended normally, an empty
+                // final step genuinely means the model said nothing.
+                text: finalText || (hadToolCallsAtCap ? lastStepText : ""),
                 toolCalls: allToolCalls,
                 toolExecutions: allToolExecutions,
                 usage,

package/dist/lib/providers/amazonBedrock/client.d.ts

@@ -38,21 +38,37 @@ export declare class AmazonBedrockProvider extends BaseProvider {
     protected getDefaultEmbeddingModel(): string;
     generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
     private conversationLoop;
-    private callBedrock;
-    private handleBedrockResponse;
     private convertToAWSMessages;
+    /**
+     * `tools` is passed in rather than re-resolved from `getAllTools()`. That
+     * call returns only the provider's own registry, so resolving here meant a
+     * tool the caller passed to generate/stream could never execute — the
+     * streaming path advertised it to the model and then failed every call to
+     * it with "Tool not found", and the generate path never advertised it at
+     * all. The turn's full merged tool set is resolved once by the caller and
+     * handed down.
+     */
     private executeSingleTool;
+    /**
+     * Resolve the turn's tools once: whatever the caller passed, else the
+     * provider's own registry. `BaseProvider.stream()` has already merged base
+     * tools into `options.tools` by the time it reaches the streaming path;
+     * the generate path has no such pre-merge, so it falls back here.
+     */
+    private resolveTurnTools;
+    /**
+     * Present the resolved tools in the shape `runAgenticLoop` dispatches
+     * through. Execution still goes through `executeSingleTool`, so the tool
+     * span, the parameter defaults and the ToolResult unwrapping are unchanged
+     * — only which tools are reachable changes.
+     */
+    private toEngineTools;
     private convertAISDKToolsToToolDefinitions;
     private formatToolsForBedrock;
     private convertToBedrockMessages;
     getBedrockClient(): BedrockRuntimeClient;
     protected executeStream(options: StreamOptions): Promise<StreamResult>;
     private streamingConversationLoop;
-    private convertToAsyncIterable;
-    private prepareStreamCommand;
-    private processStreamResponse;
-    private handleStreamStopReason;
-    private executeStreamTools;
     /**
      * Health check for Amazon Bedrock service
      * Uses ListFoundationModels API to validate connectivity and permissions