@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/servertool/handlers/clock.js

@@ -0,0 +1,544 @@
+import { registerServerToolHandler } from '../registry.js';
+import { cloneJson } from '../server-side-tools.js';
+import { dropToolByFunctionName, extractCapturedChatSeed } from './followup-request-builder.js';
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../../conversion/runtime-metadata.js';
+import { cancelClockTask, clearClockTasks, findNearbyClockTasks, hasObservedClockList, listClockTasks, loadClockSessionState, markClockListObserved, resolveClockConfig, parseDueAtMs, scheduleClockTasks, startClockDaemonIfNeeded, updateClockTask } from '../clock/task-store.js';
+import { getClockTimeSnapshot } from '../clock/ntp.js';
+import { nowMs } from '../clock/state.js';
+import { logClock } from '../clock/log.js';
+import { resolveClockSessionScope } from '../clock/session-scope.js';
+import { normalizeQuietHours, recurrenceRemainingRuns } from '../clock/recurrence.js';
+const FLOW_ID = 'clock_flow';
+const CLOCK_LIST_REQUIRED_MESSAGE = 'clock.schedule requires clock.list immediately before creating a new reminder. List existing reminders first, and prefer clock.update when you can edit an existing reminder instead of creating another one.';
+const CLOCK_NEARBY_REMINDER_WINDOW_MS = 5 * 60_000;
+let fallbackClockToolCallSeq = 0;
+function ensureClockToolCall(toolCall, requestId) {
+    if (!toolCall || toolCall.name !== 'clock') {
+        return null;
+    }
+    const existingId = typeof toolCall.id === 'string' ? toolCall.id.trim() : '';
+    if (existingId) {
+        return toolCall;
+    }
+    fallbackClockToolCallSeq += 1;
+    const reqToken = String(requestId || 'req').replace(/[^a-zA-Z0-9_-]+/g, '_') || 'req';
+    return {
+        ...toolCall,
+        id: `call_clock_fallback_${reqToken}_${fallbackClockToolCallSeq}`
+    };
+}
+function extractAssistantMessageFromChatLike(chatResponse) {
+    if (!chatResponse || typeof chatResponse !== 'object') {
+        return null;
+    }
+    const choices = Array.isArray(chatResponse.choices) ? chatResponse.choices : [];
+    if (!choices.length) {
+        return null;
+    }
+    const first = choices[0];
+    if (!first || typeof first !== 'object' || Array.isArray(first)) {
+        return null;
+    }
+    const message = first.message;
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return null;
+    }
+    const role = typeof message.role === 'string' ? String(message.role).toLowerCase() : '';
+    if (role && role !== 'assistant') {
+        return null;
+    }
+    return cloneJson(message);
+}
+function buildToolMessagesFromToolOutputs(chatResponse) {
+    const outputs = Array.isArray(chatResponse.tool_outputs) ? chatResponse.tool_outputs : [];
+    const out = [];
+    for (const entry of outputs) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const toolCallId = typeof entry.tool_call_id === 'string' ? String(entry.tool_call_id) : '';
+        if (!toolCallId)
+            continue;
+        const name = typeof entry.name === 'string' && String(entry.name).trim()
+            ? String(entry.name).trim()
+            : 'tool';
+        const rawContent = entry.content;
+        let contentText;
+        if (typeof rawContent === 'string') {
+            contentText = rawContent;
+        }
+        else {
+            try {
+                contentText = JSON.stringify(rawContent ?? {});
+            }
+            catch {
+                contentText = String(rawContent ?? '');
+            }
+        }
+        out.push({ role: 'tool', tool_call_id: toolCallId, name, content: contentText });
+    }
+    return out;
+}
+function parseToolArguments(toolCall) {
+    if (!toolCall.arguments || typeof toolCall.arguments !== 'string') {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(toolCall.arguments);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function injectClockToolOutput(base, toolCall, content) {
+    const cloned = cloneJson(base);
+    const existingOutputs = Array.isArray(cloned.tool_outputs)
+        ? cloned.tool_outputs
+        : [];
+    let payloadText;
+    if (typeof content === 'string') {
+        payloadText = content;
+    }
+    else {
+        try {
+            payloadText = JSON.stringify(content ?? {});
+        }
+        catch {
+            payloadText = String(content ?? '');
+        }
+    }
+    cloned.tool_outputs = [
+        ...existingOutputs,
+        {
+            tool_call_id: toolCall.id,
+            name: 'clock',
+            content: payloadText
+        }
+    ];
+    return cloned;
+}
+function asPlainObject(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function normalizeAction(value) {
+    const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (raw === 'get' || raw === 'list' || raw === 'cancel' || raw === 'clear' || raw === 'schedule' || raw === 'update') {
+        return raw;
+    }
+    return 'schedule';
+}
+function toIso(ms) {
+    try {
+        return new Date(ms).toISOString();
+    }
+    catch {
+        return new Date(0).toISOString();
+    }
+}
+function parseRecurrenceKind(raw) {
+    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (!value) {
+        return undefined;
+    }
+    if (value === 'daily' || value === 'day') {
+        return 'daily';
+    }
+    if (value === 'weekly' || value === 'week') {
+        return 'weekly';
+    }
+    if (value === 'interval' || value === 'every_minutes' || value === 'every-minutes' || value === 'everyminutes') {
+        return 'interval';
+    }
+    return undefined;
+}
+function parseRecurrenceFromRecord(record) {
+    const recurrenceRaw = record.recurrence ?? record.repeat ?? record.cycle;
+    if (recurrenceRaw === undefined || recurrenceRaw === null || recurrenceRaw === false) {
+        return {};
+    }
+    let kind;
+    let everyMinutesRaw;
+    let maxRunsRaw;
+    let infiniteRaw;
+    let quietHoursRaw;
+    if (typeof recurrenceRaw === 'string') {
+        kind = parseRecurrenceKind(recurrenceRaw);
+        everyMinutesRaw = record.everyMinutes;
+        maxRunsRaw = record.maxRuns;
+        infiniteRaw = record.infinite;
+        quietHoursRaw = record.quietHours ?? record.skipWindows ?? record.blackoutHours;
+    }
+    else if (recurrenceRaw && typeof recurrenceRaw === 'object' && !Array.isArray(recurrenceRaw)) {
+        const recurrenceRecord = recurrenceRaw;
+        kind = parseRecurrenceKind(recurrenceRecord.kind ?? recurrenceRecord.type ?? recurrenceRecord.mode ?? recurrenceRecord.every);
+        everyMinutesRaw = recurrenceRecord.everyMinutes ?? recurrenceRecord.minutes ?? record.everyMinutes;
+        maxRunsRaw = recurrenceRecord.maxRuns ?? record.maxRuns;
+        infiniteRaw = recurrenceRecord.infinite ?? record.infinite;
+        quietHoursRaw = recurrenceRecord.quietHours ?? recurrenceRecord.skipWindows ?? recurrenceRecord.blackoutHours
+            ?? record.quietHours ?? record.skipWindows ?? record.blackoutHours;
+    }
+    if (!kind) {
+        return { message: 'clock.schedule recurrence kind must be daily|weekly|interval' };
+    }
+    const infinite = infiniteRaw === true
+        || (typeof infiniteRaw === 'string' && ['true', '1', 'yes', 'on'].includes(infiniteRaw.trim().toLowerCase()))
+        || (typeof maxRunsRaw === 'string' && ['infinite', 'infinity', 'forever', 'unlimited', '*'].includes(maxRunsRaw.trim().toLowerCase()));
+    const quietHours = normalizeQuietHours(quietHoursRaw);
+    const hasMaxRuns = !(maxRunsRaw === undefined || maxRunsRaw === null || maxRunsRaw === '');
+    const maxRunsNum = hasMaxRuns ? Number(maxRunsRaw) : NaN;
+    const maxRuns = Number.isFinite(maxRunsNum) ? Math.floor(maxRunsNum) : NaN;
+    if (!infinite && hasMaxRuns && (!Number.isFinite(maxRuns) || maxRuns <= 0)) {
+        return { message: 'clock.schedule recurring task maxRuns must be >= 1, or use infinite=true' };
+    }
+    if (kind === 'interval') {
+        const everyMinutesNum = Number(everyMinutesRaw);
+        const everyMinutes = Number.isFinite(everyMinutesNum) ? Math.floor(everyMinutesNum) : NaN;
+        if (!Number.isFinite(everyMinutes) || everyMinutes <= 0) {
+            return { message: 'clock.schedule interval recurrence requires everyMinutes >= 1' };
+        }
+        return {
+            recurrence: {
+                kind: 'interval',
+                everyMinutes,
+                ...(infinite || !hasMaxRuns ? {} : { maxRuns }),
+                ...(quietHours ? { quietHours } : {})
+            }
+        };
+    }
+    return {
+        recurrence: {
+            kind,
+            ...(infinite || !hasMaxRuns ? {} : { maxRuns }),
+            ...(quietHours ? { quietHours } : {})
+        }
+    };
+}
+function normalizeScheduleItems(parsed) {
+    const itemsRaw = parsed.items;
+    if (!Array.isArray(itemsRaw) || itemsRaw.length === 0) {
+        return { ok: false, items: [], message: 'clock.schedule requires items: [{ dueAt, task, tool?, arguments? }]' };
+    }
+    const items = [];
+    for (const entry of itemsRaw) {
+        const rec = asPlainObject(entry);
+        if (!rec) {
+            return { ok: false, items: [], message: 'clock.schedule items must be objects' };
+        }
+        const dueAtMs = parseDueAtMs(rec.dueAt);
+        if (!dueAtMs) {
+            return { ok: false, items: [], message: 'clock.schedule dueAt must be an ISO8601 string' };
+        }
+        const task = typeof rec.task === 'string' ? rec.task.trim() : '';
+        if (!task) {
+            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 = (() => {
+            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;
+        })();
+        const recurrenceParsed = parseRecurrenceFromRecord(rec);
+        if (recurrenceParsed.message) {
+            return { ok: false, items: [], message: recurrenceParsed.message };
+        }
+        items.push({
+            dueAtMs,
+            task,
+            setBy: 'agent',
+            ...(tool ? { tool } : {}),
+            ...(argsObj ? { arguments: argsObj } : {}),
+            ...(recurrenceParsed.recurrence ? { recurrence: recurrenceParsed.recurrence } : {})
+        });
+    }
+    return { ok: true, items };
+}
+function mapTaskForTool(t) {
+    const recurrence = t.recurrence && typeof t.recurrence === 'object'
+        ? {
+            kind: t.recurrence.kind,
+            ...(typeof t.recurrence.maxRuns === 'number' ? { maxRuns: t.recurrence.maxRuns } : { infinite: true }),
+            ...(t.recurrence.kind === 'interval' && typeof t.recurrence.everyMinutes === 'number'
+                ? { everyMinutes: t.recurrence.everyMinutes }
+                : {}),
+            ...(Array.isArray(t.recurrence.quietHours) && t.recurrence.quietHours.length
+                ? { quietHours: t.recurrence.quietHours.map((window) => ({ start: window.start, end: window.end })) }
+                : {})
+        }
+        : undefined;
+    const remainingRuns = recurrence ? recurrenceRemainingRuns(t.recurrence, t.deliveryCount) : undefined;
+    return {
+        taskId: t.taskId,
+        dueAt: toIso(t.dueAtMs),
+        setBy: t.setBy === 'agent' ? 'agent' : 'user',
+        setAt: toIso(t.createdAtMs),
+        task: t.task,
+        ...(t.tool ? { tool: t.tool } : {}),
+        ...(t.arguments ? { arguments: t.arguments } : {}),
+        ...(typeof t.deliveredAtMs === 'number' ? { deliveredAt: toIso(t.deliveredAtMs) } : {}),
+        deliveryCount: t.deliveryCount,
+        ...(recurrence ? { recurrence } : {}),
+        ...(typeof remainingRuns === 'number' ? { remainingRuns } : recurrence ? { remainingRuns: 'infinite' } : {})
+    };
+}
+function buildNearbyReminderWarnings(scheduled, allTasks) {
+    const warnings = [];
+    const seen = new Set();
+    for (const task of scheduled) {
+        const nearby = findNearbyClockTasks(allTasks, task, CLOCK_NEARBY_REMINDER_WINDOW_MS);
+        if (!nearby.length) {
+            continue;
+        }
+        const nearbyIds = nearby.map((item) => item.taskId).sort().join(',');
+        const dedupeKey = `${task.taskId}:${nearbyIds}`;
+        if (seen.has(dedupeKey)) {
+            continue;
+        }
+        seen.add(dedupeKey);
+        warnings.push({
+            scheduled: mapTaskForTool(task),
+            nearby: nearby.map(mapTaskForTool),
+            message: 'Another reminder is within 5 minutes of this one. Consider using clock.update to merge or retime existing reminders instead of keeping two very close alarms.'
+        });
+    }
+    return warnings;
+}
+const handler = async (ctx) => {
+    const toolCall = ensureClockToolCall(ctx.toolCall, ctx.requestId);
+    if (!toolCall) {
+        return null;
+    }
+    const rt = readRuntimeMetadata(ctx.adapterContext);
+    const sessionId = resolveClockSessionScope(ctx.adapterContext, rt);
+    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) => {
+        return {
+            flowId: FLOW_ID,
+            finalize: async () => {
+                const patched = injectClockToolOutput(ctx.base, toolCall, payload);
+                const seed = extractCapturedChatSeed(ctx.adapterContext?.capturedChatRequest);
+                const canFollowup = Boolean(seed);
+                const bootstrapActive = rt?.antigravityThoughtSignatureBootstrap === true;
+                const forcedProviderKey = bootstrapActive &&
+                    typeof ctx.adapterContext.providerKey === 'string' &&
+                    String(ctx.adapterContext.providerKey).trim()
+                    ? String(ctx.adapterContext.providerKey).trim()
+                    : '';
+                return {
+                    chatResponse: patched,
+                    execution: {
+                        flowId: FLOW_ID,
+                        ...(canFollowup
+                            ? {
+                                followup: {
+                                    requestIdSuffix: ':clock_followup',
+                                    entryEndpoint: ctx.entryEndpoint,
+                                    ...(bootstrapActive && seed
+                                        ? {
+                                            payload: (() => {
+                                                const messages = Array.isArray(seed.messages) ? cloneJson(seed.messages) : [];
+                                                const assistant = extractAssistantMessageFromChatLike(ctx.base);
+                                                if (assistant) {
+                                                    messages.push(assistant);
+                                                }
+                                                messages.push(...buildToolMessagesFromToolOutputs(patched));
+                                                const params = seed.parameters && typeof seed.parameters === 'object' && !Array.isArray(seed.parameters)
+                                                    ? { ...seed.parameters }
+                                                    : {};
+                                                // Bootstrap-only: the first hop forces tool_config=clock; the second hop must clear it
+                                                // so the model can either answer or call other tools normally.
+                                                delete params.tool_config;
+                                                return {
+                                                    ...(seed.model ? { model: seed.model } : {}),
+                                                    messages,
+                                                    ...(Array.isArray(seed.tools)
+                                                        ? { tools: dropToolByFunctionName(cloneJson(seed.tools), 'clock') }
+                                                        : {}),
+                                                    ...(Object.keys(params).length ? { parameters: params } : {})
+                                                };
+                                            })(),
+                                            metadata: (() => {
+                                                const meta = {};
+                                                if (forcedProviderKey) {
+                                                    meta.__shadowCompareForcedProviderKey = forcedProviderKey;
+                                                }
+                                                const runtime = ensureRuntimeMetadata(meta);
+                                                runtime.antigravityThoughtSignatureBootstrapAttempted = true;
+                                                return meta;
+                                            })()
+                                        }
+                                        : {
+                                            injection: {
+                                                ops: [
+                                                    { op: 'append_assistant_message', required: true },
+                                                    { op: 'append_tool_messages_from_tool_outputs', required: true },
+                                                    { op: 'drop_tool_by_name', name: 'clock' }
+                                                ]
+                                            }
+                                        })
+                                }
+                            }
+                            : {})
+                    }
+                };
+            }
+        };
+    };
+    if (!clockConfig) {
+        logClock('disabled', { action, hasSessionId: true });
+        return respond({
+            ok: false,
+            action,
+            message: 'clock tool is not enabled (virtualrouter.clock.enabled=true required).'
+        });
+    }
+    await startClockDaemonIfNeeded(clockConfig);
+    if (action === 'get') {
+        try {
+            const snapshot = await getClockTimeSnapshot();
+            logClock('get', { hasSessionId: Boolean(sessionId) });
+            return respond({
+                ok: true,
+                action,
+                active: true,
+                nowMs: snapshot.nowMs,
+                utc: snapshot.utc,
+                local: snapshot.local,
+                timezone: snapshot.timezone,
+                ntp: snapshot.ntp
+            });
+        }
+        catch (err) {
+            logClock('get_error', { message: String(err?.message || err || '') });
+            return respond({
+                ok: false,
+                action,
+                message: `clock.get failed: ${String(err?.message || err || 'unknown')}`
+            });
+        }
+    }
+    if (!sessionId) {
+        logClock('missing_session', { action });
+        return respond({
+            ok: false,
+            action,
+            message: 'clock requires tmux session scope (clientTmuxSessionId/tmuxSessionId).'
+        });
+    }
+    if (action === 'list') {
+        const listedState = await markClockListObserved(sessionId, clockConfig);
+        const items = listedState.tasks.slice();
+        logClock('list', { sessionId, count: items.length });
+        return respond({
+            ok: true,
+            action,
+            items: items.map(mapTaskForTool),
+            guidance: 'Review existing reminders first. Prefer clock.update for edits; create a new reminder only when no existing one fits.'
+        });
+    }
+    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 });
+    }
+    if (action === 'update') {
+        const taskId = typeof parsedArgs.taskId === 'string' ? parsedArgs.taskId.trim() : '';
+        if (!taskId) {
+            logClock('update_invalid', { sessionId, action, reason: 'missing_task_id' });
+            return respond({ ok: false, action, message: 'clock.update requires taskId' });
+        }
+        const normalized = normalizeScheduleItems(parsedArgs);
+        if (!normalized.ok || normalized.items.length < 1) {
+            logClock('update_invalid', { sessionId, action, message: normalized.message ?? 'invalid update payload' });
+            return respond({ ok: false, action, message: normalized.message ?? 'clock.update requires items[0] with dueAt/task' });
+        }
+        const item = normalized.items[0];
+        const patch = {
+            dueAtMs: item.dueAtMs,
+            task: item.task,
+            resetDelivery: true,
+            ...(item.tool ? { tool: item.tool } : {}),
+            ...(item.arguments ? { arguments: item.arguments } : {}),
+            ...(item.recurrence ? { recurrence: item.recurrence } : {})
+        };
+        const updated = await updateClockTask(sessionId, taskId, patch, clockConfig);
+        if (!updated) {
+            logClock('update_miss', { sessionId, taskId });
+            return respond({ ok: false, action, message: 'clock.update failed: task not found or patch invalid' });
+        }
+        logClock('update', { sessionId, taskId });
+        return respond({ ok: true, action, updated: mapTaskForTool(updated) });
+    }
+    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 stateBeforeSchedule = await loadClockSessionState(sessionId, clockConfig);
+    if (!hasObservedClockList(stateBeforeSchedule)) {
+        logClock('schedule_blocked_missing_list', { sessionId, count: normalized.items.length });
+        return respond({
+            ok: false,
+            action,
+            message: CLOCK_LIST_REQUIRED_MESSAGE,
+            requiredAction: 'list',
+            suggestion: 'Run clock.list now, inspect current reminders, then use clock.update when possible before falling back to clock.schedule.'
+        });
+    }
+    const at = nowMs();
+    const guardedItems = normalized.items.map((item) => {
+        if (!item || typeof item !== 'object')
+            return item;
+        if (!Number.isFinite(item.dueAtMs))
+            return item;
+        // When dueAt is already within the trigger window, do NOT allow same-request injection.
+        if (item.dueAtMs <= at + clockConfig.dueWindowMs) {
+            return { ...item, notBeforeRequestId: ctx.requestId };
+        }
+        return item;
+    });
+    const scheduled = await scheduleClockTasks(sessionId, guardedItems, clockConfig);
+    logClock('schedule', { sessionId, count: scheduled.length });
+    const allTasks = await listClockTasks(sessionId, clockConfig);
+    const nearbyWarnings = buildNearbyReminderWarnings(scheduled, allTasks);
+    return respond({
+        ok: true,
+        action,
+        scheduled: scheduled.map(mapTaskForTool),
+        ...(nearbyWarnings.length
+            ? {
+                warning: 'Some reminders are within 5 minutes of another reminder. Consider editing existing reminders instead of creating nearby duplicates.',
+                nearbyReminders: nearbyWarnings
+            }
+            : {})
+    });
+};
+registerServerToolHandler('clock', handler);

package/vendor/llmswitch-core/dist/servertool/handlers/compaction-detect.d.ts

@@ -0,0 +1 @@
+export { isCompactionRequest } from '../../conversion/compaction-detect.js';

package/vendor/llmswitch-core/dist/servertool/handlers/compaction-detect.js

@@ -0,0 +1 @@
+export { isCompactionRequest } from '../../conversion/compaction-detect.js';

package/vendor/llmswitch-core/dist/servertool/handlers/continue-execution.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/servertool/handlers/continue-execution.js

@@ -0,0 +1,110 @@
+import { registerServerToolHandler } from '../registry.js';
+import { cloneJson } from '../server-side-tools.js';
+const FLOW_ID = 'continue_execution_flow';
+const TOOL_NAME = 'continue_execution';
+function parseToolArguments(toolCall) {
+    if (!toolCall.arguments || typeof toolCall.arguments !== 'string') {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(toolCall.arguments);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function injectToolOutput(base, toolCall, content) {
+    const cloned = cloneJson(base);
+    const existingOutputs = Array.isArray(cloned.tool_outputs)
+        ? cloned.tool_outputs
+        : [];
+    let payloadText;
+    if (typeof content === 'string') {
+        payloadText = content;
+    }
+    else {
+        try {
+            payloadText = JSON.stringify(content ?? {});
+        }
+        catch {
+            payloadText = String(content ?? '');
+        }
+    }
+    cloned.tool_outputs = [
+        ...existingOutputs,
+        {
+            tool_call_id: toolCall.id,
+            name: TOOL_NAME,
+            content: payloadText
+        }
+    ];
+    return cloned;
+}
+function normalizeReason(parsed) {
+    const candidate = (typeof parsed.reason === 'string' ? parsed.reason : '') ||
+        (typeof parsed.note === 'string' ? parsed.note : '') ||
+        (typeof parsed.message === 'string' ? parsed.message : '');
+    return candidate.trim();
+}
+function requireVisibleSummary(parsed) {
+    const candidate = typeof parsed.summary === 'string' ? parsed.summary.trim() : '';
+    if (!candidate) {
+        throw new Error('continue_execution requires non-empty "summary" in tool arguments');
+    }
+    return candidate;
+}
+const handler = async (ctx) => {
+    const toolCall = ctx.toolCall;
+    if (!toolCall || toolCall.name !== TOOL_NAME) {
+        return null;
+    }
+    const parsed = parseToolArguments(toolCall);
+    const reason = normalizeReason(parsed);
+    const visibleSummary = requireVisibleSummary(parsed);
+    const clientInjectText = visibleSummary;
+    return {
+        flowId: FLOW_ID,
+        finalize: async () => {
+            const patched = injectToolOutput(ctx.base, toolCall, {
+                ok: true,
+                executed: true,
+                noop: true,
+                action: 'continue_execution',
+                ...(reason ? { reason } : {}),
+                message: 'No-op acknowledged. continue_execution is mandatory before progress-only summaries or stop/end_turn. Do not emit finish_reason=stop/end_turn for progress-only updates. After summary, continue real actions immediately; server auto-followup keeps execution moving. Use clock.schedule for blocking waits, and for complex reminders write/read clock.md with template: ## 背景 / ## 当前阻塞点 / ## 下次提醒要做的第一步 / ## 不能忘的检查项.'
+            });
+            const executionContext = {
+                continue_execution: {
+                    visibleSummary
+                }
+            };
+            return {
+                chatResponse: patched,
+                execution: {
+                    flowId: FLOW_ID,
+                    context: executionContext,
+                    followup: {
+                        requestIdSuffix: ':continue_execution_followup',
+                        entryEndpoint: ctx.entryEndpoint,
+                        injection: {
+                            ops: [
+                                { op: 'preserve_tools' },
+                                { op: 'ensure_standard_tools' },
+                                { op: 'append_assistant_message', required: true },
+                                { op: 'append_tool_messages_from_tool_outputs', required: true }
+                            ]
+                        },
+                        metadata: {
+                            clientInjectOnly: true,
+                            clientInjectText,
+                            visibleSummary,
+                            clientInjectSource: 'servertool.continue_execution'
+                        }
+                    }
+                }
+            };
+        }
+    };
+};
+registerServerToolHandler(TOOL_NAME, handler);

package/vendor/llmswitch-core/dist/servertool/handlers/exec-command-guard.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/servertool/handlers/exec-command-guard.js

@@ -0,0 +1,10 @@
+import { registerServerToolHandler } from '../registry.js';
+const handler = async (_ctx) => {
+    // exec_command is executed by the client. ServerTool must not fabricate tool outputs
+    // or followups; client will run (or fail) and send the real tool_result in next request.
+    //
+    // Shape-only normalization is handled by tool-governor (validateToolCall + normalizedArgs)
+    // before the client receives the tool call.
+    return null;
+};
+registerServerToolHandler('exec_command', handler);