@juspay/neurolink 12.12.10 → 12.12.11

package/dist/core/baseProvider.d.ts

@@ -22,7 +22,6 @@ export declare abstract class BaseProvider implements AIProvider {
     } | null): void;
     private messageBuilder;
     private streamHandler;
-    private generationHandler;
     protected telemetryHandler: TelemetryHandler;
     private utilities;
     private readonly toolsManager;
@@ -185,30 +184,10 @@ export declare abstract class BaseProvider implements AIProvider {
      * @returns Promise resolving to ModelMessage array ready for AI SDK
      */
     protected buildMessagesForStream(options: StreamOptions | TextGenerationOptions): Promise<ModelMessage[]>;
-    /**
-     * Execute the generation with AI SDK - delegated to GenerationHandler
-     */
-    private executeGeneration;
-    /**
-     * Log generation completion information - delegated to GenerationHandler
-     */
-    private logGenerationComplete;
     /**
      * Record performance metrics - delegated to TelemetryHandler
      */
     protected recordPerformanceMetrics(usage: RawUsageObject | undefined, responseTime: number): Promise<void>;
-    /**
-     * Extract tool information from generation result - delegated to GenerationHandler
-     */
-    private extractToolInformation;
-    /**
-     * Format the enhanced result - delegated to GenerationHandler
-     */
-    private formatEnhancedResult;
-    /**
-     * Analyze AI response structure and log detailed debugging information - delegated to GenerationHandler
-     */
-    private analyzeAIResponse;
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
@@ -281,7 +260,6 @@ export declare abstract class BaseProvider implements AIProvider {
     private runGenerateInActiveContext;
     protected handleDirectTTSSynthesis(options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;
     private handleVideoFrameGeneration;
-    private executeStandardGenerateFlow;
     /**
      * Close out a turn produced by a provider's own native generate loop.
      *

package/dist/core/baseProvider.js

@@ -32,14 +32,13 @@ import { TimeoutError as AsyncTimeoutError, withTimeoutFn, } from "../utils/asyn
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { getKeyCount, getKeysAsString } from "../utils/transformationUtils.js";
-import { ToolExecutionRecorder, resolveToolExecutionRecords, } from "./toolExecutionRecorder.js";
+import { ToolExecutionRecorder } from "./toolExecutionRecorder.js";
 import { TTS_ERROR_CODES, TTSProcessor } from "../utils/ttsProcessor.js";
 import { executeVideoAnalysis, hasVideoFrames, } from "../utils/videoAnalysisProcessor.js";
 import { dedupeTools } from "./toolDedup.js";
 import { resolveToolPolicy, toolNameMatcher } from "../tools/toolPolicy.js";
 import { applyToolGate } from "../tools/toolGate.js";
 import { partitionToolsForDiscovery, isDiscoveryMetaTool, LARGE_CATALOG_WARN_THRESHOLD, } from "../tools/toolDiscovery.js";
-import { GenerationHandler } from "./modules/GenerationHandler.js";
 // Import modules for composition
 import { MessageBuilder } from "./modules/MessageBuilder.js";
 import { StreamHandler } from "./modules/StreamHandler.js";
@@ -137,7 +136,6 @@ export class BaseProvider {
     // alone.
     messageBuilder;
     streamHandler;
-    generationHandler;
     telemetryHandler;
     utilities;
     toolsManager;
@@ -150,7 +148,6 @@ export class BaseProvider {
         this.messageBuilder = new MessageBuilder(this.providerName, this.modelName);
         this.streamHandler = new StreamHandler(this.providerName, this.modelName);
         this.telemetryHandler = new TelemetryHandler(this.providerName, this.modelName, this.neurolink);
-        this.generationHandler = new GenerationHandler(this.providerName, this.modelName, () => this.supportsTools(), (options, type) => this.telemetryHandler.getTelemetryConfig(options, type), (toolCalls, toolResults, options, timestamp) => this.handleToolExecutionStorage(toolCalls, toolResults, options, timestamp), { getEmitterFn: () => this.neurolink?.getEventEmitter() });
         this.utilities = new Utilities(this.providerName, this.modelName, this.defaultTimeout, this.middlewareOptions);
         this.toolsManager = new ToolsManager(this.providerName, this.directTools, this.neurolink, {
             isZodSchema: (schema) => this.isZodSchema(schema),
@@ -175,7 +172,6 @@ export class BaseProvider {
         this.messageBuilder = new MessageBuilder(this.providerName, this.modelName);
         this.streamHandler = new StreamHandler(this.providerName, this.modelName);
         this.telemetryHandler = new TelemetryHandler(this.providerName, this.modelName, this.neurolink);
-        this.generationHandler = new GenerationHandler(this.providerName, this.modelName, () => this.supportsTools(), (options, type) => this.telemetryHandler.getTelemetryConfig(options, type), (toolCalls, toolResults, options, timestamp) => this.handleToolExecutionStorage(toolCalls, toolResults, options, timestamp), { getEmitterFn: () => this.neurolink?.getEventEmitter() });
         this.utilities = new Utilities(this.providerName, this.modelName, this.defaultTimeout, this.middlewareOptions);
     }
     /**
@@ -1202,42 +1198,12 @@ export class BaseProvider {
     async buildMessagesForStream(options) {
         return this.messageBuilder.buildMessagesForStream(options);
     }
-    /**
-     * Execute the generation with AI SDK - delegated to GenerationHandler
-     */
-    async executeGeneration(model, messages, tools, options) {
-        return this.generationHandler.executeGeneration(model, messages, tools, options);
-    }
-    /**
-     * Log generation completion information - delegated to GenerationHandler
-     */
-    logGenerationComplete(generateResult) {
-        this.generationHandler.logGenerationComplete(generateResult);
-    }
     /**
      * Record performance metrics - delegated to TelemetryHandler
      */
     async recordPerformanceMetrics(usage, responseTime) {
         await this.telemetryHandler.recordPerformanceMetrics(usage, responseTime);
     }
-    /**
-     * Extract tool information from generation result - delegated to GenerationHandler
-     */
-    extractToolInformation(generateResult) {
-        return this.generationHandler.extractToolInformation(generateResult);
-    }
-    /**
-     * Format the enhanced result - delegated to GenerationHandler
-     */
-    formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions, options) {
-        return this.generationHandler.formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions, options);
-    }
-    /**
-     * Analyze AI response structure and log detailed debugging information - delegated to GenerationHandler
-     */
-    analyzeAIResponse(result) {
-        this.generationHandler.analyzeAIResponse(result);
-    }
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
@@ -1398,13 +1364,28 @@ export class BaseProvider {
             if (requestKind === "tts-direct") {
                 return this.handleDirectTTSSynthesis(options, startTime);
             }
-            const { tools, model } = await this.prepareGenerationContext(options);
+            // Only `model` is used now — the video-frame path needs it. `tools`
+            // fed the standard generate flow, which no longer exists.
+            const { model } = await this.prepareGenerationContext(options);
             const messages = await this.buildMessages(options);
             const videoFrameResult = await this.handleVideoFrameGeneration(options, messages, model, startTime);
             if (videoFrameResult) {
                 return videoFrameResult;
             }
-            return await this.executeStandardGenerateFlow(options, startTime, model, messages, tools);
+            // Every provider that generates text overrides `generate()` and runs a
+            // native loop. There is no shared fallback any more: the standard flow
+            // called the ai package's `generateText`, and once that was gone the
+            // flow could only throw. Reaching here means a provider was asked for
+            // text without implementing it — an image or embedding provider handed
+            // a text model, or a new subclass with no `generate()` yet.
+            throw new NeuroLinkError({
+                code: ERROR_CODES.INVALID_CONFIGURATION,
+                message: `${this.providerName} cannot generate text: it does not override generate(). Every text provider implements a native generate() — see docs/plans/2026-09-03-completing-the-ai-sdk-removal.md`,
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.CRITICAL,
+                retriable: false,
+                context: { provider: this.providerName, model: this.modelName },
+            });
         }
         catch (error) {
             otelSpan.setStatus({
@@ -1537,50 +1518,6 @@ export class BaseProvider {
             usage,
         }, options, startTime);
     }
-    async executeStandardGenerateFlow(options, startTime, model, messages, tools) {
-        // Apply a defensive default timeout when the caller didn't pass one.
-        // Without this guard, AI SDK's generateText() will wait forever on
-        // an upstream that accepts the connection but never produces a response
-        // (observed against the litellm gateway when a request triggers the
-        // team-access denial path — connection stays open, no response is sent,
-        // and the matrix test hangs the entire suite). Callers can still pass
-        // a larger value (e.g. video generation passes 10 min).
-        //
-        // A provider descriptor may declare a LARGER generate budget than the
-        // 3-min floor (litellm: 300s — slow proxied models routinely need more
-        // than 180s end-to-end even while streaming). The declared value only
-        // ever raises the default, never lowers it: several descriptors carry
-        // aspirational sub-180s numbers (openai 30s, bedrock 45s) that were
-        // never enforced on this path, and enforcing them now would break
-        // long-running generations that have always been allowed.
-        const descriptorGenerateMs = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.timeouts?.generateMs;
-        // An explicit, valid turnTimeoutMs is the caller's whole-turn contract
-        // and owns this hard abort; `timeout` then keeps its per-model-call
-        // meaning (it reaches the model layer via providerOptions.neurolink).
-        // Before this, `timeout` alone bounded the ENTIRE multi-step loop, so a
-        // caller asking for a 40-minute turn of 5-minute calls was killed at 5
-        // minutes flat — mid-loop, dressed as "Request was aborted.".
-        const generateResult = await this.withTurnTimeout(options, descriptorGenerateMs, (timedOptions) => this.executeGeneration(model, messages, tools, timedOptions));
-        this.analyzeAIResponse(generateResult);
-        this.logGenerationComplete(generateResult);
-        const responseTime = Date.now() - startTime;
-        const { toolsUsed, toolExecutions } = this.extractToolInformation(generateResult);
-        // Prefer the per-call recorder's real records (params/result/timing per
-        // execution); fall back to a conversion of the step-extraction entries
-        // for tools the recorder could not wrap (provider-executed tools).
-        const toolExecutionRecords = resolveToolExecutionRecords(options, toolExecutions);
-        let enhancedResult = this.formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutionRecords, options);
-        // Recorded AFTER formatEnhancedResult so telemetry sees the same usage
-        // the caller gets: the cross-step aggregate (totalUsage, not last-step
-        // usage) WITH the providerMetadata cache merge applied — otherwise
-        // providers whose cache data lives only in providerMetadata would have
-        // their cache tokens billed at the full input rate in OTEL metrics,
-        // diverging from analytics.cost.
-        await this.recordPerformanceMetrics(enhancedResult.usage, responseTime);
-        enhancedResult = await this.synthesizeAIResponseIfNeeded(enhancedResult, options);
-        const finalResult = await this.enhanceResult(enhancedResult, options, startTime);
-        return finalResult;
-    }
     /**
      * Close out a turn produced by a provider's own native generate loop.
      *

package/dist/providers/anthropic/client.js

@@ -1280,7 +1280,10 @@ export class AnthropicProvider extends BaseProvider {
                 };
             },
             doStream: () => {
-                throw new Error(`${providerName}: doStream is not implemented on the delegating model — the streaming path uses executeStream directly.`);
+                throw new Error(`${providerName}: doStream is not implemented on the delegating model. ` +
+                    `NeuroLink streams through executeStream, reached via NeuroLink.stream() — ` +
+                    `use that (the browser bundle exports the NeuroLink class) rather than ` +
+                    `calling doStream on a model handle.`);
             },
         };
         return delegatingModel;

package/dist/providers/openaiChatCompletionsBase.js

@@ -784,7 +784,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 };
             },
             doStream: () => {
-                throw new Error(`${providerName}: doStream is not implemented on the delegating model — the streaming path uses executeStream directly.`);
+                throw new Error(`${providerName}: doStream is not implemented on the delegating model. ` +
+                    `NeuroLink streams through executeStream, reached via NeuroLink.stream() — ` +
+                    `use that (the browser bundle exports the NeuroLink class) rather than ` +
+                    `calling doStream on a model handle.`);
             },
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.12.10",
+  "version": "12.12.11",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {

package/dist/core/modules/GenerationHandler.d.ts

@@ -1,145 +0,0 @@
-/**
- * Generation Handler Module
- *
- * Handles text generation execution, result formatting, and tool information extraction.
- * Extracted from BaseProvider to follow Single Responsibility Principle.
- *
- * Responsibilities:
- * - Generation execution with AI SDK
- * - Tool information extraction
- * - Result formatting and enhancement
- * - Response analysis and logging
- *
- * @module core/modules/GenerationHandler
- */
-import type { GenerateTextResult, AIProviderName, EnhancedGenerateResult, NeuroLinkEvents, StandardRecord, TextGenerationOptions, ToolExecutionRecord, TypedEventEmitter } from "../../types/index.js";
-import type { LanguageModel, ModelMessage, Tool } from "../../types/index.js";
-/**
- * Turn budget + wrap-up deadline (parity with the googleVertex native loops).
- * A deadline is engaged only when the caller expressed one: turnTimeoutMs
- * wins, else an explicit generate timeout. Callers that set neither keep the
- * pre-existing behaviour (no wrap-up; the outer defensive timeout in
- * executeStandardGenerateFlow still applies). With `wrapupTimeLeadMs` left of
- * the deadline, the loop stops offering tools (toolChoice: "none") so the
- * model spends the remaining budget producing a final answer instead of being
- * guillotined mid-tool-loop with all work discarded. The lead is clamped to a
- * quarter of the budget so short explicit timeouts (e.g. 30s) don't trigger
- * wrap-up on the very first step.
- *
- * `turnStartMs` anchors the deadline to the ORIGINAL generation start:
- * callGenerateText re-runs on executeGeneration's fallback retries
- * (structured-output conflict, temperature-deprecated) and provider retries,
- * and a deadline computed from Date.now() per attempt would hand each retry
- * a fresh budget — multiplying the caller's wall-clock cap.
- */
-export declare function resolveTurnBudget(options: TextGenerationOptions, turnStartMs: number): {
-    callerTimeoutMs: number | undefined;
-    turnBudgetMs: number | undefined;
-    wrapupLeadMs: number;
-    turnDeadline: number | undefined;
-};
-/**
- * GenerationHandler class - Handles text generation operations for AI providers
- */
-export declare class GenerationHandler {
-    private readonly providerName;
-    private readonly modelName;
-    private readonly supportsToolsFn;
-    private readonly getTelemetryConfigFn;
-    private readonly handleToolStorageFn;
-    /**
-     * The remaining, optional dependencies.
-     *
-     * Grouped rather than added as further positional parameters: the
-     * constructor is already at the six-parameter cap, and both of these are
-     * optional injection seams rather than required collaborators.
-     *
-     * `generateTextFn` exists because every other dependency of this class
-     * arrives through the constructor while `generateText` was reached by
-     * static import. `utils/generation.ts` is a bare re-export of `ai`, and an
-     * ESM re-export cannot be substituted from a test, so asserting on the
-     * arguments this class builds — the entire contract of the system-message
-     * hoisting below — had no seam to work through. Production passes neither.
-     */
-    private readonly deps;
-    constructor(providerName: AIProviderName, modelName: string, supportsToolsFn: () => boolean, getTelemetryConfigFn: (options: TextGenerationOptions, type: string) => {
-        isEnabled: boolean;
-        functionId?: string;
-        metadata?: Record<string, string | number | boolean>;
-    } | undefined, handleToolStorageFn: (toolCalls: unknown[], toolResults: unknown[], options: TextGenerationOptions, timestamp: Date) => Promise<void>, 
-    /**
-     * The remaining, optional dependencies.
-     *
-     * Grouped rather than added as further positional parameters: the
-     * constructor is already at the six-parameter cap, and both of these are
-     * optional injection seams rather than required collaborators.
-     *
-     * `generateTextFn` exists because every other dependency of this class
-     * arrives through the constructor while `generateText` was reached by
-     * static import. `utils/generation.ts` is a bare re-export of `ai`, and an
-     * ESM re-export cannot be substituted from a test, so asserting on the
-     * arguments this class builds — the entire contract of the system-message
-     * hoisting below — had no seam to work through. Production passes neither.
-     */
-    deps?: {
-        getEmitterFn?: () => TypedEventEmitter<NeuroLinkEvents> | undefined;
-        generateTextFn?: (options: Record<string, unknown>) => Promise<GenerateTextResult<Record<string, Tool>, unknown>>;
-    });
-    /**
-     * Helper method to call generateText with optional structured output
-     * @private
-     */
-    /**
-     * The ai-package generate loop.
-     *
-     * Unreachable: every text provider now implements a native generate() and
-     * none of them return here. That was established by trapping the seam —
-     * replacing the ai package's generateText with a throwing stub left the full
-     * provider matrix passing and zero cells reaching it — and non-text request
-     * kinds return from runGenerateInActiveContext before this handler is
-     * consulted.
-     *
-     * Kept as an explicit failure rather than deleted outright so a provider
-     * added without a native generate() fails loudly here instead of silently
-     * reintroducing a dependency on the removed package.
-     */
-    private callGenerateText;
-    executeGeneration(model: LanguageModel, messages: ModelMessage[], tools: Record<string, Tool>, options: TextGenerationOptions): Promise<GenerateTextResult<Record<string, Tool>, unknown>>;
-    /**
-     * Extract cache metrics from provider metadata (e.g. Anthropic's providerMetadata.anthropic)
-     * The AI SDK's LanguageModelUsage only has inputTokens/outputTokens.
-     * Cache metrics are surfaced via providerMetadata by provider-specific SDK adapters.
-     */
-    /**
-     * Set gen_ai usage attributes + cache-aware cost on the span from the
-     * CROSS-STEP aggregate (result.totalUsage). result.usage is the LAST step
-     * only — using it undercounted every multi-step tool loop, and pricing the
-     * raw cache-inclusive inputTokens without the cache fields billed cache
-     * reads at the full input rate.
-     */
-    private setUsageSpanAttributes;
-    private extractCacheMetricsFromProviderMetadata;
-    /**
-     * Log generation completion information
-     */
-    logGenerationComplete(generateResult: GenerateTextResult<Record<string, Tool>, unknown>): void;
-    /**
-     * Extract tool information from generation result
-     */
-    extractToolInformation(generateResult: GenerateTextResult<Record<string, Tool>, unknown>): {
-        toolsUsed: string[];
-        toolExecutions: Array<{
-            name: string;
-            input: StandardRecord;
-            output: unknown;
-        }>;
-    };
-    /**
-     * Format the enhanced result
-     */
-    formatEnhancedResult(generateResult: GenerateTextResult<Record<string, Tool>, unknown>, tools: Record<string, Tool>, toolsUsed: string[], toolExecutions: ToolExecutionRecord[], options: TextGenerationOptions): EnhancedGenerateResult;
-    /**
-     * Analyze AI response structure and log detailed debugging information
-     */
-    analyzeAIResponse(rawResult: unknown): void;
-}