@jsonstudio/llms 0.4.3 → 0.4.5

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

@@ -1,3 +1,8 @@
+import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
+import { normalizeChatMessageContent } from '../shared/chat-output-normalizer.js';
+import { mapBridgeToolsToChat } from '../shared/tool-mapping.js';
+import { prepareGeminiToolsForBridge } from '../shared/gemini-tool-utils.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -48,49 +53,6 @@ function mapChatRoleToGemini(role) {
         return 'tool';
     return 'user';
 }
-function mapGeminiToolsToOpenAI(tools) {
-    const out = [];
-    if (!tools)
-        return out;
-    const arr = Array.isArray(tools) ? tools : [tools];
-    for (const t of arr) {
-        if (!t || typeof t !== 'object')
-            continue;
-        const tObj = t;
-        const fds = Array.isArray(tObj.functionDeclarations) ? tObj.functionDeclarations : [];
-        if (fds.length) {
-            for (const fd of fds) {
-                if (!fd || typeof fd !== 'object')
-                    continue;
-                const name = typeof fd.name === 'string' ? String(fd.name) : undefined;
-                if (!name)
-                    continue;
-                const description = typeof fd.description === 'string' ? String(fd.description) : undefined;
-                const parameters = isObject(fd.parameters)
-                    ? JSON.parse(JSON.stringify(fd.parameters))
-                    : { type: 'object', properties: {} };
-                const fn = { name, parameters };
-                if (description)
-                    fn.description = description;
-                out.push({ type: 'function', function: fn });
-            }
-            continue;
-        }
-        // 单个函数声明形状：直接把对象视为 FunctionDeclaration
-        const name = typeof tObj.name === 'string' ? String(tObj.name) : undefined;
-        if (name) {
-            const description = typeof tObj.description === 'string' ? String(tObj.description) : undefined;
-            const parameters = isObject(tObj.parameters)
-                ? JSON.parse(JSON.stringify(tObj.parameters))
-                : { type: 'object', properties: {} };
-            const fn = { name, parameters };
-            if (description)
-                fn.description = description;
-            out.push({ type: 'function', function: fn });
-        }
-    }
-    return out;
-}
 export function buildOpenAIChatFromGeminiRequest(payload) {
     const messages = [];
     // systemInstruction → Chat system 消息
@@ -160,8 +122,21 @@ export function buildOpenAIChatFromGeminiRequest(payload) {
                 continue;
             }
         }
-        if (textParts.length > 0 || toolCalls.length > 0) {
-            const msg = { role, content: textParts.join('\n') };
+        const combinedText = textParts.join('\n');
+        const normalized = combinedText.length ? normalizeChatMessageContent(combinedText) : { contentText: undefined, reasoningText: undefined };
+        const hasText = typeof normalized.contentText === 'string' && normalized.contentText.length > 0;
+        const reasoningChunks = [];
+        if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+            reasoningChunks.push(normalized.reasoningText.trim());
+        }
+        if (hasText || toolCalls.length > 0 || reasoningChunks.length > 0) {
+            const msg = {
+                role,
+                content: normalized.contentText ?? combinedText ?? ''
+            };
+            if (reasoningChunks.length) {
+                msg.reasoning_content = reasoningChunks.join('\n');
+            }
             if (toolCalls.length)
                 msg.tool_calls = toolCalls;
             messages.push(msg);
@@ -178,6 +153,7 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     const role = mapGeminiRoleToChat(content.role);
     const parts = Array.isArray(content.parts) ? content.parts : [];
     const textParts = [];
+    const reasoningParts = [];
     const toolCalls = [];
     for (const part of parts) {
         if (!part || typeof part !== 'object')
@@ -189,6 +165,21 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
                 textParts.push(t);
             continue;
         }
+        if (Array.isArray(pObj.content)) {
+            for (const inner of pObj.content) {
+                if (typeof inner === 'string') {
+                    textParts.push(inner);
+                }
+                else if (inner && typeof inner === 'object' && typeof inner.text === 'string') {
+                    textParts.push(inner.text);
+                }
+            }
+            continue;
+        }
+        if (typeof pObj.reasoning === 'string') {
+            reasoningParts.push(pObj.reasoning);
+            continue;
+        }
         if (pObj.functionCall && typeof pObj.functionCall === 'object') {
             const fc = pObj.functionCall;
             const name = typeof fc.name === 'string' ? String(fc.name) : undefined;
@@ -234,13 +225,42 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
         usage.completion_tokens = completionTokens;
     if (Number.isFinite(totalTokens))
         usage.total_tokens = totalTokens;
+    const combinedText = textParts.join('\n');
+    const normalized = combinedText.length ? normalizeChatMessageContent(combinedText) : { contentText: undefined, reasoningText: undefined };
     const chatMsg = {
         role,
-        content: textParts.join('\n')
+        content: normalized.contentText ?? combinedText ?? ''
     };
+    if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+        reasoningParts.push(normalized.reasoningText.trim());
+    }
+    if (reasoningParts.length) {
+        chatMsg.reasoning_content = reasoningParts.join('\n');
+    }
     if (toolCalls.length) {
         chatMsg.tool_calls = toolCalls;
     }
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'gemini-chat' });
+        const actions = resolvePolicyActions(bridgePolicy, 'response_inbound');
+        if (actions?.length) {
+            const actionState = createBridgeActionState({
+                messages: [chatMsg],
+                rawResponse: isObject(payload) ? payload : undefined
+            });
+            runBridgeActionPipeline({
+                stage: 'response_inbound',
+                actions,
+                protocol: bridgePolicy?.protocol ?? 'gemini-chat',
+                moduleType: bridgePolicy?.moduleType ?? 'gemini-chat',
+                requestId: typeof payload?.id === 'string' ? String(payload.id) : undefined,
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // best-effort policy execution
+    }
     const chatResp = {
         id: payload?.id || `chatcmpl_${Date.now()}`,
         object: 'chat.completion',
@@ -276,6 +296,28 @@ export function buildGeminiFromOpenAIChat(chatResp) {
         return 'STOP';
     })();
     const baseRole = mapChatRoleToGemini(msg.role || 'assistant');
+    if (msg) {
+        try {
+            const bridgePolicy = resolveBridgePolicy({ protocol: 'gemini-chat' });
+            const actions = resolvePolicyActions(bridgePolicy, 'response_outbound');
+            if (actions?.length) {
+                const actionState = createBridgeActionState({
+                    messages: [msg]
+                });
+                runBridgeActionPipeline({
+                    stage: 'response_outbound',
+                    actions,
+                    protocol: bridgePolicy?.protocol ?? 'gemini-chat',
+                    moduleType: bridgePolicy?.moduleType ?? 'gemini-chat',
+                    requestId: typeof chatResp?.id === 'string' ? String(chatResp.id) : undefined,
+                    state: actionState
+                });
+            }
+        }
+        catch {
+            // ignore policy failures
+        }
+    }
     const parts = [];
     const contentText = (() => {
         const raw = msg.content;
@@ -377,8 +419,9 @@ export class GeminiOpenAIConversionCodec {
         const { messages } = buildOpenAIChatFromGeminiRequest(payload);
         const out = { model, messages };
         try {
-            const tools = mapGeminiToolsToOpenAI(payload?.tools);
-            if (tools.length > 0)
+            const bridgeTools = prepareGeminiToolsForBridge(payload?.tools);
+            const tools = bridgeTools ? mapBridgeToolsToChat(bridgeTools) : undefined;
+            if (tools && tools.length > 0)
                 out.tools = tools;
         }
         catch {

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

@@ -1,5 +1,5 @@
 import { buildResponsesPayloadFromChat, runStandardChatRequestFilters } from '../index.js';
-import { captureResponsesContext, buildChatRequestFromResponses } from '../shared/responses-request-adapter.js';
+import { captureResponsesContext, buildChatRequestFromResponses } from '../responses/responses-openai-bridge.js';
 import { FilterEngine, ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } from '../../filters/index.js';
 // Ported from root package (no behavior change). Types relaxed.
 export class ResponsesOpenAIConversionCodec {
@@ -82,7 +82,14 @@ export class ResponsesOpenAIConversionCodec {
             entryEndpoint: context.entryEndpoint ?? dto.metadata?.entryEndpoint ?? context.endpoint,
             endpoint: context.endpoint ?? dto.metadata?.endpoint
         };
-        return runStandardChatRequestFilters(chatRequest, profile, ctxForFilters);
+        const filtered = await runStandardChatRequestFilters(chatRequest, profile, ctxForFilters);
+        if (filtered && typeof filtered === 'object') {
+            const maybe = filtered;
+            if (maybe.max_tokens === undefined && typeof maybe.max_output_tokens === 'number') {
+                maybe.max_tokens = maybe.max_output_tokens;
+            }
+        }
+        return filtered;
     }
     async convertResponse(payload, _profile, context) {
         await this.ensureInit();

package/dist/conversion/hub/format-adapters/anthropic-format-adapter.js

@@ -1,6 +1,8 @@
+import { normalizeReasoningInAnthropicPayload } from '../../shared/reasoning-normalizer.js';
 export class AnthropicFormatAdapter {
     protocol = 'anthropic-messages';
     async parseRequest(original, _ctx) {
+        normalizeReasoningInAnthropicPayload(original);
         return {
             protocol: this.protocol,
             direction: 'request',
@@ -11,6 +13,7 @@ export class AnthropicFormatAdapter {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
+        normalizeReasoningInAnthropicPayload(original);
         return {
             protocol: this.protocol,
             direction: 'response',

package/dist/conversion/hub/format-adapters/chat-format-adapter.js

@@ -1,6 +1,8 @@
+import { normalizeReasoningInChatPayload } from '../../shared/reasoning-normalizer.js';
 export class ChatFormatAdapter {
     protocol = 'openai-chat';
     async parseRequest(original, _ctx) {
+        normalizeReasoningInChatPayload(original);
         return {
             protocol: this.protocol,
             direction: 'request',
@@ -11,6 +13,7 @@ export class ChatFormatAdapter {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
+        normalizeReasoningInChatPayload(original);
         return {
             protocol: this.protocol,
             direction: 'response',

package/dist/conversion/hub/format-adapters/gemini-format-adapter.js

@@ -1,6 +1,8 @@
+import { normalizeReasoningInGeminiPayload } from '../../shared/reasoning-normalizer.js';
 export class GeminiFormatAdapter {
     protocol = 'gemini-chat';
     async parseRequest(original, _ctx) {
+        normalizeReasoningInGeminiPayload(original);
         return {
             protocol: this.protocol,
             direction: 'request',
@@ -11,6 +13,7 @@ export class GeminiFormatAdapter {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
+        normalizeReasoningInGeminiPayload(original);
         return {
             protocol: this.protocol,
             direction: 'response',

package/dist/conversion/hub/format-adapters/responses-format-adapter.d.ts

@@ -6,6 +6,8 @@ interface ResponsesFormatPayload extends JsonObject {
     input?: JsonValue[];
     tools?: JsonValue[];
     tool_outputs?: JsonValue[];
+    output?: JsonValue[];
+    id?: string;
 }
 export declare class ResponsesFormatAdapter implements FormatAdapter {
     readonly protocol = "openai-responses";

package/dist/conversion/hub/format-adapters/responses-format-adapter.js

@@ -1,6 +1,11 @@
+import { normalizeReasoningInResponsesPayload } from '../../shared/reasoning-normalizer.js';
 export class ResponsesFormatAdapter {
     protocol = 'openai-responses';
     async parseRequest(original, _ctx) {
+        normalizeReasoningInResponsesPayload(original, {
+            includeInput: true,
+            includeInstructions: true
+        });
         return {
             protocol: this.protocol,
             direction: 'request',
@@ -11,6 +16,10 @@ export class ResponsesFormatAdapter {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
+        normalizeReasoningInResponsesPayload(original, {
+            includeOutput: true,
+            includeRequiredAction: true
+        });
         return {
             protocol: this.protocol,
             direction: 'response',

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

@@ -102,6 +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;
     return {
         requestId: context.request.id,
         entryEndpoint: (typeof requestContext.entryEndpoint === 'string' ? requestContext.entryEndpoint : context.request.endpoint) ||
@@ -110,6 +111,7 @@ function deriveAdapterContext(context, fallbackProtocol) {
         providerId: (target?.providerKey || metadata.providerKey),
         routeId: metadata.routeName,
         profileId: metadata.pipelineId,
-        streamingHint
+        streamingHint,
+        toolCallIdStyle
     };
 }

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -85,7 +85,7 @@ export class HubPipeline {
         });
         return {
             processedRequest: processResult.processedRequest,
-            nodeResult: this.convertV3NodeResult('hub-chat-process', processResult.nodeResult)
+            nodeResult: this.convertProcessNodeResult('hub-chat-process', processResult.nodeResult)
         };
     }
     routeRequest(request, normalized) {
@@ -121,6 +121,9 @@ export class HubPipeline {
         metadata.providerType = target.providerType;
         metadata.modelId = target.modelId;
         metadata.processMode = target.processMode || 'chat';
+        if (target.responsesConfig?.toolCallIdStyle) {
+            metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
+        }
         if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
             const trimmed = originalModel.trim();
             if (typeof metadata.originalModelId !== 'string' || !metadata.originalModelId) {
@@ -237,9 +240,7 @@ export class HubPipeline {
         const entryEndpoint = typeof metadataRecord.entryEndpoint === 'string'
             ? normalizeEndpoint(metadataRecord.entryEndpoint)
             : endpoint;
-        const providerProtocol = typeof metadataRecord.providerProtocol === 'string'
-            ? metadataRecord.providerProtocol
-            : inferProviderProtocol(entryEndpoint);
+        const providerProtocol = resolveProviderProtocol(metadataRecord.providerProtocol);
         const processMode = metadataRecord.processMode === 'passthrough' ? 'passthrough' : 'chat';
         const direction = metadataRecord.direction === 'response' ? 'response' : 'request';
         const stage = metadataRecord.stage === 'outbound' ? 'outbound' : 'inbound';
@@ -299,17 +300,16 @@ export class HubPipeline {
             error: result.error
         };
     }
-    convertV3NodeResult(id, result) {
+    convertProcessNodeResult(id, result) {
         return {
             id,
             success: result.success,
             metadata: result.metadata,
             error: result.error
                 ? {
-                    code: result.error.code,
+                    code: result.error.code ?? 'hub_chat_process_error',
                     message: result.error.message,
-                    details: result.error.details,
-                    cause: result.error.cause
+                    details: result.error.details
                 }
                 : undefined
         };
@@ -359,15 +359,11 @@ export class HubPipeline {
         }
     }
     resolveSseProtocol(context) {
-        const providerMeta = context.metadata.provider ?? undefined;
-        const profile = typeof providerMeta?.profile === 'string' ? providerMeta.profile : undefined;
-        const providerProtocol = typeof context.metadata.providerProtocol === 'string'
-            ? context.metadata.providerProtocol
-            : context.providerProtocol;
-        const routeHint = typeof context.metadata.routeHint === 'string'
-            ? context.metadata.routeHint
-            : undefined;
-        return inferSseProtocol(routeHint, providerProtocol, context.entryEndpoint);
+        const explicitProtocol = resolveSseProtocolFromMetadata(context.metadata);
+        if (explicitProtocol) {
+            return explicitProtocol;
+        }
+        return context.providerProtocol;
     }
     extractModelHint(metadata) {
         if (typeof metadata.model === 'string' && metadata.model.trim()) {
@@ -396,26 +392,34 @@ function normalizeEndpoint(endpoint) {
     const normalized = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
     return normalized.replace(/\/{2,}/g, '/');
 }
-function inferProviderProtocol(endpoint) {
-    const lowered = endpoint.toLowerCase();
-    if (lowered.includes('/v1/messages'))
-        return 'anthropic-messages';
-    if (lowered.includes('/v1/responses'))
-        return 'openai-responses';
-    if (lowered.includes('/v1beta'))
-        return 'gemini-chat';
-    return 'openai-chat';
+function resolveProviderProtocol(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        return 'openai-chat';
+    }
+    const normalized = value.trim().toLowerCase();
+    const mapped = PROVIDER_PROTOCOL_ALIASES[normalized];
+    if (mapped) {
+        return mapped;
+    }
+    throw new Error(`[HubPipeline] Unsupported providerProtocol "${value}". Configure a valid protocol (openai-chat|openai-responses|anthropic-messages|gemini-chat).`);
 }
-function inferSseProtocol(routeHint, providerProtocol, entryEndpoint) {
-    const candidates = [routeHint, providerProtocol, entryEndpoint].filter((value) => typeof value === 'string' && value.length > 0);
-    for (const candidate of candidates) {
-        const lowered = candidate.toLowerCase();
-        if (lowered.includes('responses')) {
-            return 'openai-responses';
-        }
-        if (lowered.includes('messages') || lowered.includes('anthropic')) {
-            return 'anthropic-messages';
-        }
+const PROVIDER_PROTOCOL_ALIASES = {
+    'openai-chat': 'openai-chat',
+    openai: 'openai-chat',
+    chat: 'openai-chat',
+    'responses': 'openai-responses',
+    'openai-responses': 'openai-responses',
+    'anthropic': 'anthropic-messages',
+    'anthropic-messages': 'anthropic-messages',
+    'messages': 'anthropic-messages',
+    'gemini': 'gemini-chat',
+    'google-gemini': 'gemini-chat',
+    'gemini-chat': 'gemini-chat'
+};
+function resolveSseProtocolFromMetadata(metadata) {
+    const candidate = metadata.sseProtocol ?? metadata.clientSseProtocol ?? metadata.routeSseProtocol;
+    if (typeof candidate !== 'string' || !candidate.trim()) {
+        return undefined;
     }
-    return 'openai-chat';
+    return resolveProviderProtocol(candidate);
 }