@jsonstudio/llms 0.6.1892 → 0.6.2172

package/dist/conversion/hub/process/chat-process.js

@@ -8,6 +8,7 @@ import { clearClockSession, parseDueAtMs, resolveClockConfig, reserveDueTasksFor
 import { logClock } from '../../../servertool/clock/log.js';
 import { logContinueExecution } from '../../../servertool/continue-execution/log.js';
 import { buildTimeTagLine, getClockTimeSnapshot } from '../../../servertool/clock/ntp.js';
+import { resolveClockSessionScope } from '../../../servertool/clock/session-scope.js';
 import { clearPendingServerToolInjection, loadPendingServerToolInjection } from '../../../servertool/pending-session.js';
 import { loadRoutingInstructionStateSync } from '../../../router/virtual-router/sticky-session-store.js';
 import { isJsonObject } from '../types/json.js';
@@ -592,6 +593,12 @@ function buildWebSearchOperations(request, metadata) {
             engines = preferred;
         }
     }
+    // DeepSeek native search path:
+    // when deepseek web_search engine is configured as top priority,
+    // route directly to deepseek-search model instead of servertool tool injection.
+    if (shouldBypassServerToolWebSearch(intent, engines, semanticsWebSearch)) {
+        return [];
+    }
     if (!engines.length) {
         return [];
     }
@@ -656,6 +663,36 @@ function buildWebSearchOperations(request, metadata) {
     });
     return ops;
 }
+function shouldBypassServerToolWebSearch(intent, engines, semanticsWebSearch) {
+    if (!intent.hasIntent || intent.googlePreferred) {
+        return false;
+    }
+    // Explicit semantic force should keep servertool orchestration.
+    if (semanticsWebSearch?.force === true) {
+        return false;
+    }
+    const deepseekIndex = engines.findIndex(isDeepSeekNativeWebSearchEngine);
+    if (deepseekIndex < 0) {
+        return false;
+    }
+    const deepseekEngine = engines[deepseekIndex];
+    // Treat explicit default as highest priority; otherwise require first position.
+    if (deepseekEngine.default !== true && deepseekIndex !== 0) {
+        return false;
+    }
+    return true;
+}
+function isDeepSeekNativeWebSearchEngine(engine) {
+    const id = typeof engine.id === 'string' ? engine.id.trim().toLowerCase() : '';
+    const providerKey = typeof engine.providerKey === 'string' ? engine.providerKey.trim().toLowerCase() : '';
+    if (id === 'deepseek:web_search') {
+        return true;
+    }
+    if (!providerKey.startsWith('deepseek-web.')) {
+        return false;
+    }
+    return providerKey.endsWith('.deepseek-chat-search') || providerKey.endsWith('.deepseek-reasoner-search');
+}
 function buildClockOperations(metadata) {
     const rt = readRuntimeMetadata(metadata);
     // Do not inject clock tool into internal servertool followup hops.
@@ -905,8 +942,10 @@ function appendDirectiveToUserContent(content, directive) {
     return next;
 }
 function resolveSessionIdForClock(metadata, request) {
-    const candidate = readString(metadata.sessionId) ?? readString(request.metadata?.sessionId);
-    return candidate && candidate.trim() ? candidate.trim() : null;
+    const requestMetadata = request.metadata && typeof request.metadata === 'object' && !Array.isArray(request.metadata)
+        ? request.metadata
+        : null;
+    return resolveClockSessionScope(metadata, requestMetadata);
 }
 function stripClockClearDirectiveFromText(text) {
     const pattern = /<\*\*\s*clock\s*:\s*clear\s*\*\*>/gi;
@@ -1231,6 +1270,7 @@ async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, re
             const marker = clockScheduleDirectives[index];
             const itemBase = {
                 dueAtMs: marker.dueAtMs,
+                setBy: 'user',
                 task: marker.task,
                 ...(marker.recurrence ? { recurrence: marker.recurrence } : {})
             };
@@ -1242,7 +1282,7 @@ async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, re
                 markerToolMessages = markerToolMessages.concat(buildClockMarkerScheduleMessages(requestId, index, marker, {
                     ok: false,
                     action: 'schedule',
-                    message: 'clock requires sessionId (x-session-id header or metadata.sessionId).'
+                    message: 'clock requires session scope (sessionId/conversationId or clockDaemonId).'
                 }));
                 continue;
             }
@@ -1368,6 +1408,39 @@ async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, re
 }
 function buildClockStandardToolsOperations() {
     const tools = [
+        {
+            type: 'function',
+            function: {
+                name: 'clock',
+                description: 'Time + Alarm for this session. Use schedule/update/list/cancel/clear. For any wait requirement, call clock.schedule now.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: ['get', 'schedule', 'update', 'list', 'cancel', 'clear']
+                        },
+                        items: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    dueAt: { type: 'string' },
+                                    task: { type: 'string' },
+                                    tool: { type: 'string' },
+                                    arguments: { type: 'string' }
+                                },
+                                required: ['dueAt', 'task', 'tool', 'arguments'],
+                                additionalProperties: false
+                            }
+                        },
+                        taskId: { type: 'string' }
+                    },
+                    required: ['action', 'items', 'taskId'],
+                    additionalProperties: false
+                }
+            }
+        },
         {
             type: 'function',
             function: {
@@ -1543,26 +1616,20 @@ function detectWebSearchIntent(request) {
     if (!messages.length) {
         return { hasIntent: false, googlePreferred: false };
     }
-    // 从末尾向前找到最近一条 user 消息，忽略 tool / assistant 的工具调用轮次，
-    // 以便在 Responses / 多轮工具调用场景下仍然根据“最近一条用户输入”判断意图。
-    let lastUser;
-    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
-        const candidate = messages[idx];
-        if (candidate && candidate.role === 'user') {
-            lastUser = candidate;
-            break;
-        }
-    }
-    if (!lastUser) {
+    // 仅使用“当前请求最后一条消息且角色为 user”的文本判断 web_search 意图：
+    // - 不读取系统提示词（system/developer）。
+    // - 不读取历史 user 消息（避免历史上下文误触发）。
+    const lastMessage = messages[messages.length - 1];
+    if (!lastMessage || lastMessage.role !== 'user') {
         return { hasIntent: false, googlePreferred: false };
     }
     // 支持多模态 content：既可能是纯文本字符串，也可能是带 image_url 的分段数组。
     let content = '';
-    if (typeof lastUser.content === 'string') {
-        content = lastUser.content;
+    if (typeof lastMessage.content === 'string') {
+        content = lastMessage.content;
     }
-    else if (Array.isArray(lastUser.content)) {
-        const parts = lastUser.content;
+    else if (Array.isArray(lastMessage.content)) {
+        const parts = lastMessage.content;
         const texts = [];
         for (const part of parts) {
             if (typeof part === 'string') {

package/dist/conversion/hub/response/provider-response.js

@@ -11,12 +11,12 @@ import { runRespInboundStage3SemanticMap } from '../pipeline/stages/resp_inbound
 import { runRespInboundStageCompatResponse } from '../pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js';
 import { runRespProcessStage1ToolGovernance } from '../pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js';
 import { runRespProcessStage2Finalize } from '../pipeline/stages/resp_process/resp_process_stage2_finalize/index.js';
+import { runRespProcessStage3ServerToolOrchestration } from '../pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/index.js';
 import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
 import { ProviderProtocolError } from '../../shared/errors.js';
 import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
-import { runServerToolOrchestration } from '../../../servertool/engine.js';
 import { commitClockReservation, resolveClockConfig } from '../../../servertool/clock/task-store.js';
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
@@ -284,20 +284,6 @@ export async function convertProviderResponse(options) {
     // to re-enter the hub chat process deterministically (tools harvesting, governance, etc.).
     // Client protocol remapping happens only on the outermost request.
     const clientProtocol = isFollowup ? 'openai-chat' : resolveClientProtocol(options.entryEndpoint);
-    const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline);
-    // 是否跳过 ServerTool 编排：
-    // - Provider 不支持 ServerTool（没有 invoker/reenterPipeline）时跳过；
-    // - 对于 serverToolFollowup=true 的二/三跳内部请求，通常需要跳过以防嵌套；
-    // - 例外：stop_message_flow 允许链式触发（同一 flow 内重复检查直到 maxRepeats）。
-    const rt = readRuntimeMetadata(options.context);
-    const loopState = rt?.serverToolLoopState;
-    const flowId = loopState && typeof loopState === 'object' && !Array.isArray(loopState)
-        ? String(loopState.flowId || '').trim()
-        : '';
-    const isStopMessageFlow = flowId === 'stop_message_flow';
-    const allowNestedServerTools = isStopMessageFlow || flowId === 'antigravity_thought_signature_bootstrap';
-    // stop_message_flow 的 followup 允许再次触发（直到 maxRepeats），其他 followup 跳过。
-    const skipServerTools = (isFollowup && !allowNestedServerTools) || !hasServerToolSupport;
     // 对于由 server-side 工具触发的内部跳转（二跳/三跳），统一禁用 SSE 聚合输出，
     // 始终返回完整的 ChatCompletion JSON，便于在 llms 内部直接解析，而不是拿到
     // __sse_responses 可读流。
@@ -315,20 +301,22 @@ export async function convertProviderResponse(options) {
         wantsStream,
         stageRecorder: options.stageRecorder
     });
+    // Hard order guarantee: provider -> compat -> inbound(parse/map) -> chat_process -> outbound -> client.
+    // Transport-level SSE decode stays before compat to materialize a JSON provider payload.
+    const compatPayload = runRespInboundStageCompatResponse({
+        payload: inboundStage1.payload,
+        adapterContext: options.context,
+        stageRecorder: options.stageRecorder
+    });
+    stripInternalPolicyDebugFields(compatPayload);
     const formatAdapter = plan.createFormatAdapter();
     const mapper = plan.createMapper();
     const formatEnvelope = await runRespInboundStage2FormatParse({
         adapterContext: options.context,
-        payload: inboundStage1.payload,
+        payload: compatPayload,
         formatAdapter,
         stageRecorder: options.stageRecorder
     });
-    formatEnvelope.payload = runRespInboundStageCompatResponse({
-        payload: formatEnvelope.payload,
-        adapterContext: options.context,
-        stageRecorder: options.stageRecorder
-    });
-    stripInternalPolicyDebugFields(formatEnvelope.payload);
     // Phase 2 (shadow): response tool surface mismatch detection (provider inbound).
     // Only records diffs; does not rewrite payload.
     try {
@@ -375,34 +363,17 @@ export async function convertProviderResponse(options) {
     recordStage(options.stageRecorder, 'chat_process.resp.stage4.semantic_map_to_chat.chat', chatResponse);
     // 检查是否需要进行 ServerTool 编排
     // 使用新的 ChatEnvelope 级别的 servertool 实现
-    let effectiveChatResponse = chatResponse;
-    if (!skipServerTools && options.reenterPipeline) {
-        const orchestration = await runServerToolOrchestration({
-            chat: chatResponse,
-            adapterContext: options.context,
-            requestId: options.context.requestId,
-            entryEndpoint: options.entryEndpoint,
-            providerProtocol: options.providerProtocol,
-            stageRecorder: options.stageRecorder,
-            providerInvoker: options.providerInvoker,
-            reenterPipeline: options.reenterPipeline
-        });
-        if (orchestration.executed) {
-            effectiveChatResponse = orchestration.chat;
-            recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
-                executed: true,
-                flowId: orchestration.flowId,
-                inputShape: detectProviderResponseShape(chatResponse),
-                outputShape: detectProviderResponseShape(effectiveChatResponse)
-            });
-        }
-        else {
-            recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
-                executed: false,
-                inputShape: detectProviderResponseShape(chatResponse)
-            });
-        }
-    }
+    const orchestration = await runRespProcessStage3ServerToolOrchestration({
+        payload: chatResponse,
+        adapterContext: options.context,
+        requestId: options.context.requestId,
+        entryEndpoint: options.entryEndpoint,
+        providerProtocol: options.providerProtocol,
+        stageRecorder: options.stageRecorder,
+        providerInvoker: options.providerInvoker,
+        reenterPipeline: options.reenterPipeline
+    });
+    let effectiveChatResponse = orchestration.payload;
     // Hard gate: response-side chat_process requires an OpenAI-chat-like surface (choices[].message).
     // ServerTool followups must never replace the canonical chat completion with a client-protocol shape.
     effectiveChatResponse = await coerceClientPayloadToCanonicalChatCompletionOrThrow({

package/dist/conversion/hub/response/response-runtime.js

@@ -30,18 +30,63 @@ function sanitizeAnthropicToolUseId(raw) {
     }
     return `call_${Math.random().toString(36).slice(2, 10)}`;
 }
+function coerceNonNegativeNumber(...candidates) {
+    for (const value of candidates) {
+        if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (!trimmed.length)
+                continue;
+            const parsed = Number(trimmed);
+            if (Number.isFinite(parsed) && parsed >= 0) {
+                return parsed;
+            }
+        }
+    }
+    return undefined;
+}
 function createToolNameResolver(options) {
     const reverse = new Map();
+    const shouldReplaceAlias = (existingCanonical, nextCanonical, providerKey) => {
+        const existing = existingCanonical.trim().toLowerCase();
+        const next = nextCanonical.trim().toLowerCase();
+        if (!existing) {
+            return true;
+        }
+        // Prefer exact identity mapping first (providerName == canonicalName).
+        if (next === providerKey && existing !== providerKey) {
+            return true;
+        }
+        if (existing === providerKey && next !== providerKey) {
+            return false;
+        }
+        // When provider emits exec_command, never downgrade back to shell_command.
+        if (providerKey === 'exec_command') {
+            if (next === 'exec_command' && existing !== 'exec_command') {
+                return true;
+            }
+            if (existing === 'exec_command' && next !== 'exec_command') {
+                return false;
+            }
+        }
+        return false;
+    };
     const aliasMap = options?.aliasMap;
     if (aliasMap && typeof aliasMap === 'object') {
         for (const [canonical, providerName] of Object.entries(aliasMap)) {
             if (typeof canonical !== 'string' || typeof providerName !== 'string')
                 continue;
+            const canonicalName = canonical.trim();
+            if (!canonicalName.length)
+                continue;
             const normalizedProvider = providerName.trim().toLowerCase();
             if (!normalizedProvider.length)
                 continue;
-            if (!reverse.has(normalizedProvider)) {
-                reverse.set(normalizedProvider, canonical.trim());
+            const existing = reverse.get(normalizedProvider);
+            if (!existing || shouldReplaceAlias(existing, canonicalName, normalizedProvider)) {
+                reverse.set(normalizedProvider, canonicalName);
             }
         }
     }
@@ -259,11 +304,21 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
 function mapShellCommandArgsForAnthropic(raw) {
     const result = {};
     const source = (raw && typeof raw === 'object' && !Array.isArray(raw)) ? raw : {};
-    const commandRaw = typeof source.command === 'string' && source.command.trim().length
-        ? source.command
-        : typeof source.cmd === 'string' && source.cmd.trim().length
-            ? source.cmd
-            : '';
+    const coerceCommand = (value) => {
+        if (typeof value === 'string' && value.trim().length) {
+            return value.trim();
+        }
+        if (Array.isArray(value)) {
+            const parts = value
+                .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+                .filter((entry) => entry.length > 0);
+            if (parts.length) {
+                return parts.join(' ');
+            }
+        }
+        return '';
+    };
+    const commandRaw = coerceCommand(source.command) || coerceCommand(source.cmd);
     const command = commandRaw.trim();
     if (command) {
         result.command = command;
@@ -336,7 +391,7 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
         if (typeof fn?.name !== 'string')
             continue;
         const canonicalName = normalizeAnthropicToolName(fn.name) ?? fn.name;
-        const serializedName = outboundAliasSerializer(fn.name);
+        const serializedName = outboundAliasSerializer(canonicalName || fn.name);
         let parsedArgs = {};
         const args = fn.arguments;
         if (typeof args === 'string') {
@@ -373,6 +428,12 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
         contentBlocks.push(sanitized);
     }
     const usage = chatResponse?.usage;
+    const usageInputTokens = usage && typeof usage === 'object'
+        ? coerceNonNegativeNumber(usage.input_tokens, usage.prompt_tokens)
+        : undefined;
+    const usageOutputTokens = usage && typeof usage === 'object'
+        ? coerceNonNegativeNumber(usage.output_tokens, usage.completion_tokens)
+        : undefined;
     const stopReason = typeof choice?.finish_reason === 'string'
         ? choice.finish_reason
         : undefined;
@@ -396,8 +457,8 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
         stop_reason: stopReasonMapped,
         usage: usage && typeof usage === 'object'
             ? {
-                input_tokens: usage.prompt_tokens ?? 0,
-                output_tokens: usage.completion_tokens ?? 0
+                input_tokens: usageInputTokens ?? 0,
+                output_tokens: usageOutputTokens ?? 0
             }
             : undefined
     };

package/dist/conversion/responses/responses-openai-bridge/response-payload.d.ts

@@ -0,0 +1,3 @@
+import type { ResponsesRequestContext } from './types.js';
+export declare function buildResponsesPayloadFromChat(payload: unknown, context?: ResponsesRequestContext): Record<string, unknown> | unknown;
+export declare function extractRequestIdFromResponse(response: any): string | undefined;