recker 1.0.43 → 1.0.44

package/dist/browser/ai/adaptive-timeout.d.ts

@@ -0,0 +1,50 @@
+import type { AITimeoutOptions } from '../types/ai.js';
+interface LatencySample {
+    ttft: number;
+    betweenTokens: number;
+    total: number;
+    timestamp: number;
+}
+interface ModelProfile {
+    samples: LatencySample[];
+    avgTtft: number;
+    avgBetweenTokens: number;
+    avgTotal: number;
+    p95Ttft: number;
+    p95BetweenTokens: number;
+    p95Total: number;
+}
+export declare class AdaptiveTimeoutManager {
+    private profiles;
+    private maxSamples;
+    private sampleTtl;
+    getTimeouts(model: string, options?: AITimeoutOptions): Required<AITimeoutOptions>;
+    recordSample(model: string, ttft: number, betweenTokens: number, total: number): void;
+    getProfile(model: string): ModelProfile | undefined;
+    clear(): void;
+    export(): Record<string, LatencySample[]>;
+    import(data: Record<string, LatencySample[]>): void;
+    private findPreset;
+    private recalculateStats;
+    private percentile;
+}
+export declare class StreamTimeoutController {
+    private timeouts;
+    private abortController;
+    private firstTokenTimer;
+    private betweenTokenTimer;
+    private totalTimer;
+    private receivedFirstToken;
+    private startTime;
+    constructor(timeouts: Required<AITimeoutOptions>);
+    get signal(): AbortSignal;
+    start(): void;
+    recordToken(): void;
+    complete(): void;
+    abort(reason: string): void;
+    get elapsed(): number;
+    get ttft(): number | null;
+    private clearTimers;
+}
+export declare const adaptiveTimeouts: AdaptiveTimeoutManager;
+export {};

package/dist/browser/ai/adaptive-timeout.js

@@ -0,0 +1,208 @@
+const DEFAULT_TIMEOUTS = {
+    firstToken: 60000,
+    betweenTokens: 10000,
+    total: 300000,
+};
+const MODEL_PRESETS = {
+    'gpt-5.1-mini': { firstToken: 10000, betweenTokens: 2000, total: 60000 },
+    'gpt-5.1-nano': { firstToken: 5000, betweenTokens: 1000, total: 30000 },
+    'claude-haiku': { firstToken: 10000, betweenTokens: 2000, total: 60000 },
+    'gpt-5.1': { firstToken: 30000, betweenTokens: 5000, total: 120000 },
+    'claude-sonnet': { firstToken: 30000, betweenTokens: 5000, total: 120000 },
+    'o3': { firstToken: 120000, betweenTokens: 30000, total: 600000 },
+    'o3-mini': { firstToken: 60000, betweenTokens: 15000, total: 300000 },
+    'o4-mini': { firstToken: 60000, betweenTokens: 15000, total: 300000 },
+    'claude-opus': { firstToken: 60000, betweenTokens: 10000, total: 300000 },
+    'text-embedding': { firstToken: 10000, betweenTokens: 0, total: 30000 },
+};
+export class AdaptiveTimeoutManager {
+    profiles = new Map();
+    maxSamples = 100;
+    sampleTtl = 24 * 60 * 60 * 1000;
+    getTimeouts(model, options) {
+        let timeouts = { ...DEFAULT_TIMEOUTS, adaptive: true };
+        const preset = this.findPreset(model);
+        if (preset) {
+            timeouts = { ...timeouts, ...preset };
+        }
+        if (options?.adaptive !== false) {
+            const profile = this.profiles.get(model);
+            if (profile && profile.samples.length >= 5) {
+                timeouts.firstToken = Math.ceil(profile.p95Ttft * 1.2);
+                timeouts.betweenTokens = Math.ceil(profile.p95BetweenTokens * 1.2);
+                timeouts.total = Math.ceil(profile.p95Total * 1.2);
+            }
+        }
+        if (options?.firstToken !== undefined)
+            timeouts.firstToken = options.firstToken;
+        if (options?.betweenTokens !== undefined)
+            timeouts.betweenTokens = options.betweenTokens;
+        if (options?.total !== undefined)
+            timeouts.total = options.total;
+        return timeouts;
+    }
+    recordSample(model, ttft, betweenTokens, total) {
+        const sample = {
+            ttft,
+            betweenTokens,
+            total,
+            timestamp: Date.now(),
+        };
+        let profile = this.profiles.get(model);
+        if (!profile) {
+            profile = {
+                samples: [],
+                avgTtft: 0,
+                avgBetweenTokens: 0,
+                avgTotal: 0,
+                p95Ttft: 0,
+                p95BetweenTokens: 0,
+                p95Total: 0,
+            };
+            this.profiles.set(model, profile);
+        }
+        profile.samples.push(sample);
+        const cutoff = Date.now() - this.sampleTtl;
+        profile.samples = profile.samples.filter((s) => s.timestamp > cutoff);
+        if (profile.samples.length > this.maxSamples) {
+            profile.samples = profile.samples.slice(-this.maxSamples);
+        }
+        this.recalculateStats(profile);
+    }
+    getProfile(model) {
+        return this.profiles.get(model);
+    }
+    clear() {
+        this.profiles.clear();
+    }
+    export() {
+        const data = {};
+        for (const [model, profile] of this.profiles) {
+            data[model] = profile.samples;
+        }
+        return data;
+    }
+    import(data) {
+        for (const [model, samples] of Object.entries(data)) {
+            const profile = {
+                samples,
+                avgTtft: 0,
+                avgBetweenTokens: 0,
+                avgTotal: 0,
+                p95Ttft: 0,
+                p95BetweenTokens: 0,
+                p95Total: 0,
+            };
+            this.recalculateStats(profile);
+            this.profiles.set(model, profile);
+        }
+    }
+    findPreset(model) {
+        if (MODEL_PRESETS[model]) {
+            return MODEL_PRESETS[model];
+        }
+        const modelLower = model.toLowerCase();
+        for (const [key, preset] of Object.entries(MODEL_PRESETS)) {
+            if (modelLower.includes(key.toLowerCase())) {
+                return preset;
+            }
+        }
+        return undefined;
+    }
+    recalculateStats(profile) {
+        if (profile.samples.length === 0)
+            return;
+        const ttfts = profile.samples.map((s) => s.ttft);
+        const betweens = profile.samples.map((s) => s.betweenTokens);
+        const totals = profile.samples.map((s) => s.total);
+        profile.avgTtft = ttfts.reduce((a, b) => a + b, 0) / ttfts.length;
+        profile.avgBetweenTokens = betweens.reduce((a, b) => a + b, 0) / betweens.length;
+        profile.avgTotal = totals.reduce((a, b) => a + b, 0) / totals.length;
+        profile.p95Ttft = this.percentile(ttfts, 95);
+        profile.p95BetweenTokens = this.percentile(betweens, 95);
+        profile.p95Total = this.percentile(totals, 95);
+    }
+    percentile(values, p) {
+        if (values.length === 0)
+            return 0;
+        const sorted = [...values].sort((a, b) => a - b);
+        const index = Math.ceil((p / 100) * sorted.length) - 1;
+        return sorted[Math.max(0, index)];
+    }
+}
+export class StreamTimeoutController {
+    timeouts;
+    abortController;
+    firstTokenTimer = null;
+    betweenTokenTimer = null;
+    totalTimer = null;
+    receivedFirstToken = false;
+    startTime;
+    constructor(timeouts) {
+        this.timeouts = timeouts;
+        this.abortController = new AbortController();
+        this.startTime = Date.now();
+    }
+    get signal() {
+        return this.abortController.signal;
+    }
+    start() {
+        if (this.timeouts.firstToken > 0) {
+            this.firstTokenTimer = setTimeout(() => {
+                if (!this.receivedFirstToken) {
+                    this.abort('First token timeout exceeded');
+                }
+            }, this.timeouts.firstToken);
+        }
+        if (this.timeouts.total > 0) {
+            this.totalTimer = setTimeout(() => {
+                this.abort('Total timeout exceeded');
+            }, this.timeouts.total);
+        }
+    }
+    recordToken() {
+        if (!this.receivedFirstToken) {
+            this.receivedFirstToken = true;
+            if (this.firstTokenTimer) {
+                clearTimeout(this.firstTokenTimer);
+                this.firstTokenTimer = null;
+            }
+        }
+        if (this.betweenTokenTimer) {
+            clearTimeout(this.betweenTokenTimer);
+        }
+        if (this.timeouts.betweenTokens > 0) {
+            this.betweenTokenTimer = setTimeout(() => {
+                this.abort('Token stream stalled');
+            }, this.timeouts.betweenTokens);
+        }
+    }
+    complete() {
+        this.clearTimers();
+    }
+    abort(reason) {
+        this.clearTimers();
+        this.abortController.abort(new Error(reason));
+    }
+    get elapsed() {
+        return Date.now() - this.startTime;
+    }
+    get ttft() {
+        return this.receivedFirstToken ? Date.now() - this.startTime : null;
+    }
+    clearTimers() {
+        if (this.firstTokenTimer) {
+            clearTimeout(this.firstTokenTimer);
+            this.firstTokenTimer = null;
+        }
+        if (this.betweenTokenTimer) {
+            clearTimeout(this.betweenTokenTimer);
+            this.betweenTokenTimer = null;
+        }
+        if (this.totalTimer) {
+            clearTimeout(this.totalTimer);
+            this.totalTimer = null;
+        }
+    }
+}
+export const adaptiveTimeouts = new AdaptiveTimeoutManager();

package/dist/browser/ai/client.d.ts

@@ -0,0 +1,22 @@
+import type { AIClient, AIClientConfig, ChatOptions, AIResponse, AIStream, EmbedOptions, EmbedResponse, AIMetrics } from '../types/ai.js';
+export declare class UnifiedAIClient implements AIClient {
+    private config;
+    private providers;
+    private _metrics;
+    constructor(config?: AIClientConfig);
+    get metrics(): AIMetrics;
+    chat(optionsOrPrompt: ChatOptions | string): Promise<AIResponse>;
+    stream(options: ChatOptions): Promise<AIStream>;
+    embed(options: EmbedOptions): Promise<EmbedResponse>;
+    extend(defaults: Partial<ChatOptions>): AIClient;
+    private initializeProviders;
+    private getProvider;
+    private normalizeOptions;
+    private executeWithRetry;
+    private shouldRetry;
+    private calculateBackoff;
+    private reduceContext;
+    private logResponse;
+    private sleep;
+}
+export declare function createAI(config?: AIClientConfig): AIClient;

package/dist/browser/ai/client.js

@@ -0,0 +1,294 @@
+import { AIError, RateLimitError, ContextLengthError, OverloadedError } from './providers/base.js';
+import { OpenAIProvider } from './providers/openai.js';
+import { AnthropicProvider } from './providers/anthropic.js';
+import { GoogleProvider } from './providers/google.js';
+import { OllamaProvider } from './providers/ollama.js';
+class AIMetricsTracker {
+    data = {
+        totalRequests: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        totalLatencyTtft: 0,
+        totalLatencyTotal: 0,
+        errorCount: 0,
+        cacheHits: 0,
+        byModel: new Map(),
+        byProvider: new Map(),
+    };
+    get totalRequests() {
+        return this.data.totalRequests;
+    }
+    get totalTokens() {
+        return this.data.totalTokens;
+    }
+    get totalCost() {
+        return this.data.totalCost;
+    }
+    get avgLatency() {
+        const count = this.data.totalRequests || 1;
+        return {
+            ttft: this.data.totalLatencyTtft / count,
+            total: this.data.totalLatencyTotal / count,
+        };
+    }
+    get errorRate() {
+        const total = this.data.totalRequests + this.data.errorCount;
+        return total > 0 ? this.data.errorCount / total : 0;
+    }
+    get cacheHitRate() {
+        return this.data.totalRequests > 0
+            ? this.data.cacheHits / this.data.totalRequests
+            : 0;
+    }
+    record(response) {
+        this.data.totalRequests++;
+        this.data.totalTokens += response.usage.totalTokens;
+        this.data.totalCost += response.cost?.totalCost || 0;
+        this.data.totalLatencyTtft += response.latency.ttft;
+        this.data.totalLatencyTotal += response.latency.total;
+        if (response.cached) {
+            this.data.cacheHits++;
+        }
+        const modelStats = this.data.byModel.get(response.model) || { requests: 0, tokens: 0, cost: 0 };
+        modelStats.requests++;
+        modelStats.tokens += response.usage.totalTokens;
+        modelStats.cost += response.cost?.totalCost || 0;
+        this.data.byModel.set(response.model, modelStats);
+        const providerStats = this.data.byProvider.get(response.provider) || { requests: 0, tokens: 0, cost: 0 };
+        providerStats.requests++;
+        providerStats.tokens += response.usage.totalTokens;
+        providerStats.cost += response.cost?.totalCost || 0;
+        this.data.byProvider.set(response.provider, providerStats);
+    }
+    recordError() {
+        this.data.errorCount++;
+    }
+    summary() {
+        return {
+            totalRequests: this.totalRequests,
+            totalTokens: this.totalTokens,
+            totalCost: this.totalCost,
+            avgLatency: this.avgLatency,
+            errorRate: this.errorRate,
+            cacheHitRate: this.cacheHitRate,
+            byModel: Object.fromEntries(this.data.byModel),
+            byProvider: Object.fromEntries(this.data.byProvider),
+        };
+    }
+    reset() {
+        this.data = {
+            totalRequests: 0,
+            totalTokens: 0,
+            totalCost: 0,
+            totalLatencyTtft: 0,
+            totalLatencyTotal: 0,
+            errorCount: 0,
+            cacheHits: 0,
+            byModel: new Map(),
+            byProvider: new Map(),
+        };
+    }
+}
+export class UnifiedAIClient {
+    config;
+    providers = new Map();
+    _metrics = new AIMetricsTracker();
+    constructor(config = {}) {
+        this.config = {
+            defaultProvider: 'openai',
+            observability: true,
+            debug: false,
+            ...config,
+        };
+        this.initializeProviders();
+    }
+    get metrics() {
+        return this._metrics;
+    }
+    async chat(optionsOrPrompt) {
+        const options = this.normalizeOptions(optionsOrPrompt);
+        const provider = this.getProvider(options.provider);
+        try {
+            const response = await this.executeWithRetry(() => provider.chat(options), options);
+            if (this.config.observability) {
+                this._metrics.record(response);
+            }
+            if (this.config.debug) {
+                this.logResponse(response);
+            }
+            return response;
+        }
+        catch (error) {
+            if (this.config.observability) {
+                this._metrics.recordError();
+            }
+            throw error;
+        }
+    }
+    async stream(options) {
+        const provider = this.getProvider(options.provider);
+        return provider.stream(options);
+    }
+    async embed(options) {
+        const provider = this.getProvider(options.provider);
+        return provider.embed(options);
+    }
+    extend(defaults) {
+        const parent = this;
+        return {
+            chat: async (optionsOrPrompt) => {
+                const options = parent.normalizeOptions(optionsOrPrompt);
+                return parent.chat({ ...defaults, ...options, messages: [...(defaults.messages || []), ...options.messages] });
+            },
+            stream: async (options) => {
+                return parent.stream({ ...defaults, ...options, messages: [...(defaults.messages || []), ...options.messages] });
+            },
+            embed: async (options) => {
+                return parent.embed({ provider: defaults.provider, ...options });
+            },
+            extend: (moreDefaults) => {
+                return parent.extend({ ...defaults, ...moreDefaults });
+            },
+            metrics: parent.metrics,
+        };
+    }
+    initializeProviders() {
+        const openaiConfig = this.config.providers?.openai || {};
+        this.providers.set('openai', new OpenAIProvider(openaiConfig));
+        const anthropicConfig = this.config.providers?.anthropic || {};
+        this.providers.set('anthropic', new AnthropicProvider(anthropicConfig));
+        const googleConfig = this.config.providers?.google || {};
+        this.providers.set('google', new GoogleProvider(googleConfig));
+        const ollamaConfig = this.config.providers?.ollama || {};
+        this.providers.set('ollama', new OllamaProvider(ollamaConfig));
+    }
+    getProvider(name) {
+        const providerName = name || this.config.defaultProvider || 'openai';
+        const provider = this.providers.get(providerName);
+        if (!provider) {
+            throw new AIError(`Provider not found: ${providerName}`, providerName, 'provider_not_found');
+        }
+        return provider;
+    }
+    normalizeOptions(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === 'string') {
+            return {
+                messages: [{ role: 'user', content: optionsOrPrompt }],
+            };
+        }
+        return optionsOrPrompt;
+    }
+    async executeWithRetry(fn, options) {
+        const retryConfig = options.retry || this.config.retry;
+        if (!retryConfig) {
+            return fn();
+        }
+        const maxAttempts = retryConfig.maxAttempts || 3;
+        const retryOn = retryConfig.on || ['rate_limit', 'overloaded', 'timeout'];
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                if (!this.shouldRetry(error, retryOn, attempt, maxAttempts)) {
+                    throw error;
+                }
+                const delay = this.calculateBackoff(attempt, retryConfig.backoff);
+                if (retryConfig.onRetry) {
+                    retryConfig.onRetry(attempt, error);
+                }
+                if (this.config.debug) {
+                    console.log(`[recker/ai] Retry ${attempt}/${maxAttempts} after ${delay}ms`);
+                }
+                await this.sleep(delay);
+                if (retryConfig.fallback && options.model) {
+                    const fallbackModel = retryConfig.fallback[options.model];
+                    if (fallbackModel) {
+                        options = { ...options, model: fallbackModel };
+                        if (this.config.debug) {
+                            console.log(`[recker/ai] Falling back to model: ${fallbackModel}`);
+                        }
+                    }
+                }
+                if (retryConfig.reduceContext &&
+                    error instanceof ContextLengthError &&
+                    options.messages.length > 2) {
+                    options = {
+                        ...options,
+                        messages: this.reduceContext(options.messages),
+                    };
+                    if (this.config.debug) {
+                        console.log(`[recker/ai] Reduced context to ${options.messages.length} messages`);
+                    }
+                }
+            }
+        }
+        throw lastError || new Error('Retry exhausted');
+    }
+    shouldRetry(error, retryOn, attempt, maxAttempts) {
+        if (attempt >= maxAttempts)
+            return false;
+        if (error instanceof RateLimitError && retryOn.includes('rate_limit'))
+            return true;
+        if (error instanceof OverloadedError && retryOn.includes('overloaded'))
+            return true;
+        if (error instanceof ContextLengthError && retryOn.includes('context_length_exceeded'))
+            return true;
+        if (error.name === 'TimeoutError' && retryOn.includes('timeout'))
+            return true;
+        if (error instanceof AIError && error.retryable && retryOn.includes('server_error'))
+            return true;
+        return false;
+    }
+    calculateBackoff(attempt, strategy = 'exponential') {
+        const baseDelay = 1000;
+        const maxDelay = 30000;
+        let delay;
+        switch (strategy) {
+            case 'linear':
+                delay = baseDelay * attempt;
+                break;
+            case 'exponential':
+                delay = baseDelay * Math.pow(2, attempt - 1);
+                break;
+            case 'decorrelated':
+                delay = Math.random() * Math.min(maxDelay, baseDelay * Math.pow(3, attempt - 1));
+                break;
+            default:
+                delay = baseDelay * attempt;
+        }
+        const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+        return Math.min(maxDelay, delay + jitter);
+    }
+    reduceContext(messages) {
+        if (messages.length <= 2)
+            return messages;
+        const systemMessages = messages.filter((m) => m.role === 'system');
+        const nonSystemMessages = messages.filter((m) => m.role !== 'system');
+        if (nonSystemMessages.length <= 4) {
+            return messages;
+        }
+        const reduced = [
+            ...systemMessages,
+            nonSystemMessages[0],
+            ...nonSystemMessages.slice(-2),
+        ];
+        return reduced;
+    }
+    logResponse(response) {
+        console.log(`[recker/ai] ${response.provider}/${response.model}`);
+        console.log(`  Tokens: ${response.usage.inputTokens} in / ${response.usage.outputTokens} out`);
+        console.log(`  Latency: TTFT=${response.latency.ttft.toFixed(0)}ms, Total=${response.latency.total.toFixed(0)}ms`);
+        if (response.cost) {
+            console.log(`  Cost: $${response.cost.totalCost.toFixed(6)}`);
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+export function createAI(config) {
+    return new UnifiedAIClient(config);
+}

package/dist/browser/ai/index.d.ts

@@ -0,0 +1,14 @@
+export { UnifiedAIClient, createAI } from './client.js';
+export { ClientAIImpl, AIConfigurationError } from './client-ai.js';
+export { ConversationMemory } from './memory.js';
+export { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError } from './providers/base.js';
+export { OpenAIProvider } from './providers/openai.js';
+export { AnthropicProvider } from './providers/anthropic.js';
+export { GoogleProvider } from './providers/google.js';
+export { OllamaProvider } from './providers/ollama.js';
+export * from './vector/index.js';
+export { AdaptiveTimeoutManager, StreamTimeoutController, adaptiveTimeouts } from './adaptive-timeout.js';
+export { TokenRateLimiter, RateLimitExceededError, createRateLimiter, tokenEstimators, PROVIDER_RATE_LIMITS, } from './rate-limiter.js';
+export type { AIProvider, MessageRole, ChatMessage, ContentPart, ToolDefinition, ToolCall, TokenUsage, CostInfo, AILatency, AITimeoutOptions, AIRetryOptions, ResponseFormat, ChatOptions, EmbedOptions, AIResponse, EmbedResponse, StreamEventType, StreamEvent, TextStreamEvent, ToolCallStreamEvent, ToolCallDeltaStreamEvent, UsageStreamEvent, DoneStreamEvent, ErrorStreamEvent, AIStream, ProviderConfig, AIClientConfig, TokenRateLimitConfig, SemanticCacheConfig, CacheStorage, AIClient, AIMetrics, AIMetricsSummary, AgentTool, AgentConfig, AgentEventType, AgentStreamEvent, Agent, } from '../types/ai.js';
+export type { OpenAIConfig } from './providers/openai.js';
+export type { AnthropicConfig } from './providers/anthropic.js';

package/dist/browser/ai/index.js

@@ -0,0 +1,11 @@
+export { UnifiedAIClient, createAI } from './client.js';
+export { ClientAIImpl, AIConfigurationError } from './client-ai.js';
+export { ConversationMemory } from './memory.js';
+export { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError } from './providers/base.js';
+export { OpenAIProvider } from './providers/openai.js';
+export { AnthropicProvider } from './providers/anthropic.js';
+export { GoogleProvider } from './providers/google.js';
+export { OllamaProvider } from './providers/ollama.js';
+export * from './vector/index.js';
+export { AdaptiveTimeoutManager, StreamTimeoutController, adaptiveTimeouts } from './adaptive-timeout.js';
+export { TokenRateLimiter, RateLimitExceededError, createRateLimiter, tokenEstimators, PROVIDER_RATE_LIMITS, } from './rate-limiter.js';

package/dist/browser/ai/providers/anthropic.d.ts

@@ -0,0 +1,63 @@
+import type { ChatOptions, ChatMessage, AIResponse, AIStream, StreamEvent, EmbedOptions, EmbedResponse, ProviderConfig } from '../../types/ai.js';
+import { BaseAIProvider, ProviderRequestContext } from './base.js';
+export interface AnthropicConfig extends ProviderConfig {
+    version?: string;
+}
+interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | AnthropicContentPart[];
+}
+type AnthropicContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+};
+interface AnthropicCompletion {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    content: AnthropicContentPart[];
+    model: string;
+    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use';
+    stop_sequence?: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+export declare class AnthropicProvider extends BaseAIProvider {
+    private anthropicConfig;
+    constructor(config?: AnthropicConfig);
+    protected getEnvApiKey(): string | undefined;
+    protected getBaseUrl(): string;
+    protected buildHeaders(): Record<string, string>;
+    protected transformMessages(messages: ChatMessage[]): AnthropicMessage[];
+    private transformContent;
+    private transformTools;
+    private getSystemPrompt;
+    chat(options: ChatOptions): Promise<AIResponse>;
+    stream(options: ChatOptions): Promise<AIStream>;
+    embed(_options: EmbedOptions): Promise<EmbedResponse>;
+    private buildChatBody;
+    private makeRequest;
+    private handleError;
+    protected parseResponse(data: AnthropicCompletion, context: ProviderRequestContext): AIResponse;
+    protected parseStreamEvent(_chunk: string, _context: ProviderRequestContext): StreamEvent | null;
+    private parseAnthropicStream;
+}
+export {};