@jeffusion/bungee-llms 3.2.0

package/dist/protocol-converters/anthropic-to-gemini.converter.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Anthropic to Gemini Converter
+ *
+ * 将 Anthropic Messages API 格式转换为 Google Gemini API 格式
+ *
+ * 主要转换：
+ * - 请求：/v1/messages → /v1beta/models/{model}:generateContent
+ * - 请求：messages → contents (role: assistant → model)
+ * - 请求：system → systemInstruction
+ * - 请求：tools → functionDeclarations
+ * - 响应：Gemini 累积文本 → Anthropic 增量文本（SSE）
+ */
+import type { AIConverter, MutableRequestContext, ResponseContext, StreamChunkContext } from './base';
+export declare class AnthropicToGeminiConverter implements AIConverter {
+    readonly from = "anthropic";
+    readonly to = "gemini";
+    private toolIdToNameMap;
+    private readonly ALLOWED_QUERY_PARAMS;
+    /**
+     * 过滤 query 参数，只保留白名单中的参数
+     */
+    private filterSearchParams;
+    /**
+     * 修改请求 URL 和 body，转换为 Gemini 格式
+     */
+    onBeforeRequest(ctx: MutableRequestContext): Promise<void>;
+    /**
+     * 构建 Gemini generateContent 请求
+     */
+    private buildGenerateContentRequest;
+    /**
+     * 转换 Anthropic messages 为 Gemini contents
+     */
+    private convertMessages;
+    /**
+     * 清理 JSON Schema（移除 Gemini 不支持的字段）
+     * 按文档 3.4 Line 144: 深度清洗，去除不被 Gemini 接受的关键词
+     * 参考 llms 项目的 cleanupParameters 和 processJsonSchema 实现
+     */
+    private cleanSchema;
+    /**
+     * 处理非流式响应
+     * 将 Gemini 响应转换为 Anthropic 格式
+     */
+    onResponse(ctx: ResponseContext): Promise<Response | void>;
+    private isJsonLikeContentType;
+    private isLikelyGeminiErrorBody;
+    private isLikelyGeminiSuccessBody;
+    /**
+     * 转换 Gemini 响应为 Anthropic 格式
+     */
+    private convertGeminiResponseToAnthropic;
+    /**
+     * 处理流式响应 chunk
+     * Gemini 返回累积文本，需要转换为 Anthropic 的增量文本
+     */
+    processStreamChunk(chunk: any, ctx: StreamChunkContext): Promise<any[] | null>;
+    /**
+     * 流结束时发送最终事件
+     */
+    flushStream(_ctx: StreamChunkContext): Promise<any[]>;
+}

package/dist/protocol-converters/anthropic-to-openai.converter.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Anthropic to OpenAI Converter
+ *
+ * 将 Anthropic Messages API 格式转换为 OpenAI Chat Completions API 格式
+ *
+ * 转换规则：
+ * - 请求：/v1/messages → /v1/chat/completions
+ * - 请求：system → messages[0] (role=system)
+ * - 请求：tool_result → tool role, tool_use → tool_calls
+ * - 请求：thinking.effort / output_config.effort → reasoning_effort 映射
+ * - 响应：OpenAI → Anthropic (tool_calls, thinking 标签)
+ * - 响应：OpenAI SSE → Anthropic SSE 事件序列
+ */
+import type { AIConverter, MutableRequestContext, ResponseContext, StreamChunkContext } from './base';
+export declare class AnthropicToOpenAIConverter implements AIConverter {
+    readonly from = "anthropic";
+    readonly to = "openai";
+    private configuredApiMode?;
+    private readonly protocolConversion;
+    private readonly runtime;
+    constructor();
+    setApiMode(mode: unknown): void;
+    setRuntimeOptions(options: unknown): void;
+    private parseIntegerOption;
+    private resolveReasoningMaxCompletionTokens;
+    private resolveTargetApiMode;
+    /**
+     * 修改请求：转换为 OpenAI Chat Completions 格式
+     */
+    onBeforeRequest(ctx: MutableRequestContext): Promise<void>;
+    private canUseRuntimeRequestConversion;
+    private isAnthropicCountTokensPath;
+    private buildOpenAICountTokensRequest;
+    /**
+     * 构建 OpenAI 请求
+     */
+    private buildOpenAIRequest;
+    private isAnthropicThinkingEnabled;
+    private resolveAnthropicThinkingEffort;
+    private resolveOutputConfigEffort;
+    private normalizeOpenAIReasoningEffort;
+    private supportsXHighReasoningEffort;
+    private buildOpenAIResponsesRequest;
+    private convertSystemMessages;
+    private validateAndCleanToolCalls;
+    /**
+     * 转换 User 消息
+     */
+    private normalizeToolResultContent;
+    private convertUserMessage;
+    private convertUserContentBlock;
+    /**
+     * 转换 Assistant 消息
+     */
+    private convertAssistantMessage;
+    private normalizeToolCallId;
+    private mapAnthropicToolChoiceToOpenAI;
+    private parseOpenAIImageUrlSource;
+    private normalizeToolParametersSchema;
+    private normalizeJsonSchema;
+    /**
+     * 处理非流式响应：OpenAI → Anthropic
+     */
+    onResponse(ctx: ResponseContext): Promise<Response | void>;
+    private extractCountTokensInput;
+    private convertOpenAIErrorToAnthropic;
+    private isJsonLikeContentType;
+    private isLikelyOpenAIErrorBody;
+    private isLikelyOpenAICountTokensBody;
+    private isLikelyOpenAISuccessBody;
+    private isResponsesApiBody;
+    private extractReasoningSummaryTexts;
+    private appendUniqueThinkingBlocks;
+    private appendParsedContent;
+    private extractChatCompletionReasoningTexts;
+    private extractReasoningTextFromDeltaContentPart;
+    private extractChatThinkingDelta;
+    private getChatUsedIndices;
+    private allocateChatContentBlockIndex;
+    private ensureChatTextBlockStarted;
+    private ensureChatThinkingBlockStarted;
+    private resolveChatToolIndex;
+    private resolveResponsesReasoningIndex;
+    private ensureResponsesThinkingBlockStarted;
+    private emitResponsesThinkingDelta;
+    private extractResponsesReasoningDeltaText;
+    private convertOpenAIResponsesToAnthropic;
+    /**
+     * 转换 OpenAI 响应为 Anthropic 格式
+     */
+    private convertOpenAIResponseToAnthropic;
+    /**
+     * 处理流式响应：OpenAI chunk → Anthropic SSE
+     */
+    processStreamChunk(chunk: any, ctx: StreamChunkContext): Promise<any[] | null>;
+    /**
+     * 刷新流 - 确保流结束
+     */
+    flushStream(ctx: StreamChunkContext): Promise<any[]>;
+    private isResponsesStreamChunk;
+    private processResponsesStreamChunk;
+    private finalizeResponsesStreamEvents;
+    private extractOpenAIStreamUsage;
+    private extractDeltaText;
+}

package/dist/protocol-converters/base.d.ts

@@ -0,0 +1,27 @@
+export interface MutableRequestContext {
+    url: URL;
+    headers: Record<string, string>;
+    body: any;
+    [key: string]: any;
+}
+export interface ResponseContext {
+    response: Response;
+    [key: string]: any;
+}
+export interface StreamChunkContext {
+    streamState: Map<string, any>;
+    chunkIndex?: number;
+    isFirstChunk?: boolean;
+    isLastChunk?: boolean;
+    [key: string]: any;
+}
+export interface AIConverter {
+    readonly from: string;
+    readonly to: string;
+    setRuntimeOptions?(options: unknown): void;
+    onBeforeRequest?(ctx: MutableRequestContext): Promise<void>;
+    onResponse?(ctx: ResponseContext): Promise<Response | void>;
+    processStreamChunk?(chunk: any, ctx: StreamChunkContext): Promise<any[] | null>;
+    flushStream?(ctx: StreamChunkContext): Promise<any[]>;
+}
+export type TransformDirection = `${string}-${string}`;

package/dist/protocol-converters/default-registry.d.ts

@@ -0,0 +1 @@
+export declare function registerDefaultProtocolConverters(): void;

package/dist/protocol-converters/gemini-to-anthropic.converter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Gemini to Anthropic Plugin
+ *
+ * 将 Google Gemini API 格式转换为 Anthropic Messages API 格式
+ *
+ * 主要转换：
+ * - 请求：/v1beta/models/{model}:generateContent → /v1/messages
+ * - 请求：contents → messages (role: model → assistant, tool → user)
+ * - 请求：systemInstruction → system
+ * - 请求：functionDeclarations → tools
+ * - 响应：Anthropic 格式 → Gemini candidates 格式
+ * - 响应：Anthropic 增量 SSE → Gemini 累积 SSE
+ */
+import type { AIConverter, MutableRequestContext, ResponseContext, StreamChunkContext } from './base';
+export declare class GeminiToAnthropicConverter implements AIConverter {
+    readonly from = "gemini";
+    readonly to = "anthropic";
+    private parseGeminiEndpoint;
+    /**
+     * 修改请求 URL 和 body，转换为 Anthropic 格式
+     */
+    onBeforeRequest(ctx: MutableRequestContext): Promise<void>;
+    /**
+     * 转换 Gemini contents 为 Anthropic messages
+     */
+    private convertContentsToMessages;
+    /**
+     * 转换 Gemini tools 为 Anthropic tools
+     */
+    private convertTools;
+    /**
+     * 转换 Gemini schema 类型为 JSON Schema
+     */
+    private convertSchema;
+    /**
+     * 处理非流式响应
+     * 将 Anthropic 响应转换为 Gemini 格式
+     */
+    onResponse(ctx: ResponseContext): Promise<Response | void>;
+    /**
+     * 转换 Anthropic 错误响应为 Gemini 格式
+     */
+    private mapAnthropicErrorToGeminiStatus;
+    private transformErrorResponse;
+    private isJsonLikeContentType;
+    private isLikelyAnthropicErrorBody;
+    private isLikelyAnthropicSuccessBody;
+    /**
+     * 转换 Anthropic 响应为 Gemini candidates 格式
+     */
+    private convertAnthropicResponseToGemini;
+    /**
+     * 处理流式响应 chunk
+     * Anthropic 返回增量文本，需要累积为 Gemini 的累积格式
+     */
+    processStreamChunk(chunk: any, ctx: StreamChunkContext): Promise<any[] | null>;
+}

package/dist/protocol-converters/gemini-to-openai.converter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Gemini to OpenAI Plugin
+ *
+ * 将 Google Gemini API 格式转换为 OpenAI Chat Completions API 格式
+ *
+ * 主要转换：
+ * - 请求：/v1beta/models/{model}:generateContent → /v1/chat/completions
+ * - 请求：contents → messages
+ * - 响应：OpenAI chat.completion → Gemini candidates 格式
+ */
+import type { AIConverter, MutableRequestContext, ResponseContext, StreamChunkContext } from './base';
+export declare class GeminiToOpenAIConverter implements AIConverter {
+    readonly from = "gemini";
+    readonly to = "openai";
+    private parseGeminiEndpoint;
+    onBeforeRequest(ctx: MutableRequestContext): Promise<void>;
+    private parseToolArgumentsToObject;
+    private buildOpenAIRequest;
+    onResponse(ctx: ResponseContext): Promise<Response | void>;
+    private mapOpenAIErrorToGeminiStatus;
+    private transformErrorResponse;
+    private isJsonLikeContentType;
+    private isLikelyOpenAIErrorBody;
+    private isLikelyOpenAISuccessBody;
+    private convertOpenAIResponseToGemini;
+    processStreamChunk(chunk: any, ctx: StreamChunkContext): Promise<any[] | null>;
+    /**
+     * flushStream - 此 transformer 不需要缓冲，返回空数组
+     */
+    flushStream(ctx: StreamChunkContext): Promise<any[]>;
+}

package/dist/protocol-converters/index.d.ts

@@ -0,0 +1,10 @@
+export * from './base';
+export * from './utils';
+export * from './registry';
+export * from './default-registry';
+export * from './openai-to-anthropic.converter';
+export * from './anthropic-to-openai.converter';
+export * from './openai-to-gemini.converter';
+export * from './gemini-to-openai.converter';
+export * from './anthropic-to-gemini.converter';
+export * from './gemini-to-anthropic.converter';

package/dist/protocol-converters/openai-to-anthropic.converter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenAI to Anthropic Converter
+ *
+ * 将 OpenAI Chat Completions API 格式转换为 Anthropic Messages API 格式
+ *
+ * 转换规则：
+ * - 请求：/v1/chat/completions → /v1/messages
+ * - 请求：messages、tools、reasoning_effort
+ * - 响应：Anthropic message → OpenAI chat.completion
+ * - 响应：Anthropic SSE → OpenAI SSE
+ */
+import type { AIConverter, MutableRequestContext, ResponseContext, StreamChunkContext } from './base';
+export declare class OpenAIToAnthropicConverter implements AIConverter {
+    readonly from = "openai";
+    readonly to = "anthropic";
+    private readonly runtime;
+    constructor();
+    onBeforeRequest(ctx: MutableRequestContext): Promise<void>;
+    onResponse(ctx: ResponseContext): Promise<Response | void>;
+    private mapAnthropicErrorToOpenAIType;
+    private transformErrorResponse;
+    private isJsonLikeContentType;
+    private isLikelyAnthropicErrorBody;
+    private convertAnthropicResponseToOpenAI;
+    processStreamChunk(chunk: any, ctx: StreamChunkContext): Promise<any[] | null>;
+    flushStream(ctx: StreamChunkContext): Promise<any[]>;
+}

package/dist/protocol-converters/openai-to-gemini.converter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * OpenAI to Gemini Plugin
+ *
+ * 将 OpenAI Chat Completions API 格式转换为 Google Gemini API 格式
+ *
+ * 主要转换：
+ * - 请求：/v1/chat/completions → /v1beta/models/{model}:generateContent
+ * - 请求：messages → contents
+ * - 响应：Gemini → OpenAI chat.completion
+ */
+import type { AIConverter, MutableRequestContext, ResponseContext, StreamChunkContext } from './base';
+export declare class OpenAIToGeminiConverter implements AIConverter {
+    readonly from = "openai";
+    readonly to = "gemini";
+    private extractInstructionText;
+    private parseToolArgumentsToObject;
+    private buildToolCallIdToNameMap;
+    onBeforeRequest(ctx: MutableRequestContext): Promise<void>;
+    private buildGeminiRequest;
+    private cleanSchema;
+    onResponse(ctx: ResponseContext): Promise<Response | void>;
+    private mapGeminiErrorToOpenAIType;
+    private transformErrorResponse;
+    private isJsonLikeContentType;
+    private isLikelyGeminiErrorBody;
+    private convertGeminiResponseToOpenAI;
+    processStreamChunk(chunk: any, ctx: StreamChunkContext): Promise<any[] | null>;
+    /**
+     * flushStream - 此 transformer 不需要缓冲，返回空数组
+     */
+    flushStream(ctx: StreamChunkContext): Promise<any[]>;
+}

package/dist/protocol-converters/registry.d.ts

@@ -0,0 +1,9 @@
+import type { AIConverter, TransformDirection } from './base';
+export declare class ProtocolTransformerRegistry {
+    private static converters;
+    static register(from: string, to: string, ConverterClass: new () => AIConverter): void;
+    static get(from: string, to: string): AIConverter;
+    static has(from: string, to: string): boolean;
+    static getAllDirections(): TransformDirection[];
+    static clear(): void;
+}

package/dist/protocol-converters/utils.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Converter Utility Functions
+ *
+ * 提供转换器使用的通用工具函数
+ */
+/**
+ * 生成 Anthropic 风格的消息 ID
+ *
+ * @returns 格式为 msg_xxxxxxxxxxxxxxxxxxxxxxxx 的 ID（24位十六进制）
+ */
+export declare function generateAnthropicMessageId(): string;
+/**
+ * 生成 OpenAI 风格的聊天完成 ID
+ *
+ * @returns 格式为 chatcmpl-xxxxxxxxxxxxxxxxxxxxxxxx 的 ID
+ */
+export declare function generateOpenAIChatCompletionId(): string;
+/**
+ * 生成 Gemini 风格的候选 ID
+ *
+ * @returns 格式为 candidate-xxxxxxxx 的 ID
+ */
+export declare function generateGeminiCandidateId(): string;
+/**
+ * 解析文本中的 <thinking> 标签
+ *
+ * @param text - 包含 <thinking> 标签的文本
+ * @returns 解析后的内容块数组
+ */
+export declare function parseThinkingTags(text: string): Array<{
+    type: string;
+    text?: string;
+    thinking?: string;
+}>;
+/**
+ * 将 thinking 块转换为 <thinking> 标签文本
+ *
+ * @param blocks - 内容块数组
+ * @returns 包含 <thinking> 标签的文本
+ */
+export declare function convertThinkingBlocksToTags(blocks: any[]): string;
+/**
+ * 映射 Anthropic stop_reason 到 OpenAI finish_reason
+ *
+ * @param stopReason - Anthropic stop_reason
+ * @returns OpenAI finish_reason
+ */
+export declare function mapAnthropicStopReasonToOpenAI(stopReason: string): string;
+/**
+ * 映射 OpenAI finish_reason 到 Anthropic stop_reason
+ *
+ * @param finishReason - OpenAI finish_reason
+ * @returns Anthropic stop_reason
+ */
+export declare function mapOpenAIFinishReasonToAnthropic(finishReason: string): string;
+/**
+ * 安全解析 JSON 字符串
+ *
+ * @param jsonString - JSON 字符串
+ * @param defaultValue - 解析失败时的默认值
+ * @returns 解析结果或默认值
+ */
+export declare function safeJsonParse<T = any>(jsonString: string, defaultValue?: T): T;
+/**
+ * 安全 JSON 字符串化
+ *
+ * @param obj - 要字符串化的对象
+ * @param defaultValue - 字符串化失败时的默认值
+ * @returns JSON 字符串或默认值
+ */
+export declare function safeJsonStringify(obj: any, defaultValue?: string): string;

package/dist/providers/anthropic/anthropic-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { LLMProtocolAdapter } from '../../core/adapter';
+import type { CanonicalRequest, CanonicalResponse, CanonicalStreamEvent, ConversionContext } from '../../core/types';
+import { OpenAIToAnthropicRequestConversion } from '../openai-anthropic/request-conversion';
+type JsonRecord = Record<string, unknown>;
+export declare class AnthropicAdapter implements LLMProtocolAdapter<JsonRecord, JsonRecord, unknown> {
+    private readonly openAIToAnthropic;
+    readonly provider: "anthropic";
+    constructor(openAIToAnthropic?: OpenAIToAnthropicRequestConversion);
+    toCanonicalRequest(request: JsonRecord, context: ConversionContext): CanonicalRequest;
+    fromCanonicalRequest(request: CanonicalRequest, context: ConversionContext): JsonRecord;
+    toCanonicalResponse(response: JsonRecord, context: ConversionContext): CanonicalResponse;
+    fromCanonicalResponse(response: CanonicalResponse): JsonRecord;
+    toCanonicalStreamEvent(event: unknown): CanonicalStreamEvent;
+    fromCanonicalStreamEvent(event: CanonicalStreamEvent): unknown;
+}
+export {};

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

@@ -0,0 +1 @@
+export * from './anthropic-adapter';

package/dist/providers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './provider-catalog';
+export * from './anthropic';
+export * from './openai';
+export * from './openai-anthropic';

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

@@ -0,0 +1,3 @@
+export * from './protocol-conversion';
+export * from './messages-compat-normalization';
+export * from './openai-adapter';

package/dist/providers/openai/messages-compat-normalization.d.ts

@@ -0,0 +1,42 @@
+export interface OpenAIMessagesCompatibilityNormalizerOptions {
+    strictValidation?: boolean;
+    allowShortPathAlias?: boolean;
+}
+export interface OpenAIMessagesCompatibilityRequestLike {
+    method: string;
+    url: {
+        pathname: string;
+    };
+}
+export type OpenAIMessagesCompatibilityJsonObject = Record<string, unknown>;
+export type OpenAIMessagesCompatibilityBodyValidationResult = {
+    ok: true;
+    body: OpenAIMessagesCompatibilityJsonObject;
+} | {
+    ok: false;
+    message: string;
+};
+export declare class OpenAIMessagesCompatibilityNormalizer {
+    private readonly strictValidation;
+    private readonly allowShortPathAlias;
+    constructor(options?: OpenAIMessagesCompatibilityNormalizerOptions);
+    shouldHandleRequest(ctx: OpenAIMessagesCompatibilityRequestLike): boolean;
+    validateAndNormalizeBody(rawBody: unknown): OpenAIMessagesCompatibilityBodyValidationResult;
+    isOpenAIResponsePayload(payload: unknown): boolean;
+    isOpenAIStreamChunk(chunk: unknown): boolean;
+    buildBadRequest(message: string): Response;
+    private normalizePathname;
+    private collectConflictingFields;
+    private parseToolsInput;
+    private normalizeSingleTool;
+    private normalizeTools;
+    private normalizeToolChoice;
+    private ensureAssistantToolCallReasoningContent;
+    private normalizeMessage;
+    private normalizeToolCallId;
+    private normalizeToolResultContent;
+    private extractThinkingText;
+    private normalizeUserMessageWithToolResults;
+    private normalizeAssistantMessageWithToolUse;
+    private normalizeContentPart;
+}

package/dist/providers/openai/openai-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { LLMProtocolAdapter } from '../../core/adapter';
+import type { CanonicalRequest, CanonicalResponse, CanonicalStreamEvent, ConversionContext } from '../../core/types';
+import { OpenAIProtocolConversion } from './protocol-conversion';
+type JsonRecord = Record<string, unknown>;
+export declare class OpenAIAdapter implements LLMProtocolAdapter<JsonRecord, JsonRecord, unknown> {
+    private readonly protocolConversion;
+    readonly provider: "openai";
+    constructor(protocolConversion?: OpenAIProtocolConversion);
+    toCanonicalRequest(request: JsonRecord, context: ConversionContext): CanonicalRequest;
+    fromCanonicalRequest(request: CanonicalRequest): JsonRecord;
+    toCanonicalResponse(response: JsonRecord, context: ConversionContext): CanonicalResponse;
+    fromCanonicalResponse(response: CanonicalResponse): JsonRecord;
+    toCanonicalStreamEvent(event: unknown): CanonicalStreamEvent;
+    fromCanonicalStreamEvent(event: CanonicalStreamEvent): unknown;
+}
+export {};

package/dist/providers/openai/protocol-conversion.d.ts

@@ -0,0 +1,27 @@
+export type JsonRecord = Record<string, unknown>;
+export interface OpenAIProtocolConversionOptions {
+    trimWhitespace?: boolean;
+}
+export declare class OpenAIProtocolConversion {
+    private readonly trimWhitespace;
+    constructor(options?: OpenAIProtocolConversionOptions);
+    isResponsesPath(pathname: string): boolean;
+    isReasoningContext(body: JsonRecord): boolean;
+    normalizeResponsesReasoningBody(body: JsonRecord): JsonRecord;
+    ensureAssistantToolUseReasoningContent(response: Response): Promise<Response>;
+    ensureMessagesStreamCompatibility(events: unknown[], ctx: {
+        streamState: Map<string, unknown>;
+    }): unknown[];
+    convertChatMessagesToResponsesInput(messages: unknown): {
+        input: JsonRecord[];
+        instructions?: string;
+    };
+    mapChatToolsToResponsesTools(chatTools: unknown): JsonRecord[];
+    convertResponsesInputToMessages(input: unknown): JsonRecord[];
+    normalizeResponsesMessageContent(content: unknown): unknown;
+    private normalizeMessageCollection;
+    private normalizeAssistantToolCallCandidate;
+    private extractThinkingTextFromAnthropicContent;
+    private ensureMessageStartReasoningContent;
+    private ensureMessageDeltaUsage;
+}

package/dist/providers/openai-anthropic/index.d.ts

@@ -0,0 +1 @@
+export * from './request-conversion';

package/dist/providers/openai-anthropic/request-conversion.d.ts

@@ -0,0 +1,20 @@
+import { OpenAIProtocolConversion } from '../openai/protocol-conversion';
+export interface OpenAIToAnthropicRequestConversionResult {
+    pathname: '/v1/messages';
+    body: Record<string, unknown>;
+}
+export declare class OpenAIToAnthropicRequestConversion {
+    private readonly protocolConversion;
+    constructor(protocolConversion?: OpenAIProtocolConversion);
+    convert(pathname: string, body: unknown): OpenAIToAnthropicRequestConversionResult | null;
+    private normalizeOpenAIRequestBody;
+    private convertTools;
+    private mapOpenAIToolChoiceToAnthropic;
+    private extractInstructionText;
+    private validateAndCleanToolCalls;
+    private parseImageSource;
+    private normalizeToolResultContent;
+    private convertToolResultPart;
+    private convertToolMessageToResultBlock;
+    private convertMessages;
+}

package/dist/providers/provider-catalog.d.ts

@@ -0,0 +1,26 @@
+import type { LLMProvider } from '../core/types';
+export interface ProviderCapabilities {
+    supportsChatCompletions?: boolean;
+    supportsResponsesApi?: boolean;
+    supportsToolCalls?: boolean;
+    supportsReasoning?: boolean;
+    supportsStreaming?: boolean;
+    supportsVision?: boolean;
+    [key: string]: unknown;
+}
+export interface ProviderDescriptor {
+    provider: LLMProvider;
+    displayName?: string;
+    aliases?: string[];
+    capabilities?: ProviderCapabilities;
+    metadata?: Record<string, unknown>;
+}
+export declare class LLMProviderCatalog {
+    private readonly descriptors;
+    private readonly aliasToProvider;
+    register(descriptor: ProviderDescriptor): void;
+    unregister(provider: LLMProvider): void;
+    get(provider: LLMProvider | string): ProviderDescriptor | undefined;
+    has(provider: LLMProvider | string): boolean;
+    list(): ProviderDescriptor[];
+}

package/dist/registry.d.ts

@@ -0,0 +1 @@
+export * from './core/registry';

package/dist/runtime/index.d.ts

@@ -0,0 +1 @@
+export * from './llms-runtime';

package/dist/runtime/llms-runtime.d.ts

@@ -0,0 +1,30 @@
+import type { LLMProtocolAdapter } from '../core/adapter';
+import { LLMProtocolAdapterRegistry } from '../core/registry';
+import { LLMProtocolConversionService } from '../core/conversion-service';
+import type { LLMProvider } from '../core/types';
+import { LLMProviderCatalog, type ProviderDescriptor } from '../providers/provider-catalog';
+export interface LLMSRuntimeOptions {
+    adapterRegistry?: LLMProtocolAdapterRegistry;
+    conversionService?: LLMProtocolConversionService;
+    providerCatalog?: LLMProviderCatalog;
+}
+export interface RuntimeAdapterRegistration {
+    adapter: LLMProtocolAdapter;
+    descriptor?: ProviderDescriptor;
+}
+export declare class LLMSRuntime {
+    private readonly adapterRegistry;
+    private readonly conversionService;
+    private readonly providerCatalog;
+    constructor(options?: LLMSRuntimeOptions);
+    registerAdapter(adapter: LLMProtocolAdapter, descriptor?: ProviderDescriptor): void;
+    registerAdapters(registrations: RuntimeAdapterRegistration[]): void;
+    unregisterProvider(provider: LLMProvider): void;
+    convertRequest<T = unknown>(from: LLMProvider, to: LLMProvider, request: unknown, metadata?: Record<string, unknown>): T;
+    convertResponse<T = unknown>(from: LLMProvider, to: LLMProvider, response: unknown, metadata?: Record<string, unknown>): T;
+    convertStreamEvent<T = unknown>(from: LLMProvider, to: LLMProvider, event: unknown, metadata?: Record<string, unknown>): T | null;
+    getProviderCatalog(): LLMProviderCatalog;
+    getAdapterRegistry(): LLMProtocolAdapterRegistry;
+    getConversionService(): LLMProtocolConversionService;
+    listProviders(): ProviderDescriptor[];
+}

package/dist/service.d.ts

@@ -0,0 +1 @@
+export * from './core/conversion-service';

package/dist/types.d.ts

@@ -0,0 +1 @@
+export * from './core/types';