@jsonstudio/llms 0.6.3409 → 0.6.3541

package/dist/conversion/codecs/anthropic-openai-codec.d.ts

@@ -1,7 +1,16 @@
 import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
-import { buildAnthropicFromOpenAIChat, buildOpenAIChatFromAnthropic } from '../shared/anthropic-message-utils.js';
-export { buildAnthropicFromOpenAIChat, buildOpenAIChatFromAnthropic };
-export { buildAnthropicRequestFromOpenAIChat } from '../shared/anthropic-message-utils.js';
+import { buildAnthropicRequestFromOpenAIChat } from '../shared/anthropic-message-utils.js';
+export declare function buildOpenAIChatFromAnthropic(payload: unknown, options?: {
+    includeToolCallIds?: boolean;
+}): {
+    messages: unknown[];
+} & Record<string, unknown>;
+export declare function buildAnthropicFromOpenAIChat(payload: unknown, options?: {
+    toolNameMap?: Record<string, string>;
+    requestId?: string;
+    entryEndpoint?: string;
+}): Record<string, unknown>;
+export { buildAnthropicRequestFromOpenAIChat };
 export declare class AnthropicOpenAIConversionCodec implements ConversionCodec {
     private readonly _dependencies;
     readonly id = "anthropic-openai";

package/dist/conversion/codecs/anthropic-openai-codec.js

@@ -1,8 +1,13 @@
-import { runStandardChatRequestFilters } from '../index.js';
-import { FilterEngine, ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } from '../../filters/index.js';
-import { buildAnthropicFromOpenAIChat, buildOpenAIChatFromAnthropic, mapAnthropicToolsToChat, buildAnthropicToolAliasMap } from '../shared/anthropic-message-utils.js';
-export { buildAnthropicFromOpenAIChat, buildOpenAIChatFromAnthropic };
-export { buildAnthropicRequestFromOpenAIChat } from '../shared/anthropic-message-utils.js';
+import { buildAnthropicRequestFromOpenAIChat } from '../shared/anthropic-message-utils.js';
+import { buildAnthropicFromOpenAIChatWithNative, buildOpenAIChatFromAnthropicWithNative } from '../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+export function buildOpenAIChatFromAnthropic(payload, options) {
+    const result = buildOpenAIChatFromAnthropicWithNative((payload ?? {}), options);
+    return (result.request ?? {});
+}
+export function buildAnthropicFromOpenAIChat(payload, options) {
+    return buildAnthropicFromOpenAIChatWithNative((payload ?? {}), options);
+}
+export { buildAnthropicRequestFromOpenAIChat };
 export class AnthropicOpenAIConversionCodec {
     _dependencies;
     id = 'anthropic-openai';
@@ -11,102 +16,37 @@ export class AnthropicOpenAIConversionCodec {
     constructor(_dependencies) {
         this._dependencies = _dependencies;
     }
-    async initialize() { this.initialized = true; }
+    async initialize() {
+        this.initialized = true;
+    }
     async convertRequest(payload, _profile, context) {
-        if (!this.initialized) {
+        if (!this.initialized)
             await this.initialize();
-        }
-        const model = String(payload?.model || 'unknown');
-        const { messages } = buildOpenAIChatFromAnthropic(payload, { includeToolCallIds: true });
-        const out = { model, messages };
-        const aliasMap = buildAnthropicToolAliasMap(payload?.tools);
-        if (aliasMap) {
+        const native = buildOpenAIChatFromAnthropicWithNative(payload ?? {}, {
+            includeToolCallIds: true
+        });
+        const request = native.request && typeof native.request === 'object'
+            ? { ...native.request }
+            : {};
+        const aliasMap = native.anthropicToolNameMap && typeof native.anthropicToolNameMap === 'object'
+            ? native.anthropicToolNameMap
+            : undefined;
+        if (aliasMap && Object.keys(aliasMap).length > 0) {
             context.metadata = context.metadata ?? {};
             context.metadata.anthropicToolNameMap = aliasMap;
         }
-        // 最小必要的形状转换：Anthropic tools → OpenAI Chat function 工具
-        try {
-            const normalizedTools = mapAnthropicToolsToChat(payload?.tools);
-            if (normalizedTools) {
-                out.tools = normalizedTools;
-            }
-        }
-        catch { /* keep tools undefined on failure */ }
-        if (Array.isArray(payload?.stop_sequences)) {
-            out.stop = payload.stop_sequences;
-        }
-        if (typeof payload?.temperature === 'number') {
-            out.temperature = payload.temperature;
-        }
-        if (typeof payload?.top_p === 'number') {
-            out.top_p = payload.top_p;
-        }
-        if (typeof payload?.max_tokens === 'number') {
-            out.max_tokens = payload.max_tokens;
-        }
-        // 不设置默认 tool_choice；统一由 Chat 后半段治理
-        // 统一流控：非流式由核心过滤器处理；此处不设置 stream
-        // 统一走 Chat 请求过滤链路，使 /v1/messages 与 /v1/chat 在工具治理上保持一致
-        const ctxForFilters = {
-            ...context,
-            requestId: context.requestId ?? `req_${Date.now()}`,
-            entryEndpoint: context.entryEndpoint ?? context.endpoint,
-            endpoint: context.endpoint
-        };
-        return runStandardChatRequestFilters(out, _profile, ctxForFilters);
+        return request;
     }
     async convertResponse(payload, _profile, context) {
-        if (!this.initialized) {
+        if (!this.initialized)
             await this.initialize();
-        }
-        // 如果是 /v1/messages 且请求端声明了流式（或需要伪流式），合成 Anthropic SSE 流并透传给上层
-        // 对非流式 JSON 响应，先在 OpenAI Chat canonical 上运行统一的响应工具治理，
-        // 再映射回 Anthropic Messages 形状，保证与 /v1/chat 路径的行为一致。
-        const dto = {
-            data: payload,
-            metadata: {
-                requestId: context.requestId ?? `req_${Date.now()}`,
-                pipelineId: context.metadata?.pipelineId ?? 'conversion-router',
-                processingTime: 0,
-                stages: []
-            }
-        };
-        const resCtxBase = {
-            requestId: context.requestId ?? dto.metadata.requestId,
-            model: undefined,
-            endpoint: context.entryEndpoint || context.endpoint,
-            profile: 'openai-chat',
-            debug: { emit: () => { } }
-        };
-        const engine = new FilterEngine();
-        engine.registerFilter(new ResponseToolTextCanonicalizeFilter());
-        engine.registerFilter(new ResponseToolArgumentsStringifyFilter());
-        engine.registerFilter(new ResponseFinishInvariantsFilter());
-        let staged = await engine.run('response_pre', dto.data, resCtxBase);
-        staged = await engine.run('response_map', staged, resCtxBase);
-        staged = await engine.run('response_post', staged, resCtxBase);
-        const governedChat = staged;
-        const aliasMap = coerceAliasMap(context.metadata?.anthropicToolNameMap);
-        return buildAnthropicFromOpenAIChat(governedChat, {
+        const aliasMap = context.metadata && typeof context.metadata === 'object'
+            ? context.metadata.anthropicToolNameMap
+            : undefined;
+        return buildAnthropicFromOpenAIChatWithNative((payload ?? {}), {
             toolNameMap: aliasMap,
-            requestId: context.requestId
+            requestId: context.requestId,
+            entryEndpoint: context.entryEndpoint ?? context.endpoint
         });
     }
 }
-function coerceAliasMap(candidate) {
-    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
-        return undefined;
-    }
-    let populated = false;
-    const map = {};
-    for (const [key, value] of Object.entries(candidate)) {
-        if (typeof key !== 'string' || typeof value !== 'string')
-            continue;
-        const trimmedKey = key.trim();
-        if (!trimmedKey.length)
-            continue;
-        map[trimmedKey] = value;
-        populated = true;
-    }
-    return populated ? map : undefined;
-}

package/dist/conversion/codecs/gemini-openai-codec.d.ts

@@ -1,9 +1,10 @@
 import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
-export declare function buildOpenAIChatFromGeminiRequest(payload: any): {
-    messages: any[];
-};
-export declare function buildOpenAIChatFromGeminiResponse(payload: any): any;
-export declare function buildGeminiFromOpenAIChat(chatResp: any): any;
+import type { JsonObject, JsonValue } from '../hub/types/json.js';
+export declare function buildOpenAIChatFromGeminiRequest(payload: unknown): {
+    messages: JsonValue[];
+} & JsonObject;
+export declare function buildOpenAIChatFromGeminiResponse(payload: unknown): JsonObject;
+export declare function buildGeminiFromOpenAIChat(chatResp: unknown): JsonObject;
 export declare class GeminiOpenAIConversionCodec implements ConversionCodec {
     private readonly _dependencies;
     readonly id = "gemini-openai";