@juspay/neurolink 9.66.0 → 9.67.1

package/dist/lib/voice/index.js

@@ -8,8 +8,17 @@
  * Use STTProcessor (src/lib/utils/sttProcessor.ts) for STT.
  * Use RealtimeProcessor for realtime voice sessions.
  *
+ * Importing this module also auto-registers every shipped TTS / STT /
+ * Realtime handler whose backing API key is present in `process.env`.
+ * Registration is idempotent and silently skipped on failure.
+ *
  * @module voice
  */
+import { logger } from "../utils/logger.js";
+import { STTProcessor } from "../utils/sttProcessor.js";
+import { TTSProcessor } from "../utils/ttsProcessor.js";
+import { GoogleTTSHandler } from "../adapters/tts/googleTTSHandler.js";
+import { RealtimeProcessor } from "./RealtimeVoiceAPI.js";
 // ============================================================================
 // ERROR CODES AND CONSTANTS
 // ============================================================================
@@ -35,21 +44,134 @@ export { asyncIterableToStream, ChunkedAudioStream, StreamHandler, StreamMerger,
 // ============================================================================
 // TTS PROVIDERS
 // ============================================================================
+export { GoogleTTSHandler } from "../adapters/tts/googleTTSHandler.js";
 export { AzureTTS, AzureTTS as AzureTTSHandler } from "./providers/AzureTTS.js";
+export { CartesiaTTS, CartesiaTTS as CartesiaTTSHandler, } from "./providers/CartesiaTTS.js";
 export { ElevenLabsTTS, ElevenLabsTTS as ElevenLabsTTSHandler, } from "./providers/ElevenLabsTTS.js";
+export { FishAudioTTS, FishAudioTTS as FishAudioTTSHandler, } from "./providers/FishAudioTTS.js";
 export { OpenAITTS, OpenAITTS as OpenAITTSHandler, } from "./providers/OpenAITTS.js";
 // ============================================================================
 // STT PROVIDERS
 // ============================================================================
 export { AzureSTT, AzureSTT as AzureSTTHandler } from "./providers/AzureSTT.js";
 export { DeepgramSTT, DeepgramSTT as DeepgramSTTHandler, } from "./providers/DeepgramSTT.js";
-// Export STT provider classes for direct use
 export { GoogleSTT, GoogleSTT as GoogleSTTHandler, } from "./providers/GoogleSTT.js";
 export { OpenAISTT, OpenAISTTHandler, WhisperSTT, WhisperSTTHandler, } from "./providers/OpenAISTT.js";
 // ============================================================================
 // REALTIME PROVIDERS
 // ============================================================================
 export { GeminiLive, GeminiLive as GeminiLiveHandler, } from "./providers/GeminiLive.js";
-// Export Realtime provider classes for direct use
 export { OpenAIRealtime, OpenAIRealtime as OpenAIRealtimeHandler, } from "./providers/OpenAIRealtime.js";
+// ============================================================================
+// AUTO-REGISTRATION
+// ============================================================================
+import { AzureTTS } from "./providers/AzureTTS.js";
+import { CartesiaTTS } from "./providers/CartesiaTTS.js";
+import { ElevenLabsTTS } from "./providers/ElevenLabsTTS.js";
+import { FishAudioTTS } from "./providers/FishAudioTTS.js";
+import { OpenAITTS } from "./providers/OpenAITTS.js";
+import { AzureSTT } from "./providers/AzureSTT.js";
+import { DeepgramSTT } from "./providers/DeepgramSTT.js";
+import { GoogleSTT } from "./providers/GoogleSTT.js";
+import { OpenAISTT } from "./providers/OpenAISTT.js";
+import { GeminiLive } from "./providers/GeminiLive.js";
+import { OpenAIRealtime } from "./providers/OpenAIRealtime.js";
+const TTS_HANDLER_CANDIDATES = [
+    {
+        // Google TTS doubles as both the AI Studio and Vertex TTS handler.
+        name: "google-ai",
+        aliases: ["vertex"],
+        factory: () => new GoogleTTSHandler(),
+    },
+    { name: "openai-tts", factory: () => new OpenAITTS() },
+    {
+        name: "elevenlabs",
+        aliases: ["elevenlabs-tts"],
+        factory: () => new ElevenLabsTTS(),
+    },
+    { name: "azure-tts", factory: () => new AzureTTS() },
+    { name: "fish-audio", factory: () => new FishAudioTTS() },
+    { name: "cartesia", factory: () => new CartesiaTTS() },
+];
+const STT_HANDLER_CANDIDATES = [
+    {
+        name: "whisper",
+        aliases: ["openai-stt"],
+        factory: () => new OpenAISTT(),
+    },
+    { name: "deepgram", factory: () => new DeepgramSTT() },
+    { name: "google-stt", factory: () => new GoogleSTT() },
+    { name: "azure-stt", factory: () => new AzureSTT() },
+];
+const REALTIME_HANDLER_CANDIDATES = [
+    { name: "openai-realtime", factory: () => new OpenAIRealtime() },
+    { name: "gemini-live", factory: () => new GeminiLive() },
+];
+function registerCandidates(candidates, supports, getRegistered, register, scope, requireConfigured) {
+    for (const { name, aliases, factory } of candidates) {
+        // Compute missingName / missingAliases separately so a manually-
+        // registered primary name doesn't block alias backfill. Important for
+        // BC: existing callers that register e.g. "elevenlabs" should still
+        // see "elevenlabs-tts" wired up by this loop.
+        const missingName = !supports(name);
+        const missingAliases = (aliases ?? []).filter((alias) => !supports(alias));
+        if (!missingName && missingAliases.length === 0) {
+            continue;
+        }
+        try {
+            // If the primary is already registered, reuse that exact handler
+            // instance for any alias backfill — wiring an alias to a *different*
+            // factory-fresh instance would silently diverge from the canonical
+            // primary's behavior (different config, different credentials).
+            // Only call factory() when we actually need to register the primary.
+            let handler;
+            if (!missingName) {
+                handler = getRegistered(name);
+            }
+            if (!handler) {
+                handler = factory();
+                if (requireConfigured && !handler.isConfigured()) {
+                    continue;
+                }
+            }
+            if (missingName) {
+                register(name, handler);
+            }
+            for (const alias of missingAliases) {
+                register(alias, handler);
+            }
+        }
+        catch (err) {
+            logger.debug(`[${scope}] ${name} auto-registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+/**
+ * Register every shipped TTS handler whose backing credentials are
+ * present in the environment. Safe to call multiple times.
+ */
+export function registerDefaultTTSHandlers() {
+    registerCandidates(TTS_HANDLER_CANDIDATES, (name) => TTSProcessor.supports(name), (name) => TTSProcessor.getHandler(name), (name, handler) => TTSProcessor.registerHandler(name, handler), "voice/tts", true);
+}
+/**
+ * Register every shipped STT handler whose backing credentials are
+ * present in the environment. Safe to call multiple times.
+ */
+export function registerDefaultSTTHandlers() {
+    registerCandidates(STT_HANDLER_CANDIDATES, (name) => STTProcessor.supports(name), (name) => STTProcessor.getHandler(name), (name, handler) => STTProcessor.registerHandler(name, handler), "voice/stt", true);
+}
+/**
+ * Register every shipped Realtime handler. Realtime handlers don't gate
+ * registration on isConfigured() because session-time API keys can be
+ * supplied per-call; missing creds surface when `connect()` is invoked.
+ */
+export function registerDefaultRealtimeHandlers() {
+    registerCandidates(REALTIME_HANDLER_CANDIDATES, (name) => RealtimeProcessor.supports(name), (name) => RealtimeProcessor.getHandler(name), (name, handler) => RealtimeProcessor.registerHandler(name, handler), "voice/realtime", false);
+}
+// Run once at module import so consumers who follow the documented
+// `nl.generate(...)` flow get every configured handler without manually
+// calling `registerHandler`.
+registerDefaultTTSHandlers();
+registerDefaultSTTHandlers();
+registerDefaultRealtimeHandlers();
 //# sourceMappingURL=index.js.map

package/dist/lib/voice/providers/CartesiaTTS.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Cartesia TTS Handler (synchronous /tts/bytes endpoint)
+ *
+ * Implements the standard `TTSHandler` synchronous-request contract on top
+ * of Cartesia's REST `/tts/bytes` endpoint. The pre-existing
+ * `adapters/tts/cartesiaHandler.ts` (`CartesiaStream`) targets the
+ * realtime WebSocket flow used by the voice server and does NOT implement
+ * `TTSHandler`; this file fills the gap so `nl.generate({ tts: { provider:
+ * "cartesia" } })` works through the same `TTSProcessor` dispatch as
+ * every other shipped TTS provider.
+ *
+ * @module voice/providers/CartesiaTTS
+ * @see https://docs.cartesia.ai/api-reference/tts/bytes
+ */
+import type { TTSHandler, TTSOptions, TTSResult } from "../../types/index.js";
+/**
+ * Cartesia synchronous TTS handler.
+ *
+ * Auth: `X-API-Key: ${CARTESIA_API_KEY}` + `Cartesia-Version` header.
+ */
+export declare class CartesiaTTS implements TTSHandler {
+    readonly maxTextLength = 5000;
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly apiVersion;
+    constructor(apiKey?: string);
+    isConfigured(): boolean;
+    synthesize(text: string, options?: TTSOptions): Promise<TTSResult>;
+    private mapOutputFormat;
+    private effectiveFormat;
+}

package/dist/lib/voice/providers/CartesiaTTS.js

@@ -0,0 +1,189 @@
+/**
+ * Cartesia TTS Handler (synchronous /tts/bytes endpoint)
+ *
+ * Implements the standard `TTSHandler` synchronous-request contract on top
+ * of Cartesia's REST `/tts/bytes` endpoint. The pre-existing
+ * `adapters/tts/cartesiaHandler.ts` (`CartesiaStream`) targets the
+ * realtime WebSocket flow used by the voice server and does NOT implement
+ * `TTSHandler`; this file fills the gap so `nl.generate({ tts: { provider:
+ * "cartesia" } })` works through the same `TTSProcessor` dispatch as
+ * every other shipped TTS provider.
+ *
+ * @module voice/providers/CartesiaTTS
+ * @see https://docs.cartesia.ai/api-reference/tts/bytes
+ */
+import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
+import { withTimeout, TimeoutError } from "../../utils/async/withTimeout.js";
+import { logger } from "../../utils/logger.js";
+import { TTS_ERROR_CODES, TTSError } from "../../utils/ttsProcessor.js";
+const DEFAULT_BASE_URL = "https://api.cartesia.ai";
+const DEFAULT_API_VERSION = "2025-04-16";
+const DEFAULT_MODEL = "sonic-2";
+// Same default voice as the streaming handler — a publicly available
+// Cartesia voice id ("Bright Female"). Override per-call via TTSOptions.voice.
+const DEFAULT_VOICE_ID = "694f9389-aac1-45b6-b726-9d9369183238";
+const REQUEST_TIMEOUT_MS = 30_000;
+/**
+ * Cartesia synchronous TTS handler.
+ *
+ * Auth: `X-API-Key: ${CARTESIA_API_KEY}` + `Cartesia-Version` header.
+ */
+export class CartesiaTTS {
+    maxTextLength = 5000;
+    apiKey;
+    baseUrl;
+    apiVersion;
+    constructor(apiKey) {
+        const resolved = (apiKey ?? process.env.CARTESIA_API_KEY ?? "").trim();
+        this.apiKey = resolved.length > 0 ? resolved : null;
+        this.baseUrl = (process.env.CARTESIA_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+        this.apiVersion = process.env.CARTESIA_API_VERSION ?? DEFAULT_API_VERSION;
+    }
+    isConfigured() {
+        return this.apiKey !== null;
+    }
+    async synthesize(text, options = {}) {
+        if (!this.apiKey) {
+            throw new TTSError({
+                code: TTS_ERROR_CODES.PROVIDER_NOT_CONFIGURED,
+                message: "CARTESIA_API_KEY not configured",
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+            });
+        }
+        const startTime = Date.now();
+        const voiceId = options.voice ?? process.env.CARTESIA_VOICE_ID ?? DEFAULT_VOICE_ID;
+        const requestedFormat = options.format ?? "mp3";
+        const { container, encoding, sampleRate } = this.mapOutputFormat(requestedFormat);
+        const cartesiaOpts = options;
+        const model = cartesiaOpts.model ?? process.env.CARTESIA_MODEL ?? DEFAULT_MODEL;
+        const body = {
+            model_id: model,
+            transcript: text,
+            voice: { mode: "id", id: voiceId },
+            output_format: {
+                container,
+                encoding,
+                sample_rate: sampleRate,
+            },
+            language: cartesiaOpts.language ?? "en",
+        };
+        let response;
+        try {
+            response = await withTimeout(fetch(`${this.baseUrl}/tts/bytes`, {
+                method: "POST",
+                headers: {
+                    "X-API-Key": this.apiKey,
+                    "Cartesia-Version": this.apiVersion,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+            }), REQUEST_TIMEOUT_MS, `Cartesia request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`);
+        }
+        catch (err) {
+            if (err instanceof TimeoutError) {
+                throw new TTSError({
+                    code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                    message: err.message,
+                    category: ErrorCategory.NETWORK,
+                    severity: ErrorSeverity.HIGH,
+                    retriable: true,
+                    originalError: err,
+                });
+            }
+            throw new TTSError({
+                code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                message: `Cartesia network error: ${err instanceof Error ? err.message : String(err)}`,
+                category: ErrorCategory.NETWORK,
+                severity: ErrorSeverity.HIGH,
+                retriable: true,
+                originalError: err instanceof Error ? err : undefined,
+            });
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            const retriable = response.status === 408 ||
+                response.status === 429 ||
+                response.status >= 500;
+            throw new TTSError({
+                code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                message: `Cartesia synthesis failed: ${response.status} — ${text}`,
+                category: retriable ? ErrorCategory.NETWORK : ErrorCategory.EXECUTION,
+                severity: ErrorSeverity.HIGH,
+                retriable,
+                context: { status: response.status, voiceId, container, encoding },
+            });
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const audioBuffer = Buffer.from(arrayBuffer);
+        const latency = Date.now() - startTime;
+        const effectiveFormat = this.effectiveFormat(container, encoding);
+        const result = {
+            buffer: audioBuffer,
+            format: effectiveFormat,
+            size: audioBuffer.length,
+            voice: voiceId,
+            sampleRate,
+            metadata: {
+                latency,
+                provider: "cartesia",
+                model,
+                requestedFormat: options.format,
+                container,
+                encoding,
+            },
+        };
+        logger.info(`[CartesiaTTS] Synthesized ${audioBuffer.length} bytes in ${latency}ms`);
+        return result;
+    }
+    mapOutputFormat(format) {
+        switch (format) {
+            case "mp3":
+                return { container: "mp3", encoding: "mp3", sampleRate: 44_100 };
+            case "wav":
+                return { container: "wav", encoding: "pcm_s16le", sampleRate: 44_100 };
+            case "pcm16":
+                return { container: "raw", encoding: "pcm_s16le", sampleRate: 24_000 };
+            default:
+                // Cartesia only supports mp3 / wav / pcm16 today. Fail fast instead
+                // of silently downgrading so callers passing ogg / flac / m4a /
+                // opus / webm see a clear error rather than mislabeled MP3 bytes.
+                throw new TTSError({
+                    code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                    message: `Cartesia does not support output format "${format}". Supported: mp3, wav, pcm16.`,
+                    category: ErrorCategory.VALIDATION,
+                    severity: ErrorSeverity.MEDIUM,
+                    retriable: false,
+                    context: {
+                        format,
+                        supported: ["mp3", "wav", "pcm16"],
+                    },
+                });
+        }
+    }
+    effectiveFormat(container, encoding) {
+        if (container === "mp3") {
+            return "mp3";
+        }
+        if (container === "wav") {
+            return "wav";
+        }
+        if (encoding === "pcm_s16le") {
+            return "pcm16";
+        }
+        // In practice mapOutputFormat() throws before we reach this branch
+        // (it only emits mp3/wav/raw containers from a validated input).
+        // Throwing here too means a future container/encoding combination
+        // surfaces clearly instead of returning mislabeled bytes as "mp3".
+        throw new TTSError({
+            code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+            message: `Unsupported Cartesia output combination: container=${container}, encoding=${encoding}`,
+            category: ErrorCategory.EXECUTION,
+            severity: ErrorSeverity.HIGH,
+            retriable: false,
+            context: { container, encoding },
+        });
+    }
+}
+//# sourceMappingURL=CartesiaTTS.js.map

package/dist/lib/workflow/config.d.ts

@@ -41,9 +41,9 @@ export declare const JudgeConfigSchema: z.ZodObject<{
     criteria: z.ZodArray<z.ZodString>;
     outputFormat: z.ZodEnum<{
         scores: "scores";
+        detailed: "detailed";
         ranking: "ranking";
         best: "best";
-        detailed: "detailed";
     }>;
     customPrompt: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodOptional<z.ZodString>;
@@ -195,9 +195,9 @@ export declare const WorkflowConfigSchema: z.ZodObject<{
         criteria: z.ZodArray<z.ZodString>;
         outputFormat: z.ZodEnum<{
             scores: "scores";
+            detailed: "detailed";
             ranking: "ranking";
             best: "best";
-            detailed: "detailed";
         }>;
         customPrompt: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodOptional<z.ZodString>;
@@ -219,9 +219,9 @@ export declare const WorkflowConfigSchema: z.ZodObject<{
         criteria: z.ZodArray<z.ZodString>;
         outputFormat: z.ZodEnum<{
             scores: "scores";
+            detailed: "detailed";
             ranking: "ranking";
             best: "best";
-            detailed: "detailed";
         }>;
         customPrompt: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodOptional<z.ZodString>;

package/dist/music/index.d.ts

@@ -7,7 +7,21 @@
  * Use `MusicProcessor.generate(provider, options)` to dispatch to the
  * registered handler for `provider`.
  *
+ * Importing this module also auto-registers every shipped music handler
+ * whose backing API key is present in `process.env`. Registration is
+ * idempotent and silently skipped if a provider is already registered or
+ * its constructor throws (e.g. missing optional native dependency).
+ *
  * @module music
  */
 export { MUSIC_ERROR_CODES, MusicError, MusicProcessor, } from "../utils/musicProcessor.js";
 export { BeatovenMusic, BeatovenMusic as BeatovenMusicHandler, } from "./providers/BeatovenMusic.js";
+export { ElevenLabsMusic, ElevenLabsMusic as ElevenLabsMusicHandler, } from "./providers/ElevenLabsMusic.js";
+export { LyriaMusic, LyriaMusic as LyriaMusicHandler, } from "./providers/LyriaMusic.js";
+export { ReplicateMusic, ReplicateMusic as ReplicateMusicHandler, } from "./providers/ReplicateMusic.js";
+/**
+ * Register every shipped music handler whose backing credentials are
+ * present in the environment. Safe to call multiple times — existing
+ * registrations are preserved.
+ */
+export declare function registerDefaultMusicHandlers(): void;

package/dist/music/index.js

@@ -7,7 +7,87 @@
  * Use `MusicProcessor.generate(provider, options)` to dispatch to the
  * registered handler for `provider`.
  *
+ * Importing this module also auto-registers every shipped music handler
+ * whose backing API key is present in `process.env`. Registration is
+ * idempotent and silently skipped if a provider is already registered or
+ * its constructor throws (e.g. missing optional native dependency).
+ *
  * @module music
  */
+import { logger } from "../utils/logger.js";
+import { MusicProcessor } from "../utils/musicProcessor.js";
 export { MUSIC_ERROR_CODES, MusicError, MusicProcessor, } from "../utils/musicProcessor.js";
+// ============================================================================
+// HANDLER CLASSES
+// ============================================================================
 export { BeatovenMusic, BeatovenMusic as BeatovenMusicHandler, } from "./providers/BeatovenMusic.js";
+export { ElevenLabsMusic, ElevenLabsMusic as ElevenLabsMusicHandler, } from "./providers/ElevenLabsMusic.js";
+export { LyriaMusic, LyriaMusic as LyriaMusicHandler, } from "./providers/LyriaMusic.js";
+export { ReplicateMusic, ReplicateMusic as ReplicateMusicHandler, } from "./providers/ReplicateMusic.js";
+// ============================================================================
+// AUTO-REGISTRATION
+// ============================================================================
+import { BeatovenMusic } from "./providers/BeatovenMusic.js";
+import { ElevenLabsMusic } from "./providers/ElevenLabsMusic.js";
+import { LyriaMusic } from "./providers/LyriaMusic.js";
+import { ReplicateMusic } from "./providers/ReplicateMusic.js";
+const MUSIC_HANDLER_CANDIDATES = [
+    { name: "beatoven", factory: () => new BeatovenMusic() },
+    {
+        name: "elevenlabs-music",
+        aliases: ["elevenlabs-sound"],
+        factory: () => new ElevenLabsMusic(),
+    },
+    { name: "lyria", factory: () => new LyriaMusic() },
+    {
+        name: "replicate",
+        aliases: ["musicgen"],
+        factory: () => new ReplicateMusic(),
+    },
+];
+/**
+ * Register every shipped music handler whose backing credentials are
+ * present in the environment. Safe to call multiple times — existing
+ * registrations are preserved.
+ */
+export function registerDefaultMusicHandlers() {
+    for (const { name, aliases, factory } of MUSIC_HANDLER_CANDIDATES) {
+        // Compute missingName / missingAliases separately so a pre-registered
+        // primary doesn't block alias backfill — keeps "musicgen" reachable
+        // when only "replicate" was wired up via another path (and likewise
+        // "elevenlabs-sound" vs "elevenlabs-music").
+        const missingName = !MusicProcessor.supports(name);
+        const missingAliases = (aliases ?? []).filter((alias) => !MusicProcessor.supports(alias));
+        if (!missingName && missingAliases.length === 0) {
+            continue;
+        }
+        try {
+            // Reuse the already-registered primary's handler for alias backfill
+            // when one exists — wiring an alias to a factory-fresh instance
+            // would silently diverge from the canonical primary's config.
+            let handler;
+            if (!missingName) {
+                handler = MusicProcessor.getHandler(name);
+            }
+            if (!handler) {
+                handler = factory();
+                if (!handler.isConfigured()) {
+                    continue;
+                }
+            }
+            if (missingName) {
+                MusicProcessor.registerHandler(name, handler);
+            }
+            for (const alias of missingAliases) {
+                MusicProcessor.registerHandler(alias, handler);
+            }
+        }
+        catch (err) {
+            logger.debug(`[music] ${name} auto-registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+// Run once at module import so consumers who follow the documented
+// `nl.generate(...)` flow get every configured handler without manually
+// calling `registerHandler`.
+registerDefaultMusicHandlers();

package/dist/providers/openaiCompatible.d.ts

@@ -1,16 +1,17 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
-import type { LanguageModel, Schema } from "../types/index.js";
+import type { LanguageModel, Schema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
 /**
- * OpenAI Compatible Provider - BaseProvider Implementation
- * Provides access to one of the OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)
+ * OpenAI Compatible Provider — direct HTTP, no AI SDK.
+ *
+ * Talks to any OpenAI chat-completions-shaped endpoint (LiteLLM, vLLM,
+ * OpenRouter, etc.). The entire request/stream/tool-loop is inline above;
+ * no `streamText`, no `LanguageModelV3`, no `@ai-sdk/openai`.
  */
 export declare class OpenAICompatibleProvider extends BaseProvider {
-    private model?;
     private config;
+    private resolvedModel?;
     private discoveredModel?;
-    private customOpenAI;
     constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: {
         apiKey?: string;
         baseURL?: string;
@@ -18,33 +19,59 @@ export declare class OpenAICompatibleProvider extends BaseProvider {
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
-     * Returns the Vercel AI SDK model instance for OpenAI Compatible endpoints
-     * Handles auto-discovery if no model was specified
+     * Abstract from BaseProvider — used by the parent's generate() path which
+     * still goes through `generateText`. Returns a thin LanguageModelV3-shaped
+     * object that delegates to the same HTTP helpers used by executeStream.
+     * Stays inside this file so no AI-SDK-named import is needed here.
      */
     protected getAISDKModel(): Promise<LanguageModel>;
-    protected formatProviderError(error: unknown): Error;
+    private resolveModelName;
     /**
-     * OpenAI Compatible endpoints support tools for compatible models
+     * Returns a minimal V3-shaped model. Only used by BaseProvider's
+     * `generate()` non-streaming path which still relies on the parent's
+     * `generateText`. The streaming path bypasses this entirely.
      */
+    private buildDelegatingModel;
+    protected formatProviderError(error: unknown): Error;
     supportsTools(): boolean;
     /**
-     * Provider-specific streaming implementation
-     * Note: This is only used when tools are disabled
+     * Streaming path — drives the OpenAI endpoint directly. No streamText,
+     * no AI SDK orchestrator. Tool calls, multi-step loops, telemetry,
+     * abort handling all inline.
      */
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     /**
-     * Get available models from OpenAI Compatible endpoint
+     * Multi-step streaming orchestrator. One iteration per model turn:
      *
-     * Fetches from the /v1/models endpoint to discover available models.
-     * This is useful for auto-discovery when no model is specified.
+     *   1. POST /chat/completions with stream:true
+     *   2. Parse SSE; push text deltas to the consumer queue
+     *   3. If the step emitted tool_calls → execute each, append to
+     *      conversation, loop again
+     *   4. Otherwise resolve the deferred analytics promises and exit
+     *
+     * Bounded by `args.maxSteps`. Any thrown error rejects loopPromise and
+     * is surfaced to the consumer via `await loopPromise` in the stream
+     * generator.
      */
-    getAvailableModels(): Promise<string[]>;
+    private runStreamLoop;
     /**
-     * Get the first available model for auto-selection
+     * One streaming round-trip: POST chat-completions, parse SSE, push text
+     * deltas to the consumer queue. Returns the accumulated SSE result so
+     * the caller can decide whether to run tools and re-stream.
      */
-    getFirstAvailableModel(): Promise<string>;
+    private streamOneStep;
     /**
-     * Fallback models when discovery fails
+     * Execute every tool_call collected from one streaming step:
+     *
+     *   - append an `assistant` turn carrying the tool_calls
+     *   - resolve each tool from the local registry and run it
+     *   - emit tool:start/tool:end events
+     *   - push per-execution summaries
+     *   - append a `tool` turn per result so the next step can see them
+     *   - mirror BaseProvider's tool-events + storage hooks
      */
+    private executeToolBatch;
+    getAvailableModels(): Promise<string[]>;
+    getFirstAvailableModel(): Promise<string>;
     private getFallbackModels;
 }