@omnicross/core 0.1.0 → 0.1.2

package/dist/ApiConverter.cjs

@@ -0,0 +1,24 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkSUEGJ75Dcjs = require('./chunk-SUEGJ75D.cjs');
+
+
+
+
+
+
+
+
+
+
+
+exports.convertAnthropicRequestToOpenAI = _chunkSUEGJ75Dcjs.convertAnthropicRequestToOpenAI; exports.convertAnthropicStreamToOpenAI = _chunkSUEGJ75Dcjs.convertAnthropicStreamToOpenAI; exports.convertAnthropicToOpenAI = _chunkSUEGJ75Dcjs.convertAnthropicToOpenAI; exports.convertAnthropicToOpenAIWithThinking = _chunkSUEGJ75Dcjs.convertAnthropicToOpenAIWithThinking; exports.convertOpenAIResponseToAnthropic = _chunkSUEGJ75Dcjs.convertOpenAIResponseToAnthropic; exports.convertOpenAIStreamToAnthropic = _chunkSUEGJ75Dcjs.convertOpenAIStreamToAnthropic; exports.convertOpenAIToAnthropic = _chunkSUEGJ75Dcjs.convertOpenAIToAnthropic; exports.convertOpenAIToAnthropicWithThinking = _chunkSUEGJ75Dcjs.convertOpenAIToAnthropicWithThinking; exports.hasImageContent = _chunkSUEGJ75Dcjs.hasImageContent; exports.hasThinkingEnabled = _chunkSUEGJ75Dcjs.hasThinkingEnabled;

package/dist/ApiConverter.d.cts

@@ -0,0 +1,82 @@
+import { AnthropicChatRequest, OpenAIChatRequest, AnthropicChatResponse, OpenAIChatResponse, ConversionConfig } from '@omnicross/contracts/completion-types';
+
+/**
+ * Anthropic → OpenAI API conversion.
+ *
+ * Used by the claude-code-rerouter direction: clients call our endpoint with
+ * an Anthropic-style payload, we forward to an upstream OpenAI provider.
+ *
+ * Includes:
+ * - Response conversion (chat + tools + thinking blocks)
+ * - Request conversion (reverse direction)
+ * - Streaming chunk transform (Anthropic SSE → OpenAI SSE)
+ * - Thinking-aware response enrichment
+ */
+
+/**
+ * Convert Anthropic response to OpenAI format.
+ */
+declare function convertAnthropicToOpenAI(response: AnthropicChatResponse): OpenAIChatResponse;
+/**
+ * Convert Anthropic request to OpenAI format (reverse direction).
+ */
+declare function convertAnthropicRequestToOpenAI(request: AnthropicChatRequest): OpenAIChatRequest;
+/**
+ * Convert Anthropic response to OpenAI with thinking content preserved.
+ */
+declare function convertAnthropicToOpenAIWithThinking(response: AnthropicChatResponse): OpenAIChatResponse;
+/**
+ * Convert Anthropic streaming response to OpenAI format.
+ */
+declare function convertAnthropicStreamToOpenAI(anthropicStream: AsyncIterable<string>): AsyncGenerator<string>;
+
+/**
+ * OpenAI → Anthropic API conversion.
+ *
+ * Used by the claude-code-router direction: clients call our endpoint with
+ * an OpenAI-style payload, we forward to an upstream Anthropic provider.
+ *
+ * Includes:
+ * - Request conversion (chat + tools)
+ * - Streaming chunk transform (OpenAI SSE → Anthropic SSE)
+ * - Thinking-aware request enrichment
+ */
+
+/**
+ * Convert OpenAI chat request to Anthropic format.
+ */
+declare function convertOpenAIToAnthropic(request: OpenAIChatRequest, config: ConversionConfig): AnthropicChatRequest;
+/**
+ * Convert OpenAI response to Anthropic format.
+ */
+declare function convertOpenAIResponseToAnthropic(response: OpenAIChatResponse): AnthropicChatResponse;
+/**
+ * Convert OpenAI request to Anthropic with thinking support.
+ */
+declare function convertOpenAIToAnthropicWithThinking(request: OpenAIChatRequest, config: ConversionConfig & {
+    thinkingBudget?: number;
+}): AnthropicChatRequest;
+/**
+ * Convert OpenAI streaming response to Anthropic format.
+ * This creates an async generator that yields Anthropic SSE events.
+ */
+declare function convertOpenAIStreamToAnthropic(openaiStream: AsyncIterable<string>): AsyncGenerator<string>;
+
+/**
+ * Shared helpers for API direction converters.
+ *
+ * Pure functions used by both OpenAI→Anthropic and Anthropic→OpenAI
+ * conversion paths: tool schema mapping, stop-reason mapping, and
+ * lightweight image detection.
+ */
+
+/**
+ * Check if a request contains image content (either format).
+ */
+declare function hasImageContent(request: OpenAIChatRequest | AnthropicChatRequest): boolean;
+/**
+ * Check if a request has thinking/reasoning enabled.
+ */
+declare function hasThinkingEnabled(request: OpenAIChatRequest | AnthropicChatRequest): boolean;
+
+export { convertAnthropicRequestToOpenAI, convertAnthropicStreamToOpenAI, convertAnthropicToOpenAI, convertAnthropicToOpenAIWithThinking, convertOpenAIResponseToAnthropic, convertOpenAIStreamToAnthropic, convertOpenAIToAnthropic, convertOpenAIToAnthropicWithThinking, hasImageContent, hasThinkingEnabled };

package/dist/ApiConverter.d.ts

@@ -0,0 +1,82 @@
+import { AnthropicChatRequest, OpenAIChatRequest, AnthropicChatResponse, OpenAIChatResponse, ConversionConfig } from '@omnicross/contracts/completion-types';
+
+/**
+ * Anthropic → OpenAI API conversion.
+ *
+ * Used by the claude-code-rerouter direction: clients call our endpoint with
+ * an Anthropic-style payload, we forward to an upstream OpenAI provider.
+ *
+ * Includes:
+ * - Response conversion (chat + tools + thinking blocks)
+ * - Request conversion (reverse direction)
+ * - Streaming chunk transform (Anthropic SSE → OpenAI SSE)
+ * - Thinking-aware response enrichment
+ */
+
+/**
+ * Convert Anthropic response to OpenAI format.
+ */
+declare function convertAnthropicToOpenAI(response: AnthropicChatResponse): OpenAIChatResponse;
+/**
+ * Convert Anthropic request to OpenAI format (reverse direction).
+ */
+declare function convertAnthropicRequestToOpenAI(request: AnthropicChatRequest): OpenAIChatRequest;
+/**
+ * Convert Anthropic response to OpenAI with thinking content preserved.
+ */
+declare function convertAnthropicToOpenAIWithThinking(response: AnthropicChatResponse): OpenAIChatResponse;
+/**
+ * Convert Anthropic streaming response to OpenAI format.
+ */
+declare function convertAnthropicStreamToOpenAI(anthropicStream: AsyncIterable<string>): AsyncGenerator<string>;
+
+/**
+ * OpenAI → Anthropic API conversion.
+ *
+ * Used by the claude-code-router direction: clients call our endpoint with
+ * an OpenAI-style payload, we forward to an upstream Anthropic provider.
+ *
+ * Includes:
+ * - Request conversion (chat + tools)
+ * - Streaming chunk transform (OpenAI SSE → Anthropic SSE)
+ * - Thinking-aware request enrichment
+ */
+
+/**
+ * Convert OpenAI chat request to Anthropic format.
+ */
+declare function convertOpenAIToAnthropic(request: OpenAIChatRequest, config: ConversionConfig): AnthropicChatRequest;
+/**
+ * Convert OpenAI response to Anthropic format.
+ */
+declare function convertOpenAIResponseToAnthropic(response: OpenAIChatResponse): AnthropicChatResponse;
+/**
+ * Convert OpenAI request to Anthropic with thinking support.
+ */
+declare function convertOpenAIToAnthropicWithThinking(request: OpenAIChatRequest, config: ConversionConfig & {
+    thinkingBudget?: number;
+}): AnthropicChatRequest;
+/**
+ * Convert OpenAI streaming response to Anthropic format.
+ * This creates an async generator that yields Anthropic SSE events.
+ */
+declare function convertOpenAIStreamToAnthropic(openaiStream: AsyncIterable<string>): AsyncGenerator<string>;
+
+/**
+ * Shared helpers for API direction converters.
+ *
+ * Pure functions used by both OpenAI→Anthropic and Anthropic→OpenAI
+ * conversion paths: tool schema mapping, stop-reason mapping, and
+ * lightweight image detection.
+ */
+
+/**
+ * Check if a request contains image content (either format).
+ */
+declare function hasImageContent(request: OpenAIChatRequest | AnthropicChatRequest): boolean;
+/**
+ * Check if a request has thinking/reasoning enabled.
+ */
+declare function hasThinkingEnabled(request: OpenAIChatRequest | AnthropicChatRequest): boolean;
+
+export { convertAnthropicRequestToOpenAI, convertAnthropicStreamToOpenAI, convertAnthropicToOpenAI, convertAnthropicToOpenAIWithThinking, convertOpenAIResponseToAnthropic, convertOpenAIStreamToAnthropic, convertOpenAIToAnthropic, convertOpenAIToAnthropicWithThinking, hasImageContent, hasThinkingEnabled };

package/dist/ApiConverter.js

@@ -0,0 +1,24 @@
+import {
+  convertAnthropicRequestToOpenAI,
+  convertAnthropicStreamToOpenAI,
+  convertAnthropicToOpenAI,
+  convertAnthropicToOpenAIWithThinking,
+  convertOpenAIResponseToAnthropic,
+  convertOpenAIStreamToAnthropic,
+  convertOpenAIToAnthropic,
+  convertOpenAIToAnthropicWithThinking,
+  hasImageContent,
+  hasThinkingEnabled
+} from "./chunk-5ZQBEOMD.js";
+export {
+  convertAnthropicRequestToOpenAI,
+  convertAnthropicStreamToOpenAI,
+  convertAnthropicToOpenAI,
+  convertAnthropicToOpenAIWithThinking,
+  convertOpenAIResponseToAnthropic,
+  convertOpenAIStreamToAnthropic,
+  convertOpenAIToAnthropic,
+  convertOpenAIToAnthropicWithThinking,
+  hasImageContent,
+  hasThinkingEnabled
+};

package/dist/BuiltinToolExecutor-BluWyeob.d.ts

@@ -0,0 +1,81 @@
+import { MCPCallToolResponse, MCPTool } from '@omnicross/contracts/mcp-types';
+import { WebSearchBackend } from './ports/web-search-backend.js';
+
+/**
+ * Core-owned tool-shape types.
+ *
+ * The structural tool definitions (`OpenAITool`, `AnthropicTool`,
+ * `GeminiTools`) are pure data shapes with no host dependency — hoisted here
+ * (verbatim from the host `tools/mcp-users/ToolsLoader.ts`) so the serving core
+ * names no host module. The host `ToolsLoader.ts` re-exports these from
+ * `@omnicross/core`, keeping every existing host consumer unchanged.
+ *
+ * `McpToolProvider` is the narrow structural port for the single `callTool`
+ * method the completion tool-loop consumes from the host's concrete
+ * `McpService`. The concrete `McpService` instance is injected at the existing
+ * seam and satisfies this port structurally (type-only — no runtime coupling).
+ */
+
+/**
+ * OpenAI-compatible tool definition
+ */
+interface OpenAITool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, any>;
+    };
+}
+/**
+ * Anthropic tool definition
+ */
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: Record<string, any>;
+}
+/**
+ * Google Gemini tool definition
+ * Gemini REST API expects tools wrapped in functionDeclarations
+ */
+type GeminiTools = Array<{
+    functionDeclarations: Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, any>;
+    }>;
+}>;
+/**
+ * Narrow structural port for the host MCP tool provider — only the `callTool`
+ * method the serving-core tool-loop dispatches to. The host's concrete
+ * `McpService` satisfies this structurally.
+ */
+interface McpToolProvider {
+    callTool(serverId: string, toolName: string, args: unknown, callId: string): Promise<MCPCallToolResponse>;
+}
+
+/**
+ * BuiltinToolExecutor — Executes built-in tools (web_search, web_fetch)
+ * for the non-agent chat pipeline.
+ *
+ * Built-in tools use `serverId: 'builtin'` in MCPTool metadata and are
+ * dispatched here instead of going through McpService.callTool().
+ */
+
+declare class BuiltinToolExecutor {
+    private webSearch;
+    constructor(webSearch: WebSearchBackend);
+    execute(toolName: string, args: Record<string, unknown>): Promise<MCPCallToolResponse>;
+    private executeWebSearch;
+    private resolveProviderChain;
+    private executeWebFetch;
+}
+/** Get the built-in MCPTool definitions for web search tools. */
+declare function getBuiltinSearchTools(): MCPTool[];
+/** Convert built-in tools to OpenAI function format. */
+declare function convertBuiltinToolsToOpenAI(tools: MCPTool[]): OpenAITool[];
+/** Convert built-in tools to Anthropic format. */
+declare function convertBuiltinToolsToAnthropic(tools: MCPTool[]): AnthropicTool[];
+
+export { type AnthropicTool as A, BuiltinToolExecutor as B, type GeminiTools as G, type McpToolProvider as M, type OpenAITool as O, convertBuiltinToolsToOpenAI as a, convertBuiltinToolsToAnthropic as c, getBuiltinSearchTools as g };

package/dist/BuiltinToolExecutor-CS2WpXhM.d.cts

@@ -0,0 +1,81 @@
+import { MCPCallToolResponse, MCPTool } from '@omnicross/contracts/mcp-types';
+import { WebSearchBackend } from './ports/web-search-backend.cjs';
+
+/**
+ * Core-owned tool-shape types.
+ *
+ * The structural tool definitions (`OpenAITool`, `AnthropicTool`,
+ * `GeminiTools`) are pure data shapes with no host dependency — hoisted here
+ * (verbatim from the host `tools/mcp-users/ToolsLoader.ts`) so the serving core
+ * names no host module. The host `ToolsLoader.ts` re-exports these from
+ * `@omnicross/core`, keeping every existing host consumer unchanged.
+ *
+ * `McpToolProvider` is the narrow structural port for the single `callTool`
+ * method the completion tool-loop consumes from the host's concrete
+ * `McpService`. The concrete `McpService` instance is injected at the existing
+ * seam and satisfies this port structurally (type-only — no runtime coupling).
+ */
+
+/**
+ * OpenAI-compatible tool definition
+ */
+interface OpenAITool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, any>;
+    };
+}
+/**
+ * Anthropic tool definition
+ */
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: Record<string, any>;
+}
+/**
+ * Google Gemini tool definition
+ * Gemini REST API expects tools wrapped in functionDeclarations
+ */
+type GeminiTools = Array<{
+    functionDeclarations: Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, any>;
+    }>;
+}>;
+/**
+ * Narrow structural port for the host MCP tool provider — only the `callTool`
+ * method the serving-core tool-loop dispatches to. The host's concrete
+ * `McpService` satisfies this structurally.
+ */
+interface McpToolProvider {
+    callTool(serverId: string, toolName: string, args: unknown, callId: string): Promise<MCPCallToolResponse>;
+}
+
+/**
+ * BuiltinToolExecutor — Executes built-in tools (web_search, web_fetch)
+ * for the non-agent chat pipeline.
+ *
+ * Built-in tools use `serverId: 'builtin'` in MCPTool metadata and are
+ * dispatched here instead of going through McpService.callTool().
+ */
+
+declare class BuiltinToolExecutor {
+    private webSearch;
+    constructor(webSearch: WebSearchBackend);
+    execute(toolName: string, args: Record<string, unknown>): Promise<MCPCallToolResponse>;
+    private executeWebSearch;
+    private resolveProviderChain;
+    private executeWebFetch;
+}
+/** Get the built-in MCPTool definitions for web search tools. */
+declare function getBuiltinSearchTools(): MCPTool[];
+/** Convert built-in tools to OpenAI function format. */
+declare function convertBuiltinToolsToOpenAI(tools: MCPTool[]): OpenAITool[];
+/** Convert built-in tools to Anthropic format. */
+declare function convertBuiltinToolsToAnthropic(tools: MCPTool[]): AnthropicTool[];
+
+export { type AnthropicTool as A, BuiltinToolExecutor as B, type GeminiTools as G, type McpToolProvider as M, type OpenAITool as O, convertBuiltinToolsToOpenAI as a, convertBuiltinToolsToAnthropic as c, getBuiltinSearchTools as g };

package/dist/CompletionService-D3a47vdU.d.cts

@@ -0,0 +1,213 @@
+import { ThinkLevel } from '@omnicross/contracts/completion-types';
+import { LLMProvider } from '@omnicross/contracts/llm-config';
+import { C as CorePaths, U as UsageEventSink } from './usage-event-sink-BX7FE1NL.cjs';
+import { L as Logger } from './logger-4GvQNzhE.cjs';
+import { ProviderConfigSource } from './ports/provider-config-source.cjs';
+import { UsageRecorderImport } from './provider-proxy/types.cjs';
+import { O as OpenAITool, A as AnthropicTool, G as GeminiTools, M as McpToolProvider, B as BuiltinToolExecutor } from './BuiltinToolExecutor-CS2WpXhM.cjs';
+import { C as CompletionOptions, S as StreamCallbacks, a as CompletionResult } from './types-BScIHmPr.cjs';
+import { ApiKeyPoolService } from './completion/ApiKeyPoolService.cjs';
+import { MCPTool } from '@omnicross/contracts/mcp-types';
+
+/**
+ * VisionFallbackProvider — serving-core port for image-to-text fallback.
+ *
+ * When the active completion model lacks vision capability but a message
+ * carries images, `CompletionService.applyVisionFallback` delegates to this
+ * port to turn the images into a text description (which is then appended to
+ * the message content) before stripping the image attachments.
+ *
+ * The concrete implementation is built ON TOP OF CompletionService, so it
+ * lives in the embedding host and is injected DOWN into the serving core via
+ * `setVisionFallbackProvider` at bootstrap (instead of the core importing
+ * upward).
+ *
+ * @module completion/VisionFallbackProvider
+ */
+/**
+ * Describe a batch of images as text using an auxiliary vision-capable model.
+ *
+ * @param images  Image data URLs to describe (`{ data: 'data:<mime>;base64,…' }`).
+ * @param context Free-form context (the surrounding user message content).
+ * @param model   The resolved vision aux ModelRef (`"providerId,modelId"`).
+ * @returns A textual description, or an empty / sentinel string when
+ *          unavailable. Callers MUST tolerate `''` and
+ *          `'[Image description unavailable]'`.
+ */
+interface VisionFallbackProvider {
+    describeImages(images: {
+        data: string;
+    }[], context: string, model: string): Promise<string>;
+}
+
+/**
+ * ToolHandler - Handles streaming completion with MCP tool support
+ *
+ * Extracted from CompletionService to isolate the agentic loop logic
+ * that handles tool calls: LLM -> execute tools -> LLM again until done.
+ */
+
+/** Extended options for tool-based completion */
+interface StreamWithToolsOptions extends CompletionOptions {
+    tools: OpenAITool[] | AnthropicTool[] | GeminiTools;
+    mcpTools?: MCPTool[];
+}
+/** Extended callbacks for tool-based completion */
+interface StreamWithToolsCallbacks extends StreamCallbacks {
+    onToolCall?: (toolCall: {
+        id: string;
+        name: string;
+        args: unknown;
+    }) => void;
+    onToolResult?: (toolId: string, result: unknown) => void;
+}
+
+/**
+ * CompletionService - Handles completion API calls
+ *
+ * This service provides a unified interface for making completion API calls
+ * to different providers, handling format conversion as needed.
+ * Supports transformer chains for advanced request/response transformation.
+ *
+ * This is a thin facade that delegates to domain-specific handlers:
+ * - DirectApiHandler: Non-streaming API calls (OpenAI, Anthropic, Gemini)
+ * - StreamHandler: SSE-based streaming (OpenAI, Anthropic, Gemini)
+ * - TransformerHandler: Transformer chain-based completion
+ * - ToolHandler: Agentic tool-calling loop
+ * - ThinkingResolver: Thinking budget and max tokens resolution
+ */
+
+declare class CompletionService {
+    private paths;
+    private llmConfig;
+    private logger;
+    private apiKeyPool;
+    private usageRecorder;
+    private usageEventSink;
+    private visionFallbackProvider;
+    constructor(paths: CorePaths, llmConfig: ProviderConfigSource, logger: Logger);
+    /**
+     * Set the API key pool service for multi-key load balancing.
+     * When set, keys are resolved via the pool instead of directly from the provider.
+     */
+    setApiKeyPool(pool: ApiKeyPoolService): void;
+    /**
+     * Set the usage recorder so completion paths can persist token/cost stats.
+     * Optional — when unset, all calls succeed but nothing is recorded.
+     */
+    setUsageRecorder(recorder: UsageRecorderImport): void;
+    /**
+     * Set the usage-event sink so completion paths can push live usage events
+     * (context-meter, aggregate recorder) into the in-process hub. Injected DOWN
+     * at bootstrap with `getUsageEventHub()` immediately after construction, so
+     * emission is unconditional in production. Optional — when unset (unit-test
+     * constructors), the emit calls no-op, identical to `usageRecorder`.
+     */
+    setUsageEventSink(sink: UsageEventSink): void;
+    /**
+     * Set the vision-fallback provider used by `applyVisionFallback` to describe
+     * images for non-vision models. Injected DOWN by the host at bootstrap
+     * (the host's impl is built on top of CompletionService).
+     * Optional — when unset, `applyVisionFallback` strips images instead.
+     */
+    setVisionFallbackProvider(provider: VisionFallbackProvider): void;
+    /**
+     * Get provider by ID
+     * Delegates to the `ProviderConfigSource` which maintains its own in-memory cache.
+     */
+    getProvider(providerId: string): Promise<LLMProvider | null>;
+    /**
+     * Send a completion request
+     */
+    complete(options: CompletionOptions): Promise<CompletionResult>;
+    /**
+     * Send a streaming completion request
+     */
+    completeStream(options: CompletionOptions, callbacks: StreamCallbacks): Promise<void>;
+    /**
+     * Get available models for a provider
+     */
+    getAvailableModels(providerId: string): Promise<string[]>;
+    /**
+     * Test provider connection with a specific model.
+     * Sends "Hello" and returns the AI response, duration, etc.
+     */
+    testModel(providerId: string, modelId: string): Promise<{
+        success: boolean;
+        message: string;
+        response?: string;
+        model: string;
+        durationMs?: number;
+    }>;
+    /**
+     * Check if any messages contain images and the model lacks vision capability.
+     * If so, use the auxiliary vision model to describe images as text and remove
+     * the image attachments from the messages.
+     *
+     * Mutates options.messages in-place.
+     */
+    private applyVisionFallback;
+    /**
+     * Resolve API key for a request with priority:
+     * 1. Coding Plan override (if enabled)
+     * 2. API key pool (session-affinity weighted round-robin)
+     * 3. Legacy single key from provider config
+     */
+    private resolveApiKeyForRequest;
+    /**
+     * Extract HTTP status code from error messages like "API error (429): ..."
+     */
+    private extractHttpStatus;
+    /**
+     * Dispatch a non-streaming completion to the appropriate handler.
+     */
+    private callDirectHandler;
+    /**
+     * Dispatch a streaming completion to the appropriate handler.
+     */
+    private callStreamHandler;
+    /**
+     * Resolve API key (handle environment variable references)
+     */
+    resolveApiKey(apiKey: string): string;
+    /**
+     * Resolve effective max_tokens value with priority:
+     * 1. Session settings (if provided)
+     * 2. Global model parameters (if enabled)
+     * 3. Model's maxTokens from provider config
+     * 4. Discovered models cache (from API)
+     * 5. undefined - let API use its default
+     */
+    resolveEffectiveMaxTokens(providerId: string, modelId: string, sessionMaxTokens?: number): Promise<number | undefined>;
+    /**
+     * Get required max_tokens for providers that need it (e.g., Anthropic)
+     * Falls back to DEFAULT_MAX_TOKENS if no value is configured
+     */
+    getRequiredMaxTokens(providerId: string, modelId: string, sessionMaxTokens?: number): Promise<number>;
+    /**
+     * Calculate thinking budget and adjust max_tokens for the provider
+     */
+    resolveThinkingBudget(providerId: string, modelId: string, maxTokens: number, thinkLevel: ThinkLevel): Promise<{
+        adjustedMaxTokens: number;
+        thinkingBudget: number | undefined;
+        thinkingConfig: {
+            type?: 'enabled' | 'disabled';
+            budget_tokens?: number;
+        } | undefined;
+    }>;
+    /**
+     * Send a completion request using transformer chain
+     */
+    completeWithTransformers(options: CompletionOptions): Promise<CompletionResult>;
+    /**
+     * Send a streaming completion request using transformer chain
+     */
+    completeStreamWithTransformers(options: CompletionOptions, callbacks: StreamCallbacks): Promise<void>;
+    /**
+     * Stream completion with MCP tools support (direct API call)
+     * Implements agentic loop: calls LLM -> executes tools -> calls LLM again until done
+     */
+    streamWithTools(options: StreamWithToolsOptions, callbacks: StreamWithToolsCallbacks, mcpService?: McpToolProvider, builtinExecutor?: BuiltinToolExecutor): Promise<void>;
+}
+
+export { CompletionService as C, type VisionFallbackProvider as V };