@jsonstudio/llms 0.6.3688 → 0.6.3689

package/dist/conversion/hub/operation-table/semantic-mappers/chat-mapper.js

@@ -1,4 +1,303 @@
+import { ensureProtocolState } from '../../../protocol-state.js';
+import { isJsonObject, jsonClone } from '../../types/json.js';
 import { mapOpenaiChatFromChatWithNative, mapOpenaiChatToChatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-semantic-mappers.js';
+import { mapReqInboundBridgeToolsToChatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+const CHAT_PARAMETER_KEYS = [
+    'model',
+    'temperature',
+    'top_p',
+    'top_k',
+    'max_tokens',
+    'frequency_penalty',
+    'presence_penalty',
+    'logit_bias',
+    'response_format',
+    'parallel_tool_calls',
+    'tool_choice',
+    'seed',
+    'user',
+    'metadata',
+    'stop',
+    'stop_sequences',
+    'stream'
+];
+const KNOWN_TOP_LEVEL_FIELDS = new Set([
+    'messages',
+    'tools',
+    'tool_outputs',
+    ...CHAT_PARAMETER_KEYS,
+    'stageExpectations',
+    'stages'
+]);
+function flattenSystemContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content.map(flattenSystemContent).filter(Boolean).join('\n');
+    }
+    if (content && typeof content === 'object') {
+        const row = content;
+        if (typeof row.text === 'string') {
+            return row.text;
+        }
+        if (typeof row.content === 'string') {
+            return row.content;
+        }
+        if (Array.isArray(row.content)) {
+            return row.content.map(flattenSystemContent).filter(Boolean).join('\n');
+        }
+    }
+    return '';
+}
+function normalizeToolContent(content) {
+    if (content === null || content === undefined) {
+        return '执行成功（无输出）';
+    }
+    if (typeof content === 'string') {
+        return content.trim().length ? content : '执行成功（无输出）';
+    }
+    if (typeof content === 'object') {
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return String(content);
+        }
+    }
+    return String(content);
+}
+function isEmptyAssistantContent(content) {
+    if (content === null || content === undefined) {
+        return true;
+    }
+    if (typeof content === 'string') {
+        return content.trim().length === 0;
+    }
+    if (Array.isArray(content)) {
+        const joined = content
+            .filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry))
+            .map((entry) => (typeof entry.text === 'string' ? entry.text : ''))
+            .join('');
+        return joined.trim().length === 0;
+    }
+    return false;
+}
+function collectSystemRawBlocks(raw) {
+    if (!Array.isArray(raw)) {
+        return undefined;
+    }
+    const blocks = [];
+    for (const entry of raw) {
+        if (!isJsonObject(entry)) {
+            continue;
+        }
+        if (String(entry.role ?? '').toLowerCase() !== 'system') {
+            continue;
+        }
+        blocks.push(jsonClone(entry));
+    }
+    return blocks.length ? blocks : undefined;
+}
+function collectExtraFields(payload) {
+    const extras = {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (KNOWN_TOP_LEVEL_FIELDS.has(key) || value === undefined) {
+            continue;
+        }
+        extras[key] = jsonClone(value);
+    }
+    return Object.keys(extras).length ? extras : undefined;
+}
+function extractParameters(payload) {
+    const parameters = {};
+    for (const key of CHAT_PARAMETER_KEYS) {
+        if (payload[key] !== undefined) {
+            parameters[key] = payload[key];
+        }
+    }
+    return Object.keys(parameters).length ? parameters : undefined;
+}
+function buildOpenaiSemantics(systemSegments, extraFields, explicitEmptyTools) {
+    const semantics = {};
+    if (systemSegments.length > 0) {
+        semantics.system = {
+            textBlocks: systemSegments
+        };
+    }
+    if (extraFields && Object.keys(extraFields).length > 0) {
+        semantics.providerExtras = {
+            openaiChat: {
+                extraFields
+            }
+        };
+    }
+    if (explicitEmptyTools) {
+        semantics.tools = {
+            explicitEmpty: true
+        };
+    }
+    return Object.keys(semantics).length > 0 ? semantics : undefined;
+}
+function normalizeAssistantToolCallsFast(message) {
+    if (message.tool_calls === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(message.tool_calls)) {
+        return null;
+    }
+    const normalized = [];
+    for (const entry of message.tool_calls) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            return null;
+        }
+        const toolCall = entry;
+        const functionNode = toolCall.function && typeof toolCall.function === 'object' && !Array.isArray(toolCall.function)
+            ? toolCall.function
+            : undefined;
+        if (!functionNode) {
+            return null;
+        }
+        const rawName = typeof functionNode.name === 'string' ? functionNode.name.trim() : '';
+        if (!rawName) {
+            return null;
+        }
+        const rawArguments = functionNode.arguments;
+        if (rawArguments !== undefined && rawArguments !== null && typeof rawArguments !== 'string') {
+            return null;
+        }
+        const dot = rawName.indexOf('.');
+        const normalizedName = dot >= 0 ? rawName.slice(dot + 1).trim() : rawName;
+        if (!normalizedName) {
+            return null;
+        }
+        normalized.push({
+            ...toolCall,
+            function: {
+                ...functionNode,
+                name: normalizedName,
+                arguments: typeof rawArguments === 'string' ? rawArguments : '{}'
+            }
+        });
+    }
+    return normalized;
+}
+function normalizeToolDefinitionsFast(rawTools) {
+    if (rawTools === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(rawTools)) {
+        return null;
+    }
+    if (rawTools.length === 0) {
+        return undefined;
+    }
+    const mapped = mapReqInboundBridgeToolsToChatWithNative(rawTools);
+    return mapped.length > 0 ? mapped : null;
+}
+function tryMapOpenaiChatToChatFast(payload, ctx) {
+    if (!Array.isArray(payload.messages) || payload.tool_outputs !== undefined) {
+        return undefined;
+    }
+    const normalizedMessages = [];
+    const toolOutputs = [];
+    const seenToolOutputIds = new Set();
+    const systemSegments = [];
+    for (const entry of payload.messages) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            return undefined;
+        }
+        const message = entry;
+        const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
+        if (role !== 'system' && role !== 'user' && role !== 'assistant' && role !== 'tool') {
+            return undefined;
+        }
+        const nextMessage = {
+            ...jsonClone(message),
+            role: role
+        };
+        if (role === 'assistant') {
+            const normalizedToolCalls = normalizeAssistantToolCallsFast(message);
+            if (normalizedToolCalls === null) {
+                return undefined;
+            }
+            if (normalizedToolCalls !== undefined) {
+                nextMessage.tool_calls = normalizedToolCalls;
+            }
+            const content = nextMessage.content;
+            if (content !== undefined &&
+                content !== null &&
+                typeof content !== 'string' &&
+                !Array.isArray(content) &&
+                typeof content !== 'object') {
+                nextMessage.content = String(content);
+            }
+            if ((nextMessage.tool_calls?.length ?? 0) === 0 && isEmptyAssistantContent(nextMessage.content)) {
+                continue;
+            }
+            normalizedMessages.push(nextMessage);
+            continue;
+        }
+        if (role === 'tool') {
+            const rawToolCallId = message.tool_call_id ?? message.call_id ?? message.id;
+            const toolCallId = typeof rawToolCallId === 'string' ? rawToolCallId.trim() : '';
+            if (!toolCallId) {
+                return undefined;
+            }
+            nextMessage.tool_call_id = toolCallId;
+            nextMessage.content = normalizeToolContent(message.content ?? message.output);
+            const name = typeof message.name === 'string' && message.name.trim().length ? message.name.trim() : undefined;
+            if (!seenToolOutputIds.has(toolCallId)) {
+                seenToolOutputIds.add(toolCallId);
+                toolOutputs.push({
+                    tool_call_id: toolCallId,
+                    content: maybeAugmentApplyPatchErrorContent(nextMessage.content, name),
+                    ...(name ? { name } : {})
+                });
+            }
+            normalizedMessages.push(nextMessage);
+            continue;
+        }
+        if (role === 'system') {
+            const segment = flattenSystemContent(message.content);
+            if (segment.trim().length > 0) {
+                systemSegments.push(segment);
+            }
+        }
+        else {
+            const content = nextMessage.content;
+            if (content !== undefined &&
+                content !== null &&
+                typeof content !== 'string' &&
+                !Array.isArray(content) &&
+                typeof content !== 'object') {
+                nextMessage.content = String(content);
+            }
+        }
+        normalizedMessages.push(nextMessage);
+    }
+    const tools = normalizeToolDefinitionsFast(payload.tools);
+    if (tools === null) {
+        return undefined;
+    }
+    const metadata = { context: ctx };
+    const rawSystemBlocks = collectSystemRawBlocks(payload.messages);
+    if (rawSystemBlocks) {
+        const protocolState = ensureProtocolState(metadata, 'openai');
+        protocolState.systemMessages = jsonClone(rawSystemBlocks);
+    }
+    const parameters = extractParameters(payload);
+    const extraFields = collectExtraFields(payload);
+    const semantics = buildOpenaiSemantics(systemSegments, extraFields, Array.isArray(payload.tools) && payload.tools.length === 0);
+    return {
+        messages: normalizedMessages,
+        ...(tools ? { tools } : {}),
+        ...(toolOutputs.length > 0 ? { toolOutputs } : {}),
+        ...(parameters ? { parameters } : {}),
+        ...(semantics ? { semantics } : {}),
+        metadata
+    };
+}
 export function maybeAugmentApplyPatchErrorContent(content, toolName) {
     if (!content)
         return content;
@@ -28,7 +327,12 @@ export function maybeAugmentApplyPatchErrorContent(content, toolName) {
 }
 export class ChatSemanticMapper {
     async toChat(format, ctx) {
-        return mapOpenaiChatToChatWithNative((format.payload ?? {}), ctx);
+        const payload = (format.payload ?? {});
+        const fastMapped = tryMapOpenaiChatToChatFast(payload, ctx);
+        if (fastMapped) {
+            return fastMapped;
+        }
+        return mapOpenaiChatToChatWithNative(payload, ctx);
     }
     async fromChat(chat, ctx) {
         return mapOpenaiChatFromChatWithNative(chat, ctx);

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

@@ -35,7 +35,7 @@ import { applyHubProviderOutboundPolicy, recordHubPolicyObservation, setHubPolic
 import { applyProviderOutboundToolSurface, } from "../tool-surface/tool-surface-engine.js";
 import { cloneRuntimeMetadata, ensureRuntimeMetadata, readRuntimeMetadata, } from "../../runtime-metadata.js";
 import { containsImageAttachment, stripHistoricalImageAttachments, stripHistoricalVisualToolOutputs, repairIncompleteToolCalls, } from "../process/chat-process-media.js";
-import { measureHubStage, logHubStageTiming } from "./hub-stage-timing.js";
+import { measureHubStage, logHubStageTiming, clearHubStageTiming, } from "./hub-stage-timing.js";
 function isTruthyEnv(value) {
     const v = typeof value === "string" ? value.trim().toLowerCase() : "";
     return v === "1" || v === "true" || v === "yes" || v === "on";
@@ -1341,15 +1341,21 @@ export class HubPipeline {
     }
     async execute(request) {
         const normalized = await this.normalizeRequest(request);
-        if (normalized.direction === "request" &&
-            normalized.hubEntryMode === "chat_process") {
-            return await this.executeChatProcessEntryPipeline(normalized);
+        clearHubStageTiming(normalized.id);
+        try {
+            if (normalized.direction === "request" &&
+                normalized.hubEntryMode === "chat_process") {
+                return await this.executeChatProcessEntryPipeline(normalized);
+            }
+            const hooks = this.resolveProtocolHooks(normalized.providerProtocol);
+            if (!hooks) {
+                throw new Error(`Unsupported provider protocol for hub pipeline: ${normalized.providerProtocol}`);
+            }
+            return await this.executeRequestStagePipeline(normalized, hooks);
         }
-        const hooks = this.resolveProtocolHooks(normalized.providerProtocol);
-        if (!hooks) {
-            throw new Error(`Unsupported provider protocol for hub pipeline: ${normalized.providerProtocol}`);
+        finally {
+            clearHubStageTiming(normalized.id);
         }
-        return await this.executeRequestStagePipeline(normalized, hooks);
     }
     captureAnthropicAliasMap(normalized, adapterContext, chatEnvelope) {
         if (!this.shouldCaptureAnthropicAlias(normalized.entryEndpoint)) {

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

@@ -1,4 +1,5 @@
 export declare function isHubStageTimingDetailEnabled(): boolean;
+export declare function clearHubStageTiming(requestId: string | undefined | null): void;
 export declare function logHubStageTiming(requestId: string, stage: string, phase: 'start' | 'completed' | 'error', details?: Record<string, unknown>): void;
 export declare function measureHubStage<T>(requestId: string, stage: string, fn: () => Promise<T> | T, options?: {
     startDetails?: Record<string, unknown>;

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

@@ -120,6 +120,12 @@ function renderDetails(details) {
         return '';
     }
 }
+export function clearHubStageTiming(requestId) {
+    if (!requestId) {
+        return;
+    }
+    REQUEST_TIMELINES.delete(requestId);
+}
 export function logHubStageTiming(requestId, stage, phase, details) {
     if (!isHubStageTimingEnabled() || !requestId || !stage) {
         return;

package/dist/conversion/responses/responses-openai-bridge.js

@@ -45,6 +45,58 @@ function filterRedundantResponsesReasoningAction(actions) {
         return name !== 'reasoning.extract';
     });
 }
+const RESPONSES_TOOL_PASSTHROUGH_KEYS = [
+    'temperature',
+    'tool_choice',
+    'parallel_tool_calls',
+    'response_format',
+    'user',
+    'top_p',
+    'prompt_cache_key',
+    'reasoning',
+    'logit_bias',
+    'seed'
+];
+function pickObjectFields(value, keys) {
+    if (!value) {
+        return undefined;
+    }
+    const picked = {};
+    for (const key of keys) {
+        if (value[key] !== undefined) {
+            picked[key] = value[key];
+        }
+    }
+    return Object.keys(picked).length ? picked : undefined;
+}
+function buildSlimResponsesBridgeContext(context) {
+    if (!context || typeof context !== 'object') {
+        return undefined;
+    }
+    const slim = {};
+    if (Array.isArray(context.input) && context.input.length) {
+        slim.input = context.input;
+    }
+    if (Array.isArray(context.originalSystemMessages) && context.originalSystemMessages.length) {
+        slim.originalSystemMessages = context.originalSystemMessages;
+    }
+    if (typeof context.systemInstruction === 'string' && context.systemInstruction.trim().length) {
+        slim.systemInstruction = context.systemInstruction;
+    }
+    if (typeof context.toolCallIdStyle === 'string' && context.toolCallIdStyle.trim().length) {
+        slim.toolCallIdStyle = context.toolCallIdStyle;
+    }
+    if (context.metadata && typeof context.metadata === 'object' && !Array.isArray(context.metadata)) {
+        slim.metadata = context.metadata;
+    }
+    return Object.keys(slim).length ? slim : undefined;
+}
+function buildSlimBridgeDecisionMetadata(metadata) {
+    if (!metadata) {
+        return undefined;
+    }
+    return pickObjectFields(metadata, ['toolCallIdStyle', 'bridgeHistory']);
+}
 // normalizeTools unified in ../args-mapping.ts
 // NOTE: 自修复提示已移除（统一标准：不做模糊兜底）。
 // --- Public bridge functions ---
@@ -222,10 +274,10 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     }
     const metadataExtraFields = extractMetadataExtraFields(envelopeMetadata);
     const bridgeDecisions = resolveResponsesRequestBridgeDecisionsWithNative({
-        context: ctx && typeof ctx === 'object' ? ctx : undefined,
-        requestMetadata,
-        envelopeMetadata,
-        bridgeMetadata,
+        context: buildSlimResponsesBridgeContext(ctx),
+        requestMetadata: buildSlimBridgeDecisionMetadata(requestMetadata),
+        envelopeMetadata: buildSlimBridgeDecisionMetadata(envelopeMetadata),
+        bridgeMetadata: buildSlimBridgeDecisionMetadata(bridgeMetadata),
         extraBridgeHistory: extras?.bridgeHistory
     });
     const forceWebSearch = bridgeDecisions.forceWebSearch === true;
@@ -241,19 +293,8 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         originalTools: Array.isArray(originalTools) ? originalTools : undefined,
         chatTools: Array.isArray(responsesToolsFromChat) ? responsesToolsFromChat : undefined,
         hasServerSideWebSearch: !forceWebSearch,
-        passthroughKeys: [
-            'temperature',
-            'tool_choice',
-            'parallel_tool_calls',
-            'response_format',
-            'user',
-            'top_p',
-            'prompt_cache_key',
-            'reasoning',
-            'logit_bias',
-            'seed'
-        ],
-        request: chat
+        passthroughKeys: [...RESPONSES_TOOL_PASSTHROUGH_KEYS],
+        request: pickObjectFields(chat, RESPONSES_TOOL_PASSTHROUGH_KEYS)
     });
     const mergedTools = resolvedBridgeTools.mergedTools;
     if (mergedTools?.length) {

package/dist/conversion/shared/reasoning-normalizer.js

@@ -48,6 +48,11 @@ export function normalizeReasoningInChatPayload(payload) {
     assertReasoningNormalizerNativeAvailable();
     if (!payload)
         return;
+    const shouldNormalize = valueMayContainReasoningMarkup(payload.messages) ||
+        valueMayContainReasoningMarkup(payload.choices);
+    if (!shouldNormalize) {
+        return;
+    }
     const normalized = normalizeReasoningInChatPayloadWithNative(payload);
     if (normalized && typeof normalized === 'object') {
         Object.assign(payload, normalized);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.3688",
+  "version": "0.6.3689",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",