@juspay/neurolink 12.11.2 → 12.12.0

package/dist/constants/enums.d.ts

@@ -26,6 +26,7 @@ export declare enum AIProviderName {
     GROQ = "groq",
     INCEPTION_LABS = "inception-labs",
     IO_INTELLIGENCE = "io-intelligence",
+    MANCER = "mancer",
     MISTRAL = "mistral",
     PERPLEXITY = "perplexity",
     SAMBANOVA = "sambanova",
@@ -919,6 +920,18 @@ export declare enum IoIntelligenceModels {
     OPENAI_GPT_OSS_20B = "openai/gpt-oss-20b",
     META_LLAMA_LLAMA_3_3_70B_INSTRUCT = "meta-llama/Llama-3.3-70B-Instruct"
 }
+export declare enum MancerModels {
+    MYTHOMAX = "mythomax",
+    DEEPSEEK_V4_FLASH = "deepseek-v4-flash",
+    DEEPSEEK_V4_FLASH_0731 = "deepseek-v4-flash-0731",
+    MYTHOLITE = "mytholite",
+    REMM_SLERP = "remm-slerp",
+    MAGNUM_72B_V4 = "magnum-72b-v4",
+    GLM_4_7 = "glm-4.7",
+    GPT_OSS_120B = "gpt-oss-120b",
+    WEAVER_ALPHA = "weaver-alpha",
+    DANS_PE_1_3_24B = "dans-pe-1.3-24b"
+}
 export declare enum MistralModels {
     MISTRAL_LARGE_LATEST = "mistral-large-latest",
     MISTRAL_LARGE_2512 = "mistral-large-2512",

package/dist/constants/enums.js

@@ -31,6 +31,7 @@ export var AIProviderName;
     AIProviderName["GROQ"] = "groq";
     AIProviderName["INCEPTION_LABS"] = "inception-labs";
     AIProviderName["IO_INTELLIGENCE"] = "io-intelligence";
+    AIProviderName["MANCER"] = "mancer";
     AIProviderName["MISTRAL"] = "mistral";
     AIProviderName["PERPLEXITY"] = "perplexity";
     AIProviderName["SAMBANOVA"] = "sambanova";
@@ -1175,6 +1176,19 @@ export var IoIntelligenceModels;
     IoIntelligenceModels["OPENAI_GPT_OSS_20B"] = "openai/gpt-oss-20b";
     IoIntelligenceModels["META_LLAMA_LLAMA_3_3_70B_INSTRUCT"] = "meta-llama/Llama-3.3-70B-Instruct";
 })(IoIntelligenceModels || (IoIntelligenceModels = {}));
+export var MancerModels;
+(function (MancerModels) {
+    MancerModels["MYTHOMAX"] = "mythomax";
+    MancerModels["DEEPSEEK_V4_FLASH"] = "deepseek-v4-flash";
+    MancerModels["DEEPSEEK_V4_FLASH_0731"] = "deepseek-v4-flash-0731";
+    MancerModels["MYTHOLITE"] = "mytholite";
+    MancerModels["REMM_SLERP"] = "remm-slerp";
+    MancerModels["MAGNUM_72B_V4"] = "magnum-72b-v4";
+    MancerModels["GLM_4_7"] = "glm-4.7";
+    MancerModels["GPT_OSS_120B"] = "gpt-oss-120b";
+    MancerModels["WEAVER_ALPHA"] = "weaver-alpha";
+    MancerModels["DANS_PE_1_3_24B"] = "dans-pe-1.3-24b";
+})(MancerModels || (MancerModels = {}));
 export var MistralModels;
 (function (MistralModels) {
     MistralModels["MISTRAL_LARGE_LATEST"] = "mistral-large-latest";

package/dist/core/baseProvider.d.ts

@@ -3,7 +3,7 @@ import type { EvaluationData } from "../index.js";
 import type { NeuroLink } from "../neurolink.js";
 import type { UnknownRecord, MiddlewareFactoryOptions, StreamOptions, StreamResult, AIProvider, AnalyticsData, EnhancedGenerateResult, TextGenerationOptions, TextGenerationResult, ValidationSchema } from "../types/index.js";
 import { TelemetryHandler } from "./modules/TelemetryHandler.js";
-import type { LanguageModel, ModelMessage, Tool, ToolCallRepairFunction, ToolSet } from "../types/index.js";
+import type { LanguageModel, ModelMessage, RawUsageObject, Tool, ToolCallRepairFunction, ToolSet } from "../types/index.js";
 export declare abstract class BaseProvider implements AIProvider {
     protected modelName: string;
     protected readonly providerName: AIProviderName;
@@ -196,7 +196,7 @@ export declare abstract class BaseProvider implements AIProvider {
     /**
      * Record performance metrics - delegated to TelemetryHandler
      */
-    private recordPerformanceMetrics;
+    protected recordPerformanceMetrics(usage: RawUsageObject | undefined, responseTime: number): Promise<void>;
     /**
      * Extract tool information from generation result - delegated to GenerationHandler
      */
@@ -262,7 +262,13 @@ export declare abstract class BaseProvider implements AIProvider {
      * lifecycle callback has fired and before a chunk has reached the consumer,
      * so there is no observable output to replay.
      */
-    private runGenerateWithModelFallback;
+    /**
+     * Protected rather than private so a provider with a native generate path can
+     * reuse it. Overriding `generate()` otherwise skips this wrapper silently,
+     * and a retired default model stops degrading to the next live one in the
+     * catalog — which is exactly what the provider contract gate checks.
+     */
+    protected runGenerateWithModelFallback(attempt: () => Promise<EnhancedGenerateResult | null>, callerOwnsFallback: boolean): Promise<EnhancedGenerateResult | null>;
     /**
      * Model ids to try when this provider rejects its current model as invalid.
      * Empty by default; catalog-driven providers return their `fallbacks`.
@@ -276,6 +282,30 @@ export declare abstract class BaseProvider implements AIProvider {
     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.
+     *
+     * The native loops bypass `executeGeneration`, and with it every post-call
+     * step the standard path runs. Each one that was missed had to be found
+     * separately — `onFinish` stopped firing, TTS synthesis silently produced no
+     * audio, and OTEL saw no usage for any native provider. Routing all of them
+     * through one method is what stops the next native path from rediscovering
+     * the same list.
+     *
+     * Order matters and mirrors the standard path: metrics are recorded before
+     * synthesis so telemetry sees the model's own usage, and `enhanceResult`
+     * runs last so analytics and evaluation observe the final content.
+     */
+    protected finalizeNativeGenerate(result: EnhancedGenerateResult, options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;
+    /**
+     * Invoke a caller's `onFinish` for a native turn.
+     *
+     * On the standard path `onFinish` is converted into lifecycle middleware and
+     * applied by wrapping the model — a step the native loops skip, so they have
+     * to call it themselves. Failures are logged and swallowed: a caller's
+     * callback must not be able to fail their generation.
+     */
+    protected fireGenerateOnFinish(options: TextGenerationOptions, result: EnhancedGenerateResult | null, startTime: number): void;
     protected synthesizeAIResponseIfNeeded(enhancedResult: EnhancedGenerateResult, options: TextGenerationOptions): Promise<EnhancedGenerateResult>;
     /**
      * Build the public TTS failure detail.
@@ -393,7 +423,45 @@ export declare abstract class BaseProvider implements AIProvider {
      * REQUIRED: Every provider MUST implement this method
      * Returns the Vercel AI SDK model instance for this provider
      */
+    /**
+     * Run one whole turn under the caller's timeout contract.
+     *
+     * Every generate path must go through this, including the native loops that
+     * bypass `executeGeneration`. When the Anthropic native path was first added
+     * it built its own call and never composed a timer, so `timeout: 1000`
+     * against a three-second upstream simply returned the late response — the
+     * turn budget silently stopped existing for that provider.
+     *
+     * 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 that
+     * split, `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.".
+     *
+     * `descriptorGenerateMs` only ever RAISES the 3-minute floor, never lowers
+     * it: several descriptors carry aspirational sub-180s numbers (openai 30s,
+     * bedrock 45s) that were never enforced, and enforcing them now would break
+     * long-running generations that have always been allowed.
+     */
+    protected withTurnTimeout<T>(options: TextGenerationOptions, descriptorGenerateMs: number | undefined, run: (timedOptions: TextGenerationOptions) => Promise<T>): Promise<T>;
+    /**
+     * The per-provider generate budget from the descriptor, for native paths
+     * that call `withTurnTimeout` directly.
+     */
+    protected getDescriptorGenerateMs(): number | undefined;
     protected abstract getAISDKModel(): LanguageModel | Promise<LanguageModel>;
+    /**
+     * Public handle on this provider's model object.
+     *
+     * `getAISDKModel()` is protected because only the generation pipeline should
+     * drive it. The browser bundle needs the same handle to back its public
+     * provider factories without reaching into provider internals, so this is the
+     * one sanctioned way out. The union return lets providers that resolve their
+     * model synchronously (Anthropic) and asynchronously (the OpenAI-compatible
+     * family) both satisfy it.
+     */
+    getModel(): LanguageModel | Promise<LanguageModel>;
     /**
      * Get AI SDK model with middleware applied
      * This method wraps the base model with any configured middleware

package/dist/core/baseProvider.js

@@ -46,7 +46,7 @@ import { StreamHandler } from "./modules/StreamHandler.js";
 import { TelemetryHandler } from "./modules/TelemetryHandler.js";
 import { ToolsManager } from "./modules/ToolsManager.js";
 import { Utilities } from "./modules/Utilities.js";
-import { generateText } from "../utils/generation.js";
+import { generateOnceNative } from "../utils/nativeSingleShot.js";
 import { extractTokenUsage } from "../utils/tokenUtils.js";
 /**
  * Read the consumer-facing lifecycle callbacks buried inside a request's
@@ -1325,6 +1325,12 @@ export class BaseProvider {
      * lifecycle callback has fired and before a chunk has reached the consumer,
      * so there is no observable output to replay.
      */
+    /**
+     * Protected rather than private so a provider with a native generate path can
+     * reuse it. Overriding `generate()` otherwise skips this wrapper silently,
+     * and a retired default model stops degrading to the next live one in the
+     * catalog — which is exactly what the provider contract gate checks.
+     */
     async runGenerateWithModelFallback(attempt, callerOwnsFallback) {
         const requestedModel = this.modelName;
         try {
@@ -1505,17 +1511,15 @@ export class BaseProvider {
                     userTextLength: userText.length,
                     analysisLength: videoAnalysisResult.length,
                 });
-                const formattedResult = await generateText({
-                    model,
-                    system: options.systemPrompt,
-                    messages: [{ role: "user", content: formattingPrompt }],
+                const formattedResult = await generateOnceNative(model, {
+                    ...(options.systemPrompt ? { system: options.systemPrompt } : {}),
+                    prompt: formattingPrompt,
                     maxOutputTokens: options.maxTokens || 8192,
                     temperature: 0.3,
-                    abortSignal: options.abortSignal,
-                    experimental_telemetry: this.telemetryHandler?.getTelemetryConfig(options, "generate"),
+                    ...(options.abortSignal ? { abortSignal: options.abortSignal } : {}),
                 });
                 formattedContent = formattedResult.text;
-                usage = extractTokenUsage(formattedResult.totalUsage ?? formattedResult.usage);
+                usage = extractTokenUsage(formattedResult.usage);
                 logger.debug("[VideoAnalysis] Claude formatting complete", {
                     formattedLength: formattedContent.length,
                     usage,
@@ -1557,42 +1561,7 @@ export class BaseProvider {
         // 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 hasValidTurnTimeout = typeof options.turnTimeoutMs === "number" &&
-            Number.isFinite(options.turnTimeoutMs) &&
-            options.turnTimeoutMs > 0;
-        const effectiveTimeout = hasValidTurnTimeout
-            ? options.turnTimeoutMs
-            : (options.timeout ?? Math.max(descriptorGenerateMs ?? 0, 180_000));
-        const timeoutController = createTimeoutController(effectiveTimeout, this.providerName, "generate");
-        const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
-        const composedOptions = composedSignal
-            ? { ...options, abortSignal: composedSignal }
-            : options;
-        let generateResult;
-        try {
-            generateResult = await this.executeGeneration(model, messages, tools, composedOptions);
-        }
-        catch (error) {
-            // When OUR timer fired, provider SDKs typically normalize the abort
-            // into their own generic cancel shape (e.g. Anthropic's
-            // APIUserAbortError, "Request was aborted.") and discard the signal's
-            // reason. The TimeoutError on the signal is the honest identity —
-            // rethrow it so logs and abort classification see a timeout, not a
-            // caller cancel. A genuine caller abort (their signal fired) keeps its
-            // original shape even if our timer also expired in the race window.
-            const reason = timeoutController?.controller.signal.aborted
-                ? timeoutController.controller.signal.reason
-                : undefined;
-            if (reason instanceof TimeoutError &&
-                isAbortError(error) &&
-                options.abortSignal?.aborted !== true) {
-                throw reason;
-            }
-            throw error;
-        }
-        finally {
-            timeoutController?.cleanup();
-        }
+        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;
@@ -1613,6 +1582,62 @@ export class BaseProvider {
         const finalResult = await this.enhanceResult(enhancedResult, options, startTime);
         return finalResult;
     }
+    /**
+     * Close out a turn produced by a provider's own native generate loop.
+     *
+     * The native loops bypass `executeGeneration`, and with it every post-call
+     * step the standard path runs. Each one that was missed had to be found
+     * separately — `onFinish` stopped firing, TTS synthesis silently produced no
+     * audio, and OTEL saw no usage for any native provider. Routing all of them
+     * through one method is what stops the next native path from rediscovering
+     * the same list.
+     *
+     * Order matters and mirrors the standard path: metrics are recorded before
+     * synthesis so telemetry sees the model's own usage, and `enhanceResult`
+     * runs last so analytics and evaluation observe the final content.
+     */
+    async finalizeNativeGenerate(result, options, startTime) {
+        // onFinish is NOT fired here. `applyGenerateLifecycleMiddleware` folds it
+        // into `options.middleware.middlewareConfig.lifecycle`, and the native
+        // paths now wrap their model, so the lifecycle middleware fires it.
+        // Firing it here too would deliver every callback twice.
+        await this.recordPerformanceMetrics(result.usage, Date.now() - startTime);
+        const synthesized = await this.synthesizeAIResponseIfNeeded(result, options);
+        return this.enhanceResult(synthesized, options, startTime);
+    }
+    /**
+     * Invoke a caller's `onFinish` for a native turn.
+     *
+     * On the standard path `onFinish` is converted into lifecycle middleware and
+     * applied by wrapping the model — a step the native loops skip, so they have
+     * to call it themselves. Failures are logged and swallowed: a caller's
+     * callback must not be able to fail their generation.
+     */
+    fireGenerateOnFinish(options, result, startTime) {
+        const onFinish = options
+            .onFinish;
+        if (typeof onFinish !== "function") {
+            return;
+        }
+        try {
+            const usage = result?.usage;
+            const cb = onFinish({
+                text: result?.content || "",
+                usage: usage
+                    ? {
+                        promptTokens: usage.input ?? 0,
+                        completionTokens: usage.output ?? 0,
+                    }
+                    : undefined,
+                duration: Date.now() - startTime,
+                finishReason: result?.finishReason ?? "stop",
+            });
+            Promise.resolve(cb).catch((err) => logger.warn(`[${this.providerName}] onFinish callback rejected: ${err instanceof Error ? err.message : String(err)}`));
+        }
+        catch (err) {
+            logger.warn(`[${this.providerName}] onFinish callback threw: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     async synthesizeAIResponseIfNeeded(enhancedResult, options) {
         if (!options.tts?.enabled || !options.tts?.useAiResponse) {
             return enhancedResult;
@@ -1901,6 +1926,89 @@ export class BaseProvider {
             metadata,
         };
     }
+    /**
+     * REQUIRED: Every provider MUST implement this method
+     * Returns the Vercel AI SDK model instance for this provider
+     */
+    /**
+     * Run one whole turn under the caller's timeout contract.
+     *
+     * Every generate path must go through this, including the native loops that
+     * bypass `executeGeneration`. When the Anthropic native path was first added
+     * it built its own call and never composed a timer, so `timeout: 1000`
+     * against a three-second upstream simply returned the late response — the
+     * turn budget silently stopped existing for that provider.
+     *
+     * 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 that
+     * split, `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.".
+     *
+     * `descriptorGenerateMs` only ever RAISES the 3-minute floor, never lowers
+     * it: several descriptors carry aspirational sub-180s numbers (openai 30s,
+     * bedrock 45s) that were never enforced, and enforcing them now would break
+     * long-running generations that have always been allowed.
+     */
+    async withTurnTimeout(options, descriptorGenerateMs, run) {
+        const hasValidTurnTimeout = typeof options.turnTimeoutMs === "number" &&
+            Number.isFinite(options.turnTimeoutMs) &&
+            options.turnTimeoutMs > 0;
+        const effectiveTimeout = hasValidTurnTimeout
+            ? options.turnTimeoutMs
+            : (options.timeout ?? Math.max(descriptorGenerateMs ?? 0, 180_000));
+        const timeoutController = createTimeoutController(effectiveTimeout, this.providerName, "generate");
+        const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
+        const timedOptions = composedSignal
+            ? { ...options, abortSignal: composedSignal }
+            : options;
+        try {
+            return await run(timedOptions);
+        }
+        catch (error) {
+            // When OUR timer fired, provider SDKs typically normalize the abort
+            // into their own generic cancel shape (e.g. Anthropic's
+            // APIUserAbortError, "Request was aborted.") and discard the signal's
+            // reason. The TimeoutError on the signal is the honest identity —
+            // rethrow it so logs and abort classification see a timeout, not a
+            // caller cancel. A genuine caller abort (their signal fired) keeps its
+            // original shape even if our timer also expired in the race window.
+            const reason = timeoutController?.controller.signal.aborted
+                ? timeoutController.controller.signal.reason
+                : undefined;
+            if (reason instanceof TimeoutError &&
+                isAbortError(error) &&
+                options.abortSignal?.aborted !== true) {
+                throw reason;
+            }
+            throw error;
+        }
+        finally {
+            timeoutController?.cleanup();
+        }
+    }
+    /**
+     * The per-provider generate budget from the descriptor, for native paths
+     * that call `withTurnTimeout` directly.
+     */
+    getDescriptorGenerateMs() {
+        return PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.timeouts
+            ?.generateMs;
+    }
+    /**
+     * Public handle on this provider's model object.
+     *
+     * `getAISDKModel()` is protected because only the generation pipeline should
+     * drive it. The browser bundle needs the same handle to back its public
+     * provider factories without reaching into provider internals, so this is the
+     * one sanctioned way out. The union return lets providers that resolve their
+     * model synchronously (Anthropic) and asynchronously (the OpenAI-compatible
+     * family) both satisfy it.
+     */
+    getModel() {
+        return this.getAISDKModel();
+    }
     /**
      * Get AI SDK model with middleware applied
      * This method wraps the base model with any configured middleware

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

@@ -12,9 +12,8 @@
  *
  * @module core/modules/GenerationHandler
  */
-import type { AIProviderName, EnhancedGenerateResult, NeuroLinkEvents, StandardRecord, TextGenerationOptions, ToolExecutionRecord, TypedEventEmitter } from "../../types/index.js";
+import type { GenerateTextResult, AIProviderName, EnhancedGenerateResult, NeuroLinkEvents, StandardRecord, TextGenerationOptions, ToolExecutionRecord, TypedEventEmitter } from "../../types/index.js";
 import type { LanguageModel, ModelMessage, Tool } from "../../types/index.js";
-import { generateText } from "../../utils/generation.js";
 /**
  * Turn budget + wrap-up deadline (parity with the googleVertex native loops).
  * A deadline is engaged only when the caller expressed one: turnTimeoutMs
@@ -39,6 +38,9 @@ export declare function resolveTurnBudget(options: TextGenerationOptions, turnSt
     wrapupLeadMs: number;
     turnDeadline: number | undefined;
 };
+/**
+ * GenerationHandler class - Handles text generation operations for AI providers
+ */
 export declare class GenerationHandler {
     private readonly providerName;
     private readonly modelName;
@@ -81,17 +83,28 @@ export declare class GenerationHandler {
      */
     deps?: {
         getEmitterFn?: () => TypedEventEmitter<NeuroLinkEvents> | undefined;
-        generateTextFn?: typeof generateText;
+        generateTextFn?: (options: Record<string, unknown>) => Promise<GenerateTextResult<Record<string, Tool>, unknown>>;
     });
     /**
      * Helper method to call generateText with optional structured output
      * @private
      */
-    private callGenerateText;
     /**
-     * Execute the generation with AI SDK
+     * 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.
      */
-    executeGeneration(model: LanguageModel, messages: ModelMessage[], tools: Record<string, Tool>, options: TextGenerationOptions): Promise<Awaited<ReturnType<typeof generateText>>>;
+    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.
@@ -109,11 +122,11 @@ export declare class GenerationHandler {
     /**
      * Log generation completion information
      */
-    logGenerationComplete(generateResult: Awaited<ReturnType<typeof generateText>>): void;
+    logGenerationComplete(generateResult: GenerateTextResult<Record<string, Tool>, unknown>): void;
     /**
      * Extract tool information from generation result
      */
-    extractToolInformation(generateResult: Awaited<ReturnType<typeof generateText>>): {
+    extractToolInformation(generateResult: GenerateTextResult<Record<string, Tool>, unknown>): {
         toolsUsed: string[];
         toolExecutions: Array<{
             name: string;
@@ -124,22 +137,7 @@ export declare class GenerationHandler {
     /**
      * Format the enhanced result
      */
-    /**
-     * One re-ask with `toolChoice: "none"` when a tool loop ends on a
-     * `tool-calls` finish that carries neither a tool call nor any text.
-     *
-     * io.net's Llama endpoint does exactly this on the step after a tool result
-     * when the caller asked for JSON: the model's JSON-shaped answer trips the
-     * vendor's tool-call parser, which drops it and reports
-     * `finish_reason: tool_calls` with `content: null` and no `tool_calls`.
-     * The AI-SDK loop has nothing to execute and stops, so the caller gets an
-     * empty turn although the tool ran. Replaying that request with
-     * `tool_choice: "none"` (or no tool list) returns the answer — verified on
-     * the wire, 4/4 — so the recovery is one bounded extra step that keeps the
-     * executed tool steps and usage in the returned result.
-     */
-    private recoverEmptyToolCallsFinish;
-    formatEnhancedResult(generateResult: Awaited<ReturnType<typeof generateText>>, tools: Record<string, Tool>, toolsUsed: string[], toolExecutions: ToolExecutionRecord[], options: TextGenerationOptions): EnhancedGenerateResult;
+    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
      */