@jeffusion/bungee-llms 5.20.0 → 5.22.0

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

@@ -0,0 +1,14 @@
+import { type ProtocolSession, type ProtocolSessionContext } from './types';
+export * from './types';
+export declare const PROTOCOL_CONVERSION_RULES_VERSION = "1.0.1";
+export declare function describeProtocolConversion(): {
+    rulesVersion: string;
+    protocols: ("chat_completions" | "anthropic_messages" | "responses" | "gemini_generate_content")[];
+    matrix: {
+        readonly sourceProtocol: "chat_completions" | "anthropic_messages" | "responses" | "gemini_generate_content";
+        readonly targetProtocol: "chat_completions" | "anthropic_messages" | "responses" | "gemini_generate_content";
+        readonly mode: "passthrough" | "unsupported" | "convert";
+    }[];
+};
+/** One request/attempt, bounded retained state, plain own-property functions for local service facades. */
+export declare function createProtocolSession(context: ProtocolSessionContext): ProtocolSession;

package/dist/protocol-session/request.d.ts

@@ -0,0 +1,5 @@
+import { type JsonRecord } from '../responses-codec/common';
+import type { LLMProtocol, ProtocolSessionContext, ProtocolRequestConversion } from './types';
+/** The normative history is Responses items, not a provider plugin conversion chain. */
+export declare function canonicalRequest(raw: unknown, protocol: LLMProtocol, model: string): JsonRecord;
+export declare function convertProtocolRequest(raw: unknown, context: ProtocolSessionContext): ProtocolRequestConversion;

package/dist/protocol-session/response.d.ts

@@ -0,0 +1,23 @@
+import { type JsonRecord, type ResponsesToolNames } from '../responses-codec/common';
+import type { LLMProtocol, ProtocolSessionContext } from './types';
+export declare function safeProtocolError(): JsonRecord;
+export declare function validateUsage(raw: unknown, protocol: LLMProtocol): void;
+export declare function validateProviderResponse(raw: unknown, protocol: LLMProtocol): JsonRecord;
+export declare function validateAnthropicBlock(b: JsonRecord, path: string): void;
+export declare function validateCanonicalResponse(raw: unknown, context: ProtocolSessionContext, itemOnly?: boolean): JsonRecord;
+export declare function canonicalUsage(raw: unknown): JsonRecord;
+export declare function wireUsage(raw: unknown, protocol: LLMProtocol): JsonRecord;
+export declare function responseFromCanonical(raw: unknown, protocol: LLMProtocol, context: ProtocolSessionContext): JsonRecord;
+/** Gemini chunks carry complete function-call objects, never JSON argument deltas. */
+export declare class GeminiCanonicalDecoder {
+    private context;
+    private encoder;
+    private serial;
+    private ended;
+    private tools;
+    private ids;
+    constructor(context: ProtocolSessionContext, names: ResponsesToolNames);
+    push(raw: unknown): JsonRecord[];
+    finish(): JsonRecord[];
+}
+export declare function canonicalResponse(raw: unknown, context: ProtocolSessionContext, names: ResponsesToolNames): JsonRecord;

package/dist/protocol-session/schema.d.ts

@@ -0,0 +1,5 @@
+import { type JsonRecord } from '../responses-codec/common';
+/** Gemini's Schema is an OpenAPI dialect, not JSON Schema. Preserve supported
+ * constraints exactly and reject provider-specific ordering or unknown extensions.
+ */
+export declare function geminiSchemaToJson(raw: unknown, path: string, code?: string, depth?: number): JsonRecord;

package/dist/protocol-session/stream.d.ts

@@ -0,0 +1,35 @@
+import { type JsonRecord } from '../responses-codec/common';
+import type { LLMProtocol, ProtocolSessionContext } from './types';
+/** Validate Responses event ordering and final snapshots before rendering another wire protocol. */
+export declare class CanonicalStreamValidator {
+    private context;
+    private items;
+    private started;
+    private ended;
+    private sequence;
+    private retained;
+    private partCount;
+    private responseId?;
+    constructor(context: ProtocolSessionContext);
+    push(raw: unknown): JsonRecord[];
+    private retain;
+    finish(): JsonRecord[];
+}
+export declare class CanonicalStreamRenderer {
+    private protocol;
+    private context;
+    private id;
+    private created;
+    private toolCount;
+    private started;
+    private items;
+    private blocks;
+    private nextBlock;
+    private toolIndexes;
+    constructor(protocol: LLMProtocol, context: ProtocolSessionContext);
+    push(events: JsonRecord[]): JsonRecord[];
+    private chat;
+    private gemini;
+    private blockKey;
+    private render;
+}

package/dist/protocol-session/types.d.ts

@@ -0,0 +1,48 @@
+import type { ResponsesCodecCapabilities, ResponsesConversionDiagnostic, ResponsesToolNames } from '../responses-codec';
+export declare const LLM_PROTOCOLS: readonly ["responses", "chat_completions", "anthropic_messages", "gemini_generate_content"];
+export type LLMProtocol = typeof LLM_PROTOCOLS[number];
+export type ProtocolJsonObject = Record<string, unknown>;
+/** Every mapping is supplied by the capability owner, never inferred from a reasoning flag. */
+export interface ProtocolReasoningPolicy {
+    effortMap?: Readonly<Record<string, string>>;
+    /** Verified target effort for source budget/mode policies that have no effort label. */
+    targetEffort?: string;
+    anthropicThinkingBudget?: number;
+    anthropicThinkingMode?: 'adaptive' | 'enabled' | 'disabled';
+    geminiThinkingBudget?: number;
+    geminiThinkingLevel?: string;
+}
+export interface ProtocolSessionCapabilities extends ResponsesCodecCapabilities {
+    anthropicStructuredOutput?: boolean;
+    anthropicStrictTools?: boolean;
+    anthropicEffort?: boolean;
+    geminiJsonSchema?: boolean;
+}
+export interface ProtocolSessionContext {
+    sourceProtocol: LLMProtocol;
+    targetProtocol: LLMProtocol;
+    /** Target model; caller owns routing and source URL validation. */
+    model: string;
+    /** Transport-derived mode for protocols such as Gemini whose stream flag is in the URL. */
+    streaming?: boolean;
+    responseModel?: string;
+    capabilities?: ProtocolSessionCapabilities;
+    reasoningPolicy?: ProtocolReasoningPolicy;
+}
+export interface ProtocolRequestConversion {
+    body: ProtocolJsonObject;
+    canonicalHistory: ProtocolJsonObject[];
+    diagnostics: ResponsesConversionDiagnostic[];
+    toolNames: ResponsesToolNames;
+    streaming: boolean;
+}
+/** Requests flow source→target; responses and JSON stream events flow target→source.
+ * Transport framing, [DONE], HTTP errors, readers and cancellation are caller-owned.
+ */
+export interface ProtocolSession {
+    convertRequest(raw: unknown): ProtocolRequestConversion;
+    convertResponse(raw: unknown): ProtocolJsonObject;
+    push(event: unknown): ProtocolJsonObject[];
+    finish(): ProtocolJsonObject[];
+    dispose(): void;
+}

package/dist/protocol-session/validation.d.ts

@@ -0,0 +1,5 @@
+import { type JsonRecord } from '../responses-codec/common';
+export declare function fields(value: JsonRecord, allowed: readonly string[], path: string, code?: string): void;
+export declare function bool(value: unknown, path: string): boolean;
+export declare function integer(value: unknown, path: string, min?: number): number;
+export declare function textParts(raw: unknown, path: string, style: 'chat' | 'anthropic' | 'gemini', role: string): JsonRecord[];

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

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

package/dist/responses-codec/common.d.ts

@@ -16,16 +16,31 @@ export interface ResponsesCodecLimits {
 export declare const DEFAULT_RESPONSES_CODEC_LIMITS: Readonly<ResponsesCodecLimits>;
 export interface ResponsesCodecCapabilities {
     reasoningEffort?: boolean;
+    /** Plain reasoning history support is independent of effort parameter mapping. */
+    reasoningHistory?: boolean;
+    anthropicStrictTools?: boolean;
+    /** Include original names in alias descriptions so model-facing identity is retained. */
+    preserveToolIdentityDescription?: boolean;
+    preserveRefusalContent?: boolean;
+    /** Codex declares optional hosted search even when the selected model has no search backend. */
+    omitOptionalWebSearch?: boolean;
     /** Explicit provider-approved thinking budget; do not guess budgets from effort labels. */
     anthropicThinkingBudget?: number;
     maxOutputTokens?: number;
     limits?: Partial<ResponsesCodecLimits>;
 }
+export interface ResponsesConversionDiagnostic {
+    param: string;
+    action: 'mapped' | 'omitted';
+    reason: string;
+}
 export declare class ResponsesCodecError extends Error {
     readonly code: string;
-    constructor(code: string, message: string);
+    readonly param?: string | undefined;
+    constructor(code: string, message: string, param?: string | undefined);
 }
-export declare function fail(code: string, message: string): never;
+export declare function fail(code: string, message: string, param?: string): never;
+export declare function atParam<T>(param: string, run: () => T): T;
 export declare function record(value: unknown, where: string): JsonRecord;
 export declare function string(value: unknown, where: string, nonempty?: boolean): string;
 export declare function list(value: unknown, where: string): unknown[];

package/dist/responses-codec/events.d.ts

@@ -7,6 +7,7 @@ export declare class ResponsesEventEncoder {
     readonly protocol: ResponsesProtocol;
     readonly model: string;
     readonly toolNames: ResponsesToolNames;
+    private readonly options;
     private readonly budget;
     private readonly id;
     private readonly createdAt;
@@ -23,7 +24,12 @@ export declare class ResponsesEventEncoder {
     private poisoned;
     private sequence;
     private retained;
-    constructor(protocol: ResponsesProtocol, model: string, toolNames?: ResponsesToolNames, configuredLimits?: Partial<ResponsesCodecLimits>);
+    private lastKind?;
+    private contentSerial;
+    constructor(protocol: ResponsesProtocol, model: string, toolNames?: ResponsesToolNames, configuredLimits?: Partial<ResponsesCodecLimits>, options?: {
+        preserveContentOrder?: boolean;
+    });
+    private contentState;
     private event;
     private start;
     private retain;

package/dist/responses-codec/index.d.ts

@@ -1,4 +1,4 @@
 export { decodeResponsesRequest, type DecodedResponsesRequest } from './request';
 export { encodeResponsesResult } from './result';
 export { ResponsesEventEncoder } from './events';
-export { ResponsesCodecError, DEFAULT_RESPONSES_CODEC_LIMITS, type ResponsesProtocol, type ResponsesToolName, type ResponsesToolNames, type ResponsesCodecCapabilities, type ResponsesCodecLimits } from './common';
+export { ResponsesCodecError, DEFAULT_RESPONSES_CODEC_LIMITS, type ResponsesProtocol, type ResponsesToolName, type ResponsesToolNames, type ResponsesCodecCapabilities, type ResponsesCodecLimits, type ResponsesConversionDiagnostic } from './common';

package/dist/responses-codec/request-preferences.d.ts

@@ -0,0 +1,3 @@
+import { type JsonRecord, type ResponsesCodecCapabilities, type ResponsesConversionDiagnostic, type ResponsesProtocol } from './common';
+/** Known preferences may be omitted; output constraints are handled by the request renderer. */
+export declare function applyResponsesPreferences(body: JsonRecord, result: JsonRecord, protocol: ResponsesProtocol, capabilities: ResponsesCodecCapabilities, maxTokens: unknown, diagnostics: ResponsesConversionDiagnostic[]): void;

package/dist/responses-codec/request.d.ts

@@ -1,7 +1,9 @@
-import { type JsonRecord, type ResponsesCodecCapabilities, type ResponsesProtocol, type ResponsesToolNames } from './common';
+import { type JsonRecord, type ResponsesCodecCapabilities, type ResponsesConversionDiagnostic, type ResponsesProtocol, type ResponsesToolNames } from './common';
 export interface DecodedResponsesRequest {
     body: JsonRecord;
     toolNames: ResponsesToolNames;
+    canonicalInput: JsonRecord[];
+    diagnostics: ResponsesConversionDiagnostic[];
 }
 /** Converts only self-contained history. Reference resolution belongs to the caller. */
 export declare function decodeResponsesRequest(raw: unknown, protocol: ResponsesProtocol, capabilities?: ResponsesCodecCapabilities): DecodedResponsesRequest;

package/dist/responses-codec/web-search.d.ts

@@ -0,0 +1,3 @@
+import { type JsonRecord } from './common';
+/** Validate a known hosted declaration before an explicitly permitted omission. */
+export declare function validateWebSearch(tool: JsonRecord, path: string): void;

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@jeffusion/bungee-llms",
-  "version": "5.20.0",
+  "version": "5.22.0",
   "description": "Extensible LLM adapters and protocol conversion package for Bungee",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "dev": "bun --watch src/index.ts",
     "build": "bun build src/index.ts src/plugin-api.ts --outdir dist --target bun && tsc -p tsconfig.build.json",
-    "test": "echo 'No tests for llms package yet'",
+    "test": "bun test tests/",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@jeffusion/bungee-types": "^5.20.0"
+    "@jeffusion/bungee-types": "^5.22.0"
   },
   "devDependencies": {
     "bun-types": "^1.3.2",

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

@@ -1,62 +0,0 @@
-/**
- * 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

@@ -1,110 +0,0 @@
-/**
- * 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 readonly protocolConversion;
-    private configuredApiMode?;
-    setApiMode(mode: unknown): void;
-    setRuntimeOptions(options: unknown): void;
-    private resolveTargetApiMode;
-    /**
-     * 修改请求：转换为 OpenAI Chat Completions 格式
-     */
-    onBeforeRequest(ctx: MutableRequestContext): Promise<void>;
-    private isAnthropicCountTokensPath;
-    private buildOpenAICountTokensRequest;
-    /**
-     * 构建 OpenAI 请求
-     */
-    private buildOpenAIRequest;
-    private isOpenAINumericOSeriesModel;
-    private buildOpenAIResponsesRequest;
-    private convertAnthropicSystemToInstructions;
-    private convertAnthropicMessagesToResponsesInput;
-    private convertAnthropicImageSourceToUrl;
-    private mapAnthropicToolChoiceToResponses;
-    private resolveAnthropicReasoningEffort;
-    private supportsReasoningEffort;
-    private convertSystemMessages;
-    private sanitizeSystemText;
-    private extractTextFromOpenAIContent;
-    private normalizeOpenAISystemMessages;
-    /**
-     * 转换 User 消息
-     */
-    private normalizeToolResultContent;
-    private convertUserMessage;
-    private convertUserContentBlock;
-    /**
-     * 转换 Assistant 消息
-     */
-    private convertAssistantMessage;
-    private normalizeOpenAIMessageContent;
-    private normalizeToolParametersSchema;
-    private cleanOpenAIToolSchema;
-    private resolvePromptCacheKey;
-    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 extractStrictResponsesReasoningText;
-    private extractReasoningTextFromDeltaContentPart;
-    private extractChatThinkingDelta;
-    private getChatUsedIndices;
-    private allocateChatContentBlockIndex;
-    private ensureChatTextBlockStarted;
-    private ensureChatThinkingBlockStarted;
-    private closeChatNonToolBlock;
-    private resolveChatToolIndex;
-    private resolveResponsesReasoningIndex;
-    private nextResponsesContentIndex;
-    private resolveResponsesContentIndex;
-    private ensureResponsesTextBlockStarted;
-    private resolveResponsesToolIndex;
-    private ensureResponsesThinkingBlockStarted;
-    private emitResponsesThinkingDelta;
-    private extractResponsesReasoningDeltaText;
-    private convertOpenAIResponsesToAnthropic;
-    private mapResponsesStopReason;
-    private buildAnthropicUsageFromResponses;
-    /**
-     * 转换 OpenAI 响应为 Anthropic 格式
-     */
-    private convertOpenAIResponseToAnthropic;
-    private parseToolArguments;
-    /**
-     * 处理流式响应：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

@@ -1,38 +0,0 @@
-export interface MutableRequestContext {
-    url: URL;
-    headers: Record<string, string>;
-    body: any;
-    [key: string]: any;
-}
-export interface ResponseContext {
-    response: Response;
-    /** Shared immutable JSON view owned by the gateway. */
-    bodyHandle: {
-        json(): Promise<unknown>;
-    };
-    [key: string]: any;
-}
-export interface StreamChunkContext {
-    /** SSE metadata belongs to the transport envelope, not the JSON object. */
-    sseEvent?: {
-        event?: string;
-        id?: string;
-        retry?: string;
-        comments?: string[];
-    };
-    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

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

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

@@ -1,57 +0,0 @@
-/**
- * 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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,10 +0,0 @@
-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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,32 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-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;
-}