@jsonstudio/llms 0.6.1164 → 0.6.1354

package/dist/servertool/handlers/clock-auto.js

@@ -1,6 +1,8 @@
 import { registerServerToolHandler } from '../registry.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
-import { findNextUndeliveredDueAtMs, listClockTasks, normalizeClockConfig, startClockDaemonIfNeeded } from '../clock/task-store.js';
+import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
+import { findNextUndeliveredDueAtMs, listClockTasks, resolveClockConfig, startClockDaemonIfNeeded } from '../clock/task-store.js';
+import { logClock } from '../clock/log.js';
 const FLOW_ID = 'clock_hold_flow';
 function resolveClientConnectionState(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
@@ -96,15 +98,17 @@ const handler = async (ctx) => {
         (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
         return null;
     }
-    const clockConfig = normalizeClockConfig(record.clock);
-    if (!clockConfig) {
-        return null;
-    }
-    await startClockDaemonIfNeeded(clockConfig);
+    const rt = readRuntimeMetadata(ctx.adapterContext);
     const sessionId = resolveSessionId(ctx.adapterContext);
     if (!sessionId) {
         return null;
     }
+    // Default-enable clock when config is absent, but keep "explicitly disabled" honored.
+    const clockConfig = resolveClockConfig(rt?.clock);
+    if (!clockConfig) {
+        return null;
+    }
+    await startClockDaemonIfNeeded(clockConfig);
     const seed = extractCapturedChatSeed(record.capturedChatRequest);
     if (!seed) {
         return null;
@@ -117,6 +121,7 @@ const handler = async (ctx) => {
     }
     // Wait until the "due window" is reached (now >= dueAt - dueWindowMs).
     const thresholdMs = nextDueAtMs - clockConfig.dueWindowMs;
+    logClock('hold_start', { sessionId, nextDueAtMs, thresholdMs });
     while (Date.now() < thresholdMs) {
         const state = resolveClientConnectionState(ctx.adapterContext.clientConnectionState);
         if (state?.disconnected === true) {

package/dist/servertool/handlers/clock.js

@@ -1,7 +1,9 @@
 import { registerServerToolHandler } from '../registry.js';
 import { cloneJson } from '../server-side-tools.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
-import { cancelClockTask, clearClockTasks, listClockTasks, normalizeClockConfig, parseDueAtMs, scheduleClockTasks, startClockDaemonIfNeeded } from '../clock/task-store.js';
+import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
+import { cancelClockTask, clearClockTasks, listClockTasks, resolveClockConfig, parseDueAtMs, scheduleClockTasks, startClockDaemonIfNeeded } from '../clock/task-store.js';
+import { logClock } from '../clock/log.js';
 const FLOW_ID = 'clock_flow';
 function parseToolArguments(toolCall) {
     if (!toolCall.arguments || typeof toolCall.arguments !== 'string') {
@@ -90,9 +92,22 @@ function normalizeScheduleItems(parsed) {
             return { ok: false, items: [], message: 'clock.schedule task must be a non-empty string' };
         }
         const tool = typeof rec.tool === 'string' && rec.tool.trim().length ? rec.tool.trim() : undefined;
-        const argsObj = rec.arguments && typeof rec.arguments === 'object' && !Array.isArray(rec.arguments)
-            ? cloneJson(rec.arguments)
-            : undefined;
+        const argsObj = (() => {
+            const raw = rec.arguments;
+            if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+                return cloneJson(raw);
+            }
+            if (typeof raw === 'string' && raw.trim().length) {
+                try {
+                    const parsed = JSON.parse(raw);
+                    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return undefined;
+        })();
         items.push({
             dueAtMs,
             task,
@@ -118,8 +133,11 @@ const handler = async (ctx) => {
     if (!toolCall || toolCall.name !== 'clock') {
         return null;
     }
-    const clockConfig = normalizeClockConfig(ctx.adapterContext.clock);
+    const rt = readRuntimeMetadata(ctx.adapterContext);
     const sessionId = resolveSessionId(ctx.adapterContext);
+    const rawConfig = rt?.clock ?? ctx.adapterContext.clock;
+    // Default-enable clock when config is absent, but keep "explicitly disabled" honored.
+    const clockConfig = resolveClockConfig(rawConfig);
     const parsedArgs = parseToolArguments(toolCall);
     const action = normalizeAction(parsedArgs.action);
     const respond = (payload) => {
@@ -152,42 +170,50 @@ const handler = async (ctx) => {
             }
         };
     };
-    if (!clockConfig) {
+    if (!sessionId) {
+        logClock('missing_session', { action });
         return respond({
             ok: false,
             action,
-            message: 'clock tool is not enabled (virtualrouter.clock.enabled=true required).'
+            message: 'clock requires sessionId (x-session-id header or metadata.sessionId).'
         });
     }
-    await startClockDaemonIfNeeded(clockConfig);
-    if (!sessionId) {
+    if (!clockConfig) {
+        logClock('disabled', { action, hasSessionId: true });
         return respond({
             ok: false,
             action,
-            message: 'clock requires sessionId (x-session-id header or metadata.sessionId).'
+            message: 'clock tool is not enabled (virtualrouter.clock.enabled=true required).'
         });
     }
+    await startClockDaemonIfNeeded(clockConfig);
     if (action === 'list') {
         const items = await listClockTasks(sessionId, clockConfig);
+        logClock('list', { sessionId, count: items.length });
         return respond({ ok: true, action, items: items.map(mapTaskForTool) });
     }
     if (action === 'clear') {
         const removedCount = await clearClockTasks(sessionId, clockConfig);
+        logClock('clear', { sessionId, removedCount });
         return respond({ ok: true, action, removedCount });
     }
     if (action === 'cancel') {
         const taskId = typeof parsedArgs.taskId === 'string' ? parsedArgs.taskId.trim() : '';
         if (!taskId) {
+            logClock('cancel_invalid', { sessionId, action });
             return respond({ ok: false, action, message: 'clock.cancel requires taskId' });
         }
         const removed = await cancelClockTask(sessionId, taskId, clockConfig);
+        logClock('cancel', { sessionId, taskId, removed });
         return respond({ ok: true, action, removed: removed ? taskId : null });
     }
     const normalized = normalizeScheduleItems(parsedArgs);
     if (!normalized.ok) {
+        logClock('schedule_invalid', { sessionId, message: normalized.message ?? 'invalid schedule items' });
         return respond({ ok: false, action, message: normalized.message ?? 'invalid schedule items' });
     }
     const scheduled = await scheduleClockTasks(sessionId, normalized.items, clockConfig);
+    logClock('schedule', { sessionId, count: scheduled.length });
     return respond({
         ok: true,
         action,

package/dist/servertool/handlers/followup-request-builder.js

@@ -269,12 +269,18 @@ export function buildServerToolFollowupChatPayloadFromInjection(args) {
         return null;
     }
     let messages = Array.isArray(seed.messages) ? cloneJson(seed.messages) : [];
-    let tools = seed.tools ? cloneJson(seed.tools) : undefined;
-    const parameters = seed.parameters ? cloneJson(seed.parameters) : undefined;
     const ops = Array.isArray(args.injection?.ops) ? args.injection.ops : [];
+    // Followup is a normal request hop: inherit tool schema from the captured request and
+    // let compat/tool-governance apply standard sanitization rules.
+    let tools = Array.isArray(seed.tools) ? cloneJson(seed.tools) : undefined;
+    const parameters = seed.parameters ? cloneJson(seed.parameters) : undefined;
     for (const op of ops) {
         if (!op || typeof op !== 'object')
             continue;
+        if (op.op === 'preserve_tools') {
+            // No-op: tools are preserved by default. Kept for backward compatibility.
+            continue;
+        }
         if (op.op === 'trim_openai_messages') {
             const maxNonSystemMessages = typeof op.maxNonSystemMessages === 'number'
                 ? op.maxNonSystemMessages

package/dist/servertool/handlers/gemini-empty-reply-continue.js

@@ -1,6 +1,7 @@
 import { registerServerToolHandler } from '../registry.js';
 import { isCompactionRequest } from './compaction-detect.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
 const FLOW_ID = 'gemini_empty_reply_continue';
 const handler = async (ctx) => {
     if (!ctx.capabilities.reenterPipeline) {
@@ -8,11 +9,12 @@ const handler = async (ctx) => {
     }
     // 避免在 followup 请求里再次触发，防止循环。
     const adapterRecord = ctx.adapterContext;
-    const followupRaw = adapterRecord.serverToolFollowup;
+    const rt = readRuntimeMetadata(ctx.adapterContext);
+    const followupRaw = rt?.serverToolFollowup;
     if (followupRaw === true || (typeof followupRaw === 'string' && followupRaw.trim().toLowerCase() === 'true')) {
         return null;
     }
-    if (hasCompactionFlag(adapterRecord)) {
+    if (hasCompactionFlag(rt)) {
         return null;
     }
     // 仅针对 gemini-chat 协议 + antigravity.* providerKey 的 /v1/responses 路径启用。
@@ -40,7 +42,7 @@ const handler = async (ctx) => {
         return null;
     }
     // 统计连续空回复次数，超过上限后不再自动续写，而是返回一个可重试错误。
-    const previousCountRaw = adapterRecord.geminiEmptyReplyCount;
+    const previousCountRaw = rt?.geminiEmptyReplyCount;
     const previousCount = typeof previousCountRaw === 'number' && Number.isFinite(previousCountRaw) && previousCountRaw >= 0
         ? previousCountRaw
         : 0;
@@ -90,13 +92,17 @@ const handler = async (ctx) => {
                     entryEndpoint: ctx.entryEndpoint,
                     injection: {
                         ops: [
+                            { op: 'trim_openai_messages', maxNonSystemMessages: 16 },
                             { op: 'append_assistant_message', required: false },
-                            { op: 'append_user_text', text: '继续执行' }
+                            { op: 'append_user_text', text: 'continue' }
                         ]
                     },
-                    metadata: {
-                        geminiEmptyReplyCount: nextCount
-                    }
+                    metadata: (() => {
+                        const meta = {};
+                        const runtime = ensureRuntimeMetadata(meta);
+                        runtime.geminiEmptyReplyCount = nextCount;
+                        return meta;
+                    })()
                 }
             }
         })
@@ -250,8 +256,8 @@ function getCapturedRequest(adapterContext) {
     }
     return captured;
 }
-function hasCompactionFlag(record) {
-    const flag = record.compactionRequest;
+function hasCompactionFlag(rt) {
+    const flag = rt && typeof rt === 'object' && !Array.isArray(rt) ? rt.compactionRequest : undefined;
     if (flag === true) {
         return true;
     }

package/dist/servertool/handlers/iflow-model-error-retry.js

@@ -1,18 +1,20 @@
 import { registerServerToolHandler } from '../registry.js';
 import { isCompactionRequest } from './compaction-detect.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
 const FLOW_ID = 'iflow_model_error_retry';
 const handler = async (ctx) => {
     if (!ctx.capabilities.reenterPipeline) {
         return null;
     }
     const adapterRecord = ctx.adapterContext;
+    const rt = readRuntimeMetadata(ctx.adapterContext);
     // 避免在 followup 请求里再次触发，防止循环。
-    const followupRaw = adapterRecord.serverToolFollowup;
+    const followupRaw = rt?.serverToolFollowup;
     if (followupRaw === true || (typeof followupRaw === 'string' && followupRaw.trim().toLowerCase() === 'true')) {
         return null;
     }
-    if (hasCompactionFlag(adapterRecord)) {
+    if (hasCompactionFlag(rt)) {
         return null;
     }
     // 仅针对 openai-chat 协议 + iflow.* providerKey 的 /v1/responses 路径启用。
@@ -78,8 +80,8 @@ function getCapturedRequest(adapterContext) {
     }
     return captured;
 }
-function hasCompactionFlag(record) {
-    const flag = record.compactionRequest;
+function hasCompactionFlag(rt) {
+    const flag = rt && typeof rt === 'object' && !Array.isArray(rt) ? rt.compactionRequest : undefined;
     if (flag === true) {
         return true;
     }

package/dist/servertool/handlers/recursive-detection-guard.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { registerServerToolHandler } from '../registry.js';
 import { cloneJson } from '../server-side-tools.js';
+import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
 const FLOW_ID = 'recursive_detection_guard';
 const CONSECUTIVE_TRIGGER_COUNT = 10;
@@ -28,11 +29,12 @@ function getRecursiveDetectionConfig() {
 }
 function shouldSkipFollowup(adapterContext) {
     const record = adapterContext;
-    const loopState = record ? record.serverToolLoopState : undefined;
+    const rt = readRuntimeMetadata(record ?? undefined);
+    const loopState = rt ? rt.serverToolLoopState : undefined;
     if (loopState && typeof loopState === 'object' && !Array.isArray(loopState)) {
         return true;
     }
-    const raw = record ? record.serverToolFollowup : undefined;
+    const raw = rt ? rt.serverToolFollowup : undefined;
     if (raw === true) {
         return true;
     }

package/dist/servertool/handlers/stop-message-auto.js

@@ -2,7 +2,9 @@ import { registerServerToolHandler } from '../registry.js';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync } from '../../router/virtual-router/sticky-session-store.js';
 import { isCompactionRequest } from './compaction-detect.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
 const STOPMESSAGE_DEBUG = (process.env.ROUTECODEX_STOPMESSAGE_DEBUG || '').trim() === '1';
+const STOPMESSAGE_IMPLICIT_GEMINI = (process.env.ROUTECODEX_STOPMESSAGE_IMPLICIT_GEMINI || '').trim() === '1';
 function debugLog(message, extra) {
     if (!STOPMESSAGE_DEBUG) {
         return;
@@ -20,17 +22,26 @@ function debugLog(message, extra) {
 const FLOW_ID = 'stop_message_flow';
 const handler = async (ctx) => {
     const record = ctx.adapterContext;
+    const rt = readRuntimeMetadata(ctx.adapterContext);
     debugLog('handler_start', {
         requestId: record.requestId,
         providerProtocol: record.providerProtocol
     });
-    const followupFlagRaw = record.serverToolFollowup;
+    const followupFlagRaw = rt?.serverToolFollowup;
     if (followupFlagRaw === true ||
         (typeof followupFlagRaw === 'string' && followupFlagRaw.trim().toLowerCase() === 'true')) {
-        debugLog('skip_followup_loop');
-        return null;
+        // Allow chained followups only within the stop_message_flow loop itself.
+        // Other servertool followups must not re-trigger stopMessage (prevents cross-flow loops).
+        const loopState = rt?.serverToolLoopState;
+        const flowId = loopState && typeof loopState === 'object' && !Array.isArray(loopState)
+            ? String(loopState.flowId || '').trim()
+            : '';
+        if (flowId !== FLOW_ID) {
+            debugLog('skip_followup_loop');
+            return null;
+        }
     }
-    if (hasCompactionFlag(record)) {
+    if (hasCompactionFlag(rt)) {
         debugLog('skip_compaction_flag');
         return null;
     }
@@ -51,13 +62,28 @@ const handler = async (ctx) => {
         return null;
     }
     let state = loadRoutingInstructionStateSync(stickyKey);
+    // If stopMessage was created implicitly (auto) but implicit mode is disabled, do not run it.
+    // This avoids surprising followups like "继续执行" when the user never enabled stopMessage.
+    if (state &&
+        typeof state.stopMessageSource === 'string' &&
+        state.stopMessageSource.trim().toLowerCase() === 'auto' &&
+        !STOPMESSAGE_IMPLICIT_GEMINI) {
+        state.stopMessageText = undefined;
+        state.stopMessageMaxRepeats = undefined;
+        state.stopMessageUsed = undefined;
+        state.stopMessageUpdatedAt = undefined;
+        state.stopMessageLastUsedAt = undefined;
+        saveRoutingInstructionStateAsync(stickyKey, state);
+        debugLog('skip_auto_state_disabled', { stickyKey });
+        return null;
+    }
     if (!state || !state.stopMessageText || !state.stopMessageMaxRepeats) {
-        const fallback = resolveStopMessageSnapshot(record.stopMessageState);
+        const fallback = resolveStopMessageSnapshot(rt?.stopMessageState);
         if (fallback) {
             state = createStopMessageState(fallback);
         }
         else {
-            const implicit = resolveImplicitGeminiStopMessageSnapshot(ctx, record);
+            const implicit = STOPMESSAGE_IMPLICIT_GEMINI ? resolveImplicitGeminiStopMessageSnapshot(ctx, record) : null;
             if (!implicit) {
                 debugLog('skip_no_state', { stickyKey });
                 return null;
@@ -87,11 +113,15 @@ const handler = async (ctx) => {
             used,
             maxRepeats
         });
+        // Auto-clear after reaching max repeats to avoid leaving an "exhausted" stopMessage stuck in sticky state.
+        const now = Date.now();
         state.stopMessageText = undefined;
         state.stopMessageMaxRepeats = undefined;
         state.stopMessageUsed = undefined;
-        state.stopMessageUpdatedAt = undefined;
-        state.stopMessageLastUsedAt = undefined;
+        state.stopMessageSource = undefined;
+        // Keep monotonic timestamps as a tombstone to prevent accidental re-application from replayed history.
+        state.stopMessageUpdatedAt = now;
+        state.stopMessageLastUsedAt = now;
         saveRoutingInstructionStateAsync(stickyKey, state);
         return null;
     }
@@ -131,6 +161,7 @@ const handler = async (ctx) => {
                     injection: {
                         ops: [
                             { op: 'append_assistant_message', required: false },
+                            { op: 'preserve_tools' },
                             { op: 'append_user_text', text }
                         ]
                     },
@@ -341,8 +372,8 @@ function resolveStopMessageSnapshot(raw) {
         ...(lastUsedAt ? { lastUsedAt } : {})
     };
 }
-function hasCompactionFlag(record) {
-    const flag = record.compactionRequest;
+function hasCompactionFlag(rt) {
+    const flag = rt && typeof rt === 'object' && !Array.isArray(rt) ? rt.compactionRequest : undefined;
     if (flag === true) {
         return true;
     }
@@ -376,6 +407,12 @@ function resolveImplicitGeminiStopMessageSnapshot(ctx, record) {
         if (!isStopFinishReason(ctx.base)) {
             return null;
         }
+        // 仅在“空回复”时触发隐式 stopMessage：
+        // - 这个场景由 gemini_empty_reply_continue 专门处理；
+        // - stop_message_auto 里的隐式逻辑只作为兼容兜底（且默认关闭），避免对正常 stop 响应追加“继续执行”。
+        if (!isEmptyAssistantReply(ctx.base)) {
+            return null;
+        }
         return {
             text: '继续执行',
             maxRepeats: 1,
@@ -387,6 +424,59 @@ function resolveImplicitGeminiStopMessageSnapshot(ctx, record) {
         return null;
     }
 }
+function isEmptyAssistantReply(base) {
+    if (!base || typeof base !== 'object' || Array.isArray(base)) {
+        return false;
+    }
+    const payload = base;
+    const choicesRaw = payload.choices;
+    if (Array.isArray(choicesRaw) && choicesRaw.length) {
+        const first = choicesRaw[0];
+        if (!first || typeof first !== 'object' || Array.isArray(first)) {
+            return false;
+        }
+        const finishReasonRaw = first.finish_reason;
+        const finishReason = typeof finishReasonRaw === 'string' && finishReasonRaw.trim()
+            ? finishReasonRaw.trim().toLowerCase()
+            : '';
+        // 仅接受 stop：length 截断通常并非“空回复”，而是需要续写（由 gemini_empty_reply_continue 负责）。
+        if (finishReason !== 'stop') {
+            return false;
+        }
+        const message = first.message &&
+            typeof first.message === 'object' &&
+            !Array.isArray(first.message)
+            ? first.message
+            : null;
+        if (!message) {
+            return false;
+        }
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        if (toolCalls.length > 0) {
+            return false;
+        }
+        const contentRaw = message.content;
+        const text = typeof contentRaw === 'string' ? contentRaw.trim() : '';
+        return text.length === 0;
+    }
+    // OpenAI Responses shape: treat empty output_text + no tool-like output as empty reply.
+    const statusRaw = typeof payload.status === 'string' ? payload.status.trim().toLowerCase() : '';
+    if (statusRaw && statusRaw !== 'completed') {
+        return false;
+    }
+    if (payload.required_action && typeof payload.required_action === 'object') {
+        return false;
+    }
+    const outputText = extractResponsesOutputText(payload);
+    if (outputText.length > 0) {
+        return false;
+    }
+    const outputRaw = Array.isArray(payload.output) ? payload.output : [];
+    if (outputRaw.some((item) => hasToolLikeOutput(item))) {
+        return false;
+    }
+    return true;
+}
 function createStopMessageState(snapshot) {
     return {
         forcedTarget: undefined,

package/dist/servertool/handlers/vision.js

@@ -2,6 +2,7 @@ import { registerServerToolHandler } from '../registry.js';
 import { cloneJson, extractTextFromChatLike } from '../server-side-tools.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
 import { reenterServerToolBackend } from '../reenter-backend.js';
+import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
 const FLOW_ID = 'vision_flow';
 const handler = async (ctx) => {
     if (!ctx.capabilities.reenterPipeline) {
@@ -84,7 +85,9 @@ export async function executeVisionBackendPlan(args) {
 }
 function shouldRunVisionFlow(ctx) {
     const record = ctx.adapterContext;
-    const followupFlag = record.serverToolFollowup === true || record.serverToolFollowup === 'true';
+    const rt = readRuntimeMetadata(record);
+    const followupRaw = rt?.serverToolFollowup;
+    const followupFlag = followupRaw === true || followupRaw === 'true';
     if (followupFlag) {
         return false;
     }

package/dist/servertool/handlers/web-search.js

@@ -3,6 +3,7 @@ import { registerServerToolHandler } from '../registry.js';
 import { cloneJson, extractTextFromChatLike } from '../server-side-tools.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
 import { reenterServerToolBackend } from '../reenter-backend.js';
+import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
 const FLOW_ID = 'web_search_flow';
 const handler = async (ctx) => {
     const toolCall = ctx.toolCall;
@@ -98,7 +99,8 @@ function parseToolArguments(toolCall) {
     }
 }
 function getWebSearchConfig(ctx) {
-    const raw = ctx && typeof ctx === 'object' ? ctx.webSearch : undefined;
+    const rt = readRuntimeMetadata(ctx);
+    const raw = rt ? rt.webSearch : undefined;
     const record = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : null;
     if (!record)
         return undefined;

package/dist/servertool/pending-session.d.ts

@@ -0,0 +1,19 @@
+import type { JsonObject } from '../conversion/hub/types/json.js';
+export interface PendingServerToolInjection {
+    version: 1;
+    sessionId: string;
+    createdAtMs: number;
+    /**
+     * Client tool_call ids that must appear in the next request's tool messages
+     * before we apply the pending servertool injection.
+     */
+    afterToolCallIds: string[];
+    /**
+     * Chat messages to inject (assistant tool_call message + tool result messages).
+     */
+    messages: JsonObject[];
+    sourceRequestId?: string;
+}
+export declare function savePendingServerToolInjection(sessionId: string, pending: Omit<PendingServerToolInjection, 'version' | 'sessionId'>): Promise<void>;
+export declare function loadPendingServerToolInjection(sessionId: string): Promise<PendingServerToolInjection | null>;
+export declare function clearPendingServerToolInjection(sessionId: string): Promise<void>;

package/dist/servertool/pending-session.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { readJsonFile, writeJsonFileAtomic } from './clock/io.js';
+function readSessionDirEnv() {
+    return String(process.env.ROUTECODEX_SESSION_DIR || '').trim();
+}
+function sanitizeSegment(value) {
+    return String(value || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9_.-]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+function resolvePendingDir(sessionDir) {
+    return path.join(sessionDir, 'servertool-pending');
+}
+function resolvePendingFile(sessionDir, sessionId) {
+    const safe = sanitizeSegment(sessionId);
+    if (!safe)
+        return null;
+    return path.join(resolvePendingDir(sessionDir), `${safe}.json`);
+}
+function coercePending(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const rec = value;
+    const sessionId = typeof rec.sessionId === 'string' ? rec.sessionId.trim() : '';
+    const createdAtMs = typeof rec.createdAtMs === 'number' && Number.isFinite(rec.createdAtMs) ? Math.floor(rec.createdAtMs) : 0;
+    const afterToolCallIds = Array.isArray(rec.afterToolCallIds)
+        ? rec.afterToolCallIds.filter((x) => typeof x === 'string' && x.trim().length).map((x) => String(x).trim())
+        : [];
+    const messages = Array.isArray(rec.messages)
+        ? rec.messages.filter((m) => m && typeof m === 'object' && !Array.isArray(m))
+        : [];
+    if (!sessionId || !createdAtMs || !afterToolCallIds.length || !messages.length) {
+        return null;
+    }
+    const sourceRequestId = typeof rec.sourceRequestId === 'string' && rec.sourceRequestId.trim().length
+        ? rec.sourceRequestId.trim()
+        : undefined;
+    return {
+        version: 1,
+        sessionId,
+        createdAtMs,
+        afterToolCallIds,
+        messages,
+        ...(sourceRequestId ? { sourceRequestId } : {})
+    };
+}
+export async function savePendingServerToolInjection(sessionId, pending) {
+    const base = readSessionDirEnv();
+    if (!base)
+        return;
+    const file = resolvePendingFile(base, sessionId);
+    if (!file)
+        return;
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const payload = {
+        version: 1,
+        sessionId,
+        createdAtMs: pending.createdAtMs,
+        afterToolCallIds: pending.afterToolCallIds,
+        messages: pending.messages,
+        ...(pending.sourceRequestId ? { sourceRequestId: pending.sourceRequestId } : {})
+    };
+    await writeJsonFileAtomic(file, payload);
+}
+export async function loadPendingServerToolInjection(sessionId) {
+    const base = readSessionDirEnv();
+    if (!base)
+        return null;
+    const file = resolvePendingFile(base, sessionId);
+    if (!file)
+        return null;
+    try {
+        const raw = await readJsonFile(file);
+        return coercePending(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function clearPendingServerToolInjection(sessionId) {
+    const base = readSessionDirEnv();
+    if (!base)
+        return;
+    const file = resolvePendingFile(base, sessionId);
+    if (!file)
+        return;
+    try {
+        await fs.rm(file, { force: true });
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/servertool/reenter-backend.js

@@ -1,14 +1,16 @@
+import { ensureRuntimeMetadata } from '../conversion/shared/runtime-metadata.js';
 export async function reenterServerToolBackend(args) {
     const routeHint = typeof args.routeHint === 'string' && args.routeHint.trim().length ? args.routeHint.trim() : undefined;
     const merged = {
         providerProtocol: args.providerProtocol,
-        serverToolFollowup: true,
         stream: false,
-        preserveRouteHint: false,
-        disableStickyRoutes: true,
         ...(routeHint ? { routeHint } : {}),
         ...(args.metadata ?? {})
     };
+    const rt = ensureRuntimeMetadata(merged);
+    rt.serverToolFollowup = true;
+    rt.preserveRouteHint = false;
+    rt.disableStickyRoutes = true;
     return await args.reenterPipeline({
         entryEndpoint: args.entryEndpoint,
         requestId: args.requestId,