@umituz/web-ai 1.1.0 → 1.2.0

package/dist/providers/index.d.ts

@@ -2,12 +2,12 @@ import { C as CostEstimateRequest, d as ITextProvider, a as IMediaProvider } fro
 export { A as AnyProvider, I as IAIProvider, b as IProviderBase, P as ProviderCapability, e as ProviderFactory, f as ProviderFactoryConfig, g as createProviderFactory, i as isMediaProvider, h as isTextProvider } from '../provider.factory-B9RNUTYj.js';
 import { P as ProviderHealth, b as TextTier, T as TextRequest, G as GenerationResult, a as StructuredTextRequest, S as StructuredGeneration, d as StreamCallbacks, F as FinishReason, C as ChatMessage, c as TokenUsage } from '../index-OhvYUTXf.js';
 import { A as AIError, c as TierModelMap } from '../index-1e91KRYU.js';
-import { h as AnthropicProviderConfig, e as AnthropicEffort, x as AnthropicMessage, f as AnthropicMessagesRequest, i as AnthropicStopReason, g as AnthropicMessagesResponse, t as GroqProviderConfig, r as GroqMessage, q as GroqGenerationConfig, k as GroqChatRequest, l as GroqChatResponse, S as StreamRequestOptions$1, s as GroqMessageRole, u as GroqReasoningEffort } from '../create-ai-D-oEWzf9.js';
-export { A as AIProviderConfig, a as ANTHROPIC_API_VERSION, b as ANTHROPIC_DEFAULT_MAX_TOKENS, c as ANTHROPIC_MODELS, d as ANTHROPIC_TIERS, j as AnthropicStreamEvent, G as GroqChatChunk, m as GroqChoice, n as GroqChunkChoice, o as GroqConfig, p as GroqErrorResponse, v as GroqUsage, w as createAI } from '../create-ai-D-oEWzf9.js';
+import { h as AnthropicProviderConfig, e as AnthropicEffort, C as AnthropicMessage, f as AnthropicMessagesRequest, i as AnthropicStopReason, g as AnthropicMessagesResponse, t as GroqProviderConfig, r as GroqMessage, q as GroqGenerationConfig, k as GroqChatRequest, l as GroqChatResponse, S as StreamRequestOptions$1, s as GroqMessageRole, u as GroqReasoningEffort, O as OpenAiCompatibleProviderConfig, z as WorkersAIProviderConfig, w as WorkersAIEnv, y as WorkersAIMessage } from '../create-ai-Cq3HkJxd.js';
+export { A as AIProviderConfig, a as ANTHROPIC_API_VERSION, b as ANTHROPIC_DEFAULT_MAX_TOKENS, c as ANTHROPIC_MODELS, d as ANTHROPIC_TIERS, j as AnthropicStreamEvent, G as GroqChatChunk, m as GroqChoice, n as GroqChunkChoice, o as GroqConfig, p as GroqErrorResponse, v as GroqUsage, W as WorkersAIBinding, x as WorkersAIError, B as createAI } from '../create-ai-Cq3HkJxd.js';
 import { b as CacheStats } from '../cache-manager-Df9LLYGA.js';
-import { b as RetryManager, a as RequestQueue, R as RequestDeduplicator, A as AssistantToolCall } from '../tool-call-accumulator-C7KhaXZA.js';
-import { b as IGroqHttpClient, T as TextGenerationService, a as GenerationStage, f as PrunaModelId, h as PrunaPredictionResponse, m as TextToVideoInput, G as GenerateOptions, j as PrunaResult, e as PrunaInput } from '../cancellation-error-hYcE9AS9.js';
-export { C as CancellationError, I as IGroqChatService, c as ImageToImageInput, d as ImageToVideoInput, P as PrunaAspectRatio, g as PrunaOutput, i as PrunaResolution, S as StreamingCallbacks, k as StructuredGenerationOptions, n as TextGenerationOptions, l as TextToImageInput } from '../cancellation-error-hYcE9AS9.js';
+import { g as RetryManager, f as RequestQueue, R as RequestDeduplicator, b as AssistantToolCall, a as AiErrorCode, d as ContextMessage } from '../context-manager-CuZz0vnC.js';
+import { b as IGroqHttpClient, T as TextGenerationService, a as GenerationStage, f as PrunaModelId, h as PrunaPredictionResponse, m as TextToVideoInput, G as GenerateOptions, j as PrunaResult, e as PrunaInput } from '../cancellation-error-D9LETLCD.js';
+export { C as CancellationError, I as IGroqChatService, c as ImageToImageInput, d as ImageToVideoInput, P as PrunaAspectRatio, g as PrunaOutput, i as PrunaResolution, S as StreamingCallbacks, k as StructuredGenerationOptions, n as TextGenerationOptions, l as TextToImageInput } from '../cancellation-error-D9LETLCD.js';
 import { d as ChatService } from '../chat.service-B4Isrckn.js';
 import { c as GeminiConfig, I as ImageGenerationRequest, G as GeneratedContent, V as VideoGenerationRequest, a as ImageToVideoRequest, b as VideoToVideoRequest, F as FalConfig, P as PrunaConfig } from '../ProviderConfig-DIFa9nmG.js';
 
@@ -364,6 +364,295 @@ declare class FalProvider extends BaseProvider implements IMediaProvider {
 }
 declare function createFalProvider(config: FalConfig): FalProvider;
 
+/**
+ * Generic OpenAI-compatible text provider — the factory-registered face of
+ * the existing `createOpenAiCompatibleAdapter`. Speaks the wire every
+ * OpenAI-shaped endpoint speaks, which makes it the one block an app needs
+ * when its model access arrives through a gateway URL instead of a named
+ * vendor key.
+ */
+declare class OpenAiCompatibleProvider implements ITextProvider {
+    readonly config: OpenAiCompatibleProviderConfig;
+    readonly id = "openai-compatible";
+    readonly name = "OpenAI-compatible";
+    readonly capabilities: readonly ["text"];
+    private readonly adapter;
+    private readonly tiers;
+    private readonly jsonParser;
+    constructor(config: OpenAiCompatibleProviderConfig);
+    resolveModel(tier: TextTier): string;
+    healthCheck(): Promise<ProviderHealth>;
+    estimateCost(): Promise<number>;
+    generate(request: TextRequest): Promise<GenerationResult>;
+    generateStructured<T>(request: StructuredTextRequest): Promise<StructuredGeneration<T>>;
+    stream(request: TextRequest, callbacks: StreamCallbacks): Promise<GenerationResult>;
+    /** Drain one adapter stream to its end. `onChunk`, when given, sees answer
+     *  deltas as they arrive — the streaming surface is this same drain. */
+    private consume;
+    private modelFor;
+    private noContentError;
+    private toAdapterRequest;
+    /** Neutral messages onto the adapter's shape; systemPrompt becomes the
+     *  leading system message (in-band, the OpenAI way). */
+    private toWireMessages;
+}
+declare function createOpenAiCompatibleProvider(config: OpenAiCompatibleProviderConfig): OpenAiCompatibleProvider;
+
+/**
+ * Tier defaults for the Workers AI catalogue. `fast` drops to the 8b
+ * fp8-fast deployment; `balanced` and `powerful` share the 70b model —
+ * it is the top instruct text model the catalogue offers today, so a
+ * `powerful` request is served honestly rather than failing the tier walk.
+ */
+declare const WORKERS_AI_TIERS: TierModelMap;
+/**
+ * Cloudflare Workers AI text provider over the `env.AI` binding. There is
+ * no apiKey and no fetch — the binding IS the transport, so this provider
+ * skips BaseProvider's fetch machinery (like the transport-owning Groq and
+ * Anthropic providers do) and implements IProviderBase directly.
+ *
+ * `createAI({ workersAI: { binding: env.AI } })` registers it when the
+ * binding is present; an absent binding never registers, so unconfigured
+ * deployments fail over down the priority walk instead of erroring.
+ */
+declare class WorkersAIProvider implements ITextProvider {
+    readonly id = "workers-ai";
+    readonly name = "Cloudflare Workers AI";
+    readonly capabilities: readonly ["text"];
+    private readonly binding;
+    private readonly tiers;
+    private readonly jsonParser;
+    constructor(config: WorkersAIProviderConfig);
+    resolveModel(tier: TextTier): string;
+    healthCheck(): Promise<ProviderHealth>;
+    /** Workers AI is allocation-priced (neurons per deployment), not per
+     *  request — there is no per-call cost to estimate. */
+    estimateCost(_request: CostEstimateRequest): Promise<number>;
+    generate(request: TextRequest): Promise<GenerationResult>;
+    generateStructured<T>(request: StructuredTextRequest): Promise<StructuredGeneration<T>>;
+    stream(request: TextRequest, callbacks: StreamCallbacks): Promise<GenerationResult>;
+}
+declare function createWorkersAIProvider(config: WorkersAIProviderConfig): WorkersAIProvider;
+
+/**
+ * Workers AI text client over the `env.AI` binding — non-streaming run()
+ * plus the streaming twin, both hardened against the deployment quirks the
+ * production ports (storyora STYLORA lane) documented:
+ *
+ *   1. The fp8-fast deployments answer in BOTH shapes — the documented
+ *      legacy `{response}` mirror AND an OpenAI chat.completion body — and
+ *      the mirror has been observed MISSING on a second sequential call in
+ *      one invocation. Read either shape, legacy first.
+ *   2. Streaming answers as SSE frames (`data: {"response": "…"} …
+ *      data: [DONE]`); a JSON payload can split across chunk boundaries, so
+ *      the parser pushes an unparseable line back and waits for more bytes.
+ */
+/** Speed-optimized 70b instruct — the default. If p95 latency hurts, drop
+ *  to "@cf/meta/llama-3.1-8b-instruct-fp8-fast" (one line). */
+declare const WORKERS_AI_LLM_MODEL = "@cf/meta/llama-3.3-70b-instruct-fp8-fast";
+interface WorkersAITextOptions {
+    maxTokens?: number;
+    temperature?: number;
+    /** Explicit model id — wins over the default. */
+    model?: string;
+}
+/** The text lane is live only when the AI binding was injected. */
+declare function workersAIConfigured(env: WorkersAIEnv): boolean;
+/** One provider call with a timeout — resolves the non-streaming text by
+ *  reading both documented response shapes. Throws WorkersAIError on any
+ *  failure, including an empty reply. */
+declare function runWorkersAIText(env: WorkersAIEnv, messages: ReadonlyArray<ChatMessage | WorkersAIMessage>, opts?: WorkersAITextOptions): Promise<string>;
+/**
+ * Streaming twin — yields incremental tokens off the provider's SSE stream.
+ * Frame parsing mirrors typical client-side SSE readers (buffered lines, \r
+ * trimming, comment skip) so both ends tolerate the same wire quirks.
+ */
+declare function streamWorkersAIText(env: WorkersAIEnv, messages: ReadonlyArray<ChatMessage | WorkersAIMessage>, opts?: WorkersAITextOptions): AsyncGenerator<string>;
+
+/** Engine descriptor: the catalog id plus melotts's langParam, when a
+ *  model takes one ("tr", "en", …). */
+interface WorkersAISpeechEngine {
+    model: string;
+    langParam?: string;
+}
+interface WorkersAISpeechResult {
+    /** mp3 bytes — every verified engine answers audio/mpeg. */
+    bytes: Uint8Array;
+}
+/** One engine call — resolves mp3 bytes. Throws WorkersAIError on timeout,
+ *  transport failure or an empty/foreign-shaped reply. */
+declare function speakWithWorkersAI(env: WorkersAIEnv, engine: WorkersAISpeechEngine, text: string): Promise<WorkersAISpeechResult>;
+
+/**
+ * Entities for the fal.ai QUEUE client — the async lane (submit → poll →
+ * harvest) that long-running image/video/audio models ride, as opposed to
+ * the sync FalProvider in ./fal.provider.ts. Apps persist jobs in their own
+ * storage; this module only speaks the queue wire.
+ */
+/** Any env carrying the fal key as an optional secret (app envs satisfy it). */
+interface FalQueueEnv {
+    FAL_KEY?: string;
+}
+/** Error carrying the provider status when one exists (route → HTTP code). */
+declare class FalQueueError extends Error {
+    readonly status?: number;
+    constructor(message: string, status?: number);
+}
+/** Queue lifecycle as fal reports it. */
+type FalJobStatus = 'IN_QUEUE' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED';
+/** POST /{model} response — the ABSOLUTE URLs apps store on their job rows. */
+type FalSubmitResponse = {
+    status: string;
+    request_id: string;
+    response_url: string;
+    status_url: string;
+};
+type FalStatusResponse = {
+    status: FalJobStatus;
+    queue_position?: number;
+    logs?: Array<{
+        message?: string;
+        level?: string;
+    }>;
+};
+/** What submit() hands back — stored verbatim, never reconstructed. */
+interface FalSubmittedJob {
+    requestId: string;
+    statusUrl: string;
+    responseUrl: string;
+}
+/** One checkStatus() result — logs are flattened to message strings. */
+interface FalStatusSnapshot {
+    status: FalJobStatus;
+    queuePosition?: number;
+    logs?: string[];
+}
+/**
+ * Capability-neutral job input — every lane's request folded into one
+ * shape. Wire builders pick the fields the picked model takes; anything a
+ * model does not take is rejected by the app's spec gate, never silently
+ * dropped onto the wire.
+ */
+interface FalJobInput {
+    prompt: string;
+    /** Image lane: how many images were requested. */
+    numImages?: number;
+    aspectRatio?: string;
+    /** Video lane (i2v): source image — https URL or data URI. */
+    imageUrl?: string;
+    /** Video/audio lane: selected length in seconds (spec-driven). */
+    durationSeconds?: number;
+    /** Video lane: provider negative prompt, when the model supports one. */
+    negativePrompt?: string;
+    /** Video lane: e.g. "720p", when the model offers resolutions. */
+    resolution?: string;
+    /** Audio lane: lyrics with structural [verse]/[chorus] tags. */
+    lyrics?: string;
+    /** Audio lane: vocals off — instrumental render. */
+    instrumental?: boolean;
+}
+/**
+ * Parsed provider output — fal-hosted URLs, persisted verbatim by the app.
+ * fal.media URLs are temporary (~7 days); apps harvest into durable storage.
+ * Parsers return null/empty when nothing usable came back — that is a
+ * failed job, never an empty success.
+ */
+interface FalJobOutput {
+    /** Image lane: one URL per requested image. */
+    imageUrls?: string[];
+    videoUrl?: string;
+    audioUrl?: string;
+    seed?: number;
+    width?: number;
+    height?: number;
+    contentType?: string;
+    fileSize?: number;
+}
+/**
+ * Per-model input contract for the video lane. Every entry is read off the
+ * live model schema — a model without a verified spec entry stays locked in
+ * the app's catalog (the registry IS the availability contract).
+ */
+interface FalVideoModelSpec {
+    /** Selectable durations in seconds — what the studio's chips offer. */
+    durations: number[];
+    /** How the provider serializes duration: kling "5", veo "8s", wan none. */
+    durationFormat: 'plain' | 's-suffix' | 'none';
+    /** Absent = no aspect is sent; i2v video follows the input image. */
+    aspectRatios?: string[];
+    resolutions?: string[];
+    supportsNegativePrompt: boolean;
+    /** Model can generate an audio track (veo family) — sent as true. */
+    generateAudio?: boolean;
+}
+/** Per-model input contract for the audio (music) lane. */
+interface FalAudioModelSpec {
+    /** Selectable durations in seconds. */
+    durations: number[];
+    /** Model separates lyrics from the tag prompt ([verse]/[chorus] tags). */
+    supportsLyrics: boolean;
+    /** Model takes an instrumental flag (vocals off). */
+    supportsInstrumental: boolean;
+}
+/** The fal image_size values each picker ratio maps onto (flux family). */
+declare const FAL_ASPECT_IMAGE_SIZES: Record<string, string>;
+
+/** The fal lane is live only when the FAL_KEY secret exists. */
+declare function falQueueConfigured(env: FalQueueEnv): boolean;
+/** The queue surface one env yields. Stateless by design — one object per
+ *  request handler is fine, and so is a module-level singleton. */
+interface FalQueueClient {
+    /** POST /{model} — returns the absolute URLs persisted on the job row. */
+    submit(model: string, input: Record<string, unknown>): Promise<FalSubmittedJob>;
+    /** GET the STORED status URL — never reconstructed from model paths. */
+    checkStatus(statusUrl: string): Promise<FalStatusSnapshot>;
+    /** GET the STORED response URL — only called after COMPLETED. */
+    fetchResult(responseUrl: string): Promise<unknown>;
+}
+/** Build the queue client for an env (`createFalQueue(c.env)` in a route). */
+declare function createFalQueue(env: FalQueueEnv): FalQueueClient;
+
+/** Image input mapper — flux family takes image_size off the aspect ratio;
+ *  fast-sdxl takes prompt + num_images only (kept minimal until its full
+ *  schema is verified against fal). */
+declare function buildFalImageInput(model: string, input: FalJobInput): Record<string, unknown>;
+/** Normalize image output — flux family `{images:[{url,w,h}]}`, single-image
+ *  models `{image:{url}}`, plus the seed some models echo back. */
+declare function parseFalImageOutput(raw: unknown): FalJobOutput;
+/** Video input mapper — entirely spec-driven. The caller has already
+ *  validated the request against the model's spec, so this only serializes:
+ *  duration format per family (kling "5", veo "8s", wan none), aspect/
+ *  resolution only when the model takes them, image_url for i2v.
+ *  Unsupported params are never silently dropped onto the wire. */
+declare function buildFalVideoInput(spec: FalVideoModelSpec, input: FalJobInput): Record<string, unknown>;
+/** Every verified fal video model returns `{video: {url, content_type?,
+ *  file_size?}}`. Returns null when there's no usable video — the caller
+ *  fails the job ("provider completed without a video") rather than
+ *  persisting an empty output. */
+declare function parseFalVideoOutput(raw: unknown): FalJobOutput | null;
+/** ACE-Step reads tag-style prompts ("lofi, hiphop, chill"): lowercase,
+ *  words over three characters, five keywords max, comma-joined. A
+ *  comma-separated brief passes through nearly untouched; prose collapses
+ *  to its strongest words. */
+declare function buildFalTagPrompt(prompt: string): string;
+/** Lyrics normalization: instrumental renders get the [inst] marker; bare
+ *  lyrics are wrapped in a [verse] block so the model reads structure even
+ *  when the writer used no tags. Lyrics that already carry structural tags
+ *  pass through verbatim. */
+declare function buildFalAudioLyrics(input: {
+    lyrics?: string;
+    instrumental?: boolean;
+}): string | undefined;
+/** Audio input mapper — spec-driven like the video lane. CassetteAI's
+ *  verified contract is the lean one (tags + duration); ACE-Step takes the
+ *  tag prompt, normalized lyrics, duration and the instrumental flag. */
+declare function buildFalAudioInput(spec: FalAudioModelSpec, input: FalJobInput): Record<string, unknown>;
+/** The verified fal music models answer in different shapes — ace-step
+ *  `{audio_url: {url}}`, CassetteAI `{audio_file: {url}}`, plus the
+ *  `audio.url` and flat-string variants. Returns null when there's no
+ *  usable audio — the caller fails the job rather than persisting emptiness. */
+declare function parseFalAudioOutput(raw: unknown): FalJobOutput | null;
+
 declare class AuthenticationError extends Error {
     constructor(message?: string);
 }
@@ -526,9 +815,11 @@ interface ToolDefinition {
 interface AdapterRequest {
     readonly externalModelId: string;
     readonly messages: readonly AdapterChatMessage[];
-    readonly temperature: number;
-    readonly maxOutputTokens: number;
-    readonly topP: number;
+    /** Sampling hints — absent fields stay off the wire (undefined keys are
+     *  dropped by JSON.stringify), matching callers that specify none. */
+    readonly temperature?: number;
+    readonly maxOutputTokens?: number;
+    readonly topP?: number;
     readonly tools?: readonly ToolDefinition[];
     readonly images?: readonly RequestImage[];
     readonly signal?: AbortSignal;
@@ -548,7 +839,11 @@ interface ChatAdapter {
     stream(req: AdapterRequest): AsyncIterable<ProviderEvent>;
 }
 interface AdapterConfig {
-    readonly baseUrl: string;
+    /** API root, e.g. https://api.openai.com/v1 — /chat/completions is appended. */
+    readonly baseUrl?: string;
+    /** Full endpoint URL; wins over baseUrl. Gateways (Cloudflare AI Gateway,
+     *  OpenRouter proxies) hand out the complete chat-completions URL. */
+    readonly endpointUrl?: string;
     readonly apiKey: string;
     readonly timeoutMs: number;
 }
@@ -557,4 +852,121 @@ declare function createOpenAiCompatibleAdapter(config: AdapterConfig): ChatAdapt
 
 declare function createAnthropicAdapter(config: AdapterConfig): ChatAdapter;
 
-export { API_ENDPOINTS, type AdapterChatMessage, type AdapterChatRole, type AdapterConfig, type AdapterRequest, AnthropicEffort, AnthropicHttpTransport, AnthropicMessagesRequest, AnthropicMessagesResponse, AnthropicProvider, AnthropicProviderConfig, AnthropicRequestBuilder, AnthropicStopReason, type AppContainer, type AudioTranscriptionAdapter, type AudioTranscriptionRequest, type AudioTranscriptionResult, AuthenticationError, BaseProvider as BaseAIProvider, BaseProvider, type BaseProviderConfig, type ChatAdapter, CostEstimateRequest, DEFAULT_BASE_URL, DEFAULT_GENERATION_CONFIG, DEFAULT_MODELS, type EmbeddingsAdapter, type EmbeddingsRequest, type EmbeddingsResult, FalProvider, GEMINI_TIERS, GROQ_MODELS, GROQ_TIERS, GeminiProvider, GenerateOptions, GenerationFailedError, GenerationStage, GroqChatRequest, GroqChatRequestBuilder, GroqChatResponse, GroqConfigStore, GroqGenerationConfig, GroqHttpClient, type GroqHttpClientDeps, GroqHttpTransport, GroqMessage, GroqMessageRole, GroqProvider, GroqProviderConfig, GroqReasoningEffort, IGroqHttpClient, IMAGE_B64_LIMIT, IMAGE_QUALITIES, IMAGE_SIZES, IMediaProvider, ITextProvider, type ImageAdapter, type ImageQuality, type ImageRequest, type ImageResult, type ImageSize, type OpenAiCompatibleConfig, ProviderError, type ProviderEvent, PrunaInput, PrunaModelId, PrunaPredictionResponse, type PrunaProgressStage, PrunaProvider, type PrunaRequest, PrunaResult, type RequestImage, SPEECH_INPUT_MAX, SPEECH_VOICES, type SpeechAdapter, type SpeechRequest, type SpeechResult, type SpeechVoice, StreamRequestOptions$1 as StreamRequestOptions, type StructuredJsonRequest, TIMEOUTS, TextGenerationService, TextToVideoInput, TimeoutError, type ToolDefinition, ValidationError, configureProvider, consumeAnthropicStream, consumeGroqStream, createAnthropicAdapter, createAssistantMessage, createFalProvider, createGeminiProvider, createGroqProvider, createMessage, createOpenAiAudioTranscriptionAdapter, createOpenAiCompatibleAdapter, createOpenAiEmbeddingsAdapter, createOpenAiImageAdapter, createOpenAiSpeechAdapter, createPrunaProvider, createSystemMessage, createUserMessage, defaultEffortForModel, extractContentFromSsePayload, extractTextFromMessages, formatMessagesForDisplay, generateImageThenVideo, generate as generatePruna, generateWithPruna, getProvider, mapAnthropicStopReason, pollForResult, promptToMessages, requestStructuredJson, resetProvider, submitPrediction, toGroqMessages, uploadImage };
+declare const ADAPTER_TIMEOUT_MS = 60000;
+declare const ADAPTER_MEDIA_TIMEOUT_MS = 120000;
+/** Binding with the key already resolved — for apps that source keys from
+ *  somewhere other than the process/request environment (KV, secrets
+ *  manager, unit tests). */
+interface AdapterProviderBinding {
+    readonly adapter: string;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+}
+/** Binding naming an environment variable — the common case for Workers. */
+interface AdapterEnvBinding {
+    readonly adapter: string;
+    readonly baseUrl: string;
+    readonly apiKeyEnv: string;
+}
+interface AdapterResolverTiming {
+    /** Chat/embeddings/transcription timeout; default 60s. */
+    readonly timeoutMs?: number;
+    /** Image/speech timeout; default 120s (generation is slower). */
+    readonly mediaTimeoutMs?: number;
+}
+/** Read an API key from an env-like object; throws `AiError('missing_key')`
+ *  when unset or blank. */
+declare function resolveApiKey(env: object, apiKeyEnv: string): string;
+/** Non-throwing availability probe for provider filtering. */
+declare function apiKeyAvailable(env: object, apiKeyEnv: string): boolean;
+/** Chat adapter for either supported kind (openai-compatible, anthropic). */
+declare function chatAdapterFor(binding: AdapterProviderBinding, timing?: AdapterResolverTiming): ChatAdapter;
+/** Image generation (openai-compatible only). */
+declare function imageAdapterFor(binding: AdapterProviderBinding, timing?: AdapterResolverTiming): ImageAdapter;
+/** Text embeddings (openai-compatible only). */
+declare function embeddingsAdapterFor(binding: AdapterProviderBinding, timing?: AdapterResolverTiming): EmbeddingsAdapter;
+/** Audio transcription (openai-compatible only). */
+declare function audioTranscriptionAdapterFor(binding: AdapterProviderBinding, timing?: AdapterResolverTiming): AudioTranscriptionAdapter;
+/** Speech synthesis (openai-compatible only). */
+declare function speechAdapterFor(binding: AdapterProviderBinding, timing?: AdapterResolverTiming): SpeechAdapter;
+interface AdapterResolver {
+    chat(binding: AdapterEnvBinding): ChatAdapter;
+    image(binding: AdapterEnvBinding): ImageAdapter;
+    embeddings(binding: AdapterEnvBinding): EmbeddingsAdapter;
+    audioTranscription(binding: AdapterEnvBinding): AudioTranscriptionAdapter;
+    speech(binding: AdapterEnvBinding): SpeechAdapter;
+    available(binding: AdapterEnvBinding): boolean;
+}
+/**
+ * Bind the resolver to one environment object (a Workers `env`, a request
+ * context, a test fixture) and hand out adapters per provider row.
+ */
+declare function createAdapterResolver(env: object, timing?: AdapterResolverTiming): AdapterResolver;
+
+interface ConversationAttemptModel {
+    /** Model id as the provider API knows it. */
+    readonly externalModelId: string;
+    /** Context window in tokens; drives history windowing per attempt. */
+    readonly contextWindow: number;
+}
+interface ConversationAttemptSettings {
+    readonly temperature?: number;
+    readonly maxOutputTokens?: number;
+    readonly topP?: number;
+}
+interface ConversationAttempt {
+    readonly adapter: ChatAdapter;
+    readonly model: ConversationAttemptModel;
+    readonly settings: ConversationAttemptSettings;
+}
+interface RunConversationInput<M extends ContextMessage = ContextMessage> {
+    /** Conversation history, oldest first. Tool roles / toolCalls are
+     *  preserved so follow-up turns after tool execution stay coherent. */
+    readonly history: ReadonlyArray<M>;
+    readonly systemPrompt: string;
+    /** Ordered failover chain: attempts[0] is primary; later entries are
+     *  tried only after a transient error with nothing streamed yet. */
+    readonly attempts: ReadonlyArray<ConversationAttempt>;
+    readonly tools?: ReadonlyArray<ToolDefinition>;
+    readonly images?: ReadonlyArray<RequestImage>;
+    readonly signal?: AbortSignal;
+}
+/** Everything accumulated during the attempt that ended the turn. */
+interface ConversationTurnResult {
+    readonly answer: string;
+    readonly reasoning: string;
+    readonly usage: TokenUsage | null;
+    readonly toolCalls: ReadonlyArray<AssistantToolCall>;
+    readonly durationMs: number;
+}
+type ConversationEvent = {
+    readonly type: "attempt";
+    readonly index: number;
+} | {
+    readonly type: "delta";
+    readonly channel: "answer" | "reasoning";
+    readonly text: string;
+}
+/** The consumer aborted mid-stream; persist partials as "stopped". */
+ | {
+    readonly type: "stopped";
+    readonly result: ConversationTurnResult;
+}
+/** All attempts are exhausted (or the error was non-transient). */
+ | {
+    readonly type: "failed";
+    readonly code: AiErrorCode;
+    readonly message: string;
+    readonly result: ConversationTurnResult;
+}
+/** The model requested tool calls while tools were offered. */
+ | {
+    readonly type: "tool_calls";
+    readonly result: ConversationTurnResult;
+} | {
+    readonly type: "done";
+    readonly result: ConversationTurnResult;
+};
+declare function runConversation<M extends ContextMessage = ContextMessage>(input: RunConversationInput<M>): AsyncGenerator<ConversationEvent>;
+
+export { ADAPTER_MEDIA_TIMEOUT_MS, ADAPTER_TIMEOUT_MS, API_ENDPOINTS, type AdapterChatMessage, type AdapterChatRole, type AdapterConfig, type AdapterEnvBinding, type AdapterProviderBinding, type AdapterRequest, type AdapterResolver, type AdapterResolverTiming, AnthropicEffort, AnthropicHttpTransport, AnthropicMessagesRequest, AnthropicMessagesResponse, AnthropicProvider, AnthropicProviderConfig, AnthropicRequestBuilder, AnthropicStopReason, type AppContainer, type AudioTranscriptionAdapter, type AudioTranscriptionRequest, type AudioTranscriptionResult, AuthenticationError, BaseProvider as BaseAIProvider, BaseProvider, type BaseProviderConfig, type ChatAdapter, type ConversationAttempt, type ConversationAttemptModel, type ConversationAttemptSettings, type ConversationEvent, type ConversationTurnResult, CostEstimateRequest, DEFAULT_BASE_URL, DEFAULT_GENERATION_CONFIG, DEFAULT_MODELS, type EmbeddingsAdapter, type EmbeddingsRequest, type EmbeddingsResult, FAL_ASPECT_IMAGE_SIZES, type FalAudioModelSpec, type FalJobInput, type FalJobOutput, type FalJobStatus, FalProvider, type FalQueueClient, type FalQueueEnv, FalQueueError, type FalStatusResponse, type FalStatusSnapshot, type FalSubmitResponse, type FalSubmittedJob, type FalVideoModelSpec, GEMINI_TIERS, GROQ_MODELS, GROQ_TIERS, GeminiProvider, GenerateOptions, GenerationFailedError, GenerationStage, GroqChatRequest, GroqChatRequestBuilder, GroqChatResponse, GroqConfigStore, GroqGenerationConfig, GroqHttpClient, type GroqHttpClientDeps, GroqHttpTransport, GroqMessage, GroqMessageRole, GroqProvider, GroqProviderConfig, GroqReasoningEffort, IGroqHttpClient, IMAGE_B64_LIMIT, IMAGE_QUALITIES, IMAGE_SIZES, IMediaProvider, ITextProvider, type ImageAdapter, type ImageQuality, type ImageRequest, type ImageResult, type ImageSize, type OpenAiCompatibleConfig, OpenAiCompatibleProvider, OpenAiCompatibleProviderConfig, ProviderError, type ProviderEvent, PrunaInput, PrunaModelId, PrunaPredictionResponse, type PrunaProgressStage, PrunaProvider, type PrunaRequest, PrunaResult, type RequestImage, type RunConversationInput, SPEECH_INPUT_MAX, SPEECH_VOICES, type SpeechAdapter, type SpeechRequest, type SpeechResult, type SpeechVoice, StreamRequestOptions$1 as StreamRequestOptions, type StructuredJsonRequest, TIMEOUTS, TextGenerationService, TextToVideoInput, TimeoutError, type ToolDefinition, ValidationError, WORKERS_AI_LLM_MODEL, WORKERS_AI_TIERS, WorkersAIEnv, WorkersAIMessage, WorkersAIProvider, WorkersAIProviderConfig, type WorkersAISpeechEngine, type WorkersAISpeechResult, type WorkersAITextOptions, apiKeyAvailable, audioTranscriptionAdapterFor, buildFalAudioInput, buildFalAudioLyrics, buildFalImageInput, buildFalTagPrompt, buildFalVideoInput, chatAdapterFor, configureProvider, consumeAnthropicStream, consumeGroqStream, createAdapterResolver, createAnthropicAdapter, createAssistantMessage, createFalProvider, createFalQueue, createGeminiProvider, createGroqProvider, createMessage, createOpenAiAudioTranscriptionAdapter, createOpenAiCompatibleAdapter, createOpenAiCompatibleProvider, createOpenAiEmbeddingsAdapter, createOpenAiImageAdapter, createOpenAiSpeechAdapter, createPrunaProvider, createSystemMessage, createUserMessage, createWorkersAIProvider, defaultEffortForModel, embeddingsAdapterFor, extractContentFromSsePayload, extractTextFromMessages, falQueueConfigured, formatMessagesForDisplay, generateImageThenVideo, generate as generatePruna, generateWithPruna, getProvider, imageAdapterFor, mapAnthropicStopReason, parseFalAudioOutput, parseFalImageOutput, parseFalVideoOutput, pollForResult, promptToMessages, requestStructuredJson, resetProvider, resolveApiKey, runConversation, runWorkersAIText, speakWithWorkersAI, speechAdapterFor, streamWorkersAIText, submitPrediction, toGroqMessages, uploadImage, workersAIConfigured };