@clinebot/llms 0.0.0

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

@@ -0,0 +1,64 @@
+/**
+ * OpenAI Responses API Handler
+ *
+ * Handler for OpenAI's Responses API format, which is used by newer models
+ * that require native tool calling (e.g., GPT-5, o3, codex).
+ *
+ * The Responses API has a different structure than Chat Completions:
+ * - Uses `instructions` instead of system messages
+ * - Uses `input` instead of messages array
+ * - Has different streaming event types (response.*, not choices.delta)
+ * - Supports reasoning with encrypted content
+ */
+import OpenAI from "openai";
+import type { ApiStream, HandlerModelInfo, ModelInfo, ProviderConfig } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import { BaseHandler } from "./base";
+/**
+ * Convert messages to Responses API input format
+ */
+declare function convertToResponsesInput(messages: Message[]): {
+    type: "message";
+    role: "user" | "assistant";
+    content: string | Array<{
+        type: "input_text" | "output_text";
+        text: string;
+    }>;
+}[];
+/**
+ * Handler for OpenAI Responses API
+ *
+ * Uses ProviderConfig fields:
+ * - baseUrl: Base URL for the API
+ * - modelId: Model ID
+ * - knownModels: Known models with their info
+ * - headers: Custom headers
+ */
+export declare class OpenAIResponsesHandler extends BaseHandler {
+    protected client: OpenAI | undefined;
+    /**
+     * Ensure the OpenAI client is initialized
+     */
+    protected ensureClient(): OpenAI;
+    /**
+     * Get model info, falling back to provider defaults
+     */
+    getModel(): HandlerModelInfo;
+    protected getDefaultModelInfo(): ModelInfo;
+    getMessages(_systemPrompt: string, messages: Message[]): ReturnType<typeof convertToResponsesInput>;
+    /**
+     * Create a streaming message using the Responses API
+     */
+    createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    private createMessageInternal;
+    /**
+     * Process a single chunk from the Responses API stream
+     */
+    protected processResponseChunk(chunk: any, _modelInfo: ModelInfo, responseId: string): Generator<import("../types").ApiStreamChunk>;
+    private getApiResponseId;
+}
+/**
+ * Create an OpenAI Responses API handler
+ */
+export declare function createOpenAIResponsesHandler(config: ProviderConfig): OpenAIResponsesHandler;
+export {};

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

@@ -0,0 +1,43 @@
+/**
+ * Provider Configurations
+ *
+ * Pre-configured settings for all supported OpenAI-compatible providers.
+ * Model data is sourced from @clinebot/models (the single registry).
+ */
+/** biome-ignore-all lint/style/noNonNullAssertion: static */
+import type { ModelCatalogConfig, ModelInfo, ProviderCapability, ProviderConfig } from "../types/index";
+/**
+ * Provider defaults for OpenAI-compatible providers
+ */
+export interface ProviderDefaults {
+    /** Base URL for the API */
+    baseUrl: string;
+    /** Default model ID */
+    modelId: string;
+    /** Known models with their info */
+    knownModels?: Record<string, ModelInfo>;
+    /** Capabilities this provider supports */
+    capabilities?: ProviderCapability[];
+}
+export declare const DEFAULT_MODELS_CATALOG_URL = "https://models.dev/api.json";
+export declare function getLiveModelsCatalog(options?: Pick<ModelCatalogConfig, "url" | "cacheTtlMs">): Promise<Record<string, Record<string, ModelInfo>>>;
+export declare function clearLiveModelsCatalogCache(url?: string): void;
+export declare function clearPrivateModelsCatalogCache(): void;
+/**
+ * All OpenAI-compatible provider configurations
+ *
+ * Model data is sourced from @clinebot/models to maintain a single source of truth.
+ */
+export declare const OPENAI_COMPATIBLE_PROVIDERS: Record<string, ProviderDefaults>;
+/**
+ * Get provider configuration by ID
+ */
+export declare function getProviderConfig(providerId: string): ProviderDefaults | undefined;
+/**
+ * Resolve provider configuration and optionally merge live catalog metadata
+ */
+export declare function resolveProviderConfig(providerId: string, modelCatalog?: ModelCatalogConfig, config?: ProviderConfig): Promise<ProviderDefaults | undefined>;
+/**
+ * Check if a provider is OpenAI-compatible
+ */
+export declare function isOpenAICompatibleProvider(providerId: string): boolean;

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

@@ -0,0 +1,62 @@
+/**
+ * R1 Base Handler
+ *
+ * Handler for R1-based reasoning models (DeepSeek Reasoner, etc.)
+ * These models have special requirements:
+ * 1. Consecutive messages with the same role must be merged
+ * 2. reasoning_content field for tool calling continuations
+ * 3. No temperature parameter
+ * 4. Response includes reasoning_content in the delta
+ */
+import OpenAI from "openai";
+import type { ChatCompletionChunk } from "openai/resources/chat/completions";
+import type { ApiStream, ApiStreamChunk, 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 R1-based reasoning models
+ *
+ * Uses ProviderConfig fields:
+ * - baseUrl: Base URL for the API
+ * - modelId: Model ID
+ * - knownModels: Known models with their info
+ * - headers: Custom headers
+ */
+export declare class R1BaseHandler extends BaseHandler {
+    protected client: OpenAI | undefined;
+    /**
+     * Ensure the OpenAI client is initialized
+     */
+    protected ensureClient(): OpenAI;
+    /**
+     * Get model info, falling back to provider defaults
+     */
+    getModel(): HandlerModelInfo;
+    protected getDefaultModelInfo(): ModelInfo;
+    /**
+     * Check if this model is a reasoner model (no temperature allowed)
+     */
+    protected isReasonerModel(modelId: string): boolean;
+    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
+     */
+    protected processChunk(chunk: ChatCompletionChunk, toolCallProcessor: ToolCallProcessor, modelInfo: ModelInfo, responseId: string): Generator<ApiStreamChunk>;
+    /**
+     * Process usage information with R1-specific cache handling
+     *
+     * DeepSeek reports total input AND cache reads/writes,
+     * where the input tokens is the sum of the cache hits/misses.
+     */
+    protected processUsage(usage: OpenAI.CompletionUsage, _modelInfo: ModelInfo, responseId: string): Generator<ApiStreamChunk>;
+}
+/**
+ * Create an R1-compatible handler
+ */
+export declare function createR1Handler(config: ProviderConfig): R1BaseHandler;

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

@@ -0,0 +1,106 @@
+/**
+ * Custom Handler Registry
+ *
+ * Allows users to register their own custom handlers that extend BaseHandler.
+ * This is useful for providers that require dependencies not included in this package
+ * (e.g., VSCode LM handler that requires the vscode package).
+ *
+ * @example
+ * ```typescript
+ * import { registerHandler, BaseHandler, type ProviderConfig, type ApiStream, type Message } from "@clinebot/providers"
+ * import * as vscode from "vscode"
+ *
+ * class VSCodeLmHandler extends BaseHandler {
+ *   async *createMessage(systemPrompt: string, messages: Message[]): ApiStream {
+ *     // Implementation using vscode.lm API
+ *   }
+ * }
+ *
+ * // Register the handler
+ * registerHandler("vscode-lm", (config) => new VSCodeLmHandler(config))
+ *
+ * // Now createHandler will use your custom handler for "vscode-lm"
+ * const handler = createHandler({ providerId: "vscode-lm", modelId: "copilot" })
+ * ```
+ */
+import type { ApiHandler, HandlerFactory, LazyHandlerFactory, ProviderConfig } from "../types";
+/**
+ * Register a custom handler factory for a provider ID
+ *
+ * Use this to add handlers for providers that require external dependencies
+ * not bundled with this package, or to override built-in handlers.
+ *
+ * @param providerId - The provider ID to register (can be existing or new)
+ * @param factory - Factory function that creates the handler
+ *
+ * @example
+ * ```typescript
+ * // Simple registration
+ * registerHandler("my-provider", (config) => new MyHandler(config))
+ *
+ * // Override built-in handler
+ * registerHandler("anthropic", (config) => new MyCustomAnthropicHandler(config))
+ * ```
+ */
+export declare function registerHandler(providerId: string, factory: HandlerFactory<ProviderConfig>): void;
+/**
+ * Register an async handler factory for lazy loading
+ *
+ * Use this when your handler has heavy dependencies that should be
+ * loaded only when needed.
+ *
+ * @param providerId - The provider ID to register
+ * @param factory - Async factory function that creates the handler
+ *
+ * @example
+ * ```typescript
+ * registerAsyncHandler("heavy-provider", async (config) => {
+ *   const { HeavyHandler } = await import("./heavy-handler")
+ *   return new HeavyHandler(config)
+ * })
+ * ```
+ */
+export declare function registerAsyncHandler(providerId: string, factory: LazyHandlerFactory<ProviderConfig>): void;
+/**
+ * Unregister a custom handler
+ *
+ * @param providerId - The provider ID to unregister
+ * @returns true if a handler was removed, false if none existed
+ */
+export declare function unregisterHandler(providerId: string): boolean;
+/**
+ * Check if a custom handler is registered for a provider ID
+ *
+ * @param providerId - The provider ID to check
+ */
+export declare function hasRegisteredHandler(providerId: string): boolean;
+/**
+ * Get a registered handler (internal use)
+ *
+ * @param providerId - The provider ID to get
+ * @param config - The config to pass to the factory
+ * @returns The handler instance, or undefined if not registered
+ */
+export declare function getRegisteredHandler(providerId: string, config: ProviderConfig): ApiHandler | undefined;
+/**
+ * Get a registered handler asynchronously (internal use)
+ *
+ * @param providerId - The provider ID to get
+ * @param config - The config to pass to the factory
+ * @returns The handler instance, or undefined if not registered
+ */
+export declare function getRegisteredHandlerAsync(providerId: string, config: ProviderConfig): Promise<ApiHandler | undefined>;
+/**
+ * Check if a registered handler is async
+ *
+ * @param providerId - The provider ID to check
+ */
+export declare function isRegisteredHandlerAsync(providerId: string): boolean;
+/**
+ * Get all registered provider IDs
+ */
+export declare function getRegisteredProviderIds(): string[];
+/**
+ * Clear all registered handlers (mainly for testing)
+ */
+export declare function clearRegistry(): void;

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

@@ -0,0 +1,32 @@
+/**
+ * Vertex Handler
+ *
+ * Routes Vertex models by family:
+ * - Gemini models -> Google GenAI Vertex path via GeminiHandler
+ * - Claude models -> AI SDK Google Vertex Anthropic provider
+ */
+import { type ApiStream, type HandlerModelInfo, type ProviderConfig } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import { BaseHandler } from "./base";
+/**
+ * Handler for Vertex AI that supports both Gemini and Claude models.
+ */
+export declare class VertexHandler extends BaseHandler {
+    private geminiHandler;
+    private vertexAnthropicModelFactory;
+    private vertexAnthropicModelFactoryPromise;
+    private getProjectId;
+    private getConfiguredRegion;
+    private getRequiredClaudeRegion;
+    private getGeminiRegion;
+    private ensureGeminiHandler;
+    private ensureVertexAnthropicModelFactory;
+    getModel(): HandlerModelInfo;
+    getMessages(systemPrompt: string, messages: Message[]): unknown;
+    createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    private createMessageInternal;
+}
+/**
+ * Create a Vertex handler
+ */
+export declare function createVertexHandler(config: ProviderConfig): VertexHandler;

package/dist/providers/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @clinebot/providers
+ *
+ * SDK-like package for creating and managing LLM provider handlers.
+ *
+ * This package provides a unified interface for interacting with various LLM providers.
+ * It standardizes configuration, message formats, and streaming responses.
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { createHandler, type ProviderConfig } from "@clinebot/providers"
+ *
+ * const config: ProviderConfig = {
+ *   providerId: "anthropic",
+ *   apiKey: process.env.ANTHROPIC_API_KEY,
+ *   modelId: "claude-sonnet-4-20250514",
+ * }
+ *
+ * const handler = createHandler(config)
+ * const stream = handler.createMessage("You are a helpful assistant.", messages)
+ *
+ * for await (const chunk of stream) {
+ *   if (chunk.type === "text") {
+ *     process.stdout.write(chunk.text)
+ *   }
+ * }
+ * ```
+ *
+ * ## Supported Providers
+ *
+ * - **anthropic**: Anthropic's Claude models
+ * - **claude-code**: Claude Code local subscription provider
+ * - **gemini**: Google's Gemini models (including Vertex AI)
+ * - **openai**: OpenAI's GPT models
+ * - **openai-compat**: Any OpenAI-compatible API (DeepSeek, xAI, Together, etc.)
+ *
+ * @module
+ */
+export { ApiFormat, type ApiHandler, type ApiStream, type ApiStreamChunk, type ApiStreamReasoningChunk, type ApiStreamTextChunk, type ApiStreamToolCall, type ApiStreamToolCallsChunk, type ApiStreamUsageChunk, type AuthConfig, type AuthSettings, AuthSettingsSchema, type AwsConfig, type AwsSettings, AwsSettingsSchema, type AzureConfig, type AzureSettings, AzureSettingsSchema, type BuiltInProviderId, type CloudConfig, type ContentBlock, createConfig, createProviderConfig, type EndpointConfig, type FileContent, type GcpConfig, type GcpSettings, GcpSettingsSchema, getModelPricing, type HandlerFactory, type HandlerModelInfo, hasCapability, hasModelCapability, type ImageContent, type LazyHandlerFactory, type Message, type MessageRole, type MessageWithMetadata, type ModelCapability, type ModelCatalogConfig, type ModelCatalogSettings, ModelCatalogSettingsSchema, type ModelConfig, type ModelInfo, type ModelPricing, type ModelWithId, type OcaConfig, type OcaSettings, OcaSettingsSchema, type OpenAICompatibleModelInfo, type ProviderCapability, type ProviderCategory, type ProviderConfig, type ProviderDefaultsConfig, type ProviderId, ProviderIdSchema, type ProviderOptions, type ProviderSettings, ProviderSettingsSchema, type ProviderSpecificConfig, parseSettings, type ReasoningConfig, type ReasoningSettings, ReasoningSettingsSchema, type RedactedThinkingContent, type RegionConfig, type SapConfig, type SapSettings, SapSettingsSchema, type SimpleProviderConfig, type SingleCompletionHandler, safeCreateProviderConfig, safeParseSettings, supportsPromptCache, supportsReasoning, type TextContent, type ThinkingConfig, type ThinkingContent, type TokenConfig, type ToolDefinition, type ToolResultContent, type ToolUseContent, toProviderConfig, } from "./types";
+export { AnthropicHandler, AskSageHandler, BaseHandler, ClaudeCodeHandler, CodexHandler, clearLiveModelsCatalogCache, clearPrivateModelsCatalogCache, clearRegistry, createAnthropicHandler, createAskSageHandler, createClaudeCodeHandler, createCodexHandler, createDifyHandler, createGeminiHandler, createMistralHandler, createOpenAIHandler, createOpenAIResponsesHandler, createOpenCodeHandler, createR1Handler, createSapAiCoreHandler, createVertexHandler, DEFAULT_MODELS_CATALOG_URL, DifyHandler, GeminiHandler, getLiveModelsCatalog, getMissingApiKeyError, getProviderConfig, getRegisteredHandler, getRegisteredHandlerAsync, getRegisteredProviderIds, hasRegisteredHandler, isOpenAICompatibleProvider, isRegisteredHandlerAsync, MistralHandler, normalizeProviderId, OPENAI_COMPATIBLE_PROVIDERS, OpenAIBaseHandler, OpenAIResponsesHandler, OpenCodeHandler, R1BaseHandler, registerAsyncHandler, registerHandler, resolveProviderConfig, SapAiCoreHandler, unregisterHandler, VertexHandler, } from "./handlers";
+export { convertToAnthropicMessages, convertToGeminiMessages, convertToOpenAIMessages, convertToolsToAnthropic, convertToolsToGemini, convertToolsToOpenAI, convertToR1Messages, getOpenAIToolParams, type R1Message, } from "./transform";
+export { type AssistantContentBlock, type AssistantRedactedThinkingBlock, type AssistantTextBlock, type AssistantThinkingBlock, type AssistantToolUseBlock, calculateRetryDelay, isRetriableError, type ProcessedResponse, type ReasoningDetailParam, RetriableError, type RetryOptions, retryAsync, retryStream, StreamResponseProcessor, sleep, ToolCallProcessor, type UsageInfo, } from "./utils";
+import { type ApiHandler, type ProviderConfig, type ProviderId } from "./types";
+/**
+ * Create an API handler for the specified provider
+ *
+ * This is the main entry point for creating handlers. It automatically
+ * selects the appropriate handler class based on the provider ID.
+ *
+ * Custom handlers registered via `registerHandler()` take precedence over
+ * built-in handlers.
+ *
+ * @param config - Provider configuration
+ * @returns An API handler instance
+ * @throws Error if the provider has an async handler - use `createHandlerAsync()` instead
+ *
+ * @example
+ * ```typescript
+ * const handler = createHandler({
+ *   providerId: "anthropic",
+ *   apiKey: "sk-...",
+ *   modelId: "claude-sonnet-4-20250514",
+ * })
+ * ```
+ */
+export declare function createHandler(config: ProviderConfig): ApiHandler;
+/**
+ * Create an API handler asynchronously
+ *
+ * Use this when you have handlers registered with `registerAsyncHandler()`.
+ * This function works with both sync and async registered handlers.
+ *
+ * @param config - Provider configuration
+ * @returns Promise resolving to an API handler instance
+ *
+ * @example
+ * ```typescript
+ * // Register an async handler for lazy loading
+ * registerAsyncHandler("my-provider", async (config) => {
+ *   const { MyHandler } = await import("./my-handler")
+ *   return new MyHandler(config)
+ * })
+ *
+ * // Use createHandlerAsync to get the handler
+ * const handler = await createHandlerAsync({
+ *   providerId: "my-provider",
+ *   modelId: "my-model",
+ * })
+ * ```
+ */
+export declare function createHandlerAsync(config: ProviderConfig): Promise<ApiHandler>;
+/**
+ * List of all built-in provider IDs
+ */
+export declare const BUILT_IN_PROVIDERS: ProviderId[];
+/**
+ * Check if a provider ID is supported (built-in or registered)
+ */
+export declare function isProviderSupported(providerId: string): boolean;

package/dist/providers/public.browser.d.ts

@@ -0,0 +1,2 @@
+export { OPENAI_COMPATIBLE_PROVIDERS, type ProviderDefaults, } from "./handlers/providers";
+export { getModelPricing, hasModelCapability, type ModelCapability, type ModelInfo, type ModelPricing, normalizeProviderId, type ProviderCapability, type ProviderId, type ProviderSettings, ProviderSettingsSchema, parseSettings, supportsModelThinking, toProviderConfig, } from "./types/index";

package/dist/providers/public.d.ts

@@ -0,0 +1,3 @@
+export { OPENAI_COMPATIBLE_PROVIDERS, type ProviderDefaults, resolveProviderConfig, } from "./handlers/providers";
+export { BUILT_IN_PROVIDERS, createHandler, createHandlerAsync, isProviderSupported, } from "./index";
+export { type ApiHandler, type ApiStream, type ApiStreamChunk, type ApiStreamReasoningChunk, type ApiStreamTextChunk, type ApiStreamToolCall, type ApiStreamToolCallsChunk, type ApiStreamUsageChunk, type ContentBlock, type FileContent, getModelPricing, type HandlerFactory, type HandlerModelInfo, hasModelCapability, type ImageContent, type LazyHandlerFactory, type Message, type MessageRole, type MessageWithMetadata, type ModelCapability, type ModelInfo, type ModelPricing, normalizeProviderId, type ProviderCapability, type ProviderConfig, type ProviderId, type ProviderSettings, ProviderSettingsSchema, parseSettings, type RedactedThinkingContent, supportsModelThinking, type TextContent, type ThinkingContent, type ToolDefinition, type ToolResultContent, type ToolUseContent, toProviderConfig, } from "./types/index";

package/dist/providers/shared/openai-compatible.d.ts

@@ -0,0 +1,10 @@
+import type { ModelInfo, ProviderCapability } from "../../models/schemas/index";
+export interface OpenAICompatibleProviderDefaults {
+    baseUrl: string;
+    modelId: string;
+    knownModels?: Record<string, ModelInfo>;
+    capabilities?: ProviderCapability[];
+}
+export declare function buildOpenAICompatibleProviderDefaults(options?: {
+    includeKnownModels?: boolean;
+}): Record<string, OpenAICompatibleProviderDefaults>;

package/dist/providers/transform/ai-sdk-community-format.d.ts

@@ -0,0 +1,9 @@
+import type { Message } from "../types/messages";
+export type AiSdkMessagePart = Record<string, unknown>;
+export type AiSdkMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | AiSdkMessagePart[];
+};
+export declare function toAiSdkMessages(systemContent: string | AiSdkMessagePart[], messages: Message[], options?: {
+    assistantToolCallArgKey?: "args" | "input";
+}): AiSdkMessage[];

package/dist/providers/transform/anthropic-format.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Anthropic Message Format Converter
+ *
+ * Converts our unified Message format to Anthropic's MessageParam format.
+ */
+import type { Anthropic } from "@anthropic-ai/sdk";
+import type { Message } from "../types/messages";
+type AnthropicMessage = Anthropic.MessageParam;
+/**
+ * Convert messages to Anthropic format
+ *
+ * @param messages - Messages to convert
+ * @param enableCaching - Whether to add cache control markers
+ */
+export declare function convertToAnthropicMessages(messages: Message[], enableCaching?: boolean): AnthropicMessage[];
+/**
+ * Convert tool definitions to Anthropic format
+ */
+export declare function convertToolsToAnthropic(tools: Array<{
+    name: string;
+    description: string;
+    inputSchema: unknown;
+}>): Anthropic.Tool[];
+export {};

package/dist/providers/transform/content-format.d.ts

@@ -0,0 +1,3 @@
+import type { FileContent, ImageContent, TextContent } from "../types/messages";
+export declare function normalizeToolUseInput(input: Record<string, unknown>): Record<string, unknown>;
+export declare function serializeToolResultContent(content: string | Array<TextContent | ImageContent | FileContent>): string;

package/dist/providers/transform/gemini-format.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Gemini Message Format Converter
+ *
+ * Converts our unified Message format to Google Gemini's Content format.
+ */
+import type { Content, FunctionDeclaration } from "@google/genai";
+import type { Message } from "../types/messages";
+/**
+ * Convert messages to Gemini format
+ */
+export declare function convertToGeminiMessages(messages: Message[]): Content[];
+/**
+ * Convert tool definitions to Gemini format
+ */
+export declare function convertToolsToGemini(tools: Array<{
+    name: string;
+    description: string;
+    inputSchema: unknown;
+}>): FunctionDeclaration[];

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

@@ -0,0 +1,10 @@
+/**
+ * Transform Module Index
+ *
+ * Re-exports all message format converters.
+ */
+export { type AiSdkMessage, type AiSdkMessagePart, toAiSdkMessages, } from "./ai-sdk-community-format";
+export { convertToAnthropicMessages, convertToolsToAnthropic, } from "./anthropic-format";
+export { convertToGeminiMessages, convertToolsToGemini } from "./gemini-format";
+export { convertToOpenAIMessages, convertToolsToOpenAI, getOpenAIToolParams, } from "./openai-format";
+export { convertToR1Messages, type R1Message } from "./r1-format";

package/dist/providers/transform/openai-format.d.ts

@@ -0,0 +1,36 @@
+/**
+ * OpenAI Message Format Converter
+ *
+ * Converts our unified Message format to OpenAI's ChatCompletionMessageParam format.
+ */
+import type OpenAI from "openai";
+import type { Message } from "../types/messages";
+type OpenAIMessage = OpenAI.Chat.ChatCompletionMessageParam;
+/**
+ * Convert messages to OpenAI format
+ */
+export declare function convertToOpenAIMessages(messages: Message[]): OpenAIMessage[];
+/**
+ * Convert tool definitions to OpenAI format
+ */
+export declare function convertToolsToOpenAI(tools: Array<{
+    name: string;
+    description: string;
+    inputSchema: unknown;
+}>, options?: {
+    strict?: boolean;
+}): OpenAI.Chat.ChatCompletionTool[];
+/**
+ * Build tool params for OpenAI request
+ */
+export declare function getOpenAIToolParams(tools?: Array<{
+    name: string;
+    description: string;
+    inputSchema: unknown;
+}>, options?: {
+    strict?: boolean;
+}): {
+    tools?: OpenAI.Chat.ChatCompletionTool[];
+    tool_choice?: OpenAI.Chat.ChatCompletionToolChoiceOption;
+};
+export {};

package/dist/providers/transform/r1-format.d.ts

@@ -0,0 +1,26 @@
+/**
+ * R1 Message Format Converter
+ *
+ * Handles the special message format required by DeepSeek Reasoner and other R1-based models.
+ * Key requirements:
+ * 1. Consecutive messages with the same role must be merged
+ * 2. reasoning_content should be passed back during tool calling in the same turn
+ * 3. No temperature parameter for reasoner models
+ */
+import type OpenAI from "openai";
+import type { Message } from "../types/messages";
+/**
+ * DeepSeek Reasoner message format with reasoning_content support
+ */
+export type R1Message = OpenAI.Chat.ChatCompletionMessageParam & {
+    reasoning_content?: string;
+};
+/**
+ * Convert messages to R1 format
+ *
+ * This handles:
+ * 1. Converting content blocks to OpenAI format
+ * 2. Merging consecutive messages with the same role
+ * 3. Adding reasoning_content for tool calling continuations
+ */
+export declare function convertToR1Messages(messages: Message[]): R1Message[];