@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/conversion/shared/responses-tool-utils.d.ts

@@ -0,0 +1,12 @@
+export type ToolCallIdStyle = 'preserve' | 'fc';
+type BridgeInputItem = Record<string, unknown>;
+export interface CallIdTransformer {
+    normalizeCallId(raw: unknown): string;
+    normalizeOutputId(callId: string, raw: unknown): string;
+}
+export declare function createToolCallIdTransformer(style: ToolCallIdStyle): CallIdTransformer | null;
+export declare function enforceToolCallIdStyle(input: BridgeInputItem[], transformer: CallIdTransformer): void;
+export declare function resolveToolCallIdStyle(metadata: Record<string, unknown> | undefined): ToolCallIdStyle;
+export declare function stripInternalToolingMetadata(metadata: unknown): void;
+export declare function sanitizeResponsesFunctionName(rawName: unknown): string | undefined;
+export {};

package/dist/conversion/shared/responses-tool-utils.js

@@ -0,0 +1,90 @@
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
+export function createToolCallIdTransformer(style) {
+    if (style !== 'fc') {
+        return null;
+    }
+    let callCounter = 0;
+    let outputCounter = 0;
+    const alias = new Map();
+    const normalizeCallId = (raw) => {
+        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
+        if (rawStr && alias.has(rawStr)) {
+            return alias.get(rawStr);
+        }
+        const normalized = normalizeFunctionCallId({
+            callId: rawStr,
+            fallback: `fc_call_${++callCounter}`
+        });
+        if (rawStr) {
+            alias.set(rawStr, normalized);
+        }
+        return normalized;
+    };
+    const normalizeOutputId = (callId, raw) => {
+        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
+        return normalizeFunctionCallOutputId({
+            callId,
+            fallback: rawStr ?? `fc_tool_${++outputCounter}`
+        });
+    };
+    return {
+        normalizeCallId,
+        normalizeOutputId
+    };
+}
+export function enforceToolCallIdStyle(input, transformer) {
+    for (const entry of input) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
+        if (type === 'function_call') {
+            const normalized = transformer.normalizeCallId(entry.call_id ?? entry.id);
+            entry.call_id = normalized;
+            entry.id = normalized;
+            continue;
+        }
+        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
+            const normalized = transformer.normalizeCallId(entry.call_id ?? entry.id);
+            entry.call_id = normalized;
+            entry.id = transformer.normalizeOutputId(normalized, entry.id);
+        }
+    }
+}
+export function resolveToolCallIdStyle(metadata) {
+    if (!metadata)
+        return 'fc';
+    const raw = metadata.toolCallIdStyle;
+    if (typeof raw === 'string') {
+        const lowered = raw.trim().toLowerCase();
+        if (lowered === 'fc') {
+            return 'fc';
+        }
+        if (lowered === 'preserve') {
+            return 'preserve';
+        }
+    }
+    return 'fc';
+}
+export function stripInternalToolingMetadata(metadata) {
+    if (!metadata || typeof metadata !== 'object')
+        return;
+    if ('toolCallIdStyle' in metadata) {
+        delete metadata.toolCallIdStyle;
+    }
+}
+export function sanitizeResponsesFunctionName(rawName) {
+    if (typeof rawName !== 'string') {
+        return undefined;
+    }
+    const trimmed = rawName.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const dotIndex = trimmed.indexOf('.');
+    const base = dotIndex >= 0 ? trimmed.slice(dotIndex + 1) : trimmed;
+    const sanitized = base.replace(/[^A-Za-z0-9_-]/g, '_');
+    if (sanitized.length > 0) {
+        return sanitized;
+    }
+    return 'tool_call';
+}

package/dist/conversion/shared/responses-types.d.ts

@@ -0,0 +1,33 @@
+export type ResponsesContentPart = {
+    type: string;
+    text?: string;
+    content?: unknown;
+};
+export type ResponsesInputItem = {
+    type: string;
+    role?: string;
+    content?: Array<ResponsesContentPart> | null;
+    name?: string;
+    arguments?: unknown;
+    call_id?: string;
+    output?: unknown;
+    function?: {
+        name?: string;
+        arguments?: unknown;
+    };
+    message?: {
+        role?: string;
+        content?: Array<ResponsesContentPart>;
+    };
+    id?: string;
+    tool_call_id?: string;
+    tool_use_id?: string;
+    text?: string;
+};
+export type ResponsesToolDefinition = {
+    type: string;
+    name?: string;
+    description?: string;
+    strict?: boolean;
+    parameters?: unknown;
+};

package/dist/conversion/shared/responses-types.js

@@ -0,0 +1 @@
+export {};

package/dist/conversion/shared/tool-call-utils.d.ts

@@ -0,0 +1,11 @@
+type UnknownRecord = Record<string, unknown>;
+/**
+ * Derive a deterministic key for a tool call by combining the normalized
+ * function name and serialized arguments. Used to deduplicate inferred calls.
+ */
+export declare function deriveToolCallKey(call: UnknownRecord | null | undefined): string | null;
+/**
+ * Merge tool call entries with deduplication (by derived key). Returns the new array.
+ */
+export declare function mergeToolCalls(existing: UnknownRecord[] | undefined, additions: UnknownRecord[] | undefined): UnknownRecord[];
+export {};

package/dist/conversion/shared/tool-call-utils.js

@@ -0,0 +1,56 @@
+/**
+ * Derive a deterministic key for a tool call by combining the normalized
+ * function name and serialized arguments. Used to deduplicate inferred calls.
+ */
+export function deriveToolCallKey(call) {
+    if (!call || typeof call !== 'object') {
+        return null;
+    }
+    const fn = call.function;
+    const name = typeof fn?.name === 'string' ? fn.name.trim() : '';
+    const argsRaw = fn?.arguments;
+    let args = '';
+    if (typeof argsRaw === 'string') {
+        args = argsRaw.trim();
+    }
+    else if (argsRaw !== undefined) {
+        try {
+            args = JSON.stringify(argsRaw);
+        }
+        catch {
+            args = '';
+        }
+    }
+    if (!name && !args) {
+        return null;
+    }
+    return `${name}::${args}`;
+}
+/**
+ * Merge tool call entries with deduplication (by derived key). Returns the new array.
+ */
+export function mergeToolCalls(existing, additions) {
+    const base = Array.isArray(existing) ? [...existing] : [];
+    const next = Array.isArray(additions) ? additions : [];
+    if (!next.length) {
+        return base;
+    }
+    const seen = new Set();
+    for (const call of base) {
+        const key = deriveToolCallKey(call);
+        if (key) {
+            seen.add(key);
+        }
+    }
+    for (const call of next) {
+        const key = deriveToolCallKey(call);
+        if (key && seen.has(key)) {
+            continue;
+        }
+        base.push(call);
+        if (key) {
+            seen.add(key);
+        }
+    }
+    return base;
+}

package/dist/conversion/shared/tool-mapping.d.ts

@@ -1,3 +1,5 @@
+import type { ChatToolDefinition } from '../hub/types/chat-envelope.js';
+import type { BridgeToolDefinition } from './bridge-message-types.js';
 export interface ToolCallFunction {
     name: string;
     arguments: string;
@@ -8,3 +10,10 @@ export interface ToolCallItem {
     function: ToolCallFunction;
 }
 export declare function stringifyArgs(args: unknown): string;
+export interface BridgeToolMapOptions {
+    sanitizeName?: (raw: unknown) => string | undefined;
+}
+export declare function bridgeToolToChatDefinition(rawTool: BridgeToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): ChatToolDefinition | null;
+export declare function mapBridgeToolsToChat(rawTools: unknown, options?: BridgeToolMapOptions): ChatToolDefinition[] | undefined;
+export declare function chatToolToBridgeDefinition(rawTool: ChatToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): BridgeToolDefinition | null;
+export declare function mapChatToolsToBridge(rawTools: unknown, options?: BridgeToolMapOptions): BridgeToolDefinition[] | undefined;

package/dist/conversion/shared/tool-mapping.js

@@ -8,3 +8,127 @@ export function stringifyArgs(args) {
         return String(args);
     }
 }
+const DEFAULT_SANITIZER = (value) => {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length ? trimmed : undefined;
+    }
+    return undefined;
+};
+function resolveToolName(candidate, options) {
+    const sanitized = options?.sanitizeName?.(candidate);
+    if (typeof sanitized === 'string' && sanitized.trim().length) {
+        return sanitized.trim();
+    }
+    return DEFAULT_SANITIZER(candidate);
+}
+function pickToolName(candidates, options) {
+    for (const candidate of candidates) {
+        const name = resolveToolName(candidate, options);
+        if (name) {
+            return name;
+        }
+    }
+    return undefined;
+}
+function resolveToolDescription(candidate) {
+    if (typeof candidate === 'string' && candidate.trim().length) {
+        return candidate.trim();
+    }
+    return undefined;
+}
+function resolveToolParameters(container, fallback) {
+    if (container && Object.prototype.hasOwnProperty.call(container, 'parameters')) {
+        return container.parameters;
+    }
+    if (fallback && Object.prototype.hasOwnProperty.call(fallback, 'parameters')) {
+        return fallback.parameters;
+    }
+    return undefined;
+}
+function resolveToolStrict(container, fallback) {
+    if (container && typeof container.strict === 'boolean') {
+        return container.strict;
+    }
+    if (fallback && typeof fallback.strict === 'boolean') {
+        return fallback.strict;
+    }
+    return undefined;
+}
+export function bridgeToolToChatDefinition(rawTool, options) {
+    if (!rawTool || typeof rawTool !== 'object') {
+        return null;
+    }
+    const tool = rawTool;
+    const fnNode = tool.function && typeof tool.function === 'object' ? tool.function : undefined;
+    const name = pickToolName([fnNode?.name, tool.name], options);
+    if (!name) {
+        return null;
+    }
+    const description = resolveToolDescription(fnNode?.description ?? tool.description);
+    const parameters = resolveToolParameters(fnNode, tool);
+    const strict = resolveToolStrict(fnNode, tool);
+    const rawType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
+    const normalizedType = rawType.toLowerCase() === 'custom' ? 'function' : rawType;
+    const fnOut = { name };
+    if (description !== undefined) {
+        fnOut.description = description;
+    }
+    if (parameters !== undefined) {
+        fnOut.parameters = parameters;
+    }
+    if (strict !== undefined) {
+        fnOut.strict = strict;
+    }
+    return {
+        type: normalizedType,
+        function: fnOut
+    };
+}
+export function mapBridgeToolsToChat(rawTools, options) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    const mapped = rawTools
+        .map((entry) => bridgeToolToChatDefinition(entry, options))
+        .filter((entry) => !!entry);
+    return mapped.length ? mapped : undefined;
+}
+export function chatToolToBridgeDefinition(rawTool, options) {
+    if (!rawTool || typeof rawTool !== 'object') {
+        return null;
+    }
+    const tool = rawTool;
+    const fnNode = tool.function && typeof tool.function === 'object' ? tool.function : undefined;
+    const name = pickToolName([fnNode?.name, tool.name], options);
+    if (!name) {
+        return null;
+    }
+    const description = resolveToolDescription(fnNode?.description);
+    const parameters = resolveToolParameters(fnNode, undefined);
+    const strict = resolveToolStrict(fnNode, undefined);
+    const normalizedType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
+    const responseShape = {
+        type: normalizedType,
+        name
+    };
+    if (description !== undefined) {
+        responseShape.description = description;
+    }
+    if (parameters !== undefined) {
+        responseShape.parameters = parameters;
+    }
+    if (strict !== undefined) {
+        responseShape.strict = strict;
+    }
+    return responseShape;
+}
+export function mapChatToolsToBridge(rawTools, options) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    const mapped = rawTools
+        .map((entry) => chatToolToBridgeDefinition(entry, options))
+        .filter((entry) => !!entry);
+    return mapped.length ? mapped : undefined;
+}

package/dist/conversion/shared/tool-normalizers.d.ts

@@ -0,0 +1,4 @@
+import type { ChatToolDefinition, MissingField } from '../hub/types/chat-envelope.js';
+import type { JsonValue } from '../hub/types/json.js';
+export declare function normalizeAnthropicTools(rawTools: JsonValue | undefined, missing?: MissingField[]): ChatToolDefinition[] | undefined;
+export declare function normalizeGeminiTools(rawTools: JsonValue | undefined, missing?: MissingField[]): ChatToolDefinition[] | undefined;

package/dist/conversion/shared/tool-normalizers.js

@@ -0,0 +1,84 @@
+import { isJsonObject, jsonClone } from '../hub/types/json.js';
+export function normalizeAnthropicTools(rawTools, missing) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0)
+        return undefined;
+    const tools = [];
+    rawTools.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            missing?.push({
+                path: `tools[${index}]`,
+                reason: 'invalid_entry',
+                originalValue: jsonClone(entry)
+            });
+            return;
+        }
+        const nameValue = entry.name;
+        if (typeof nameValue !== 'string' || !nameValue.trim())
+            return;
+        const desc = entry.description;
+        const schema = entry.input_schema;
+        const parameters = schema && typeof schema === 'object' && !Array.isArray(schema)
+            ? schema
+            : { type: 'object', properties: {} };
+        tools.push({
+            type: 'function',
+            function: {
+                name: nameValue,
+                description: typeof desc === 'string' ? desc : undefined,
+                parameters
+            }
+        });
+    });
+    return tools.length ? tools : undefined;
+}
+export function normalizeGeminiTools(rawTools, missing) {
+    if (!rawTools)
+        return undefined;
+    const arr = Array.isArray(rawTools) ? rawTools : [rawTools];
+    const tools = [];
+    arr.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object') {
+            missing?.push({
+                path: `tools[${index}]`,
+                reason: 'invalid_entry',
+                originalValue: jsonClone(entry)
+            });
+            return;
+        }
+        const obj = entry;
+        const declarations = Array.isArray(obj.functionDeclarations) ? obj.functionDeclarations : undefined;
+        if (declarations && declarations.length) {
+            declarations.forEach((decl, declIndex) => {
+                if (!decl || typeof decl !== 'object') {
+                    missing?.push({ path: `tools[${index}].functionDeclarations[${declIndex}]`, reason: 'invalid_entry' });
+                    return;
+                }
+                const def = decl;
+                const name = typeof def.name === 'string' ? def.name : undefined;
+                if (!name)
+                    return;
+                tools.push({
+                    type: 'function',
+                    function: {
+                        name,
+                        description: typeof def.description === 'string' ? def.description : undefined,
+                        parameters: isJsonObject(def.parameters) ? jsonClone(def.parameters) : { type: 'object', properties: {} }
+                    }
+                });
+            });
+            return;
+        }
+        const name = typeof obj.name === 'string' ? obj.name : undefined;
+        if (!name)
+            return;
+        tools.push({
+            type: 'function',
+            function: {
+                name,
+                description: typeof obj.description === 'string' ? obj.description : undefined,
+                parameters: isJsonObject(obj.parameters) ? jsonClone(obj.parameters) : { type: 'object', properties: {} }
+            }
+        });
+    });
+    return tools.length ? tools : undefined;
+}

package/dist/router/virtual-router/bootstrap.js

@@ -99,7 +99,8 @@ function buildProviderRuntimeEntries(providers) {
                 auth: runtimeAuth,
                 outboundProfile: normalizedProvider.outboundProfile,
                 compatibilityProfile: normalizedProvider.compatibilityProfile,
-                processMode: normalizedProvider.processMode
+                processMode: normalizedProvider.processMode,
+                responsesConfig: normalizedProvider.responsesConfig
             };
         }
     }
@@ -154,7 +155,8 @@ function buildProviderProfiles(targetKeys, runtimeEntries) {
             compatibilityProfile: runtime.compatibilityProfile,
             runtimeKey,
             modelId: parsed.modelId,
-            processMode: runtime.processMode || 'chat'
+            processMode: runtime.processMode || 'chat',
+            responsesConfig: runtime.responsesConfig
         };
         targetRuntime[targetKey] = {
             ...runtime,
@@ -207,6 +209,7 @@ function normalizeProvider(providerId, raw) {
                 : '';
     const headers = normalizeHeaders(provider.headers);
     const compatibilityProfile = resolveCompatibilityProfile(provider);
+    const responsesConfig = normalizeResponsesConfig(provider);
     const processMode = normalizeProcessMode(provider.process);
     return {
         providerId,
@@ -215,9 +218,21 @@ function normalizeProvider(providerId, raw) {
         headers,
         outboundProfile: mapOutboundProfile(providerType),
         compatibilityProfile,
-        processMode
+        processMode,
+        responsesConfig
     };
 }
+function normalizeResponsesConfig(provider) {
+    const node = asRecord(provider.responses);
+    if (!node) {
+        return undefined;
+    }
+    const rawStyle = typeof node.toolCallIdStyle === 'string' ? node.toolCallIdStyle.trim().toLowerCase() : undefined;
+    if (rawStyle === 'fc' || rawStyle === 'preserve') {
+        return { toolCallIdStyle: rawStyle };
+    }
+    return undefined;
+}
 function resolveCompatibilityProfile(provider) {
     const compat = provider.compat;
     if (typeof compat === 'string' && compat.trim().length > 0) {

package/dist/router/virtual-router/provider-registry.js

@@ -41,7 +41,8 @@ export class ProviderRegistry {
             compatibilityProfile: profile.compatibilityProfile,
             runtimeKey: profile.runtimeKey,
             modelId,
-            processMode: profile.processMode || 'chat'
+            processMode: profile.processMode || 'chat',
+            responsesConfig: profile.responsesConfig
         };
     }
     static normalizeProfile(key, profile) {
@@ -56,7 +57,8 @@ export class ProviderRegistry {
             compatibilityProfile: profile.compatibilityProfile,
             runtimeKey: profile.runtimeKey,
             modelId,
-            processMode: profile.processMode || 'chat'
+            processMode: profile.processMode || 'chat',
+            responsesConfig: profile.responsesConfig
         };
     }
 }

package/dist/router/virtual-router/types.d.ts

@@ -31,6 +31,7 @@ export interface ProviderProfile {
     runtimeKey?: string;
     modelId?: string;
     processMode?: 'chat' | 'passthrough';
+    responsesConfig?: ResponsesProviderConfig;
 }
 export interface ProviderRuntimeProfile {
     runtimeKey: string;
@@ -44,6 +45,7 @@ export interface ProviderRuntimeProfile {
     compatibilityProfile?: string;
     modelId?: string;
     processMode?: 'chat' | 'passthrough';
+    responsesConfig?: ResponsesProviderConfig;
 }
 export interface VirtualRouterClassifierConfig {
     longContextThresholdTokens?: number;
@@ -134,6 +136,10 @@ export interface TargetMetadata {
     runtimeKey?: string;
     modelId: string;
     processMode?: 'chat' | 'passthrough';
+    responsesConfig?: ResponsesProviderConfig;
+}
+export interface ResponsesProviderConfig {
+    toolCallIdStyle?: 'fc' | 'preserve';
 }
 export declare enum VirtualRouterErrorCode {
     NO_STANDARDIZED_REQUEST = "NO_STANDARDIZED_REQUEST",

package/dist/sse/index.d.ts

@@ -4,14 +4,19 @@
  */
 import type { ChatCompletionResponse, ChatJsonToSseOptions, ResponsesJsonToSseOptions, ResponsesResponse, SseToChatJsonOptions, SseToResponsesJsonOptions } from './types/index.js';
 import type { AnthropicMessageResponse } from './types/anthropic-types.js';
+import type { GeminiResponse, GeminiJsonToSseOptions, SseToGeminiJsonOptions } from './types/gemini-types.js';
 import { ChatSseToJsonConverter as ChatSseToJsonConverterCtor } from './sse-to-json/index.js';
 import { ResponsesSseToJsonConverter as ResponsesSseToJsonConverterCtor } from './sse-to-json/index.js';
 import { AnthropicJsonToSseConverter as AnthropicJsonToSseConverterCtor } from './json-to-sse/anthropic-json-to-sse-converter.js';
 import { AnthropicSseToJsonConverter as AnthropicSseToJsonConverterCtor } from './sse-to-json/anthropic-sse-to-json-converter.js';
+import { GeminiJsonToSseConverter as GeminiJsonToSseConverterCtor } from './json-to-sse/gemini-json-to-sse-converter.js';
+import { GeminiSseToJsonConverter as GeminiSseToJsonConverterCtor } from './sse-to-json/gemini-sse-to-json-converter.js';
 export { ChatJsonToSseConverter } from './json-to-sse/index.js';
 export { ChatSseToJsonConverter } from './sse-to-json/index.js';
 export { ResponsesJsonToSseConverter } from './json-to-sse/index.js';
 export { ResponsesSseToJsonConverter } from './sse-to-json/index.js';
+export { GeminiJsonToSseConverter } from './json-to-sse/index.js';
+export { GeminiSseToJsonConverter } from './sse-to-json/index.js';
 export * from './shared/utils.js';
 export * from './types/index.js';
 /**
@@ -45,8 +50,18 @@ export declare function createAnthropicConverters(): {
     roundTrip(input: AnthropicMessageResponse, options: {
         requestId: string;
         model: string;
+        reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+        reasoningTextPrefix?: string;
     }): Promise<AnthropicMessageResponse>;
 };
+/**
+ * 工厂函数：创建Gemini协议转换器
+ */
+export declare function createGeminiConverters(): {
+    jsonToSse: GeminiJsonToSseConverterCtor;
+    sseToJson: GeminiSseToJsonConverterCtor;
+    roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+};
 /**
  * 工厂函数：创建完整的双向转换器（支持Chat和Responses协议）
  */
@@ -73,12 +88,19 @@ export declare function createBidirectionalConverters(): {
         roundTrip(input: AnthropicMessageResponse, options: {
             requestId: string;
             model: string;
+            reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+            reasoningTextPrefix?: string;
         }): Promise<AnthropicMessageResponse>;
     };
+    gemini: {
+        jsonToSse: GeminiJsonToSseConverterCtor;
+        sseToJson: GeminiSseToJsonConverterCtor;
+        roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+    };
     /**
      * 自动检测协议类型并执行转换
      */
-    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse>;
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse | GeminiResponse>;
 };
 /**
  * 默认转换器实例
@@ -122,12 +144,19 @@ export declare const bidirectionalConverters: {
         roundTrip(input: AnthropicMessageResponse, options: {
             requestId: string;
             model: string;
+            reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+            reasoningTextPrefix?: string;
         }): Promise<AnthropicMessageResponse>;
     };
+    gemini: {
+        jsonToSse: GeminiJsonToSseConverterCtor;
+        sseToJson: GeminiSseToJsonConverterCtor;
+        roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+    };
     /**
      * 自动检测协议类型并执行转换
      */
-    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse>;
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse | GeminiResponse>;
 };
 export declare const anthropicConverters: {
     jsonToSse: AnthropicJsonToSseConverterCtor;
@@ -135,6 +164,13 @@ export declare const anthropicConverters: {
     roundTrip(input: AnthropicMessageResponse, options: {
         requestId: string;
         model: string;
+        reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+        reasoningTextPrefix?: string;
     }): Promise<AnthropicMessageResponse>;
 };
+export declare const geminiConverters: {
+    jsonToSse: GeminiJsonToSseConverterCtor;
+    sseToJson: GeminiSseToJsonConverterCtor;
+    roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+};
 export { defaultSseCodecRegistry, SseCodecRegistry, type SseCodec, type SseProtocol, type JsonToSseContext, type SseToJsonContext, type NormalizeSseContext } from './registry/sse-codec-registry.js';