@clinebot/llms 0.0.0

package/dist/models/schemas/query.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Model Query Schema Definitions
+ *
+ * Zod schemas for configuring model queries and filters.
+ * Users can use these to find models matching specific criteria.
+ */
+import { z } from "zod";
+import { type ModelInfo } from "./model";
+/**
+ * Configuration for querying models
+ */
+export declare const ModelQueryConfigSchema: z.ZodObject<{
+    providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        images: "images";
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
+        "reasoning-effort": "reasoning-effort";
+        "computer-use": "computer-use";
+        "global-endpoint": "global-endpoint";
+        structured_output: "structured_output";
+        temperature: "temperature";
+        files: "files";
+    }>>>;
+    anyCapabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        images: "images";
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
+        "reasoning-effort": "reasoning-effort";
+        "computer-use": "computer-use";
+        "global-endpoint": "global-endpoint";
+        structured_output: "structured_output";
+        temperature: "temperature";
+        files: "files";
+    }>>>;
+    excludeCapabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        images: "images";
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
+        "reasoning-effort": "reasoning-effort";
+        "computer-use": "computer-use";
+        "global-endpoint": "global-endpoint";
+        structured_output: "structured_output";
+        temperature: "temperature";
+        files: "files";
+    }>>>;
+    status: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        active: "active";
+        preview: "preview";
+        deprecated: "deprecated";
+        legacy: "legacy";
+    }>>>;
+    includeDeprecated: z.ZodOptional<z.ZodBoolean>;
+    apiFormat: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        "openai-responses": "openai-responses";
+        r1: "r1";
+    }>>;
+    minContextWindow: z.ZodOptional<z.ZodNumber>;
+    maxContextWindow: z.ZodOptional<z.ZodNumber>;
+    minMaxTokens: z.ZodOptional<z.ZodNumber>;
+    maxInputPrice: z.ZodOptional<z.ZodNumber>;
+    maxOutputPrice: z.ZodOptional<z.ZodNumber>;
+    search: z.ZodOptional<z.ZodString>;
+    hasThinking: z.ZodOptional<z.ZodBoolean>;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        outputPrice: "outputPrice";
+        name: "name";
+        maxTokens: "maxTokens";
+        contextWindow: "contextWindow";
+        inputPrice: "inputPrice";
+    }>>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ModelQueryConfig = z.infer<typeof ModelQueryConfigSchema>;
+/**
+ * Result of a model query
+ */
+export declare const ModelQueryResultSchema: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        providerId: z.ZodString;
+        modelId: z.ZodString;
+        info: z.ZodAny;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    config: z.ZodObject<{
+        providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            images: "images";
+            tools: "tools";
+            streaming: "streaming";
+            "prompt-cache": "prompt-cache";
+            reasoning: "reasoning";
+            "reasoning-effort": "reasoning-effort";
+            "computer-use": "computer-use";
+            "global-endpoint": "global-endpoint";
+            structured_output: "structured_output";
+            temperature: "temperature";
+            files: "files";
+        }>>>;
+        anyCapabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            images: "images";
+            tools: "tools";
+            streaming: "streaming";
+            "prompt-cache": "prompt-cache";
+            reasoning: "reasoning";
+            "reasoning-effort": "reasoning-effort";
+            "computer-use": "computer-use";
+            "global-endpoint": "global-endpoint";
+            structured_output: "structured_output";
+            temperature: "temperature";
+            files: "files";
+        }>>>;
+        excludeCapabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            images: "images";
+            tools: "tools";
+            streaming: "streaming";
+            "prompt-cache": "prompt-cache";
+            reasoning: "reasoning";
+            "reasoning-effort": "reasoning-effort";
+            "computer-use": "computer-use";
+            "global-endpoint": "global-endpoint";
+            structured_output: "structured_output";
+            temperature: "temperature";
+            files: "files";
+        }>>>;
+        status: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            active: "active";
+            preview: "preview";
+            deprecated: "deprecated";
+            legacy: "legacy";
+        }>>>;
+        includeDeprecated: z.ZodOptional<z.ZodBoolean>;
+        apiFormat: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "openai-responses": "openai-responses";
+            r1: "r1";
+        }>>;
+        minContextWindow: z.ZodOptional<z.ZodNumber>;
+        maxContextWindow: z.ZodOptional<z.ZodNumber>;
+        minMaxTokens: z.ZodOptional<z.ZodNumber>;
+        maxInputPrice: z.ZodOptional<z.ZodNumber>;
+        maxOutputPrice: z.ZodOptional<z.ZodNumber>;
+        search: z.ZodOptional<z.ZodString>;
+        hasThinking: z.ZodOptional<z.ZodBoolean>;
+        sortBy: z.ZodOptional<z.ZodEnum<{
+            outputPrice: "outputPrice";
+            name: "name";
+            maxTokens: "maxTokens";
+            contextWindow: "contextWindow";
+            inputPrice: "inputPrice";
+        }>>;
+        sortDirection: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ModelQueryResult = z.infer<typeof ModelQueryResultSchema>;
+export interface ModelMatch {
+    providerId: string;
+    modelId: string;
+    info: ModelInfo;
+}
+/**
+ * Check if a model matches the query config
+ */
+export declare function matchesQuery(modelId: string, info: ModelInfo, config: ModelQueryConfig): boolean;
+/**
+ * Sort model results
+ */
+export declare function sortModels(models: ModelMatch[], sortBy: ModelQueryConfig["sortBy"], direction?: "asc" | "desc"): ModelMatch[];
+/**
+ * Validate query config
+ */
+export declare function validateQueryConfig(data: unknown): ModelQueryConfig;
+/**
+ * Safely validate query config (returns undefined on failure)
+ */
+export declare function safeValidateQueryConfig(data: unknown): ModelQueryConfig | undefined;

package/dist/providers/handlers/ai-sdk-community.d.ts

@@ -0,0 +1,46 @@
+import type { ApiStream } from "../types";
+export type { AiSdkMessage, AiSdkMessagePart, } from "../transform/ai-sdk-community-format";
+export { toAiSdkMessages } from "../transform/ai-sdk-community-format";
+type AiSdkStreamPart = {
+    type?: string;
+    [key: string]: unknown;
+};
+type AiSdkUsage = {
+    inputTokens?: unknown;
+    outputTokens?: unknown;
+    reasoningTokens?: unknown;
+    thoughtsTokenCount?: unknown;
+    cachedInputTokens?: unknown;
+};
+export type AiSdkStream = {
+    fullStream?: AsyncIterable<AiSdkStreamPart>;
+    textStream?: AsyncIterable<string>;
+    text?: Promise<string> | string;
+    usage?: Promise<Record<string, unknown>>;
+};
+type AiSdkUsageMetrics = {
+    inputTokens: number;
+    outputTokens: number;
+    thoughtsTokenCount: number;
+    cacheReadTokens: number;
+    cacheWriteTokens?: number;
+};
+export type EmitAiSdkStreamOptions = {
+    responseId: string;
+    errorMessage: string;
+    calculateCost: (inputTokens: number, outputTokens: number, cacheReadTokens: number) => number | undefined;
+    reasoningTypes?: string[];
+    enableToolCalls?: boolean;
+    toolCallArgsOrder?: Array<"args" | "input">;
+    toolCallFunctionIncludeId?: boolean;
+    enableTextFallback?: boolean;
+    resolveUsageMetrics?: (usage: AiSdkUsage, part?: AiSdkStreamPart) => AiSdkUsageMetrics;
+};
+export type LoadAiSdkOptions = {
+    beforeImport?: () => void;
+};
+export declare function loadAiSdkModule(options?: LoadAiSdkOptions): Promise<{
+    streamText: (input: Record<string, unknown>) => AiSdkStream;
+}>;
+export declare function numberOrZero(value: unknown): number;
+export declare function emitAiSdkStream(stream: AiSdkStream, options: EmitAiSdkStreamOptions): ApiStream;

package/dist/providers/handlers/ai-sdk-provider-base.d.ts

@@ -0,0 +1,32 @@
+import type { ApiStream, HandlerModelInfo, ProviderConfig } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import { type EmitAiSdkStreamOptions, type LoadAiSdkOptions } from "./ai-sdk-community";
+import { BaseHandler } from "./base";
+type AiSdkCommunityProvider = (modelId: string, settings?: Record<string, unknown>) => unknown;
+type CommunityProviderDefinition = {
+    moduleName: string;
+    createExportName: string;
+    providerExportName: string;
+    missingDependencyError: string;
+};
+export declare function resolveHandlerModel(config: ProviderConfig, defaultModelId?: string): HandlerModelInfo;
+export declare abstract class AiSdkProviderHandler extends BaseHandler {
+    private provider;
+    private providerPromise;
+    protected abstract getProviderDefinition(): CommunityProviderDefinition;
+    protected abstract getDefaultModelId(): string;
+    protected getProviderCreateOptions(): Record<string, unknown> | undefined;
+    protected beforeLoadProviderModule(): Promise<void>;
+    protected getProviderModelSettings(): Record<string, unknown> | undefined;
+    protected getLoadAiSdkOptions(): LoadAiSdkOptions | undefined;
+    protected getStreamErrorMessage(): string;
+    protected getEmitStreamOptions(): Omit<EmitAiSdkStreamOptions, "responseId" | "errorMessage" | "calculateCost">;
+    protected getAssistantToolCallArgKey(): "args" | "input";
+    protected normalizeModelId(modelId: string): string;
+    protected ensureProvider(): Promise<AiSdkCommunityProvider>;
+    getModel(): HandlerModelInfo;
+    getMessages(systemPrompt: string, messages: Message[]): import("./ai-sdk-community").AiSdkMessage[];
+    createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    private createMessageInternal;
+}
+export {};

package/dist/providers/handlers/anthropic-base.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Anthropic Base Handler
+ *
+ * Handler for Anthropic's API using the official SDK.
+ * Supports prompt caching, extended thinking, and native tool calling.
+ */
+import { Anthropic } from "@anthropic-ai/sdk";
+import { type ApiStream, type HandlerModelInfo, type ProviderConfig } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import { BaseHandler } from "./base";
+/**
+ * Handler for Anthropic's API
+ */
+export declare class AnthropicHandler extends BaseHandler {
+    private client;
+    private ensureClient;
+    getModel(): HandlerModelInfo;
+    getMessages(_systemPrompt: string, messages: Message[]): Anthropic.MessageParam[];
+    createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    private createMessageInternal;
+    private processChunk;
+}
+/**
+ * Create an Anthropic handler
+ */
+export declare function createAnthropicHandler(config: ProviderConfig): AnthropicHandler;

package/dist/providers/handlers/asksage.d.ts

@@ -0,0 +1,12 @@
+import type { ApiStream, HandlerModelInfo, ProviderConfig } from "../types";
+import type { Message } from "../types/messages";
+import { FetchBaseHandler } from "./fetch-base";
+export declare const DEFAULT_ASKSAGE_BASE_URL = "https://api.asksage.ai/server";
+export declare class AskSageHandler extends FetchBaseHandler {
+    protected getDefaultBaseUrl(): string;
+    getModel(): HandlerModelInfo;
+    protected getJsonHeaders(extra?: Record<string, string>): Record<string, string>;
+    protected createMessageWithFetch(systemPrompt: string, messages: Message[]): ApiStream;
+    private serializeMessageContent;
+}
+export declare function createAskSageHandler(config: ProviderConfig): AskSageHandler;

package/dist/providers/handlers/auth.d.ts

@@ -0,0 +1,5 @@
+import { normalizeProviderId } from "../types/provider-ids";
+export { normalizeProviderId };
+export declare function getProviderEnvKeys(providerId: string): readonly string[];
+export declare function resolveApiKeyForProvider(providerId: string, explicitApiKey: string | undefined, env?: Record<string, string | undefined>): string | undefined;
+export declare function getMissingApiKeyError(providerId: string): string;

package/dist/providers/handlers/base.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Base Handler
+ *
+ * Abstract base class that provides common functionality for all handlers.
+ */
+import type { ApiHandler, ApiStream, ApiStreamUsageChunk, HandlerModelInfo, ProviderConfig } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import type { ApiStreamChunk } from "../types/stream";
+export declare const DEFAULT_REQUEST_HEADERS: Record<string, string>;
+/**
+ * Base handler class with common functionality
+ */
+export declare abstract class BaseHandler implements ApiHandler {
+    protected config: ProviderConfig;
+    protected abortController: AbortController | undefined;
+    constructor(config: ProviderConfig);
+    /**
+     * Convert Cline messages to provider-specific format
+     * Must be implemented by subclasses
+     */
+    abstract getMessages(systemPrompt: string, messages: Message[]): unknown;
+    /**
+     * Create a streaming message completion
+     * Must be implemented by subclasses
+     */
+    abstract createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    /**
+     * Get the current model configuration
+     * Can be overridden by subclasses for provider-specific logic
+     */
+    getModel(): HandlerModelInfo;
+    /**
+     * Get usage information (optional)
+     * Override in subclasses that support this
+     */
+    getApiStreamUsage(): Promise<ApiStreamUsageChunk | undefined>;
+    /**
+     * Get the abort signal for the current request
+     * Creates a new AbortController if one doesn't exist or was already aborted
+     * Combines with config.abortSignal if provided
+     */
+    protected getAbortSignal(): AbortSignal;
+    /**
+     * Abort the current request
+     */
+    abort(): void;
+    /**
+     * Helper to calculate cost from usage
+     */
+    protected calculateCost(inputTokens: number, outputTokens: number, cacheReadTokens?: number): number | undefined;
+    protected createResponseId(): string;
+    protected withResponseId<T extends ApiStreamChunk>(chunk: T, responseId: string): T;
+    protected withResponseIdForAll(chunks: Iterable<ApiStreamChunk>, responseId: string): Generator<ApiStreamChunk>;
+    protected getRequestHeaders(): Record<string, string>;
+}

package/dist/providers/handlers/bedrock-base.d.ts

@@ -0,0 +1,23 @@
+import { type ApiStream, type HandlerModelInfo, type ProviderConfig } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import { BaseHandler } from "./base";
+type ModelMessagePart = Record<string, unknown>;
+type ModelMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | ModelMessagePart[];
+};
+/**
+ * Handler for AWS Bedrock using AI SDK's Amazon Bedrock provider.
+ *
+ * This handler is async-lazy loaded via createHandlerAsync.
+ */
+export declare class BedrockHandler extends BaseHandler {
+    private clientFactory;
+    private ensureClientFactory;
+    getModel(): HandlerModelInfo;
+    getMessages(systemPrompt: string, messages: Message[]): ModelMessage[];
+    createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    private createMessageInternal;
+}
+export declare function createBedrockHandler(config: ProviderConfig): BedrockHandler;
+export {};

package/dist/providers/handlers/bedrock-client.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderConfig } from "../types";
+type BedrockFactory = (modelId: string) => unknown;
+export declare function createBedrockClient(config: ProviderConfig, defaultHeaders: Record<string, string>): Promise<BedrockFactory>;
+export {};

package/dist/providers/handlers/community-sdk.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Community SDK Handlers
+ *
+ * Consolidated handlers for:
+ * - Codex CLI (`openai-codex`)
+ * - Claude Code (`claude-code`)
+ * - OpenCode (`opencode`)
+ * - Mistral (`mistral`)
+ * - Dify (`dify`)
+ * - SAP AI Core (`sapaicore`)
+ */
+import type { ProviderConfig } from "../types";
+import type { EmitAiSdkStreamOptions } from "./ai-sdk-community";
+import { AiSdkProviderHandler } from "./ai-sdk-provider-base";
+export declare class CodexHandler extends AiSdkProviderHandler {
+    protected getProviderDefinition(): {
+        moduleName: string;
+        createExportName: string;
+        providerExportName: string;
+        missingDependencyError: string;
+    };
+    protected getDefaultModelId(): string;
+    protected beforeLoadProviderModule(): Promise<void>;
+    protected getProviderCreateOptions(): Record<string, unknown>;
+    protected getProviderModelSettings(): Record<string, unknown> | undefined;
+    protected getStreamErrorMessage(): string;
+    protected getEmitStreamOptions(): Omit<EmitAiSdkStreamOptions, "responseId" | "errorMessage" | "calculateCost">;
+}
+export declare class ClaudeCodeHandler extends AiSdkProviderHandler {
+    protected getProviderDefinition(): {
+        moduleName: string;
+        createExportName: string;
+        providerExportName: string;
+        missingDependencyError: string;
+    };
+    protected getDefaultModelId(): string;
+    protected getProviderCreateOptions(): Record<string, unknown> | undefined;
+    protected getLoadAiSdkOptions(): {
+        beforeImport: () => void;
+    };
+    protected getStreamErrorMessage(): string;
+    protected getEmitStreamOptions(): Omit<EmitAiSdkStreamOptions, "responseId" | "errorMessage" | "calculateCost">;
+}
+export declare class OpenCodeHandler extends AiSdkProviderHandler {
+    protected getProviderDefinition(): {
+        moduleName: string;
+        createExportName: string;
+        providerExportName: string;
+        missingDependencyError: string;
+    };
+    protected getDefaultModelId(): string;
+    protected getProviderCreateOptions(): Record<string, unknown>;
+    protected getProviderModelSettings(): Record<string, unknown> | undefined;
+    protected normalizeModelId(modelId: string): string;
+    protected getStreamErrorMessage(): string;
+    protected getEmitStreamOptions(): Omit<EmitAiSdkStreamOptions, "responseId" | "errorMessage" | "calculateCost">;
+}
+export declare class SapAiCoreHandler extends AiSdkProviderHandler {
+    protected getProviderDefinition(): {
+        moduleName: string;
+        createExportName: string;
+        providerExportName: string;
+        missingDependencyError: string;
+    };
+    protected getDefaultModelId(): string;
+    protected getProviderCreateOptions(): Record<string, unknown> | undefined;
+    protected getStreamErrorMessage(): string;
+    protected getEmitStreamOptions(): Omit<EmitAiSdkStreamOptions, "responseId" | "errorMessage" | "calculateCost">;
+}
+export declare class MistralHandler extends AiSdkProviderHandler {
+    protected getProviderDefinition(): {
+        moduleName: string;
+        createExportName: string;
+        providerExportName: string;
+        missingDependencyError: string;
+    };
+    protected getDefaultModelId(): string;
+    protected getStreamErrorMessage(): string;
+}
+export declare class DifyHandler extends AiSdkProviderHandler {
+    protected getProviderDefinition(): {
+        moduleName: string;
+        createExportName: string;
+        providerExportName: string;
+        missingDependencyError: string;
+    };
+    protected getDefaultModelId(): string;
+    protected getProviderCreateOptions(): Record<string, unknown> | undefined;
+    protected getProviderModelSettings(): Record<string, unknown> | undefined;
+    protected getStreamErrorMessage(): string;
+}
+export declare function createCodexHandler(config: ProviderConfig): CodexHandler;
+export declare function createClaudeCodeHandler(config: ProviderConfig): ClaudeCodeHandler;
+export declare function createOpenCodeHandler(config: ProviderConfig): OpenCodeHandler;
+export declare function createSapAiCoreHandler(config: ProviderConfig): SapAiCoreHandler;
+export declare function createMistralHandler(config: ProviderConfig): MistralHandler;
+export declare function createDifyHandler(config: ProviderConfig): DifyHandler;

package/dist/providers/handlers/fetch-base.d.ts

@@ -0,0 +1,18 @@
+import type { ApiStream } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import { BaseHandler } from "./base";
+type JsonRecord = Record<string, unknown>;
+export declare abstract class FetchBaseHandler extends BaseHandler {
+    protected abstract getDefaultBaseUrl(): string;
+    getMessages(systemPrompt: string, messages: Message[]): unknown;
+    protected getBaseUrl(): string;
+    protected getJsonHeaders(extra?: Record<string, string>): Record<string, string>;
+    protected fetchJson<T>(path: string, init: {
+        method?: string;
+        body?: JsonRecord;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    protected abstract createMessageWithFetch(systemPrompt: string, messages: Message[]): ApiStream;
+}
+export {};

package/dist/providers/handlers/gemini-base.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Gemini Base Handler
+ *
+ * Handler for Google's Gemini API using the official SDK.
+ * Supports Vertex AI, thinking/reasoning, and native tool calling.
+ */
+import { type ApiStream, type HandlerModelInfo, type ProviderConfig } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import { BaseHandler } from "./base";
+/**
+ * Handler for Google's Gemini API
+ */
+export declare class GeminiHandler extends BaseHandler {
+    private client;
+    private ensureClient;
+    getModel(): HandlerModelInfo;
+    getMessages(_systemPrompt: string, messages: Message[]): import("@google/genai").Content[];
+    createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    private createMessageInternal;
+    private calculateGeminiCost;
+}
+/**
+ * Create a Gemini handler
+ */
+export declare function createGeminiHandler(config: ProviderConfig): GeminiHandler;

package/dist/providers/handlers/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Handlers Index
+ *
+ * Re-exports all handler classes and factory functions.
+ */
+export { AnthropicHandler, createAnthropicHandler } from "./anthropic-base";
+export { AskSageHandler, createAskSageHandler } from "./asksage";
+export { getMissingApiKeyError, getProviderEnvKeys, normalizeProviderId, resolveApiKeyForProvider, } from "./auth";
+export { BaseHandler } from "./base";
+export { BedrockHandler, createBedrockHandler } from "./bedrock-base";
+export { ClaudeCodeHandler, CodexHandler, createClaudeCodeHandler, createCodexHandler, createDifyHandler, createMistralHandler, createOpenCodeHandler, createSapAiCoreHandler, DifyHandler, MistralHandler, OpenCodeHandler, SapAiCoreHandler, } from "./community-sdk";
+export { FetchBaseHandler } from "./fetch-base";
+export { createGeminiHandler, GeminiHandler } from "./gemini-base";
+export { createOpenAIHandler, OpenAIBaseHandler } from "./openai-base";
+export { createOpenAIResponsesHandler, OpenAIResponsesHandler, } from "./openai-responses";
+export { clearLiveModelsCatalogCache, clearPrivateModelsCatalogCache, DEFAULT_MODELS_CATALOG_URL, getLiveModelsCatalog, getProviderConfig, isOpenAICompatibleProvider, OPENAI_COMPATIBLE_PROVIDERS, type ProviderDefaults, resolveProviderConfig, } from "./providers";
+export { createR1Handler, R1BaseHandler } from "./r1-base";
+export { clearRegistry, getRegisteredHandler, getRegisteredHandlerAsync, getRegisteredProviderIds, hasRegisteredHandler, isRegisteredHandlerAsync, registerAsyncHandler, registerHandler, unregisterHandler, } from "./registry";
+export { createVertexHandler, VertexHandler } from "./vertex";

package/dist/providers/handlers/openai-base.d.ts

@@ -0,0 +1,54 @@
+/**
+ * OpenAI Base Handler
+ *
+ * Base class for all handlers using the OpenAI SDK.
+ * This handles the common streaming logic and can be extended for:
+ * - Standard OpenAI API
+ * - OpenAI-compatible providers (DeepSeek, xAI, Together, etc.)
+ * - OpenRouter
+ * - Azure OpenAI
+ */
+import OpenAI from "openai";
+import type { ChatCompletionChunk } from "openai/resources/chat/completions";
+import type { ApiStream, HandlerModelInfo, ModelInfo, ProviderConfig } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import { ToolCallProcessor } from "../utils/tool-processor";
+import { BaseHandler } from "./base";
+/**
+ * Base handler for OpenAI SDK-based providers
+ *
+ * Uses ProviderConfig fields:
+ * - baseUrl: Base URL for the API
+ * - modelId: Model ID
+ * - knownModels: Known models with their info
+ * - headers: Custom headers
+ * - capabilities: Array of supported capabilities (reasoning, prompt-cache, etc.)
+ */
+export declare class OpenAIBaseHandler extends BaseHandler {
+    protected client: OpenAI | undefined;
+    /**
+     * Ensure the OpenAI client is initialized
+     * Can be overridden for custom client creation (e.g., Azure)
+     */
+    protected ensureClient(): OpenAI;
+    /**
+     * Get model info, falling back to provider defaults
+     */
+    getModel(): HandlerModelInfo;
+    protected getDefaultModelInfo(): ModelInfo;
+    getMessages(systemPrompt: string, messages: Message[]): OpenAI.Chat.ChatCompletionMessageParam[];
+    /**
+     * Create a streaming message
+     */
+    createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    private createMessageInternal;
+    /**
+     * Process a single chunk from the stream
+     * Can be overridden for provider-specific handling
+     */
+    protected processChunk(chunk: ChatCompletionChunk, toolCallProcessor: ToolCallProcessor, _modelInfo: ModelInfo, responseId: string): Generator<import("../types").ApiStreamChunk>;
+}
+/**
+ * Create an OpenAI-compatible handler
+ */
+export declare function createOpenAIHandler(config: ProviderConfig): OpenAIBaseHandler;