@clinebot/llms 0.0.0

package/dist/providers/types/settings.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Settings Schema
+ *
+ * User-friendly settings interface with Zod validation.
+ * Converts to internal ProviderConfig for handler creation.
+ */
+import { z } from "zod";
+import type { ProviderConfig } from "./config";
+/**
+ * All supported provider IDs as a Zod enum
+ */
+export declare const ProviderIdSchema: z.ZodString;
+/**
+ * Authentication settings
+ */
+export declare const AuthSettingsSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    accountId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AuthSettings = z.infer<typeof AuthSettingsSchema>;
+export declare const ReasoningSettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        medium: "medium";
+        none: "none";
+    }>>;
+    budgetTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ReasoningSettings = z.infer<typeof ReasoningSettingsSchema>;
+/**
+ * AWS Bedrock configuration
+ */
+export declare const AwsSettingsSchema: z.ZodObject<{
+    accessKey: z.ZodOptional<z.ZodString>;
+    secretKey: z.ZodOptional<z.ZodString>;
+    sessionToken: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    profile: z.ZodOptional<z.ZodString>;
+    authentication: z.ZodOptional<z.ZodEnum<{
+        iam: "iam";
+        "api-key": "api-key";
+        profile: "profile";
+    }>>;
+    usePromptCache: z.ZodOptional<z.ZodBoolean>;
+    useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
+    useGlobalInference: z.ZodOptional<z.ZodBoolean>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    customModelBaseId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AwsSettings = z.infer<typeof AwsSettingsSchema>;
+/**
+ * Google Cloud Vertex AI configuration
+ */
+export declare const GcpSettingsSchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GcpSettings = z.infer<typeof GcpSettingsSchema>;
+/**
+ * Azure OpenAI configuration
+ */
+export declare const AzureSettingsSchema: z.ZodObject<{
+    apiVersion: z.ZodOptional<z.ZodString>;
+    useIdentity: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AzureSettings = z.infer<typeof AzureSettingsSchema>;
+/**
+ * SAP AI Core configuration
+ */
+export declare const SapSettingsSchema: z.ZodObject<{
+    clientId: z.ZodOptional<z.ZodString>;
+    clientSecret: z.ZodOptional<z.ZodString>;
+    tokenUrl: z.ZodOptional<z.ZodString>;
+    resourceGroup: z.ZodOptional<z.ZodString>;
+    deploymentId: z.ZodOptional<z.ZodString>;
+    useOrchestrationMode: z.ZodOptional<z.ZodBoolean>;
+    api: z.ZodOptional<z.ZodEnum<{
+        orchestration: "orchestration";
+        "foundation-models": "foundation-models";
+    }>>;
+    defaultSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type SapSettings = z.infer<typeof SapSettingsSchema>;
+/**
+ * Oracle Cloud AI configuration
+ */
+export declare const OcaSettingsSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        internal: "internal";
+        external: "external";
+    }>>;
+    usePromptCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OcaSettings = z.infer<typeof OcaSettingsSchema>;
+/**
+ * Runtime model catalog refresh configuration
+ */
+export declare const ModelCatalogSettingsSchema: z.ZodObject<{
+    loadLatestOnInit: z.ZodOptional<z.ZodBoolean>;
+    loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodString>;
+    cacheTtlMs: z.ZodOptional<z.ZodNumber>;
+    failOnError: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ModelCatalogSettings = z.infer<typeof ModelCatalogSettingsSchema>;
+/**
+ * Main provider settings schema
+ *
+ * This is the user-friendly interface for configuring providers.
+ * Use `parseSettings()` or `toProviderConfig()` to convert to ProviderConfig.
+ */
+export declare const ProviderSettingsSchema: z.ZodObject<{
+    provider: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    auth: z.ZodOptional<z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        accessToken: z.ZodOptional<z.ZodString>;
+        refreshToken: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        accountId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            medium: "medium";
+            none: "none";
+        }>>;
+        budgetTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    aws: z.ZodOptional<z.ZodObject<{
+        accessKey: z.ZodOptional<z.ZodString>;
+        secretKey: z.ZodOptional<z.ZodString>;
+        sessionToken: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        profile: z.ZodOptional<z.ZodString>;
+        authentication: z.ZodOptional<z.ZodEnum<{
+            iam: "iam";
+            "api-key": "api-key";
+            profile: "profile";
+        }>>;
+        usePromptCache: z.ZodOptional<z.ZodBoolean>;
+        useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
+        useGlobalInference: z.ZodOptional<z.ZodBoolean>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        customModelBaseId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    gcp: z.ZodOptional<z.ZodObject<{
+        projectId: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    azure: z.ZodOptional<z.ZodObject<{
+        apiVersion: z.ZodOptional<z.ZodString>;
+        useIdentity: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    sap: z.ZodOptional<z.ZodObject<{
+        clientId: z.ZodOptional<z.ZodString>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        tokenUrl: z.ZodOptional<z.ZodString>;
+        resourceGroup: z.ZodOptional<z.ZodString>;
+        deploymentId: z.ZodOptional<z.ZodString>;
+        useOrchestrationMode: z.ZodOptional<z.ZodBoolean>;
+        api: z.ZodOptional<z.ZodEnum<{
+            orchestration: "orchestration";
+            "foundation-models": "foundation-models";
+        }>>;
+        defaultSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    oca: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            internal: "internal";
+            external: "external";
+        }>>;
+        usePromptCache: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    region: z.ZodOptional<z.ZodString>;
+    apiLine: z.ZodOptional<z.ZodEnum<{
+        china: "china";
+        international: "international";
+    }>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
+        "computer-use": "computer-use";
+        oauth: "oauth";
+        vision: "vision";
+    }>>>;
+    modelCatalog: z.ZodOptional<z.ZodObject<{
+        loadLatestOnInit: z.ZodOptional<z.ZodBoolean>;
+        loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+        cacheTtlMs: z.ZodOptional<z.ZodNumber>;
+        failOnError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProviderSettings = z.infer<typeof ProviderSettingsSchema>;
+/**
+ * Parse and validate settings
+ *
+ * @param input - Raw settings input (unknown type)
+ * @returns Validated ProviderSettings
+ * @throws ZodError if validation fails
+ *
+ * @example
+ * ```typescript
+ * const settings = parseSettings({
+ *   provider: "anthropic",
+ *   apiKey: "sk-...",
+ *   model: "claude-sonnet-4-20250514",
+ * })
+ * ```
+ */
+export declare function parseSettings(input: unknown): ProviderSettings;
+/**
+ * Safely parse settings without throwing
+ *
+ * @param input - Raw settings input (unknown type)
+ * @returns SafeParseResult with success/error info
+ *
+ * @example
+ * ```typescript
+ * const result = safeParseSettings({ provider: "anthropic" })
+ * if (result.success) {
+ *   console.log(result.data)
+ * } else {
+ *   console.error(result.error.issues)
+ * }
+ * ```
+ */
+export declare function safeParseSettings(input: unknown): ReturnType<typeof ProviderSettingsSchema.safeParse>;
+/**
+ * Convert validated settings to ProviderConfig
+ *
+ * This function takes validated ProviderSettings and converts them
+ * to the internal ProviderConfig format used by handlers.
+ *
+ * @param settings - Validated provider settings
+ * @returns ProviderConfig ready for handler creation
+ *
+ * @example
+ * ```typescript
+ * const settings = parseSettings({ provider: "openai", apiKey: "sk-..." })
+ * const config = toProviderConfig(settings)
+ * const handler = createHandler(config)
+ * ```
+ */
+export declare function toProviderConfig(settings: ProviderSettings): ProviderConfig;
+/**
+ * Parse settings and convert to ProviderConfig in one step
+ *
+ * This is a convenience function that combines `parseSettings()` and `toProviderConfig()`.
+ *
+ * @param input - Raw settings input (unknown type)
+ * @returns ProviderConfig ready for handler creation
+ * @throws ZodError if validation fails
+ *
+ * @example
+ * ```typescript
+ * import { createHandler, createProviderConfig } from "@clinebot/providers"
+ *
+ * const config = createProviderConfig({
+ *   provider: "anthropic",
+ *   apiKey: process.env.ANTHROPIC_API_KEY,
+ *   model: "claude-sonnet-4-20250514",
+ *   reasoning: { effort: "high" },
+ * })
+ *
+ * const handler = createHandler(config)
+ * ```
+ */
+export declare function createProviderConfig(input: unknown): ProviderConfig;
+/**
+ * Safely create ProviderConfig without throwing
+ *
+ * @param input - Raw settings input
+ * @returns Object with either `config` on success or `error` on failure
+ *
+ * @example
+ * ```typescript
+ * const result = safeCreateProviderConfig({ provider: "openai" })
+ * if (result.success) {
+ *   const handler = createHandler(result.config)
+ * } else {
+ *   console.error("Invalid settings:", result.error.issues)
+ * }
+ * ```
+ */
+export declare function safeCreateProviderConfig(input: unknown): {
+    success: true;
+    config: ProviderConfig;
+} | {
+    success: false;
+    error: z.ZodError;
+};

package/dist/providers/types/stream.d.ts

@@ -0,0 +1,106 @@
+/**
+ * API Stream Types
+ *
+ * Unified streaming response types that all providers yield.
+ * This provides a consistent interface regardless of the underlying provider.
+ */
+/**
+ * The main stream type - an async generator that yields chunks
+ */
+export type ApiStream = AsyncGenerator<ApiStreamChunk> & {
+    id?: string;
+};
+/**
+ * Union of all possible chunk types
+ */
+export type ApiStreamChunk = ApiStreamTextChunk | ApiStreamReasoningChunk | ApiStreamUsageChunk | ApiStreamToolCallsChunk | ApiStreamDoneChunk;
+/**
+ * Text content chunk
+ */
+export interface ApiStreamTextChunk {
+    type: "text";
+    /** Text content generated by the model */
+    text: string;
+    /** Response ID associated with this chunk */
+    id: string;
+    /** Thought signature (used by Gemini) */
+    signature?: string;
+}
+/**
+ * Reasoning/thinking content chunk
+ */
+export interface ApiStreamReasoningChunk {
+    type: "reasoning";
+    /** The reasoning text generated by the model */
+    reasoning: string;
+    /** Additional reasoning details (provider-specific) */
+    details?: unknown;
+    /** Signature for the thinking block (Anthropic, Gemini) */
+    signature?: string;
+    /** Redacted reasoning data */
+    redacted_data?: string;
+    /** Response ID associated with this chunk */
+    id: string;
+}
+/**
+ * Usage/token count chunk
+ */
+export interface ApiStreamUsageChunk {
+    type: "usage";
+    /** Number of input tokens (excluding cached) */
+    inputTokens: number;
+    /** Number of output tokens */
+    outputTokens: number;
+    /** Number of tokens written to cache */
+    cacheWriteTokens?: number;
+    /** Number of tokens read from cache */
+    cacheReadTokens?: number;
+    /** Number of thinking/reasoning tokens */
+    thoughtsTokenCount?: number;
+    /** Total cost in USD (if calculable) */
+    totalCost?: number;
+    /** Response ID */
+    id: string;
+}
+/**
+ * Tool call chunk
+ */
+export interface ApiStreamToolCallsChunk {
+    type: "tool_calls";
+    /** The tool call information */
+    tool_call: ApiStreamToolCall;
+    /** Response ID */
+    id: string;
+    /** Thought signature (Gemini) */
+    signature?: string;
+}
+/**
+ * Tool call details
+ */
+export interface ApiStreamToolCall {
+    /** Call ID for this tool invocation */
+    call_id?: string;
+    /** Function/tool information */
+    function: {
+        /** Tool call ID */
+        id?: string;
+        /** Name of the tool */
+        name?: string;
+        /** Arguments passed to the tool (can be string or parsed object) */
+        arguments?: string | Record<string, unknown>;
+    };
+}
+/**
+ * Stream completion chunk - indicates the stream has finished
+ */
+export interface ApiStreamDoneChunk {
+    type: "done";
+    /** Whether the stream completed successfully */
+    success: boolean;
+    /** Error message if the stream failed */
+    error?: string;
+    /** Reason for incomplete response (e.g., "max_output_tokens") */
+    incompleteReason?: string;
+    /** Response ID */
+    id: string;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Utils Index
+ */
+export type { RetryOptions } from "./retry";
+export { calculateRetryDelay, isRetriableError, RetriableError, retryAsync, retryStream, sleep, } from "./retry";
+export { type AssistantContentBlock, type AssistantRedactedThinkingBlock, type AssistantTextBlock, type AssistantThinkingBlock, type AssistantToolUseBlock, type ProcessedResponse, type ReasoningDetailParam, StreamResponseProcessor, type UsageInfo, } from "./stream-processor";
+export { ToolCallProcessor } from "./tool-processor";

package/dist/providers/utils/retry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Retry Utilities
+ *
+ * Provides retry logic with exponential backoff for API calls.
+ */
+export interface RetryOptions {
+    maxRetries?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    onRetryAttempt?: (attempt: number, maxRetries: number, delay: number, error: unknown) => void;
+}
+/**
+ * Error that indicates the operation should be retried
+ */
+export declare class RetriableError extends Error {
+    readonly retryAfterSeconds?: number | undefined;
+    constructor(message: string, retryAfterSeconds?: number | undefined, options?: ErrorOptions);
+}
+/**
+ * Check if an error is retriable
+ */
+export declare function isRetriableError(error: unknown): boolean;
+/**
+ * Calculate delay for retry attempt with exponential backoff and jitter
+ */
+export declare function calculateRetryDelay(attempt: number, options?: RetryOptions): number;
+/**
+ * Sleep for a given number of milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Retry an async generator factory using the same retry policy as retryAsync.
+ */
+export declare function retryStream<T>(createStream: () => AsyncGenerator<T, void, unknown>, options?: RetryOptions): AsyncGenerator<T, void, unknown>;
+/**
+ * Wrap an async function with retry logic
+ */
+export declare function retryAsync<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/providers/utils/stream-processor.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Stream Response Processor
+ *
+ * Processes ApiStreamChunks and assembles them into Cline's message content format.
+ * This provides a clean interface between the streaming API and Cline's storage format.
+ */
+import type { ApiStreamChunk } from "../types/stream";
+export interface ReasoningDetailParam {
+    type: "reasoning.text" | string;
+    text: string;
+    signature: string;
+    format: "anthropic-claude-v1" | string;
+    index: number;
+}
+export interface AssistantTextBlock {
+    type: "text";
+    text: string;
+    call_id?: string;
+    reasoning_details?: ReasoningDetailParam[];
+    signature?: string;
+}
+export interface AssistantToolUseBlock {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    call_id?: string;
+    reasoning_details?: ReasoningDetailParam[];
+    signature?: string;
+}
+export interface AssistantThinkingBlock {
+    type: "thinking";
+    thinking: string;
+    signature: string;
+    call_id?: string;
+    summary?: ReasoningDetailParam[];
+}
+export interface AssistantRedactedThinkingBlock {
+    type: "redacted_thinking";
+    data: string;
+    call_id?: string;
+}
+export type AssistantContentBlock = AssistantTextBlock | AssistantToolUseBlock | AssistantThinkingBlock | AssistantRedactedThinkingBlock;
+export interface UsageInfo {
+    inputTokens: number;
+    outputTokens: number;
+    cacheWriteTokens?: number;
+    cacheReadTokens?: number;
+    thoughtsTokenCount?: number;
+    totalCost?: number;
+}
+export interface ProcessedResponse {
+    content: AssistantContentBlock[];
+    usage?: UsageInfo;
+    responseId?: string;
+    incompleteReason?: string;
+}
+/**
+ * Processes streaming API responses and assembles content blocks.
+ *
+ * Usage:
+ * ```ts
+ * const processor = new StreamResponseProcessor()
+ * for await (const chunk of apiStream) {
+ *   const partial = processor.process(chunk)
+ *   // Use partial for live updates
+ * }
+ * const final = processor.finalize()
+ * ```
+ */
+export declare class StreamResponseProcessor {
+    private text;
+    private textSignature?;
+    private toolUses;
+    private reasoning;
+    private usage;
+    private responseId?;
+    private incompleteReason?;
+    /**
+     * Process a single stream chunk and return current partial state.
+     * Call this for each chunk to get live updates.
+     */
+    process(chunk: ApiStreamChunk): ProcessedResponse;
+    /**
+     * Finalize and return the complete response.
+     * Call this after all chunks have been processed.
+     */
+    finalize(): ProcessedResponse;
+    /**
+     * Get current partial response for live streaming updates.
+     */
+    getPartialResponse(): ProcessedResponse;
+    /**
+     * Reset processor state for reuse.
+     */
+    reset(): void;
+    private processText;
+    private processReasoning;
+    private processToolCall;
+    private processUsage;
+    private createPendingToolUse;
+    private finalizeToolInput;
+    /**
+     * Extract fields from incomplete JSON during streaming.
+     */
+    private extractPartialJson;
+    private unescapeString;
+    private isReasoningDetail;
+    private isRecord;
+}

package/dist/providers/utils/tool-processor.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Tool Call Processor
+ *
+ * Handles incremental assembly of tool calls from streaming responses.
+ * Tool calls can arrive in chunks that need to be accumulated.
+ */
+import type { ApiStreamToolCall, ApiStreamToolCallsChunk } from "../types/stream";
+export type { ApiStreamToolCallsChunk };
+interface ToolCallDelta {
+    index: number;
+    id?: string;
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+}
+/**
+ * Processes tool call deltas from streaming API responses
+ */
+export declare class ToolCallProcessor {
+    private toolCalls;
+    /**
+     * Process tool call deltas and yield complete tool calls
+     */
+    processToolCallDeltas(deltas: ToolCallDelta[], responseId: string): ApiStreamToolCallsChunk[];
+    /**
+     * Get all accumulated tool calls
+     */
+    getToolCalls(): ApiStreamToolCall[];
+    /**
+     * Reset the processor state
+     */
+    reset(): void;
+}

package/dist/sdk.d.ts

@@ -0,0 +1,18 @@
+import { type ApiHandler } from "./providers/index";
+import type { CreateHandlerInput, LlmsConfig, LlmsSdk, RegisteredProviderSummary, RegisterModelInput, RegisterProviderInput } from "./types";
+export declare class DefaultLlmsSdk implements LlmsSdk {
+    private readonly providerConfigs;
+    constructor(config: LlmsConfig);
+    createHandler(input: CreateHandlerInput): ApiHandler;
+    createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler>;
+    private toProviderHandlerConfig;
+    registerProvider(input: RegisterProviderInput): void;
+    registerModel(input: RegisterModelInput): void;
+    getProviders(): RegisteredProviderSummary[];
+    getModels(providerId: string): string[];
+    isProviderConfigured(providerId: string): boolean;
+    isModelConfigured(providerId: string, modelId: string): boolean;
+    private applyConfig;
+    private requireConfiguredProvider;
+}
+export declare function createLlmsSdk(config: LlmsConfig): LlmsSdk;

package/dist/types.d.ts

@@ -0,0 +1,60 @@
+import type { ModelCollection, ModelInfo } from "./models/index";
+import type { ApiHandler, HandlerFactory, LazyHandlerFactory, ProviderCapability, ProviderConfig } from "./providers/index";
+export type ProviderConfigDefaults = Omit<ProviderConfig, "providerId" | "modelId">;
+export interface ProviderSelectionConfig {
+    id: string;
+    models: string[];
+    defaultModel?: string;
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    capabilities?: ProviderCapability[];
+    settings?: ProviderConfigDefaults;
+}
+export interface AdditionalModelConfig {
+    providerId: string;
+    modelId: string;
+    info: ModelInfo;
+}
+export interface CustomProviderConfig {
+    collection: ModelCollection;
+    defaults?: ProviderConfigDefaults;
+    handlerFactory?: HandlerFactory;
+    asyncHandlerFactory?: LazyHandlerFactory;
+}
+export interface LlmsConfig {
+    providers: ProviderSelectionConfig[];
+    models?: AdditionalModelConfig[];
+    customProviders?: CustomProviderConfig[];
+}
+export interface CreateHandlerInput {
+    providerId: string;
+    modelId?: string;
+    overrides?: ProviderConfigDefaults;
+}
+export interface RegisteredProviderSummary {
+    id: string;
+    models: string[];
+    defaultModel: string;
+}
+export interface RegisterProviderInput extends CustomProviderConfig {
+    exposeModels?: string[];
+    defaultModel?: string;
+}
+export interface RegisterModelInput {
+    providerId: string;
+    modelId: string;
+    info: ModelInfo;
+}
+export interface LlmsSdk {
+    createHandler(input: CreateHandlerInput): ApiHandler;
+    createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler>;
+    registerProvider(input: RegisterProviderInput): void;
+    registerModel(input: RegisterModelInput): void;
+    getProviders(): RegisteredProviderSummary[];
+    getModels(providerId: string): string[];
+    isProviderConfigured(providerId: string): boolean;
+    isModelConfigured(providerId: string, modelId: string): boolean;
+}