@jsonstudio/llms 0.6.938 → 0.6.1164

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

@@ -2,7 +2,9 @@ import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js'
 import { ToolGovernanceEngine } from '../tool-governance/index.js';
 import { ensureApplyPatchSchema } from '../../shared/tool-mapping.js';
 import { normalizeApplyPatchToolCallsOnRequest } from '../../shared/tool-governor.js';
+import { clearClockSession, normalizeClockConfig, reserveDueTasksForRequest, startClockDaemonIfNeeded } from '../../../servertool/clock/task-store.js';
 import { isJsonObject } from '../types/json.js';
+import { applyHubOperations } from '../ops/operations.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
     const startTime = Date.now();
@@ -90,28 +92,22 @@ async function applyRequestToolGovernance(request, context) {
         merged.metadata.hasImageAttachment = true;
     }
     if (typeof inboundStreamIntent === 'boolean') {
-        merged.metadata = {
-            ...merged.metadata,
-            inboundStream: inboundStreamIntent
-        };
+        merged = applyHubOperations(merged, buildInboundStreamingOperations(inboundStreamIntent));
     }
     if (typeof governed.stream === 'boolean') {
-        merged.parameters = {
-            ...merged.parameters,
-            stream: governed.stream
-        };
+        merged = applyHubOperations(merged, buildOutboundStreamingOperations(governed.stream));
     }
     if (governed.tool_choice !== undefined) {
-        merged.parameters = {
-            ...merged.parameters,
-            tool_choice: governed.tool_choice
-        };
+        merged = applyHubOperations(merged, buildToolChoiceOperations(governed.tool_choice));
     }
     if (typeof governed.model === 'string' && governed.model.trim()) {
         merged.model = governed.model.trim();
     }
     // Server-side web_search tool injection (config-driven, best-effort).
-    merged = maybeInjectWebSearchTool(merged, metadata);
+    merged = applyHubOperations(merged, buildWebSearchOperations(merged, metadata));
+    // Server-side clock tool + scheduled reminders injection (config-driven, best-effort).
+    merged = applyHubOperations(merged, buildClockOperations(metadata));
+    merged = await maybeInjectClockRemindersAndApplyDirectives(merged, metadata, context.requestId);
     const { request: sanitized, summary } = toolGovernanceEngine.governRequest(merged, providerProtocol);
     if (summary.applied) {
         sanitized.metadata = {
@@ -397,18 +393,49 @@ function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 function maybeInjectWebSearchTool(request, metadata) {
+    const ops = buildWebSearchOperations(request, metadata);
+    if (!ops.length) {
+        return request;
+    }
+    return applyHubOperations(request, ops);
+}
+function buildInboundStreamingOperations(intent) {
+    return [
+        {
+            op: 'set_request_metadata_fields',
+            fields: { inboundStream: intent }
+        }
+    ];
+}
+function buildOutboundStreamingOperations(stream) {
+    return [
+        {
+            op: 'set_request_parameter_fields',
+            fields: { stream }
+        }
+    ];
+}
+function buildToolChoiceOperations(toolChoice) {
+    return [
+        {
+            op: 'set_request_parameter_fields',
+            fields: { tool_choice: toolChoice }
+        }
+    ];
+}
+function buildWebSearchOperations(request, metadata) {
     // ServerTool 二/三跳（serverToolFollowup=true）不再注入 web_search 工具，
     // 以避免在 web_search 流程内部形成循环命中。
     if (metadata.serverToolFollowup === true) {
-        return request;
+        return [];
     }
     const rawConfig = metadata.webSearch;
     if (!rawConfig || !Array.isArray(rawConfig.engines) || rawConfig.engines.length === 0) {
-        return request;
+        return [];
     }
     const semanticsWebSearch = extractWebSearchSemantics(request.semantics);
     if (semanticsWebSearch?.disable === true) {
-        return request;
+        return [];
     }
     const injectPolicy = semanticsWebSearch?.force === true
         ? 'always'
@@ -420,26 +447,10 @@ function maybeInjectWebSearchTool(request, metadata) {
         // 仅当当前这一轮用户输入明确表达“联网搜索”意图时才注入 web_search。
         // 不再依赖上一轮工具分类（read/search/websearch），避免形成隐式续写语义。
         if (!intent.hasIntent) {
-            return request;
+            return [];
         }
     }
     const existingTools = Array.isArray(request.tools) ? request.tools : [];
-    const hasWebSearch = existingTools.some((tool) => {
-        if (!tool || typeof tool !== 'object')
-            return false;
-        const fn = tool.function;
-        return typeof fn?.name === 'string' && fn.name.trim() === 'web_search';
-    });
-    if (hasWebSearch) {
-        const nextMetadata = {
-            ...(request.metadata ?? {}),
-            webSearchEnabled: true
-        };
-        return {
-            ...request,
-            metadata: nextMetadata
-        };
-    }
     let engines = rawConfig.engines.filter((engine) => typeof engine?.id === 'string' && !!engine.id.trim() && !engine.serverToolsDisabled);
     // 当用户明确要求「谷歌搜索」时，只暴露 Gemini / Antigravity 类搜索后端：
     // - providerKey 以 gemini-cli. 或 antigravity. 开头；
@@ -461,7 +472,7 @@ function maybeInjectWebSearchTool(request, metadata) {
         }
     }
     if (!engines.length) {
-        return request;
+        return [];
     }
     const engineIds = engines.map((engine) => engine.id.trim());
     const engineDescriptions = engines
@@ -511,15 +522,215 @@ function maybeInjectWebSearchTool(request, metadata) {
             strict: true
         }
     };
-    const nextMetadata = {
-        ...(request.metadata ?? {}),
-        webSearchEnabled: true
+    const ops = [
+        {
+            op: 'set_request_metadata_fields',
+            fields: { webSearchEnabled: true }
+        }
+    ];
+    ops.push({
+        op: 'append_tool_if_missing',
+        toolName: 'web_search',
+        tool: webSearchTool
+    });
+    return ops;
+}
+function buildClockOperations(metadata) {
+    const rawConfig = metadata.clock;
+    const clockConfig = normalizeClockConfig(rawConfig);
+    if (!clockConfig) {
+        return [];
+    }
+    const parameters = {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['schedule', 'list', 'cancel', 'clear'],
+                description: 'Schedule, list, cancel, or clear session-scoped reminders.'
+            },
+            items: {
+                type: 'array',
+                description: 'For schedule: list of reminders to add.',
+                items: {
+                    type: 'object',
+                    properties: {
+                        dueAt: {
+                            type: 'string',
+                            description: 'ISO8601 datetime with timezone (e.g. 2026-01-21T20:30:00-08:00).'
+                        },
+                        task: {
+                            type: 'string',
+                            description: 'Reminder text (should include which tool to use and what to do).'
+                        },
+                        tool: {
+                            type: 'string',
+                            description: 'Optional suggested tool name (hint only).'
+                        },
+                        arguments: {
+                            type: 'object',
+                            description: 'Optional suggested tool arguments (hint only).',
+                            additionalProperties: true
+                        }
+                    },
+                    required: ['dueAt', 'task'],
+                    additionalProperties: false
+                }
+            },
+            taskId: {
+                type: 'string',
+                description: 'For cancel: taskId to remove.'
+            }
+        },
+        required: ['action'],
+        additionalProperties: false
     };
-    return {
-        ...request,
-        metadata: nextMetadata,
-        tools: [...existingTools, webSearchTool]
+    const clockTool = {
+        type: 'function',
+        function: {
+            name: 'clock',
+            description: 'Schedule session-scoped reminders. Use schedule/list/cancel/clear. Scheduled reminders will be injected into future requests as [scheduled task:"..."].',
+            parameters,
+            strict: true
+        }
     };
+    return [
+        { op: 'set_request_metadata_fields', fields: { clockEnabled: true, serverToolRequired: true } },
+        { op: 'append_tool_if_missing', toolName: 'clock', tool: clockTool }
+    ];
+}
+function resolveSessionIdForClock(metadata, request) {
+    const candidate = readString(metadata.sessionId) ?? readString(request.metadata?.sessionId);
+    return candidate && candidate.trim() ? candidate.trim() : null;
+}
+function stripClockClearDirectiveFromText(text) {
+    const pattern = /<\*\*\s*clock\s*:\s*clear\s*\*\*>/gi;
+    const hadClear = pattern.test(text);
+    if (!hadClear) {
+        return { hadClear: false, next: text };
+    }
+    const replaced = text.replace(pattern, '');
+    // Clean up leftover excessive blank lines to keep prompts tidy.
+    const next = replaced.replace(/\n{3,}/g, '\n\n').trim();
+    return { hadClear: true, next };
+}
+function stripClockClearDirectiveFromContent(content) {
+    if (typeof content === 'string') {
+        const { hadClear, next } = stripClockClearDirectiveFromText(content);
+        return { hadClear, next };
+    }
+    if (Array.isArray(content)) {
+        let hadClear = false;
+        const next = content.map((part) => {
+            if (typeof part === 'string') {
+                const stripped = stripClockClearDirectiveFromText(part);
+                if (stripped.hadClear)
+                    hadClear = true;
+                return stripped.next;
+            }
+            if (part && typeof part === 'object' && !Array.isArray(part)) {
+                const block = part;
+                const text = typeof block.text === 'string' ? block.text : undefined;
+                if (!text)
+                    return part;
+                const stripped = stripClockClearDirectiveFromText(text);
+                if (stripped.hadClear)
+                    hadClear = true;
+                return { ...block, text: stripped.next };
+            }
+            return part;
+        });
+        return { hadClear, next };
+    }
+    return { hadClear: false, next: content };
+}
+function findLastUserMessageIndex(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return -1;
+    }
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const candidate = messages[idx];
+        if (candidate && candidate.role === 'user') {
+            return idx;
+        }
+    }
+    return -1;
+}
+async function maybeInjectClockRemindersAndApplyDirectives(request, metadata, requestId) {
+    const rawConfig = metadata.clock;
+    const clockConfig = normalizeClockConfig(rawConfig);
+    if (!clockConfig) {
+        return request;
+    }
+    try {
+        await startClockDaemonIfNeeded(clockConfig);
+    }
+    catch {
+        // best-effort
+    }
+    const sessionId = resolveSessionIdForClock(metadata, request);
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    const lastUserIdx = findLastUserMessageIndex(messages);
+    // 1) Apply <**clock:clear**> directive (latest user message only).
+    let hadClear = false;
+    let nextMessages = messages;
+    if (lastUserIdx >= 0) {
+        const lastUser = messages[lastUserIdx];
+        const stripped = stripClockClearDirectiveFromContent(lastUser.content);
+        hadClear = stripped.hadClear;
+        if (hadClear) {
+            nextMessages = messages.slice();
+            nextMessages[lastUserIdx] = { ...lastUser, content: stripped.next };
+        }
+    }
+    if (hadClear) {
+        if (sessionId) {
+            try {
+                await clearClockSession(sessionId);
+            }
+            catch {
+                // best-effort: user directive should not crash request
+            }
+        }
+        return { ...request, messages: nextMessages };
+    }
+    // 2) Inject due reminders as a system message + attach reservation for response-side commit.
+    if (!sessionId) {
+        return request;
+    }
+    try {
+        const { reservation, injectText } = await reserveDueTasksForRequest({
+            reservationId: `${requestId}:clock`,
+            sessionId,
+            config: clockConfig
+        });
+        if (!reservation || typeof injectText !== 'string' || !injectText.trim()) {
+            return request;
+        }
+        const baseMetadata = request.metadata && typeof request.metadata === 'object'
+            ? request.metadata
+            : {
+                originalEndpoint: readString(metadata.originalEndpoint) ?? '/v1/chat/completions'
+            };
+        return {
+            ...request,
+            messages: [
+                ...messages,
+                {
+                    role: 'system',
+                    content: injectText.trim()
+                }
+            ],
+            metadata: {
+                ...baseMetadata,
+                __clockReservation: reservation
+            }
+        };
+    }
+    catch {
+        // best-effort: never break request due to reminder injection failures
+        return request;
+    }
 }
 function extractWebSearchSemantics(semantics) {
     if (!semantics || typeof semantics !== 'object') {

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

@@ -15,6 +15,7 @@ import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbou
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
 import { runServerToolOrchestration } from '../../../servertool/engine.js';
+import { commitClockReservation, normalizeClockConfig } from '../../../servertool/clock/task-store.js';
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
         createFormatAdapter: () => new ChatFormatAdapter(),
@@ -52,6 +53,123 @@ function resolveClientProtocol(entryEndpoint) {
         return 'anthropic-messages';
     return 'openai-chat';
 }
+function isToolSurfaceShadowEnabled() {
+    const raw = String(process.env.ROUTECODEX_HUB_TOOL_SURFACE_MODE || '').trim().toLowerCase();
+    if (!raw)
+        return false;
+    if (raw === 'off' || raw === '0' || raw === 'false')
+        return false;
+    return raw === 'observe' || raw === 'shadow' || raw === 'enforce';
+}
+function isJsonRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function coerceClockReservation(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const rec = value;
+    const reservationId = typeof rec.reservationId === 'string' ? rec.reservationId.trim() : '';
+    const sessionId = typeof rec.sessionId === 'string' ? rec.sessionId.trim() : '';
+    const taskIdsRaw = Array.isArray(rec.taskIds) ? rec.taskIds : [];
+    const taskIds = taskIdsRaw
+        .filter((t) => typeof t === 'string' && t.trim().length)
+        .map((t) => String(t).trim());
+    const reservedAtMs = typeof rec.reservedAtMs === 'number' && Number.isFinite(rec.reservedAtMs)
+        ? Math.floor(rec.reservedAtMs)
+        : Date.now();
+    if (!reservationId || !sessionId || taskIds.length === 0) {
+        return null;
+    }
+    return { reservationId, sessionId, taskIds, reservedAtMs };
+}
+async function maybeCommitClockReservationFromContext(context) {
+    try {
+        const clockConfig = normalizeClockConfig(context.clock);
+        if (!clockConfig) {
+            return;
+        }
+        const reservation = coerceClockReservation(context.__clockReservation);
+        if (!reservation) {
+            return;
+        }
+        await commitClockReservation(reservation, clockConfig);
+    }
+    catch {
+        // best-effort: never break response conversion due to clock persistence errors
+    }
+}
+function detectProviderResponseShape(payload) {
+    if (!isJsonRecord(payload))
+        return 'unknown';
+    const obj = payload;
+    if (Array.isArray(obj.choices))
+        return 'openai-chat';
+    if (Array.isArray(obj.output) || obj.object === 'response')
+        return 'openai-responses';
+    if (typeof obj.type === 'string' && String(obj.type).toLowerCase() === 'message' && Array.isArray(obj.content)) {
+        return 'anthropic-messages';
+    }
+    if (Array.isArray(obj.candidates))
+        return 'gemini-chat';
+    return 'unknown';
+}
+function summarizeToolCallsFromProviderResponse(payload) {
+    try {
+        if (!isJsonRecord(payload))
+            return {};
+        const obj = payload;
+        // openai-chat
+        if (Array.isArray(obj.choices)) {
+            const msg = obj.choices?.[0]?.message;
+            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+            const names = tcs
+                .map((tc) => String(tc?.function?.name || '').trim())
+                .filter((s) => s.length)
+                .slice(0, 10);
+            return { toolCallCount: tcs.length, toolNames: names.length ? names : undefined };
+        }
+        // openai-responses
+        if (Array.isArray(obj.output)) {
+            const out = obj.output;
+            const fnCalls = out.filter((it) => it && typeof it === 'object' && String(it.type || '').toLowerCase() === 'function_call');
+            const names = fnCalls
+                .map((it) => String(it?.name || '').trim())
+                .filter((s) => s.length)
+                .slice(0, 10);
+            return { toolCallCount: fnCalls.length, toolNames: names.length ? names : undefined };
+        }
+        // anthropic-messages
+        if (Array.isArray(obj.content)) {
+            const blocks = obj.content;
+            const uses = blocks.filter((b) => b && typeof b === 'object' && String(b.type || '').toLowerCase() === 'tool_use');
+            const names = uses
+                .map((b) => String(b?.name || '').trim())
+                .filter((s) => s.length)
+                .slice(0, 10);
+            return { toolCallCount: uses.length, toolNames: names.length ? names : undefined };
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+function stripInternalPolicyDebugFields(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return;
+    }
+    const target = payload;
+    // These are internal debug/transport markers that must not leak across hub boundaries.
+    // They also break hub policy allowlists (Phase 0/1 observation) and confuse tool-surface detection.
+    delete target._transformed;
+    delete target._originalFormat;
+    delete target._targetFormat;
+    delete target.__responses_output_text_meta;
+    delete target.__responses_reasoning;
+    delete target.__responses_payload_snapshot;
+    delete target.__responses_passthrough;
+}
 function supportsSseProtocol(protocol) {
     return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages' || protocol === 'gemini-chat';
 }
@@ -68,6 +186,16 @@ function extractDisplayModel(context) {
     }
     return undefined;
 }
+function extractClientFacingRequestId(context) {
+    const contextAny = context;
+    const candidates = [contextAny.clientRequestId, contextAny.groupRequestId, context.requestId];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
 function applyModelOverride(payload, model) {
     if (!model || !payload || typeof payload !== 'object') {
         return;
@@ -107,6 +235,7 @@ export async function convertProviderResponse(options) {
         /* logging best-effort */
     }
     const displayModel = extractDisplayModel(options.context);
+    const clientFacingRequestId = extractClientFacingRequestId(options.context) ?? options.context.requestId;
     const plan = PROVIDER_RESPONSE_REGISTRY[options.providerProtocol];
     if (!plan) {
         throw new Error(`Unknown provider protocol: ${options.providerProtocol}`);
@@ -142,6 +271,27 @@ export async function convertProviderResponse(options) {
         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 {
+        if (options.stageRecorder && isToolSurfaceShadowEnabled()) {
+            const detected = detectProviderResponseShape(formatEnvelope.payload);
+            if (detected !== 'unknown' && detected !== options.providerProtocol) {
+                const summary = summarizeToolCallsFromProviderResponse(formatEnvelope.payload);
+                options.stageRecorder.record('hub_toolsurface.shadow.provider_inbound', {
+                    kind: 'provider_inbound',
+                    expectedProtocol: options.providerProtocol,
+                    detectedProtocol: detected,
+                    ...(summary.toolCallCount !== undefined ? { toolCallCount: summary.toolCallCount } : {}),
+                    ...(summary.toolNames ? { toolNames: summary.toolNames } : {})
+                });
+            }
+        }
+    }
+    catch {
+        // never break response conversion
+    }
     // Phase 0/1: observe provider inbound payload violations (best-effort; no rewrites here).
     try {
         if (formatEnvelope.payload && typeof formatEnvelope.payload === 'object' && !Array.isArray(formatEnvelope.payload)) {
@@ -183,6 +333,7 @@ export async function convertProviderResponse(options) {
             requestId: options.context.requestId,
             entryEndpoint: options.entryEndpoint,
             providerProtocol: options.providerProtocol,
+            stageRecorder: options.stageRecorder,
             providerInvoker: options.providerInvoker,
             reenterPipeline: options.reenterPipeline
         });
@@ -229,11 +380,31 @@ export async function convertProviderResponse(options) {
     const clientPayload = runRespOutboundStage1ClientRemap({
         payload: finalizeResult.finalizedPayload,
         clientProtocol,
-        requestId: options.context.requestId,
+        requestId: clientFacingRequestId,
         adapterContext: options.context,
         stageRecorder: options.stageRecorder
     });
     applyModelOverride(clientPayload, displayModel);
+    stripInternalPolicyDebugFields(clientPayload);
+    // Phase 2 (shadow): response tool surface mismatch detection (client outbound).
+    try {
+        if (options.stageRecorder && isToolSurfaceShadowEnabled()) {
+            const detected = detectProviderResponseShape(clientPayload);
+            if (detected !== 'unknown' && detected !== clientProtocol) {
+                const summary = summarizeToolCallsFromProviderResponse(clientPayload);
+                options.stageRecorder.record('hub_toolsurface.shadow.client_outbound', {
+                    kind: 'client_outbound',
+                    expectedProtocol: clientProtocol,
+                    detectedProtocol: detected,
+                    ...(summary.toolCallCount !== undefined ? { toolCallCount: summary.toolCallCount } : {}),
+                    ...(summary.toolNames ? { toolNames: summary.toolNames } : {})
+                });
+            }
+        }
+    }
+    catch {
+        // never break response conversion
+    }
     // Phase 0/1: observe client outbound payload violations (best-effort; no rewrites here).
     try {
         if (clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)) {
@@ -252,10 +423,12 @@ export async function convertProviderResponse(options) {
     const outbound = await runRespOutboundStage2SseStream({
         clientPayload,
         clientProtocol,
-        requestId: options.context.requestId,
+        requestId: clientFacingRequestId,
         wantsStream,
         stageRecorder: options.stageRecorder
     });
+    // Commit scheduled-task delivery only after a successful client payload/stream is prepared.
+    await maybeCommitClockReservationFromContext(options.context);
     if (outbound.stream) {
         return { __sse_responses: outbound.stream, format: clientProtocol };
     }

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

@@ -189,7 +189,7 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
         switch (reason) {
             case 'tool_use': return 'tool_calls';
             case 'max_tokens': return 'length';
-            case 'stop_sequence': return 'content_filter';
+            case 'stop_sequence': return 'stop';
             default: return 'stop';
         }
     };

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.d.ts

@@ -1,8 +1 @@
-import type { SemanticMapper } from '../format-adapters/index.js';
-import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
-import type { FormatEnvelope } from '../types/format-envelope.js';
-export declare class AnthropicSemanticMapper implements SemanticMapper {
-    private readonly chatMapper;
-    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
-    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
-}
+export { AnthropicSemanticMapper } from '../operation-table/semantic-mappers/anthropic-mapper.js';