@umituz/web-ai 0.0.0-stage → 1.0.0

package/dist/providers/index.d.cts

@@ -0,0 +1,333 @@
+import { C as CostEstimateRequest, b as ITextProvider, I as IMediaProvider } from '../provider.factory-COsnprLH.cjs';
+export { A as AnyProvider, a as IProviderBase, P as ProviderCapability, c as ProviderFactory, d as ProviderFactoryConfig, i as isMediaProvider, e as isTextProvider } from '../provider.factory-COsnprLH.cjs';
+import { P as ProviderHealth, c as TextTier, T as TextRequest, G as GenerationResult, b as StructuredTextRequest, a as StructuredGeneration, S as StreamCallbacks, F as FinishReason, C as ChatMessage, d as TokenUsage } from '../index-fXjxTR5W.cjs';
+import { q as AIError, h as AnthropicProviderConfig, e as AnthropicEffort, s as AnthropicMessage, f as AnthropicMessagesRequest, i as AnthropicStopReason, g as AnthropicMessagesResponse, n as GroqProviderConfig, m as GroqMessage, t as GroqGenerationConfig, k as GroqChatRequest, l as GroqChatResponse, S as StreamRequestOptions$1 } from '../create-ai-DGZFBOA1.cjs';
+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, o as createAI } from '../create-ai-DGZFBOA1.cjs';
+import { b as CacheStats } from '../cache-manager-Df9LLYGA.cjs';
+import { a as TierModelMap } from '../index-DjX9ZKuM.cjs';
+import { b as RetryManager, a as RequestQueue, R as RequestDeduplicator } from '../request-deduplicator.util-NDo0_n1y.cjs';
+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-a55tLhWT.cjs';
+
+interface BaseProviderConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    retryAttempts?: number;
+}
+/**
+ * Convenience base for providers that talk raw fetch (gemini/fal/pruna style):
+ * timeout-bounded fetch plus a simple retry loop. The Groq and Anthropic
+ * providers bring their own transport machinery and do not extend this.
+ */
+declare abstract class BaseProvider {
+    protected config: BaseProviderConfig;
+    constructor(config: BaseProviderConfig);
+    healthCheck(): Promise<ProviderHealth>;
+    estimateCost(_request: CostEstimateRequest): Promise<number>;
+    protected fetchWithTimeout(url: string, options: RequestInit, timeout?: number): Promise<Response>;
+    protected withRetry<T>(fn: () => Promise<T>, maxAttempts?: number): Promise<T>;
+}
+declare class ProviderError extends AIError {
+    readonly providerId: string;
+    constructor(message: string, providerId: string, originalError?: unknown);
+}
+
+/**
+ * Anthropic provider over raw fetch — no SDK dependency, Workers-safe.
+ * Implements the neutral ITextProvider surface with tier-based model
+ * resolution and full token-usage propagation.
+ */
+declare class AnthropicProvider implements ITextProvider {
+    readonly config: AnthropicProviderConfig;
+    readonly id = "anthropic";
+    readonly name = "Anthropic";
+    readonly capabilities: readonly ["text"];
+    private readonly transport;
+    private readonly tiers;
+    private readonly jsonParser;
+    constructor(config: AnthropicProviderConfig);
+    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>;
+    private toGenerationResult;
+}
+
+/**
+ * Builds Messages API requests from neutral TextRequests.
+ *
+ * Wire rules enforced here (anthropic-version 2026-10-21):
+ *  - `max_tokens` is always set — the API rejects requests without it.
+ *  - temperature/top_p are NEVER emitted. This API version rejects them with
+ *    a 400 even when copied straight from the request; they stay hints on
+ *    TextRequest for providers that still honor sampling.
+ *  - `systemPrompt` maps to the top-level `system` slot, not an in-band message.
+ *  - `thinking` is omitted — adaptive thinking is the API's default.
+ *  - `output_config.effort` defaults per model (opus/haiku medium, sonnet high)
+ *    unless the caller pinned one on provider config.
+ */
+declare class AnthropicRequestBuilder {
+    private readonly model;
+    private messages;
+    private systemPrompt;
+    private maxTokens;
+    private effort;
+    private stopSequences;
+    private streamEnabled;
+    constructor(model: string);
+    static for(model: string): AnthropicRequestBuilder;
+    withRequest(request: TextRequest): this;
+    withEffort(effort: AnthropicEffort | undefined): this;
+    withStream(stream: boolean): this;
+    withSystemPromptOverride(systemPrompt: string | undefined): this;
+    withMessagesOverride(messages: AnthropicMessage[]): this;
+    build(): AnthropicMessagesRequest;
+}
+declare function defaultEffortForModel(model: string): AnthropicEffort;
+
+declare function mapAnthropicStopReason(reason: AnthropicStopReason | null | undefined): FinishReason | undefined;
+interface AnthropicStreamOutcome {
+    readonly text: string;
+    readonly model: string | null;
+    readonly inputTokens: number | undefined;
+    readonly outputTokens: number | undefined;
+    readonly finishReason: FinishReason | undefined;
+}
+/**
+ * Line-buffered SSE consumer for Anthropic stream events. Only `data:` lines
+ * carry payloads (each JSON payload self-describes via `type`); `event:`
+ * lines are ignored as decoration. Harvests the model from message_start,
+ * output tokens + stop reason from message_delta, and input tokens from the
+ * message_start usage block, so the final GenerationResult matches the
+ * non-streaming shape.
+ */
+declare function consumeAnthropicStream(stream: ReadableStream<Uint8Array>, callbacks: Pick<StreamCallbacks, "onChunk">): Promise<AnthropicStreamOutcome>;
+
+interface StreamRequestOptions {
+    readonly signal?: AbortSignal;
+}
+/**
+ * Raw HTTP transport for the Anthropic Messages API (anthropic-version
+ * 2026-10-21). Auth is `x-api-key` — NOT a Bearer header. All failures leave
+ * here as core AIError with the neutral taxonomy (401→INVALID_API_KEY,
+ * 429→RATE_LIMIT, ≥500→SERVER, network TypeError→NETWORK, abort→ABORT).
+ */
+declare class AnthropicHttpTransport {
+    private readonly config;
+    constructor(config: AnthropicProviderConfig);
+    postMessages(request: AnthropicMessagesRequest, options?: StreamRequestOptions): Promise<AnthropicMessagesResponse>;
+    streamMessages(request: AnthropicMessagesRequest, options?: StreamRequestOptions): Promise<ReadableStream<Uint8Array>>;
+    listModels(): Promise<Response>;
+    private baseUrl;
+    private buildHeaders;
+    private throwFromErrorResponse;
+    private normalizeError;
+}
+
+/**
+ * Groq provider over the ported machinery (dedupe/retry/queue pipeline,
+ * LRU+TTL response cache). Implements the neutral ITextProvider surface:
+ * tier-based model resolution, GenerationResult with token usage, and
+ * callback-based streaming.
+ */
+declare class GroqProvider implements ITextProvider {
+    readonly config: GroqProviderConfig;
+    readonly id = "groq";
+    readonly name = "Groq";
+    readonly capabilities: readonly ["text"];
+    private readonly client;
+    private readonly tiers;
+    private readonly cache;
+    private readonly jsonParser;
+    constructor(config: GroqProviderConfig);
+    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>;
+    getCacheStats(): CacheStats;
+    clearCache(): void;
+    cancelPendingRequests(): void;
+    private buildWireRequest;
+    private generationConfig;
+}
+/** Maps neutral messages to Groq's wire format; systemPrompt becomes the leading system message. */
+declare function toGroqMessages(messages: ReadonlyArray<ChatMessage>, systemPrompt?: string): GroqMessage[];
+
+declare const GROQ_MODELS: {
+    readonly LLAMA_3_1_8B_INSTANT: "llama-3.1-8b-instant";
+    readonly LLAMA_3_3_70B_VERSATILE: "llama-3.3-70b-versatile";
+    readonly LLAMA_3_1_70B_VERSATILE: "llama-3.1-70b-versatile";
+    readonly GPT_OSS_20B: "openai/gpt-oss-20b";
+    readonly GPT_OSS_120B: "openai/gpt-oss-120b";
+    readonly MIXTRAL_8X7B: "mixtral-8x7b-32768";
+    readonly GEMMA_2_9B: "gemma2-9b-it";
+    readonly LLAMA_4_SCOUT_17B: "meta-llama/llama-4-scout-17b-16e-instruct";
+    readonly KIMI_K2_INSTRUCT: "moonshotai/kimi-k2-instruct";
+    readonly QWEN3_32B: "qwen/qwen3-32b";
+};
+/**
+ * Neutral tier → Groq model. fast = 8b instant for cheap high-volume turns,
+ * balanced = 70b versatile for everyday quality, powerful = gpt-oss-120b for
+ * the heavy lifting. Override per instance via `models` in provider config.
+ */
+declare const GROQ_TIERS: TierModelMap;
+
+declare class GroqChatRequestBuilder {
+    private readonly model;
+    private messages;
+    private generationConfig;
+    private streamEnabled;
+    private jsonResponse;
+    constructor(model: string);
+    static for(model: string): GroqChatRequestBuilder;
+    withMessages(messages: ReadonlyArray<GroqMessage>): this;
+    withConfig(config: GroqGenerationConfig | undefined): this;
+    withStream(stream: boolean): this;
+    withJsonResponse(enabled: boolean): this;
+    build(): GroqChatRequest;
+}
+
+/**
+ * Raw HTTP transport for Groq's OpenAI-compatible chat/completions endpoint.
+ * All failures leave here as core AIError with the right AIErrorType —
+ * callers up the stack only ever see the neutral taxonomy.
+ */
+declare class GroqHttpTransport {
+    private readonly config;
+    private readonly pendingAbortControllers;
+    constructor(config: GroqProviderConfig);
+    cancelPendingRequests(): void;
+    postChatCompletion(request: GroqChatRequest): Promise<GroqChatResponse>;
+    streamChatCompletion(request: GroqChatRequest, options?: StreamRequestOptions$1): Promise<ReadableStream<Uint8Array>>;
+    private baseUrl;
+    private request;
+    private buildHeaders;
+    private throwFromErrorResponse;
+    private normalizeError;
+}
+
+interface GroqHttpClientDeps {
+    readonly transport?: GroqHttpTransport;
+    readonly retryManager?: RetryManager;
+    readonly queue?: RequestQueue;
+    readonly deduplicator?: RequestDeduplicator;
+}
+/**
+ * Groq HTTP client with the ported strategy stack: identical concurrent
+ * requests are deduplicated, transient failures retried with backoff, and
+ * everything is funneled through a priority queue. Composition root for
+ * GroqProvider — no global state.
+ */
+declare class GroqHttpClient {
+    private readonly transport;
+    private readonly executor;
+    constructor(config: GroqProviderConfig, deps?: GroqHttpClientDeps);
+    cancelPendingRequests(): void;
+    postChatCompletion(request: GroqChatRequest): Promise<GroqChatResponse>;
+    streamChatCompletion(request: GroqChatRequest, options?: StreamRequestOptions$1): Promise<ReadableStream<Uint8Array>>;
+}
+
+/**
+ * Extracts the displayable text delta from one Groq SSE `data:` payload.
+ * Returns null for role-only chunks, finish-only chunks, and unparseable
+ * payloads — the generic line machinery skips nulls.
+ */
+declare function extractContentFromSsePayload(payload: string): string | null;
+interface GroqStreamOutcome {
+    readonly text: string;
+    readonly model: string | null;
+    readonly finishReason: FinishReason | undefined;
+    readonly usage: TokenUsage | undefined;
+}
+/**
+ * Consumes a Groq SSE body: forwards text deltas through `callbacks.onChunk`
+ * and harvests model/finish_reason/usage from the surrounding chunks so the
+ * resulting GenerationResult is as complete as the non-streaming one.
+ */
+declare function consumeGroqStream(stream: ReadableStream<Uint8Array>, callbacks: Pick<StreamCallbacks, "onChunk">): Promise<GroqStreamOutcome>;
+
+declare const GEMINI_TIERS: TierModelMap;
+/**
+ * Gemini provider — text via generateContent (multi-turn aware, system
+ * instruction in the proper slot) plus inline image generation. Video is not
+ * supported by this surface and throws with a clear message.
+ */
+declare class GeminiProvider extends BaseProvider implements ITextProvider, IMediaProvider {
+    readonly id = "gemini";
+    readonly name = "Google Gemini";
+    readonly capabilities: readonly ["text", "image"];
+    private models;
+    private readonly tiers;
+    private readonly jsonParser;
+    constructor(config: GeminiConfig);
+    resolveModel(tier: TextTier): string;
+    healthCheck(): Promise<ProviderHealth>;
+    estimateCost(request: CostEstimateRequest): Promise<number>;
+    generate(request: TextRequest): Promise<GenerationResult>;
+    generateStructured<T>(request: StructuredTextRequest): Promise<StructuredGeneration<T>>;
+    stream(request: TextRequest, callbacks: StreamCallbacks): Promise<GenerationResult>;
+    generateImage(request: ImageGenerationRequest): Promise<GeneratedContent>;
+    generateVideo(_request: VideoGenerationRequest): Promise<GeneratedContent>;
+    imageToVideo(_request: ImageToVideoRequest): Promise<GeneratedContent>;
+    videoToVideo(_request: VideoToVideoRequest): Promise<GeneratedContent>;
+    private authHeaders;
+    private buildImagePrompt;
+}
+declare function createGeminiProvider(config: GeminiConfig): GeminiProvider;
+
+/** Media-only provider: fal.ai for image and video generation. */
+declare class FalProvider extends BaseProvider implements IMediaProvider {
+    readonly id = "fal";
+    readonly name = "FAL";
+    readonly capabilities: readonly ["image", "video"];
+    private models;
+    constructor(config: FalConfig);
+    healthCheck(): Promise<ProviderHealth>;
+    estimateCost(request: CostEstimateRequest): Promise<number>;
+    generateImage(request: ImageGenerationRequest): Promise<GeneratedContent>;
+    generateVideo(request: VideoGenerationRequest): Promise<GeneratedContent>;
+    imageToVideo(request: ImageToVideoRequest): Promise<GeneratedContent>;
+    videoToVideo(_request: VideoToVideoRequest): Promise<GeneratedContent>;
+}
+declare function createFalProvider(config: FalConfig): FalProvider;
+
+interface PrunaRequest {
+    model?: string;
+    image?: string;
+    [key: string]: unknown;
+}
+interface PrunaProgressStage {
+    stage: 'uploading' | 'processing' | 'polling' | 'predicting';
+    result?: {
+        url: string;
+        model?: string;
+    };
+    error?: Error;
+}
+declare function generateWithPruna(request: PrunaRequest, apiKey: string, signal?: AbortSignal, onProgress?: (stage: PrunaProgressStage['stage'], attempt?: number) => void): AsyncGenerator<PrunaProgressStage>;
+
+/**
+ * Placeholder seat for the Pruna fleet: registering it makes the provider
+ * visible to health/fallback machinery, while actual generation goes through
+ * the lazy-loaded `generateWithPruna` helper (peer optional dependency).
+ */
+declare class PrunaProvider implements IMediaProvider {
+    readonly config: PrunaConfig;
+    readonly id = "pruna";
+    readonly name = "Pruna AI";
+    readonly capabilities: readonly ["image", "video"];
+    constructor(config: PrunaConfig);
+    healthCheck(): Promise<ProviderHealth>;
+    estimateCost(_request: CostEstimateRequest): Promise<number>;
+    generateImage(_request: ImageGenerationRequest): Promise<GeneratedContent>;
+    generateVideo(_request: VideoGenerationRequest): Promise<GeneratedContent>;
+    imageToVideo(_request: ImageToVideoRequest): Promise<GeneratedContent>;
+    videoToVideo(_request: VideoToVideoRequest): Promise<GeneratedContent>;
+}
+declare function createPrunaProvider(config: PrunaConfig): PrunaProvider;
+
+export { AnthropicEffort, AnthropicHttpTransport, AnthropicMessagesRequest, AnthropicMessagesResponse, AnthropicProvider, AnthropicProviderConfig, AnthropicRequestBuilder, AnthropicStopReason, BaseProvider, type BaseProviderConfig, CostEstimateRequest, FalProvider, GEMINI_TIERS, GROQ_MODELS, GROQ_TIERS, GeminiProvider, GroqChatRequest, GroqChatRequestBuilder, GroqChatResponse, GroqHttpClient, GroqHttpTransport, GroqMessage, GroqProvider, GroqProviderConfig, IMediaProvider, ITextProvider, ProviderError, type PrunaProgressStage, PrunaProvider, type PrunaRequest, consumeAnthropicStream, consumeGroqStream, createFalProvider, createGeminiProvider, createPrunaProvider, defaultEffortForModel, extractContentFromSsePayload, generateWithPruna, mapAnthropicStopReason, toGroqMessages };

package/dist/providers/index.d.ts

@@ -0,0 +1,333 @@
+import { C as CostEstimateRequest, b as ITextProvider, I as IMediaProvider } from '../provider.factory-CpWFyjbw.js';
+export { A as AnyProvider, a as IProviderBase, P as ProviderCapability, c as ProviderFactory, d as ProviderFactoryConfig, i as isMediaProvider, e as isTextProvider } from '../provider.factory-CpWFyjbw.js';
+import { P as ProviderHealth, c as TextTier, T as TextRequest, G as GenerationResult, b as StructuredTextRequest, a as StructuredGeneration, S as StreamCallbacks, F as FinishReason, C as ChatMessage, d as TokenUsage } from '../index-fXjxTR5W.js';
+import { q as AIError, h as AnthropicProviderConfig, e as AnthropicEffort, s as AnthropicMessage, f as AnthropicMessagesRequest, i as AnthropicStopReason, g as AnthropicMessagesResponse, n as GroqProviderConfig, m as GroqMessage, t as GroqGenerationConfig, k as GroqChatRequest, l as GroqChatResponse, S as StreamRequestOptions$1 } from '../create-ai-BhNaz86i.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, o as createAI } from '../create-ai-BhNaz86i.js';
+import { b as CacheStats } from '../cache-manager-Df9LLYGA.js';
+import { a as TierModelMap } from '../index-DxLvE588.js';
+import { b as RetryManager, a as RequestQueue, R as RequestDeduplicator } from '../request-deduplicator.util-NDo0_n1y.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-a55tLhWT.js';
+
+interface BaseProviderConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    retryAttempts?: number;
+}
+/**
+ * Convenience base for providers that talk raw fetch (gemini/fal/pruna style):
+ * timeout-bounded fetch plus a simple retry loop. The Groq and Anthropic
+ * providers bring their own transport machinery and do not extend this.
+ */
+declare abstract class BaseProvider {
+    protected config: BaseProviderConfig;
+    constructor(config: BaseProviderConfig);
+    healthCheck(): Promise<ProviderHealth>;
+    estimateCost(_request: CostEstimateRequest): Promise<number>;
+    protected fetchWithTimeout(url: string, options: RequestInit, timeout?: number): Promise<Response>;
+    protected withRetry<T>(fn: () => Promise<T>, maxAttempts?: number): Promise<T>;
+}
+declare class ProviderError extends AIError {
+    readonly providerId: string;
+    constructor(message: string, providerId: string, originalError?: unknown);
+}
+
+/**
+ * Anthropic provider over raw fetch — no SDK dependency, Workers-safe.
+ * Implements the neutral ITextProvider surface with tier-based model
+ * resolution and full token-usage propagation.
+ */
+declare class AnthropicProvider implements ITextProvider {
+    readonly config: AnthropicProviderConfig;
+    readonly id = "anthropic";
+    readonly name = "Anthropic";
+    readonly capabilities: readonly ["text"];
+    private readonly transport;
+    private readonly tiers;
+    private readonly jsonParser;
+    constructor(config: AnthropicProviderConfig);
+    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>;
+    private toGenerationResult;
+}
+
+/**
+ * Builds Messages API requests from neutral TextRequests.
+ *
+ * Wire rules enforced here (anthropic-version 2026-10-21):
+ *  - `max_tokens` is always set — the API rejects requests without it.
+ *  - temperature/top_p are NEVER emitted. This API version rejects them with
+ *    a 400 even when copied straight from the request; they stay hints on
+ *    TextRequest for providers that still honor sampling.
+ *  - `systemPrompt` maps to the top-level `system` slot, not an in-band message.
+ *  - `thinking` is omitted — adaptive thinking is the API's default.
+ *  - `output_config.effort` defaults per model (opus/haiku medium, sonnet high)
+ *    unless the caller pinned one on provider config.
+ */
+declare class AnthropicRequestBuilder {
+    private readonly model;
+    private messages;
+    private systemPrompt;
+    private maxTokens;
+    private effort;
+    private stopSequences;
+    private streamEnabled;
+    constructor(model: string);
+    static for(model: string): AnthropicRequestBuilder;
+    withRequest(request: TextRequest): this;
+    withEffort(effort: AnthropicEffort | undefined): this;
+    withStream(stream: boolean): this;
+    withSystemPromptOverride(systemPrompt: string | undefined): this;
+    withMessagesOverride(messages: AnthropicMessage[]): this;
+    build(): AnthropicMessagesRequest;
+}
+declare function defaultEffortForModel(model: string): AnthropicEffort;
+
+declare function mapAnthropicStopReason(reason: AnthropicStopReason | null | undefined): FinishReason | undefined;
+interface AnthropicStreamOutcome {
+    readonly text: string;
+    readonly model: string | null;
+    readonly inputTokens: number | undefined;
+    readonly outputTokens: number | undefined;
+    readonly finishReason: FinishReason | undefined;
+}
+/**
+ * Line-buffered SSE consumer for Anthropic stream events. Only `data:` lines
+ * carry payloads (each JSON payload self-describes via `type`); `event:`
+ * lines are ignored as decoration. Harvests the model from message_start,
+ * output tokens + stop reason from message_delta, and input tokens from the
+ * message_start usage block, so the final GenerationResult matches the
+ * non-streaming shape.
+ */
+declare function consumeAnthropicStream(stream: ReadableStream<Uint8Array>, callbacks: Pick<StreamCallbacks, "onChunk">): Promise<AnthropicStreamOutcome>;
+
+interface StreamRequestOptions {
+    readonly signal?: AbortSignal;
+}
+/**
+ * Raw HTTP transport for the Anthropic Messages API (anthropic-version
+ * 2026-10-21). Auth is `x-api-key` — NOT a Bearer header. All failures leave
+ * here as core AIError with the neutral taxonomy (401→INVALID_API_KEY,
+ * 429→RATE_LIMIT, ≥500→SERVER, network TypeError→NETWORK, abort→ABORT).
+ */
+declare class AnthropicHttpTransport {
+    private readonly config;
+    constructor(config: AnthropicProviderConfig);
+    postMessages(request: AnthropicMessagesRequest, options?: StreamRequestOptions): Promise<AnthropicMessagesResponse>;
+    streamMessages(request: AnthropicMessagesRequest, options?: StreamRequestOptions): Promise<ReadableStream<Uint8Array>>;
+    listModels(): Promise<Response>;
+    private baseUrl;
+    private buildHeaders;
+    private throwFromErrorResponse;
+    private normalizeError;
+}
+
+/**
+ * Groq provider over the ported machinery (dedupe/retry/queue pipeline,
+ * LRU+TTL response cache). Implements the neutral ITextProvider surface:
+ * tier-based model resolution, GenerationResult with token usage, and
+ * callback-based streaming.
+ */
+declare class GroqProvider implements ITextProvider {
+    readonly config: GroqProviderConfig;
+    readonly id = "groq";
+    readonly name = "Groq";
+    readonly capabilities: readonly ["text"];
+    private readonly client;
+    private readonly tiers;
+    private readonly cache;
+    private readonly jsonParser;
+    constructor(config: GroqProviderConfig);
+    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>;
+    getCacheStats(): CacheStats;
+    clearCache(): void;
+    cancelPendingRequests(): void;
+    private buildWireRequest;
+    private generationConfig;
+}
+/** Maps neutral messages to Groq's wire format; systemPrompt becomes the leading system message. */
+declare function toGroqMessages(messages: ReadonlyArray<ChatMessage>, systemPrompt?: string): GroqMessage[];
+
+declare const GROQ_MODELS: {
+    readonly LLAMA_3_1_8B_INSTANT: "llama-3.1-8b-instant";
+    readonly LLAMA_3_3_70B_VERSATILE: "llama-3.3-70b-versatile";
+    readonly LLAMA_3_1_70B_VERSATILE: "llama-3.1-70b-versatile";
+    readonly GPT_OSS_20B: "openai/gpt-oss-20b";
+    readonly GPT_OSS_120B: "openai/gpt-oss-120b";
+    readonly MIXTRAL_8X7B: "mixtral-8x7b-32768";
+    readonly GEMMA_2_9B: "gemma2-9b-it";
+    readonly LLAMA_4_SCOUT_17B: "meta-llama/llama-4-scout-17b-16e-instruct";
+    readonly KIMI_K2_INSTRUCT: "moonshotai/kimi-k2-instruct";
+    readonly QWEN3_32B: "qwen/qwen3-32b";
+};
+/**
+ * Neutral tier → Groq model. fast = 8b instant for cheap high-volume turns,
+ * balanced = 70b versatile for everyday quality, powerful = gpt-oss-120b for
+ * the heavy lifting. Override per instance via `models` in provider config.
+ */
+declare const GROQ_TIERS: TierModelMap;
+
+declare class GroqChatRequestBuilder {
+    private readonly model;
+    private messages;
+    private generationConfig;
+    private streamEnabled;
+    private jsonResponse;
+    constructor(model: string);
+    static for(model: string): GroqChatRequestBuilder;
+    withMessages(messages: ReadonlyArray<GroqMessage>): this;
+    withConfig(config: GroqGenerationConfig | undefined): this;
+    withStream(stream: boolean): this;
+    withJsonResponse(enabled: boolean): this;
+    build(): GroqChatRequest;
+}
+
+/**
+ * Raw HTTP transport for Groq's OpenAI-compatible chat/completions endpoint.
+ * All failures leave here as core AIError with the right AIErrorType —
+ * callers up the stack only ever see the neutral taxonomy.
+ */
+declare class GroqHttpTransport {
+    private readonly config;
+    private readonly pendingAbortControllers;
+    constructor(config: GroqProviderConfig);
+    cancelPendingRequests(): void;
+    postChatCompletion(request: GroqChatRequest): Promise<GroqChatResponse>;
+    streamChatCompletion(request: GroqChatRequest, options?: StreamRequestOptions$1): Promise<ReadableStream<Uint8Array>>;
+    private baseUrl;
+    private request;
+    private buildHeaders;
+    private throwFromErrorResponse;
+    private normalizeError;
+}
+
+interface GroqHttpClientDeps {
+    readonly transport?: GroqHttpTransport;
+    readonly retryManager?: RetryManager;
+    readonly queue?: RequestQueue;
+    readonly deduplicator?: RequestDeduplicator;
+}
+/**
+ * Groq HTTP client with the ported strategy stack: identical concurrent
+ * requests are deduplicated, transient failures retried with backoff, and
+ * everything is funneled through a priority queue. Composition root for
+ * GroqProvider — no global state.
+ */
+declare class GroqHttpClient {
+    private readonly transport;
+    private readonly executor;
+    constructor(config: GroqProviderConfig, deps?: GroqHttpClientDeps);
+    cancelPendingRequests(): void;
+    postChatCompletion(request: GroqChatRequest): Promise<GroqChatResponse>;
+    streamChatCompletion(request: GroqChatRequest, options?: StreamRequestOptions$1): Promise<ReadableStream<Uint8Array>>;
+}
+
+/**
+ * Extracts the displayable text delta from one Groq SSE `data:` payload.
+ * Returns null for role-only chunks, finish-only chunks, and unparseable
+ * payloads — the generic line machinery skips nulls.
+ */
+declare function extractContentFromSsePayload(payload: string): string | null;
+interface GroqStreamOutcome {
+    readonly text: string;
+    readonly model: string | null;
+    readonly finishReason: FinishReason | undefined;
+    readonly usage: TokenUsage | undefined;
+}
+/**
+ * Consumes a Groq SSE body: forwards text deltas through `callbacks.onChunk`
+ * and harvests model/finish_reason/usage from the surrounding chunks so the
+ * resulting GenerationResult is as complete as the non-streaming one.
+ */
+declare function consumeGroqStream(stream: ReadableStream<Uint8Array>, callbacks: Pick<StreamCallbacks, "onChunk">): Promise<GroqStreamOutcome>;
+
+declare const GEMINI_TIERS: TierModelMap;
+/**
+ * Gemini provider — text via generateContent (multi-turn aware, system
+ * instruction in the proper slot) plus inline image generation. Video is not
+ * supported by this surface and throws with a clear message.
+ */
+declare class GeminiProvider extends BaseProvider implements ITextProvider, IMediaProvider {
+    readonly id = "gemini";
+    readonly name = "Google Gemini";
+    readonly capabilities: readonly ["text", "image"];
+    private models;
+    private readonly tiers;
+    private readonly jsonParser;
+    constructor(config: GeminiConfig);
+    resolveModel(tier: TextTier): string;
+    healthCheck(): Promise<ProviderHealth>;
+    estimateCost(request: CostEstimateRequest): Promise<number>;
+    generate(request: TextRequest): Promise<GenerationResult>;
+    generateStructured<T>(request: StructuredTextRequest): Promise<StructuredGeneration<T>>;
+    stream(request: TextRequest, callbacks: StreamCallbacks): Promise<GenerationResult>;
+    generateImage(request: ImageGenerationRequest): Promise<GeneratedContent>;
+    generateVideo(_request: VideoGenerationRequest): Promise<GeneratedContent>;
+    imageToVideo(_request: ImageToVideoRequest): Promise<GeneratedContent>;
+    videoToVideo(_request: VideoToVideoRequest): Promise<GeneratedContent>;
+    private authHeaders;
+    private buildImagePrompt;
+}
+declare function createGeminiProvider(config: GeminiConfig): GeminiProvider;
+
+/** Media-only provider: fal.ai for image and video generation. */
+declare class FalProvider extends BaseProvider implements IMediaProvider {
+    readonly id = "fal";
+    readonly name = "FAL";
+    readonly capabilities: readonly ["image", "video"];
+    private models;
+    constructor(config: FalConfig);
+    healthCheck(): Promise<ProviderHealth>;
+    estimateCost(request: CostEstimateRequest): Promise<number>;
+    generateImage(request: ImageGenerationRequest): Promise<GeneratedContent>;
+    generateVideo(request: VideoGenerationRequest): Promise<GeneratedContent>;
+    imageToVideo(request: ImageToVideoRequest): Promise<GeneratedContent>;
+    videoToVideo(_request: VideoToVideoRequest): Promise<GeneratedContent>;
+}
+declare function createFalProvider(config: FalConfig): FalProvider;
+
+interface PrunaRequest {
+    model?: string;
+    image?: string;
+    [key: string]: unknown;
+}
+interface PrunaProgressStage {
+    stage: 'uploading' | 'processing' | 'polling' | 'predicting';
+    result?: {
+        url: string;
+        model?: string;
+    };
+    error?: Error;
+}
+declare function generateWithPruna(request: PrunaRequest, apiKey: string, signal?: AbortSignal, onProgress?: (stage: PrunaProgressStage['stage'], attempt?: number) => void): AsyncGenerator<PrunaProgressStage>;
+
+/**
+ * Placeholder seat for the Pruna fleet: registering it makes the provider
+ * visible to health/fallback machinery, while actual generation goes through
+ * the lazy-loaded `generateWithPruna` helper (peer optional dependency).
+ */
+declare class PrunaProvider implements IMediaProvider {
+    readonly config: PrunaConfig;
+    readonly id = "pruna";
+    readonly name = "Pruna AI";
+    readonly capabilities: readonly ["image", "video"];
+    constructor(config: PrunaConfig);
+    healthCheck(): Promise<ProviderHealth>;
+    estimateCost(_request: CostEstimateRequest): Promise<number>;
+    generateImage(_request: ImageGenerationRequest): Promise<GeneratedContent>;
+    generateVideo(_request: VideoGenerationRequest): Promise<GeneratedContent>;
+    imageToVideo(_request: ImageToVideoRequest): Promise<GeneratedContent>;
+    videoToVideo(_request: VideoToVideoRequest): Promise<GeneratedContent>;
+}
+declare function createPrunaProvider(config: PrunaConfig): PrunaProvider;
+
+export { AnthropicEffort, AnthropicHttpTransport, AnthropicMessagesRequest, AnthropicMessagesResponse, AnthropicProvider, AnthropicProviderConfig, AnthropicRequestBuilder, AnthropicStopReason, BaseProvider, type BaseProviderConfig, CostEstimateRequest, FalProvider, GEMINI_TIERS, GROQ_MODELS, GROQ_TIERS, GeminiProvider, GroqChatRequest, GroqChatRequestBuilder, GroqChatResponse, GroqHttpClient, GroqHttpTransport, GroqMessage, GroqProvider, GroqProviderConfig, IMediaProvider, ITextProvider, ProviderError, type PrunaProgressStage, PrunaProvider, type PrunaRequest, consumeAnthropicStream, consumeGroqStream, createFalProvider, createGeminiProvider, createPrunaProvider, defaultEffortForModel, extractContentFromSsePayload, generateWithPruna, mapAnthropicStopReason, toGroqMessages };