@jsonstudio/llms 0.6.1892 → 0.6.2172

package/dist/router/virtual-router/token-counter.js

@@ -64,11 +64,54 @@ function countMessageTokens(message, encoder) {
     }
     return total;
 }
+function detectMediaKind(record) {
+    const typeValue = typeof record.type === 'string' ? record.type.trim().toLowerCase() : '';
+    if (typeValue.includes('video')) {
+        return 'video';
+    }
+    if (typeValue.includes('image')) {
+        return 'image';
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'video_url')) {
+        return 'video';
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'image_url')) {
+        return 'image';
+    }
+    const dataField = typeof record.data === 'string' ? record.data.trim().toLowerCase() : '';
+    if (dataField.startsWith('data:video/')) {
+        return 'video';
+    }
+    if (dataField.startsWith('data:image/')) {
+        return 'image';
+    }
+    return null;
+}
+function parseStructuredContentString(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const likelyJson = (trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'));
+    if (!likelyJson) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
 function encodeContent(content, encoder) {
     if (content === null || content === undefined) {
         return 0;
     }
     if (typeof content === 'string') {
+        const structured = parseStructuredContentString(content);
+        if (structured !== undefined) {
+            return encodeContent(structured, encoder);
+        }
         return encodeText(content, encoder);
     }
     if (Array.isArray(content)) {
@@ -79,17 +122,11 @@ function encodeContent(content, encoder) {
             }
             else if (part && typeof part === 'object') {
                 const record = part;
-                const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
-                // Large binary/image payloads (data URIs, base64, etc.) should not
-                // dominate context estimation. For image-like blocks, only count a
-                // small textual placeholder instead of the full JSON/body.
-                if (typeValue.startsWith('image')) {
-                    const caption = typeof record.caption === 'string' && record.caption.trim().length
-                        ? record.caption
-                        : '[image]';
-                    total += encodeText(caption, encoder);
+                // Ignore image/video payload blocks in token estimation.
+                if (detectMediaKind(record)) {
+                    continue;
                 }
-                else if (typeof record.text === 'string') {
+                if (typeof record.text === 'string') {
                     total += encodeText(record.text, encoder);
                 }
                 else {
@@ -100,6 +137,10 @@ function encodeContent(content, encoder) {
         return total;
     }
     if (typeof content === 'object') {
+        const record = content;
+        if (detectMediaKind(record)) {
+            return 0;
+        }
         return encodeText(JSON.stringify(content), encoder);
     }
     return encodeText(String(content), encoder);

package/dist/router/virtual-router/tool-signals.js

@@ -1,5 +1,6 @@
 const WEB_TOOL_KEYWORDS = ['websearch', 'web_search', 'web-search', 'webfetch', 'web_fetch', 'web_request', 'search_web', 'internet_search'];
 const READ_TOOL_EXACT = new Set([
+    'read',
     'read_file',
     'read_text',
     'view_file',
@@ -11,6 +12,9 @@ const READ_TOOL_EXACT = new Set([
     'describe_current_request'
 ]);
 const WRITE_TOOL_EXACT = new Set([
+    'edit',
+    'write',
+    'multiedit',
     'apply_patch',
     'write_file',
     'create_file',

package/dist/router/virtual-router/types.d.ts

@@ -386,6 +386,9 @@ export interface RoutingFeatures {
     hasToolCallResponses: boolean;
     hasVisionTool: boolean;
     hasImageAttachment: boolean;
+    hasVideoAttachment?: boolean;
+    hasRemoteVideoAttachment?: boolean;
+    hasLocalVideoAttachment?: boolean;
     hasWebTool: boolean;
     hasWebSearchToolDeclared?: boolean;
     hasCodingTool: boolean;
@@ -473,6 +476,9 @@ export interface StopMessageStateSnapshot {
     stopMessageObservationHash?: string;
     stopMessageObservationStableCount?: number;
     stopMessageBdWorkState?: string;
+    stopMessageAssignedIssueId?: string;
+    stopMessageAssignedIssueSource?: 'in_progress' | 'ready' | 'open';
+    stopMessageNoTaskSummaryUsed?: boolean;
 }
 export interface PreCommandStateSnapshot {
     preCommandScriptPath: string;
@@ -484,6 +490,15 @@ export interface RoutingStatusSnapshot {
         providers: string[];
         hits: number;
         lastUsedProvider?: string;
+        lastHit?: {
+            timestampMs: number;
+            reason?: string;
+            requestTokens?: number;
+            selectionPenalty?: number;
+            stopMessageActive: boolean;
+            stopMessageMode?: 'on' | 'off' | 'auto';
+            stopMessageRemaining?: number;
+        };
     }>;
     health: ProviderHealthState[];
 }

package/dist/servertool/clock/session-scope.d.ts

@@ -0,0 +1,3 @@
+export declare function buildClockSessionScopeFromDaemonId(daemonId: string): string;
+export declare function extractClockDaemonIdFromSessionScope(sessionScope: string): string | null;
+export declare function resolveClockSessionScope(primary?: Record<string, unknown> | null, fallback?: Record<string, unknown> | null): string | null;

package/dist/servertool/clock/session-scope.js

@@ -0,0 +1,52 @@
+const CLOCK_DAEMON_SESSION_PREFIX = 'clockd.';
+function readToken(value) {
+    return typeof value === 'string' && value.trim().length ? value.trim() : '';
+}
+function readRecordToken(record, keys) {
+    if (!record) {
+        return '';
+    }
+    for (const key of keys) {
+        const value = readToken(record[key]);
+        if (value) {
+            return value;
+        }
+    }
+    return '';
+}
+export function buildClockSessionScopeFromDaemonId(daemonId) {
+    const normalized = readToken(daemonId);
+    if (!normalized) {
+        return '';
+    }
+    return `${CLOCK_DAEMON_SESSION_PREFIX}${normalized}`;
+}
+export function extractClockDaemonIdFromSessionScope(sessionScope) {
+    const normalized = readToken(sessionScope);
+    if (!normalized.startsWith(CLOCK_DAEMON_SESSION_PREFIX)) {
+        return null;
+    }
+    const daemonId = normalized.slice(CLOCK_DAEMON_SESSION_PREFIX.length).trim();
+    return daemonId || null;
+}
+export function resolveClockSessionScope(primary, fallback) {
+    const daemonId = readRecordToken(primary, ['clockDaemonId', 'clockClientDaemonId', 'clock_daemon_id', 'clock_client_daemon_id']) ||
+        readRecordToken(fallback, ['clockDaemonId', 'clockClientDaemonId', 'clock_daemon_id', 'clock_client_daemon_id']);
+    if (daemonId) {
+        const daemonScope = buildClockSessionScopeFromDaemonId(daemonId);
+        if (daemonScope) {
+            return daemonScope;
+        }
+    }
+    const sessionId = readRecordToken(primary, ['sessionId', 'session_id']) ||
+        readRecordToken(fallback, ['sessionId', 'session_id']);
+    if (sessionId) {
+        return sessionId;
+    }
+    const conversationId = readRecordToken(primary, ['conversationId', 'conversation_id']) ||
+        readRecordToken(fallback, ['conversationId', 'conversation_id']);
+    if (conversationId) {
+        return conversationId;
+    }
+    return null;
+}

package/dist/servertool/clock/state.js

@@ -24,6 +24,13 @@ function normalizeRecurrence(raw) {
     }
     return { kind, maxRuns };
 }
+function normalizeTaskSetter(raw) {
+    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (value === 'agent') {
+        return 'agent';
+    }
+    return 'user';
+}
 export function setClockOffsetMs(value) {
     if (typeof value !== 'number' || !Number.isFinite(value))
         return;
@@ -68,12 +75,14 @@ export function coerceState(raw, sessionId) {
             : undefined;
         const deliveryCount = typeof e.deliveryCount === 'number' && Number.isFinite(e.deliveryCount) ? Math.max(0, Math.floor(e.deliveryCount)) : 0;
         const recurrence = normalizeRecurrence(e.recurrence);
+        const setBy = normalizeTaskSetter(e.setBy);
         tasks.push({
             taskId,
             sessionId,
             dueAtMs,
             createdAtMs,
             updatedAtMs,
+            setBy,
             task,
             ...(tool ? { tool } : {}),
             ...(args ? { arguments: args } : {}),

package/dist/servertool/clock/tasks.js

@@ -50,6 +50,13 @@ function normalizeRecurrence(raw) {
     }
     return { kind, maxRuns };
 }
+function normalizeTaskSetter(raw) {
+    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (value === 'agent') {
+        return 'agent';
+    }
+    return 'user';
+}
 function resolveRecurringStepMs(recurrence) {
     if (recurrence.kind === 'daily') {
         return 24 * 60 * 60_000;
@@ -139,6 +146,7 @@ export async function scheduleClockTasks(sessionId, items, config) {
         if (item.recurrence && !recurrence) {
             continue;
         }
+        const setBy = normalizeTaskSetter(item.setBy);
         const taskId = buildTaskId();
         scheduled.push({
             taskId,
@@ -146,6 +154,7 @@ export async function scheduleClockTasks(sessionId, items, config) {
             dueAtMs: Math.floor(dueAtMs),
             createdAtMs: at,
             updatedAtMs: at,
+            setBy,
             task: text,
             ...(item.tool ? { tool: item.tool } : {}),
             ...(item.arguments ? { arguments: item.arguments } : {}),
@@ -355,13 +364,15 @@ export async function reserveDueTasksForRequest(args) {
     const injectText = due
         .map((t) => {
         const dueAtIso = new Date(t.dueAtMs).toISOString();
+        const setAtIso = new Date(t.createdAtMs).toISOString();
         const toolLabel = t.tool ? ` tool=${t.tool}` : '';
         const argsLabel = t.arguments ? ` args=${safeJson(t.arguments)}` : '';
+        const setByLabel = t.setBy === 'agent' ? 'agent' : 'user';
         const recurrence = normalizeRecurrence(t.recurrence);
         const recurrenceLabel = recurrence
             ? ` recurrence=${recurrence.kind}${recurrence.kind === 'interval' ? `(${recurrence.everyMinutes}m)` : ''} maxRuns=${recurrence.maxRuns} run=${Math.max(0, t.deliveryCount)}/${recurrence.maxRuns}`
             : '';
-        return `[scheduled task:${safeQuoted(t.task)}${toolLabel}${argsLabel}${recurrenceLabel} dueAt=${dueAtIso}]`;
+        return `[scheduled task:${safeQuoted(t.task)}${toolLabel}${argsLabel}${recurrenceLabel} dueAt=${dueAtIso} setBy=${setByLabel} setAt=${setAtIso}]`;
     })
         .join('\n');
     return { reservation, injectText };

package/dist/servertool/clock/types.d.ts

@@ -4,12 +4,14 @@ export type ClockTaskRecurrence = {
     maxRuns: number;
     everyMinutes?: number;
 };
+export type ClockTaskSetter = 'user' | 'agent';
 export type ClockTask = {
     taskId: string;
     sessionId: string;
     dueAtMs: number;
     createdAtMs: number;
     updatedAtMs: number;
+    setBy: ClockTaskSetter;
     task: string;
     tool?: string;
     arguments?: Record<string, unknown>;
@@ -49,6 +51,7 @@ export type ClockConfigSnapshot = {
 export type ClockScheduleItem = {
     dueAtMs: number;
     task: string;
+    setBy?: ClockTaskSetter;
     tool?: string;
     arguments?: Record<string, unknown>;
     notBeforeRequestId?: string;

package/dist/servertool/engine.js

@@ -7,6 +7,7 @@ import { deserializeRoutingInstructionState, serializeRoutingInstructionState }
 import { applyHubFollowupPolicyShadow } from './followup-shadow.js';
 import { buildServerToolFollowupChatPayloadFromInjection, extractCapturedChatSeed } from './handlers/followup-request-builder.js';
 import { findNextUndeliveredDueAtMs, listClockTasks, resolveClockConfig } from './clock/task-store.js';
+import { resolveClockSessionScope } from './clock/session-scope.js';
 import { savePendingServerToolInjection } from './pending-session.js';
 import { appendServerToolProgressFileEvent } from './log/progress-file.js';
 import { attachStopGatewayContext, inspectStopGatewaySignal } from './stop-gateway-context.js';
@@ -46,6 +47,57 @@ function withTimeout(promise, timeoutMs, buildError) {
         });
     });
 }
+class ServerToolClientDisconnectedError extends Error {
+    code = 'SERVERTOOL_CLIENT_DISCONNECTED';
+}
+function createServerToolClientDisconnectedError(options) {
+    const error = new ServerToolClientDisconnectedError(`[servertool] client disconnected during followup` + (options.flowId ? ` flow=${options.flowId}` : ''));
+    error.details = {
+        requestId: options.requestId,
+        flowId: options.flowId
+    };
+    return error;
+}
+function isServerToolClientDisconnectedError(error) {
+    return Boolean(error &&
+        typeof error === 'object' &&
+        typeof error.code === 'string' &&
+        error.code === 'SERVERTOOL_CLIENT_DISCONNECTED');
+}
+function createClientDisconnectWatcher(options) {
+    const interval = typeof options.pollIntervalMs === 'number' && Number.isFinite(options.pollIntervalMs) && options.pollIntervalMs > 0
+        ? Math.max(20, Math.floor(options.pollIntervalMs))
+        : 80;
+    let timer;
+    let active = true;
+    const cancel = () => {
+        active = false;
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    const promise = new Promise((_resolve, reject) => {
+        const check = () => {
+            if (!active) {
+                return;
+            }
+            if (isAdapterClientDisconnected(options.adapterContext)) {
+                cancel();
+                reject(createServerToolClientDisconnectedError({
+                    requestId: options.requestId,
+                    flowId: options.flowId
+                }));
+                return;
+            }
+            timer = setTimeout(check, interval);
+            timer.unref?.();
+        };
+        timer = setTimeout(check, interval);
+        timer.unref?.();
+    });
+    return { promise, cancel };
+}
 function isServerToolTimeoutError(error) {
     return Boolean(error &&
         typeof error === 'object' &&
@@ -194,6 +246,21 @@ function isEmptyClientResponsePayload(payload) {
     }
     return true;
 }
+function createEmptyFollowupError(args) {
+    const wrapped = new ProviderProtocolError(`[servertool] Followup returned empty response for flow ${args.flowId ?? 'unknown'}`, {
+        code: 'SERVERTOOL_EMPTY_FOLLOWUP',
+        category: 'EXTERNAL_ERROR',
+        details: {
+            flowId: args.flowId,
+            requestId: args.requestId,
+            error: args.lastError instanceof Error ? args.lastError.message : undefined,
+            ...(args.originalResponseWasEmpty ? { originalResponseWasEmpty: true } : {})
+        }
+    });
+    wrapped.status = 502;
+    wrapped.cause = args.lastError;
+    return wrapped;
+}
 function isStopFinishReasonWithoutToolCalls(base) {
     return inspectStopGatewaySignal(base).eligible;
 }
@@ -204,7 +271,7 @@ async function shouldDisableServerToolTimeoutForClockHold(args) {
     }
     const record = args.adapterContext;
     const rt = readRuntimeMetadata(record);
-    const sessionId = typeof record.sessionId === 'string' ? record.sessionId.trim() : '';
+    const sessionId = resolveClockSessionScope(record, rt);
     if (!sessionId) {
         return false;
     }
@@ -526,6 +593,7 @@ export async function runServerToolOrchestration(options) {
     }
     const isStopMessageFlow = engineResult.execution.flowId === 'stop_message_flow';
     const isClockHoldFlow = engineResult.execution.flowId === 'clock_hold_flow';
+    const isContinueExecutionFlow = engineResult.execution.flowId === 'continue_execution_flow';
     const isEmptyReplyContinue = engineResult.execution.flowId === 'empty_reply_continue';
     const isApplyPatchGuard = engineResult.execution.flowId === 'apply_patch_guard';
     const isExecCommandGuard = engineResult.execution.flowId === 'exec_command_guard';
@@ -570,6 +638,7 @@ export async function runServerToolOrchestration(options) {
         };
     }
     const loopState = buildServerToolLoopState(options.adapterContext, engineResult.execution.flowId, followupPayloadRaw, engineResult.finalChatResponse);
+    const stopMessageReservation = null;
     if (applyAutoLimit && loopState && typeof loopState.repeatCount === 'number' && loopState.repeatCount >= 3) {
         logProgress(5, totalSteps, 'completed (auto limit hit)', { flowId });
         return {
@@ -640,9 +709,10 @@ export async function runServerToolOrchestration(options) {
         (typeof options.entryEndpoint === 'string' && options.entryEndpoint.trim().length
             ? options.entryEndpoint
             : followupEntryEndpoint);
-    // For stateful auto-followups (e.g. stop_message_flow / clock_hold_flow), keep the same providerKey/alias.
+    // For stateful auto-followups (e.g. stop_message_flow / clock_hold_flow / continue_execution_flow),
+    // keep the same providerKey/alias.
     // Otherwise the followup requestId suffix would cause round-robin alias switching and compatibility drift.
-    if (isStopMessageFlow || isClockHoldFlow) {
+    if (isStopMessageFlow || isClockHoldFlow || isContinueExecutionFlow) {
         const providerKeyRaw = options.adapterContext.providerKey;
         const providerKey = typeof providerKeyRaw === 'string' && providerKeyRaw.trim().length ? providerKeyRaw.trim() : '';
         if (providerKey) {
@@ -669,7 +739,6 @@ export async function runServerToolOrchestration(options) {
     // 否则会出现下一轮仍然自动触发 → 再次失败 → 客户端永远 502 的死循环。
     //
     // stop_message_flow 的计数器递增由 handler 在决定触发时处理，engine 不再提前递增。
-    const stopMessageReservation = null;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         const elapsedBeforeAttempt = isStopMessageFlow && loopState && typeof loopState.startedAtMs === 'number' && Number.isFinite(loopState.startedAtMs)
             ? Math.max(0, Date.now() - loopState.startedAtMs)
@@ -687,13 +756,19 @@ export async function runServerToolOrchestration(options) {
         const attemptTimeoutMs = isStopMessageFlow && STOP_MESSAGE_STAGE_TIMEOUT_MS > elapsedBeforeAttempt
             ? Math.max(1, Math.min(followupTimeoutMs, STOP_MESSAGE_STAGE_TIMEOUT_MS - elapsedBeforeAttempt))
             : followupTimeoutMs;
+        const disconnectWatcher = createClientDisconnectWatcher({
+            adapterContext: options.adapterContext,
+            requestId: options.requestId,
+            flowId: engineResult.execution.flowId
+        });
         try {
-            followup = await withTimeout(options.reenterPipeline({
+            const followupPromise = options.reenterPipeline({
                 entryEndpoint: followupEntryEndpoint,
                 requestId: followupRequestId,
                 body: followupPayload,
                 metadata
-            }), attemptTimeoutMs, () => isStopMessageFlow
+            });
+            followup = await withTimeout(Promise.race([followupPromise, disconnectWatcher.promise]), attemptTimeoutMs, () => isStopMessageFlow
                 ? createStopMessageFetchFailedError({
                     requestId: options.requestId,
                     reason: 'stage_timeout',
@@ -710,6 +785,7 @@ export async function runServerToolOrchestration(options) {
                     attempt,
                     maxAttempts
                 }));
+            disconnectWatcher.cancel();
             // Treat empty followup as failure for auto followup flows:
             // - retry once (maxAttempts=2)
             // - if still empty, surface as HTTP error so client can retry.
@@ -729,6 +805,15 @@ export async function runServerToolOrchestration(options) {
             break;
         }
         catch (error) {
+            disconnectWatcher.cancel();
+            if (isServerToolClientDisconnectedError(error) || isAdapterClientDisconnected(options.adapterContext)) {
+                logProgress(5, totalSteps, 'completed (client disconnected)', { flowId, attempt });
+                return {
+                    chat: engineResult.finalChatResponse,
+                    executed: true,
+                    flowId: engineResult.execution.flowId
+                };
+            }
             if (isServerToolTimeoutError(error)) {
                 throw error;
             }
@@ -755,28 +840,30 @@ export async function runServerToolOrchestration(options) {
         : undefined;
     if (retryEmptyFollowupOnce && (!followupBody || isEmptyClientResponsePayload(followupBody))) {
         if (isStopMessageFlow) {
-            // 对 stopMessage：避免把 empty followup 升级为 502，直接清理 stopMessage 状态并返回原始响应。
-            // 这样客户端至少能拿到本轮输出，且 stopMessage 不会在后续请求里继续触发导致“永远 502”。
+            // 对 stopMessage：先清理状态，避免后续请求继续触发失败循环；
+            // 若原始响应可用则回退原始响应，否则显式抛错，避免“静默空响应”。
             disableStopMessageAfterFailedFollowup(options.adapterContext, stopMessageReservation);
-            logProgress(5, totalSteps, 'completed (stopMessage followup empty; cleaned state)', { flowId });
-            return {
-                chat: engineResult.finalChatResponse,
-                executed: true,
-                flowId: engineResult.execution.flowId
-            };
-        }
-        const wrapped = new ProviderProtocolError(`[servertool] Followup returned empty response for flow ${engineResult.execution.flowId ?? 'unknown'}`, {
-            code: 'SERVERTOOL_EMPTY_FOLLOWUP',
-            category: 'EXTERNAL_ERROR',
-            details: {
+            const fallbackOriginal = engineResult.finalChatResponse;
+            if (fallbackOriginal && !isEmptyClientResponsePayload(fallbackOriginal)) {
+                logProgress(5, totalSteps, 'completed (stopMessage followup empty; fallback to original)', { flowId });
+                return {
+                    chat: fallbackOriginal,
+                    executed: true,
+                    flowId: engineResult.execution.flowId
+                };
+            }
+            throw createEmptyFollowupError({
                 flowId: engineResult.execution.flowId,
                 requestId: options.requestId,
-                error: lastError instanceof Error ? lastError.message : undefined
-            }
+                lastError,
+                originalResponseWasEmpty: true
+            });
+        }
+        throw createEmptyFollowupError({
+            flowId: engineResult.execution.flowId,
+            requestId: options.requestId,
+            lastError
         });
-        wrapped.status = 502;
-        wrapped.cause = lastError;
-        throw wrapped;
     }
     // Special case: Antigravity thoughtSignature bootstrap flow.
     // - First followup performs a minimal preflight (forces clock.get) to obtain a fresh signature.
@@ -899,19 +986,78 @@ function resolveStickyKeyFromAdapterContext(adapterContext) {
     if (!adapterContext || typeof adapterContext !== 'object') {
         return undefined;
     }
-    const sessionId = typeof adapterContext.sessionId === 'string'
-        ? adapterContext.sessionId.trim()
-        : '';
-    const conversationId = typeof adapterContext.conversationId === 'string'
-        ? adapterContext.conversationId.trim()
-        : '';
+    const record = adapterContext;
+    const runtime = readRuntimeMetadata(record);
+    const providerProtocol = readTextFromAny(record.providerProtocol) ||
+        readTextFromAny(runtime?.providerProtocol) ||
+        readTextFromAny(record.provider_protocol) ||
+        readTextFromAny(runtime?.provider_protocol);
+    if (providerProtocol.trim().toLowerCase() === 'openai-responses') {
+        const previousRequestId = resolveResponsesResumePreviousRequestId(record, runtime);
+        if (previousRequestId) {
+            return previousRequestId;
+        }
+        const requestId = resolveStickyRequestId(record, runtime);
+        if (requestId) {
+            return requestId;
+        }
+    }
+    const sessionId = readTextFromAny(record.sessionId) ||
+        readTextFromAny(record.session_id) ||
+        readTextFromAny(runtime?.sessionId) ||
+        readTextFromAny(runtime?.session_id);
+    const conversationId = readTextFromAny(record.conversationId) ||
+        readTextFromAny(record.conversation_id) ||
+        readTextFromAny(runtime?.conversationId) ||
+        readTextFromAny(runtime?.conversation_id);
     if (sessionId) {
         return `session:${sessionId}`;
     }
     if (conversationId) {
         return `conversation:${conversationId}`;
     }
-    return undefined;
+    const requestId = resolveStickyRequestId(record, runtime);
+    return requestId || undefined;
+}
+function resolveStickyRequestId(context, runtime) {
+    return (readTextFromAny(context.requestId) ||
+        readTextFromAny(context.request_id) ||
+        readTextFromAny(runtime?.requestId) ||
+        readTextFromAny(runtime?.request_id));
+}
+function resolveResponsesResumePreviousRequestId(context, runtime) {
+    const contextMetadata = asRecord(context.metadata);
+    const contextMetadataContext = asRecord(contextMetadata?.context);
+    const originalRequest = asRecord(context.originalRequest);
+    const originalMetadata = asRecord(originalRequest?.metadata);
+    const candidates = [
+        context.responsesResume,
+        contextMetadata?.responsesResume,
+        contextMetadataContext?.responsesResume,
+        originalRequest?.responsesResume,
+        originalMetadata?.responsesResume,
+        runtime?.responsesResume
+    ];
+    for (const candidate of candidates) {
+        const resume = asRecord(candidate);
+        if (!resume) {
+            continue;
+        }
+        const previousRequestId = readTextFromAny(resume.previousRequestId) || readTextFromAny(resume.previous_request_id);
+        if (previousRequestId) {
+            return previousRequestId;
+        }
+    }
+    return '';
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function readTextFromAny(value) {
+    return typeof value === 'string' && value.trim().length ? value.trim() : '';
 }
 function cloneRoutingInstructionState(state) {
     if (!state) {

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

@@ -4,6 +4,7 @@ import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js
 import { findNextUndeliveredDueAtMs, listClockTasks, reserveDueTasksForRequest, resolveClockConfig, startClockDaemonIfNeeded } from '../clock/task-store.js';
 import { nowMs } from '../clock/state.js';
 import { logClock } from '../clock/log.js';
+import { resolveClockSessionScope } from '../clock/session-scope.js';
 import { isStopEligibleForServerTool } from '../stop-gateway-context.js';
 const FLOW_ID = 'clock_hold_flow';
 function resolveClientConnectionState(value) {
@@ -40,13 +41,6 @@ function clientWantsStreaming(adapterContext) {
     }
     return false;
 }
-function resolveSessionId(adapterContext) {
-    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
-        return null;
-    }
-    const sessionId = typeof adapterContext.sessionId === 'string' ? String(adapterContext.sessionId).trim() : '';
-    return sessionId || null;
-}
 function computeHoldSleepMs(remainingMs) {
     if (remainingMs <= 0)
         return 0;
@@ -81,7 +75,7 @@ const handler = async (ctx) => {
         return null;
     }
     const rt = readRuntimeMetadata(ctx.adapterContext);
-    const sessionId = resolveSessionId(ctx.adapterContext);
+    const sessionId = resolveClockSessionScope(ctx.adapterContext, rt);
     if (!sessionId) {
         return null;
     }