@jsonstudio/llms 0.4.6 → 0.6.2

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

@@ -1,6 +1,6 @@
 import { runStandardChatRequestFilters } from '../index.js';
 import { FilterEngine, ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } from '../../filters/index.js';
-import { buildAnthropicFromOpenAIChat, buildOpenAIChatFromAnthropic, mapAnthropicToolsToChat } from '../shared/anthropic-message-utils.js';
+import { buildAnthropicFromOpenAIChat, buildOpenAIChatFromAnthropic, mapAnthropicToolsToChat, buildAnthropicToolAliasMap } from '../shared/anthropic-message-utils.js';
 export { buildAnthropicFromOpenAIChat, buildOpenAIChatFromAnthropic };
 export { buildAnthropicRequestFromOpenAIChat } from '../shared/anthropic-message-utils.js';
 export class AnthropicOpenAIConversionCodec {
@@ -19,6 +19,11 @@ export class AnthropicOpenAIConversionCodec {
         const model = String(payload?.model || 'unknown');
         const { messages } = buildOpenAIChatFromAnthropic(payload);
         const out = { model, messages };
+        const aliasMap = buildAnthropicToolAliasMap(payload?.tools);
+        if (aliasMap) {
+            context.metadata = context.metadata ?? {};
+            context.metadata.anthropicToolNameMap = aliasMap;
+        }
         // 最小必要的形状转换：Anthropic tools → OpenAI Chat function 工具
         try {
             const normalizedTools = mapAnthropicToolsToChat(payload?.tools);
@@ -86,6 +91,27 @@ export class AnthropicOpenAIConversionCodec {
         staged = await engine.run('response_map', staged, resCtxBase);
         staged = await engine.run('response_post', staged, resCtxBase);
         const governedChat = staged;
-        return buildAnthropicFromOpenAIChat(governedChat);
+        const aliasMap = coerceAliasMap(context.metadata?.anthropicToolNameMap);
+        return buildAnthropicFromOpenAIChat(governedChat, {
+            toolNameMap: aliasMap,
+            requestId: context.requestId
+        });
+    }
+}
+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.js

@@ -3,6 +3,7 @@ import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-poli
 import { normalizeChatMessageContent } from '../shared/chat-output-normalizer.js';
 import { mapBridgeToolsToChat } from '../shared/tool-mapping.js';
 import { prepareGeminiToolsForBridge } from '../shared/gemini-tool-utils.js';
+import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta } from '../shared/responses-reasoning-registry.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -276,6 +277,14 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     if (Object.keys(usage).length > 0) {
         chatResp.usage = usage;
     }
+    const preservedReasoning = consumeResponsesReasoning(chatResp.id);
+    if (preservedReasoning && preservedReasoning.length) {
+        chatResp.__responses_reasoning = preservedReasoning;
+    }
+    const preservedOutputMeta = consumeResponsesOutputTextMeta(chatResp.id);
+    if (preservedOutputMeta) {
+        chatResp.__responses_output_text_meta = preservedOutputMeta;
+    }
     return chatResp;
 }
 export function buildGeminiFromOpenAIChat(chatResp) {
@@ -344,6 +353,12 @@ export function buildGeminiFromOpenAIChat(chatResp) {
     if (contentText && contentText.length) {
         parts.push({ text: contentText });
     }
+    const reasoningText = typeof msg?.reasoning_content === 'string' && msg.reasoning_content.trim().length
+        ? String(msg.reasoning_content).trim()
+        : undefined;
+    if (reasoningText) {
+        parts.push({ reasoning: reasoningText });
+    }
     const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
     for (const tc of toolCalls) {
         if (!tc || typeof tc !== 'object')
@@ -388,7 +403,9 @@ export function buildGeminiFromOpenAIChat(chatResp) {
         usageMetadata.candidatesTokenCount = completionTokens;
     if (Number.isFinite(totalTokens))
         usageMetadata.totalTokenCount = totalTokens;
+    const responseId = typeof chatResp?.id === 'string' ? String(chatResp.id) : `chatcmpl_${Date.now()}`;
     const out = {
+        id: responseId,
         candidates: [candidate]
     };
     if (chatResp?.model) {
@@ -396,6 +413,12 @@ export function buildGeminiFromOpenAIChat(chatResp) {
     }
     if (Object.keys(usageMetadata).length > 0)
         out.usageMetadata = usageMetadata;
+    if (Array.isArray(chatResp?.__responses_reasoning)) {
+        registerResponsesReasoning(responseId, chatResp.__responses_reasoning);
+    }
+    if (chatResp?.__responses_output_text_meta) {
+        registerResponsesOutputTextMeta(responseId, chatResp.__responses_output_text_meta);
+    }
     return out;
 }
 export class GeminiOpenAIConversionCodec {

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

@@ -151,7 +151,14 @@ export class ResponsesOpenAIConversionCodec {
         // Debug snapshot after mapping to Responses JSON (non-stream)
         try {
             const { writeSnapshotViaHooks } = await import('../shared/snapshot-hooks.js');
-            await writeSnapshotViaHooks({ endpoint: '/v1/responses', stage: 'response_mapped_json', requestId: context.requestId || `req_${Date.now()}`, data: responsesJson, verbosity: 'verbose' });
+            await writeSnapshotViaHooks({
+                endpoint: '/v1/responses',
+                stage: 'response_mapped_json',
+                requestId: context.requestId || `req_${Date.now()}`,
+                data: responsesJson,
+                channel: 'responses',
+                verbosity: 'verbose'
+            });
         }
         catch { /* ignore */ }
         return responsesJson;

package/dist/conversion/hub/node-support.js

@@ -102,7 +102,7 @@ function deriveAdapterContext(context, fallbackProtocol) {
         (typeof metadata.providerProtocol === 'string' ? metadata.providerProtocol : undefined) ||
         fallbackProtocol;
     const streamingHint = metadata.stream === true ? 'force' : metadata.stream === false ? 'disable' : 'auto';
-    const toolCallIdStyle = typeof metadata.toolCallIdStyle === 'string' ? metadata.toolCallIdStyle : undefined;
+    const toolCallIdStyle = normalizeToolCallIdStyleCandidate(metadata.toolCallIdStyle);
     return {
         requestId: context.request.id,
         entryEndpoint: (typeof requestContext.entryEndpoint === 'string' ? requestContext.entryEndpoint : context.request.endpoint) ||
@@ -115,3 +115,16 @@ function deriveAdapterContext(context, fallbackProtocol) {
         toolCallIdStyle
     };
 }
+function normalizeToolCallIdStyleCandidate(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'fc') {
+        return 'fc';
+    }
+    if (normalized === 'preserve') {
+        return 'preserve';
+    }
+    return undefined;
+}

package/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -0,0 +1,66 @@
+import { Readable } from 'node:stream';
+import type { StandardizedRequest, ProcessedRequest } from '../types/standardized.js';
+import type { JsonObject } from '../types/json.js';
+import type { VirtualRouterConfig, RoutingDecision, RoutingDiagnostics, TargetMetadata } from '../../../router/virtual-router/types.js';
+import { type HubProcessNodeResult } from '../process/chat-process.js';
+export interface HubPipelineConfig {
+    virtualRouter: VirtualRouterConfig;
+}
+export interface HubPipelineRequestMetadata extends Record<string, unknown> {
+    entryEndpoint?: string;
+    providerProtocol?: string;
+    processMode?: 'chat' | 'passthrough';
+    stage?: 'inbound' | 'outbound';
+    direction?: 'request' | 'response';
+    stream?: boolean;
+    routeHint?: string;
+}
+export interface HubPipelineRequest {
+    id?: string;
+    endpoint: string;
+    payload: Record<string, unknown> | {
+        readable?: Readable;
+    } | Readable;
+    metadata?: HubPipelineRequestMetadata;
+}
+type HubPipelineNodeMetadata = HubProcessNodeResult['metadata'] | Record<string, unknown>;
+export interface HubPipelineNodeResult {
+    id: string;
+    success: boolean;
+    metadata: HubPipelineNodeMetadata;
+    error?: JsonObject;
+}
+export interface HubPipelineResult {
+    requestId: string;
+    providerPayload?: Record<string, unknown>;
+    standardizedRequest?: StandardizedRequest;
+    processedRequest?: ProcessedRequest;
+    routingDecision?: RoutingDecision;
+    routingDiagnostics?: RoutingDiagnostics;
+    target?: TargetMetadata;
+    metadata: Record<string, unknown>;
+    nodeResults: HubPipelineNodeResult[];
+}
+export declare class HubPipeline {
+    private readonly routerEngine;
+    private config;
+    constructor(config: HubPipelineConfig);
+    updateVirtualRouterConfig(nextConfig: VirtualRouterConfig): void;
+    private executeRequestStagePipeline;
+    execute(request: HubPipelineRequest): Promise<HubPipelineResult>;
+    private captureAnthropicAliasMap;
+    private shouldCaptureAnthropicAlias;
+    private resolveAliasMapFromSources;
+    private resolveProtocolHooks;
+    private buildAdapterContext;
+    private maybeCreateStageRecorder;
+    private asJsonObject;
+    private normalizeRequest;
+    private convertProcessNodeResult;
+    private materializePayload;
+    private unwrapReadable;
+    private convertSsePayload;
+    private resolveSseProtocol;
+    private extractModelHint;
+}
+export {};