@probeo/anymodel 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -1,14 +1,632 @@
-export { AnyModel } from './client.js';
-export type { Message, Role, ContentPart, Tool, ToolChoice, ToolCall, ChatCompletionRequest, ChatCompletion, ChatCompletionChoice, ChatCompletionChunk, ChunkChoice, ChunkDelta, ResponseFormat, ProviderPreferences, Usage, FinishReason, ModelInfo, ModelPricing, ModelArchitecture, ModelTopProvider, GenerationStats, BatchCreateRequest, BatchRequestItem, BatchObject, BatchResultItem, BatchResults, BatchUsageSummary, BatchStatus, BatchMode, AnyModelConfig, ProviderConfig, CustomProviderConfig, AnyModelErrorMetadata, } from './types.js';
-export { AnyModelError } from './types.js';
-export { resolveConfig } from './config.js';
-export { GenerationStatsStore } from './utils/generation-stats.js';
-export { BatchManager, BatchStore } from './batch/index.js';
-export type { BatchPollOptions } from './batch/index.js';
-export { createAnyModelServer, startServer } from './server.js';
-export type { ServerOptions } from './server.js';
-export { readFileQueued, writeFileQueued, writeFileFlushedQueued, appendFileQueued, ensureDir, joinPath, getFsQueueStatus, waitForFsQueuesIdle, } from './utils/fs-io.js';
-export type { ProviderAdapter, BatchAdapter, NativeBatchStatus } from './providers/adapter.js';
-export { createOpenAIBatchAdapter } from './providers/openai-batch.js';
-export { createAnthropicBatchAdapter } from './providers/anthropic-batch.js';
-//# sourceMappingURL=index.d.ts.map
+import { createServer } from 'node:http';
+
+type Role = 'system' | 'user' | 'assistant' | 'tool';
+interface Message {
+    role: Role;
+    content: string | ContentPart[];
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+}
+interface ContentPart {
+    type: 'text' | 'image_url';
+    text?: string;
+    image_url?: {
+        url: string;
+        detail?: 'auto' | 'low' | 'high';
+    };
+}
+interface Tool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+type ToolChoice = 'none' | 'auto' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+};
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+type ResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json_object';
+} | {
+    type: 'json_schema';
+    json_schema: {
+        name: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+};
+interface ProviderPreferences {
+    order?: string[];
+    only?: string[];
+    ignore?: string[];
+    allow_fallbacks?: boolean;
+    require_parameters?: boolean;
+    sort?: 'price' | 'throughput' | 'latency';
+}
+interface ChatCompletionRequest {
+    model: string;
+    messages: Message[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    repetition_penalty?: number;
+    seed?: number;
+    stop?: string | string[];
+    stream?: boolean;
+    logprobs?: boolean;
+    top_logprobs?: number;
+    response_format?: ResponseFormat;
+    tools?: Tool[];
+    tool_choice?: ToolChoice;
+    user?: string;
+    models?: string[];
+    route?: 'fallback';
+    transforms?: string[];
+    provider?: ProviderPreferences;
+}
+type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'error';
+interface Usage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+interface ChatCompletionChoice {
+    index: number;
+    message: Message;
+    finish_reason: FinishReason;
+    logprobs?: unknown;
+}
+interface ChatCompletion {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: ChatCompletionChoice[];
+    usage: Usage;
+}
+interface ChunkDelta {
+    role?: Role;
+    content?: string;
+    tool_calls?: Partial<ToolCall>[];
+}
+interface ChunkChoice {
+    index: number;
+    delta: ChunkDelta;
+    finish_reason: FinishReason | null;
+    logprobs?: unknown;
+}
+interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: ChunkChoice[];
+    usage?: Usage;
+}
+interface ModelPricing {
+    prompt: string;
+    completion: string;
+}
+interface ModelArchitecture {
+    modality: string;
+    input_modalities: string[];
+    output_modalities: string[];
+    tokenizer: string;
+}
+interface ModelTopProvider {
+    context_length: number;
+    max_completion_tokens: number;
+    is_moderated: boolean;
+}
+interface ModelInfo {
+    id: string;
+    name: string;
+    created: number;
+    description: string;
+    context_length: number;
+    pricing: ModelPricing;
+    architecture: ModelArchitecture;
+    top_provider: ModelTopProvider;
+    supported_parameters: string[];
+}
+interface GenerationStats {
+    id: string;
+    model: string;
+    provider_name: string;
+    total_cost: number;
+    tokens_prompt: number;
+    tokens_completion: number;
+    latency: number;
+    generation_time: number;
+    created_at: string;
+    finish_reason: FinishReason;
+    streamed: boolean;
+}
+interface AnyModelErrorMetadata {
+    provider_name?: string;
+    raw?: unknown;
+}
+declare class AnyModelError extends Error {
+    readonly code: number;
+    readonly metadata: AnyModelErrorMetadata;
+    constructor(code: number, message: string, metadata?: AnyModelErrorMetadata);
+    toJSON(): {
+        error: {
+            code: number;
+            message: string;
+            metadata: AnyModelErrorMetadata;
+        };
+    };
+}
+type BatchStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+type BatchMode = 'native' | 'concurrent';
+interface BatchRequestItem {
+    custom_id: string;
+    messages: Message[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    stop?: string | string[];
+    response_format?: ResponseFormat;
+    tools?: Tool[];
+    tool_choice?: ToolChoice;
+}
+interface BatchCreateRequest {
+    model: string;
+    requests: BatchRequestItem[];
+    options?: {
+        temperature?: number;
+        max_tokens?: number;
+        top_p?: number;
+        top_k?: number;
+        stop?: string | string[];
+        response_format?: ResponseFormat;
+        tools?: Tool[];
+        tool_choice?: ToolChoice;
+    };
+    webhook?: string;
+}
+interface BatchObject {
+    id: string;
+    object: 'batch';
+    status: BatchStatus;
+    model: string;
+    provider_name: string;
+    batch_mode: BatchMode;
+    total: number;
+    completed: number;
+    failed: number;
+    created_at: string;
+    completed_at: string | null;
+    expires_at: string | null;
+}
+interface BatchResultItem {
+    custom_id: string;
+    status: 'success' | 'error';
+    response: ChatCompletion | null;
+    error: {
+        code: number;
+        message: string;
+    } | null;
+}
+interface BatchUsageSummary {
+    total_prompt_tokens: number;
+    total_completion_tokens: number;
+    estimated_cost: number;
+}
+interface BatchResults {
+    id: string;
+    status: BatchStatus;
+    results: BatchResultItem[];
+    usage_summary: BatchUsageSummary;
+}
+interface ProviderConfig {
+    apiKey?: string;
+    defaultModel?: string;
+}
+interface CustomProviderConfig {
+    baseURL: string;
+    apiKey?: string;
+    models?: string[];
+}
+interface AnyModelConfig {
+    anthropic?: ProviderConfig;
+    openai?: ProviderConfig;
+    google?: ProviderConfig;
+    mistral?: ProviderConfig;
+    groq?: ProviderConfig;
+    deepseek?: ProviderConfig;
+    xai?: ProviderConfig;
+    together?: ProviderConfig;
+    fireworks?: ProviderConfig;
+    perplexity?: ProviderConfig;
+    ollama?: ProviderConfig & {
+        baseURL?: string;
+    };
+    custom?: Record<string, CustomProviderConfig>;
+    aliases?: Record<string, string>;
+    defaults?: {
+        temperature?: number;
+        max_tokens?: number;
+        retries?: number;
+        timeout?: number;
+        transforms?: string[];
+    };
+    routing?: {
+        fallback_order?: string[];
+        allow_fallbacks?: boolean;
+    };
+    batch?: {
+        dir?: string;
+        pollInterval?: number;
+        concurrencyFallback?: number;
+        retentionDays?: number;
+    };
+    io?: {
+        readConcurrency?: number;
+        writeConcurrency?: number;
+    };
+}
+
+interface ProviderAdapter {
+    readonly name: string;
+    translateRequest(request: ChatCompletionRequest): unknown;
+    translateResponse(response: unknown): ChatCompletion;
+    translateStream(stream: ReadableStream<Uint8Array>): AsyncIterable<ChatCompletionChunk>;
+    translateError(error: unknown): {
+        code: number;
+        message: string;
+        metadata: AnyModelErrorMetadata;
+    };
+    listModels(): Promise<ModelInfo[]>;
+    supportsParameter(param: string): boolean;
+    supportsBatch(): boolean;
+    sendRequest(request: ChatCompletionRequest): Promise<ChatCompletion>;
+    sendStreamingRequest(request: ChatCompletionRequest): Promise<AsyncIterable<ChatCompletionChunk>>;
+}
+interface NativeBatchStatus {
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    total: number;
+    completed: number;
+    failed: number;
+}
+interface BatchAdapter {
+    createBatch(model: string, requests: BatchRequestItem[], options?: Record<string, unknown>): Promise<{
+        providerBatchId: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    pollBatch(providerBatchId: string): Promise<NativeBatchStatus>;
+    getBatchResults(providerBatchId: string): Promise<BatchResultItem[]>;
+    cancelBatch(providerBatchId: string): Promise<void>;
+}
+
+declare class ProviderRegistry {
+    private adapters;
+    register(slug: string, adapter: ProviderAdapter): void;
+    get(slug: string): ProviderAdapter;
+    has(slug: string): boolean;
+    list(): string[];
+    all(): ProviderAdapter[];
+}
+
+/**
+ * Per-provider rate limit tracker.
+ * Tracks rate limit state from provider response headers and 429 errors.
+ */
+interface RateLimitState {
+    provider: string;
+    remaining: number | null;
+    resetAt: number | null;
+    retryAfter: number | null;
+    lastUpdated: number;
+}
+declare class RateLimitTracker {
+    private state;
+    /**
+     * Update rate limit state from response headers.
+     */
+    updateFromHeaders(provider: string, headers: Record<string, string>): void;
+    /**
+     * Record a 429 for a provider.
+     */
+    recordRateLimit(provider: string, retryAfterMs?: number): void;
+    /**
+     * Check if a provider is currently rate-limited.
+     */
+    isRateLimited(provider: string): boolean;
+    /**
+     * Get ms until rate limit resets for a provider.
+     */
+    getWaitTime(provider: string): number;
+    /**
+     * Get state for a provider.
+     */
+    getState(provider: string): RateLimitState | undefined;
+    private getOrCreate;
+}
+
+declare class Router {
+    private registry;
+    private aliases?;
+    private config?;
+    private rateLimiter;
+    constructor(registry: ProviderRegistry, aliases?: Record<string, string> | undefined, config?: AnyModelConfig | undefined);
+    /**
+     * Strip parameters that the target provider doesn't support.
+     */
+    private stripUnsupported;
+    /**
+     * Apply transforms (e.g., middle-out) to the request messages.
+     */
+    private applyTransforms;
+    /**
+     * Order models based on provider preferences.
+     */
+    private applyProviderPreferences;
+    private getRetryOptions;
+    complete(request: ChatCompletionRequest): Promise<ChatCompletion>;
+    stream(request: ChatCompletionRequest): Promise<AsyncIterable<ChatCompletionChunk>>;
+    private completeWithFallback;
+    private streamWithFallback;
+    getRateLimiter(): RateLimitTracker;
+}
+
+interface BatchPollOptions {
+    /** Poll interval in ms. Default: 5000 */
+    interval?: number;
+    /** Timeout in ms. 0 = indefinite. Default: 0 */
+    timeout?: number;
+    /** Progress callback */
+    onProgress?: (batch: BatchObject) => void;
+}
+declare class BatchManager {
+    private store;
+    private router;
+    private concurrencyLimit;
+    private defaultPollInterval;
+    private batchAdapters;
+    constructor(router: Router, options?: {
+        dir?: string;
+        concurrency?: number;
+        pollInterval?: number;
+    });
+    /**
+     * Register a native batch adapter for a provider.
+     */
+    registerBatchAdapter(providerName: string, adapter: BatchAdapter): void;
+    /**
+     * Check if a provider has native batch support.
+     */
+    private getNativeBatchAdapter;
+    /**
+     * Create a batch and return immediately (no polling).
+     */
+    create(request: BatchCreateRequest): Promise<BatchObject>;
+    /**
+     * Create a batch and poll until completion.
+     */
+    createAndPoll(request: BatchCreateRequest, options?: BatchPollOptions): Promise<BatchResults>;
+    /**
+     * Poll an existing batch until completion.
+     */
+    poll(id: string, options?: BatchPollOptions): Promise<BatchResults>;
+    /**
+     * Get the current status of a batch.
+     */
+    get(id: string): Promise<BatchObject | null>;
+    /**
+     * Get results for a completed batch.
+     */
+    getResults(id: string): Promise<BatchResults>;
+    /**
+     * List all batches.
+     */
+    list(): Promise<BatchObject[]>;
+    /**
+     * Cancel a batch.
+     */
+    cancel(id: string): Promise<BatchObject>;
+    /**
+     * Process batch via native provider batch API.
+     */
+    private processNativeBatch;
+    /**
+     * Sync native batch status from provider.
+     */
+    private syncNativeBatchStatus;
+    /**
+     * Process batch requests concurrently (fallback path).
+     */
+    private processConcurrentBatch;
+}
+
+declare class AnyModel {
+    private registry;
+    private router;
+    private config;
+    private modelCache;
+    private statsStore;
+    private batchManager;
+    readonly chat: {
+        completions: {
+            create: (request: ChatCompletionRequest) => Promise<ChatCompletion | AsyncIterable<ChatCompletionChunk>>;
+        };
+    };
+    readonly models: {
+        list: (opts?: {
+            provider?: string;
+        }) => Promise<ModelInfo[]>;
+        refresh: () => Promise<ModelInfo[]>;
+    };
+    readonly generation: {
+        get: (id: string) => GenerationStats | undefined;
+        list: (limit?: number) => GenerationStats[];
+    };
+    readonly batches: {
+        create: (request: BatchCreateRequest) => Promise<BatchObject>;
+        createAndPoll: (request: BatchCreateRequest, options?: BatchPollOptions) => Promise<BatchResults>;
+        poll: (id: string, options?: BatchPollOptions) => Promise<BatchResults>;
+        get: (id: string) => Promise<BatchObject | null>;
+        list: () => Promise<BatchObject[]>;
+        cancel: (id: string) => Promise<BatchObject>;
+        results: (id: string) => Promise<BatchResults>;
+    };
+    constructor(config?: AnyModelConfig);
+    private registerProviders;
+    private registerBatchAdapters;
+    private applyDefaults;
+    private fetchModels;
+    getRegistry(): ProviderRegistry;
+}
+
+/**
+ * Resolve config with precedence: programmatic → local → global → env vars.
+ */
+declare function resolveConfig(programmatic?: AnyModelConfig, cwd?: string): AnyModelConfig;
+
+interface GenerationRecord {
+    id: string;
+    model: string;
+    providerName: string;
+    promptTokens: number;
+    completionTokens: number;
+    startTime: number;
+    endTime: number;
+    finishReason: FinishReason;
+    streamed: boolean;
+}
+/**
+ * In-memory generation stats store.
+ * Tracks recent completions for the generation stats endpoint.
+ */
+declare class GenerationStatsStore {
+    private records;
+    private maxRecords;
+    constructor(maxRecords?: number);
+    record(entry: GenerationRecord): void;
+    get(id: string): GenerationStats | undefined;
+    list(limit?: number): GenerationStats[];
+}
+
+/**
+ * Disk-based batch persistence store.
+ * Uses queued, concurrency-limited IO for high-volume operations.
+ * Structure: {dir}/{batchId}/meta.json, requests.jsonl, results.jsonl, provider.json
+ */
+declare class BatchStore {
+    private dir;
+    private initialized;
+    constructor(dir?: string);
+    private init;
+    private batchDir;
+    /**
+     * Create a new batch directory and save initial metadata.
+     */
+    create(batch: BatchObject): Promise<void>;
+    /**
+     * Update batch metadata (atomic write).
+     */
+    updateMeta(batch: BatchObject): Promise<void>;
+    /**
+     * Save requests as JSONL.
+     */
+    saveRequests(id: string, requests: unknown[]): Promise<void>;
+    /**
+     * Append a result to results.jsonl.
+     */
+    appendResult(id: string, result: BatchResultItem): Promise<void>;
+    /**
+     * Save provider-specific state (e.g., provider batch ID).
+     */
+    saveProviderState(id: string, state: Record<string, unknown>): Promise<void>;
+    /**
+     * Load provider state.
+     */
+    loadProviderState(id: string): Promise<Record<string, unknown> | null>;
+    /**
+     * Get batch metadata.
+     */
+    getMeta(id: string): Promise<BatchObject | null>;
+    /**
+     * Get all results for a batch.
+     */
+    getResults(id: string): Promise<BatchResultItem[]>;
+    /**
+     * List all batch IDs.
+     */
+    listBatches(): Promise<string[]>;
+    /**
+     * Check if a batch exists.
+     */
+    exists(id: string): Promise<boolean>;
+}
+
+interface ServerOptions {
+    port?: number;
+    host?: string;
+    config?: AnyModelConfig;
+}
+declare function createAnyModelServer(options?: ServerOptions): ReturnType<typeof createServer>;
+declare function startServer(options?: ServerOptions): void;
+
+/**
+ * Concurrency-limited filesystem helpers for high-volume file operations.
+ *
+ * Based on probeo-core/common/fs-io. Provides queued reads/writes,
+ * atomic durable writes, directory caching, and path memoization.
+ */
+
+/**
+ * Configure the filesystem IO concurrency limits.
+ * Call before any IO operations to adjust defaults.
+ */
+declare function configureFsIO(options: {
+    readConcurrency?: number;
+    writeConcurrency?: number;
+}): void;
+declare function ensureDir(dir: string): Promise<void>;
+declare function readFileQueued(filePath: string, encoding?: BufferEncoding | null): Promise<string | Buffer>;
+declare function writeFileQueued(filePath: string, data: string | Buffer): Promise<void>;
+declare function appendFileQueued(filePath: string, data: string | Buffer): Promise<void>;
+/**
+ * Atomically write a file with fsync to ensure data hits disk.
+ * Uses temp file + rename + directory fsync.
+ */
+declare function writeFileFlushedQueued(filePath: string, data: string | Buffer): Promise<void>;
+declare function joinPath(...segments: string[]): string;
+declare function getFsQueueStatus(): {
+    read: {
+        size: number;
+        pending: number;
+    };
+    write: {
+        size: number;
+        pending: number;
+    };
+};
+declare function waitForFsQueuesIdle(): Promise<void>;
+
+declare function createOpenAIBatchAdapter(apiKey: string): BatchAdapter;
+
+declare function createAnthropicBatchAdapter(apiKey: string): BatchAdapter;
+
+export { AnyModel, type AnyModelConfig, AnyModelError, type AnyModelErrorMetadata, type BatchAdapter, type BatchCreateRequest, BatchManager, type BatchMode, type BatchObject, type BatchPollOptions, type BatchRequestItem, type BatchResultItem, type BatchResults, type BatchStatus, BatchStore, type BatchUsageSummary, type ChatCompletion, type ChatCompletionChoice, type ChatCompletionChunk, type ChatCompletionRequest, type ChunkChoice, type ChunkDelta, type ContentPart, type CustomProviderConfig, type FinishReason, type GenerationStats, GenerationStatsStore, type Message, type ModelArchitecture, type ModelInfo, type ModelPricing, type ModelTopProvider, type NativeBatchStatus, type ProviderAdapter, type ProviderConfig, type ProviderPreferences, type ResponseFormat, type Role, type ServerOptions, type Tool, type ToolCall, type ToolChoice, type Usage, appendFileQueued, configureFsIO, createAnthropicBatchAdapter, createAnyModelServer, createOpenAIBatchAdapter, ensureDir, getFsQueueStatus, joinPath, readFileQueued, resolveConfig, startServer, waitForFsQueuesIdle, writeFileFlushedQueued, writeFileQueued };