@jsonstudio/rcc 0.90.701 → 0.90.814

package/node_modules/@jsonstudio/llms/dist/servertool/followup-shadow.d.ts

@@ -0,0 +1,16 @@
+import type { StageRecorder } from '../conversion/hub/format-adapters/index.js';
+import type { JsonObject } from '../conversion/hub/types/json.js';
+export type HubFollowupMode = 'off' | 'shadow' | 'enforce';
+export interface HubFollowupConfig {
+    mode: HubFollowupMode;
+    sampleRate?: number;
+}
+export declare function resolveHubFollowupConfigFromEnv(): HubFollowupConfig;
+export declare function applyHubFollowupPolicyShadow(args: {
+    config?: HubFollowupConfig;
+    requestId?: string;
+    entryEndpoint?: string;
+    flowId?: string;
+    payload: JsonObject;
+    stageRecorder?: StageRecorder;
+}): JsonObject;

package/node_modules/@jsonstudio/llms/dist/servertool/followup-shadow.js

@@ -0,0 +1,145 @@
+import { isJsonObject, jsonClone } from '../conversion/hub/types/json.js';
+function clampSampleRate(value) {
+    const num = typeof value === 'number' && Number.isFinite(value) ? value : 1;
+    if (num <= 0)
+        return 0;
+    if (num >= 1)
+        return 1;
+    return num;
+}
+function fnv1a32(input) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i);
+        hash = (hash * 0x01000193) >>> 0;
+    }
+    return hash >>> 0;
+}
+function shouldSample(config, requestId) {
+    const rate = clampSampleRate(config.sampleRate);
+    if (rate <= 0)
+        return false;
+    if (rate >= 1)
+        return true;
+    const key = typeof requestId === 'string' && requestId.trim().length ? requestId.trim() : 'no_request_id';
+    const bucket = fnv1a32(key) / 0xffffffff;
+    return bucket < rate;
+}
+function readMode(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (normalized === 'off' || normalized === '0' || normalized === 'false')
+        return 'off';
+    if (normalized === 'shadow')
+        return 'shadow';
+    if (normalized === 'enforce')
+        return 'enforce';
+    return null;
+}
+export function resolveHubFollowupConfigFromEnv() {
+    const raw = String(process.env.ROUTECODEX_HUB_FOLLOWUP_MODE || '').trim();
+    const mode = readMode(raw) ?? 'off';
+    const sampleRateRaw = String(process.env.ROUTECODEX_HUB_FOLLOWUP_SAMPLE_RATE || '').trim();
+    const sampleRate = sampleRateRaw ? Number(sampleRateRaw) : undefined;
+    return {
+        mode,
+        ...(Number.isFinite(sampleRate) ? { sampleRate } : {})
+    };
+}
+function dropKeyByPrefix(root, prefixes) {
+    for (const key of Object.keys(root)) {
+        if (prefixes.some((p) => key.startsWith(p))) {
+            try {
+                delete root[key];
+            }
+            catch {
+                root[key] = undefined;
+            }
+        }
+    }
+}
+function normalizeFollowupPayload(payload) {
+    const out = jsonClone(payload);
+    const record = out;
+    // Followup requests must be non-streaming and must not carry route hints.
+    if (record.stream !== undefined) {
+        record.stream = false;
+    }
+    if (record.routeHint !== undefined) {
+        delete record.routeHint;
+    }
+    if (record.route_hint !== undefined) {
+        delete record.route_hint;
+    }
+    // Remove internal/private carriers from the body (metadata belongs to request metadata, not body).
+    dropKeyByPrefix(record, ['__']);
+    const parameters = record.parameters;
+    if (isJsonObject(parameters)) {
+        const params = parameters;
+        if (params.stream !== undefined) {
+            delete params.stream;
+        }
+    }
+    return out;
+}
+function diffPayloads(baseline, candidate, p = '<root>') {
+    if (Object.is(baseline, candidate))
+        return [];
+    if (typeof baseline !== typeof candidate)
+        return [{ path: p, baseline, candidate }];
+    if (Array.isArray(baseline) && Array.isArray(candidate)) {
+        const max = Math.max(baseline.length, candidate.length);
+        const diffs = [];
+        for (let i = 0; i < max; i += 1) {
+            diffs.push(...diffPayloads(baseline[i], candidate[i], `${p}[${i}]`));
+        }
+        return diffs;
+    }
+    if (baseline && typeof baseline === 'object' && candidate && typeof candidate === 'object') {
+        const a = baseline;
+        const b = candidate;
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        const diffs = [];
+        for (const key of keys) {
+            const next = p === '<root>' ? key : `${p}.${key}`;
+            if (!(key in b))
+                diffs.push({ path: next, baseline: a[key], candidate: undefined });
+            else if (!(key in a))
+                diffs.push({ path: next, baseline: undefined, candidate: b[key] });
+            else
+                diffs.push(...diffPayloads(a[key], b[key], next));
+        }
+        return diffs;
+    }
+    return [{ path: p, baseline, candidate }];
+}
+export function applyHubFollowupPolicyShadow(args) {
+    const cfg = args.config ?? resolveHubFollowupConfigFromEnv();
+    if (!cfg || cfg.mode === 'off') {
+        return args.payload;
+    }
+    if (!shouldSample(cfg, args.requestId)) {
+        return args.payload;
+    }
+    const candidate = normalizeFollowupPayload(args.payload);
+    const diffs = diffPayloads(args.payload, candidate);
+    if (diffs.length > 0) {
+        const stage = `hub_followup.${cfg.mode}.payload`;
+        args.stageRecorder?.record(stage, {
+            kind: 'hub_followup_payload_shadow',
+            requestId: args.requestId,
+            entryEndpoint: args.entryEndpoint,
+            flowId: args.flowId,
+            diffCount: diffs.length,
+            diffPaths: diffs.slice(0, 50).map((d) => d.path),
+            diffHead: diffs.slice(0, 50).map((d) => ({ path: d.path, baseline: d.baseline, candidate: d.candidate })),
+            baseline: jsonClone(args.payload),
+            candidate: jsonClone(candidate)
+        });
+    }
+    if (cfg.mode === 'enforce') {
+        return candidate;
+    }
+    return args.payload;
+}

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/antigravity-thought-signature-bootstrap.d.ts

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

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/antigravity-thought-signature-bootstrap.js

@@ -0,0 +1,201 @@
+import { registerServerToolHandler } from '../registry.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../../conversion/runtime-metadata.js';
+import { cloneJson } from '../server-side-tools.js';
+const FLOW_ID = 'antigravity_thought_signature_bootstrap';
+function readProviderKey(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object') {
+        return '';
+    }
+    const raw = adapterContext.providerKey ?? adapterContext.runtimeKey ?? adapterContext.providerId;
+    return typeof raw === 'string' ? raw.trim() : '';
+}
+function isAntigravityFamily(providerKey) {
+    const lowered = providerKey.toLowerCase();
+    return lowered.startsWith('antigravity.') || lowered.startsWith('gemini-cli.');
+}
+function readErrorInfo(base) {
+    const err = base.error;
+    if (!err || typeof err !== 'object' || Array.isArray(err)) {
+        return null;
+    }
+    const codeRaw = err.code;
+    const msgRaw = err.message;
+    const statusRaw = err.status ?? err.statusCode;
+    const code = typeof codeRaw === 'string' ? codeRaw.trim() : typeof codeRaw === 'number' ? String(codeRaw) : undefined;
+    const message = typeof msgRaw === 'string' ? msgRaw.trim() : undefined;
+    const status = typeof statusRaw === 'number' && Number.isFinite(statusRaw)
+        ? Math.floor(statusRaw)
+        : typeof code === 'string' && /^HTTP_\d{3}$/i.test(code)
+            ? Number(code.split('_')[1])
+            : typeof code === 'string' && /^\d{3}$/.test(code)
+                ? Number(code)
+                : undefined;
+    return { ...(status ? { status } : {}), ...(code ? { code } : {}), ...(message ? { message } : {}) };
+}
+function isSignatureInvalidError(error) {
+    const code = (error.code || '').toLowerCase();
+    if (code.includes('signature')) {
+        return true;
+    }
+    const msg = (error.message || '').toLowerCase();
+    return msg.includes('signature') && (msg.includes('invalid') || msg.includes('corrupt') || msg.includes('validator'));
+}
+function shouldTriggerBootstrap(error) {
+    // One-shot bootstrap trigger:
+    // - Always attempt once on 429 (may be quota OR signature validator; one-shot prevents loops).
+    // - Also attempt on 400 when we can confidently classify as signature invalid/missing.
+    if (error.status === 429)
+        return true;
+    if (error.status === 400 && isSignatureInvalidError(error))
+        return true;
+    return false;
+}
+function buildClockToolSchema() {
+    // Keep this schema aligned with docs/SERVERTOOL_CLOCK_DESIGN.md + chat-process injection.
+    return {
+        type: 'function',
+        function: {
+            name: 'clock',
+            description: 'Time + Alarm for this session. Mandatory workflow: before every new clock.schedule, call clock.list first; without a fresh list, new reminder creation is invalid. After listing, prefer clock.update over clock.schedule whenever an existing reminder can be edited. If two reminders would be within 5 minutes, merge or retime them instead of keeping near-duplicate alarms. Use clock.schedule for any blocking wait so work can continue non-blockingly and you will get an interrupt reminder later. If waiting 3 minutes or longer is required, call clock.schedule now (do not only promise to wait). You may set multiple reminders when they are meaningfully different. For complex reminders, write clock.md before waiting and read it first when reminded. Required clock.md template: ## 背景 / ## 当前阻塞点 / ## 下次提醒要做的第一步 / ## 不能忘的检查项. Format example: {"action":"list","items":[],"taskId":""} before {"action":"schedule","items":[{"dueAt":"<ISO8601>","task":"<exact follow-up action>","tool":"<tool-name-or-empty>","arguments":"<json-string-or-{}>"}],"taskId":""}. Use get/schedule/update/list/cancel/clear. Scheduled reminders will be injected into future requests.',
+            strict: true,
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['get', 'schedule', 'update', 'list', 'cancel', 'clear'],
+                        description: 'Get current time, or schedule/update/list/cancel/clear session-scoped reminders. Mandatory rule: before every new clock.schedule, call clock.list first; without a fresh list, new reminder creation is invalid. After listing, prefer clock.update over clock.schedule whenever an existing reminder can be edited. If reminders end up within 5 minutes of each other, reconsider and merge or retime them. Use clock.schedule for blocking waits that should not stall execution. If waiting 3 minutes or longer is required, use action="schedule" immediately. For complex reminders, write the context into clock.md using this template: ## 背景 / ## 当前阻塞点 / ## 下次提醒要做的第一步 / ## 不能忘的检查项.'
+                    },
+                    items: {
+                        type: 'array',
+                        description: 'For schedule/update: list of reminders (update uses items[0]).',
+                        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: 'string',
+                                    description: 'Optional suggested tool arguments as a JSON string (hint only). Use "{}" when unsure.'
+                                }
+                            },
+                            required: ['dueAt', 'task', 'tool', 'arguments'],
+                            additionalProperties: false
+                        }
+                    },
+                    taskId: {
+                        type: 'string',
+                        description: 'For cancel/update: taskId to target.'
+                    }
+                },
+                required: ['action', 'items', 'taskId'],
+                additionalProperties: false
+            }
+        }
+    };
+}
+function ensureClockTool(tools) {
+    const list = Array.isArray(tools) ? cloneJson(tools) : [];
+    const hasClock = list.some((tool) => {
+        const fn = tool && typeof tool === 'object' && !Array.isArray(tool) ? tool.function : undefined;
+        const name = fn && typeof fn === 'object' && typeof fn.name === 'string' ? String(fn.name) : '';
+        return name.trim() === 'clock';
+    });
+    if (hasClock) {
+        return list;
+    }
+    return [...list, buildClockToolSchema()];
+}
+const BOOTSTRAP_USER_PROMPT = '请先调用 `clock` 工具并传入 `{\"action\":\"get\",\"items\":[],\"taskId\":\"\"}` 获取当前时间；' +
+    '得到工具返回后只需回复 `OK`（不要调用其它工具）。';
+const handler = async (ctx) => {
+    if (!ctx.capabilities.reenterPipeline) {
+        return null;
+    }
+    if (ctx.providerProtocol !== 'gemini-chat') {
+        return null;
+    }
+    const providerKey = readProviderKey(ctx.adapterContext);
+    if (!providerKey || !isAntigravityFamily(providerKey)) {
+        return null;
+    }
+    const rt = readRuntimeMetadata(ctx.adapterContext);
+    if (rt?.serverToolFollowup === true) {
+        return null;
+    }
+    if (rt?.antigravityThoughtSignatureBootstrapAttempted === true) {
+        return null;
+    }
+    const error = readErrorInfo(ctx.base);
+    if (!error || !shouldTriggerBootstrap(error)) {
+        return null;
+    }
+    const captured = ctx.adapterContext?.capturedChatRequest;
+    const seed = extractCapturedChatSeed(captured);
+    if (!seed) {
+        return null;
+    }
+    // Preflight bootstrap request:
+    // - Avoid any historical tool calls so Gemini can emit a fresh thoughtSignature.
+    // - Keep the FIRST user message identical to the original request to preserve derived session_id.
+    const originalMessages = Array.isArray(seed.messages) ? cloneJson(seed.messages) : [];
+    const firstUser = originalMessages.find((m) => {
+        const role = typeof m?.role === 'string' ? String(m.role).toLowerCase() : '';
+        return role === 'user';
+    });
+    if (!firstUser) {
+        return null;
+    }
+    const messages = [cloneJson(firstUser), { role: 'user', content: BOOTSTRAP_USER_PROMPT }];
+    const parameters = {
+        ...(seed.parameters && typeof seed.parameters === 'object' && !Array.isArray(seed.parameters)
+            ? cloneJson(seed.parameters)
+            : {})
+    };
+    // Gemini toolConfig forcing: request the model to emit a clock call first, before any other tools.
+    parameters.tool_config = {
+        functionCallingConfig: {
+            mode: 'ANY',
+            allowedFunctionNames: ['clock']
+        }
+    };
+    const followupPayload = {
+        ...(seed.model ? { model: seed.model } : {}),
+        messages,
+        tools: ensureClockTool([]),
+        ...(Object.keys(parameters).length ? { parameters } : {})
+    };
+    const followupMetadata = {
+        __shadowCompareForcedProviderKey: providerKey
+    };
+    const followupRt = ensureRuntimeMetadata(followupMetadata);
+    followupRt.antigravityThoughtSignatureBootstrap = true;
+    followupRt.antigravityThoughtSignatureBootstrapAttempted = true;
+    return {
+        flowId: FLOW_ID,
+        finalize: async () => ({
+            chatResponse: ctx.base,
+            execution: {
+                flowId: FLOW_ID,
+                followup: {
+                    requestIdSuffix: ':antigravity_ts_bootstrap',
+                    entryEndpoint: ctx.entryEndpoint,
+                    payload: followupPayload,
+                    metadata: followupMetadata
+                }
+            }
+        })
+    };
+};
+registerServerToolHandler(FLOW_ID, handler, { trigger: 'auto', hook: { phase: 'default', priority: 30 } });

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/apply-patch-guard.d.ts

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

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/apply-patch-guard.js

@@ -0,0 +1,5 @@
+import { registerServerToolHandler } from '../registry.js';
+const handler = async (ctx) => {
+    return null;
+};
+registerServerToolHandler('apply_patch', handler);

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/clock-auto.d.ts

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

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/clock-auto.js

@@ -0,0 +1,177 @@
+import { registerServerToolHandler } from '../registry.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { readRuntimeMetadata } from '../../conversion/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) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.disconnected !== 'boolean') {
+        return null;
+    }
+    return { disconnected: record.disconnected };
+}
+function clientWantsStreaming(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return false;
+    }
+    const record = adapterContext;
+    if (record.stream === true ||
+        record.inboundStream === true ||
+        record.outboundStream === true ||
+        record.clientStream === true) {
+        return true;
+    }
+    const streamingHint = typeof record.streamingHint === 'string' ? record.streamingHint.trim().toLowerCase() : '';
+    if (streamingHint === 'force') {
+        return true;
+    }
+    const clientHeaders = record.clientHeaders;
+    if (clientHeaders && typeof clientHeaders === 'object' && !Array.isArray(clientHeaders)) {
+        const accept = clientHeaders.accept;
+        if (typeof accept === 'string' && accept.toLowerCase().includes('text/event-stream')) {
+            return true;
+        }
+    }
+    return false;
+}
+function computeHoldSleepMs(remainingMs) {
+    if (remainingMs <= 0)
+        return 0;
+    if (remainingMs > 10 * 60_000)
+        return 30_000;
+    if (remainingMs > 60_000)
+        return 10_000;
+    if (remainingMs > 10_000)
+        return 1_000;
+    return 200;
+}
+async function sleep(ms) {
+    if (!Number.isFinite(ms) || ms <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+const handler = async (ctx) => {
+    const record = ctx.adapterContext;
+    // Only trigger on stop/length completion (no tool calls).
+    if (!isStopEligibleForServerTool(ctx.base, ctx.adapterContext)) {
+        return null;
+    }
+    // When client already disconnected, skip holding.
+    const connectionState = resolveClientConnectionState(record.clientConnectionState);
+    if (connectionState?.disconnected === true) {
+        return null;
+    }
+    const clientDisconnectedRaw = record.clientDisconnected;
+    if (clientDisconnectedRaw === true ||
+        (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
+        return null;
+    }
+    const rt = readRuntimeMetadata(ctx.adapterContext);
+    const sessionId = resolveClockSessionScope(ctx.adapterContext, rt);
+    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);
+    // IMPORTANT: clock hold requires a long-lived client connection.
+    // - Streaming/SSE clients: ok to hold (keepalive is handled by host SSE bridge).
+    // - Non-streaming/JSON clients: only hold when explicitly enabled via config,
+    //   and only within a small max window (holdMaxMs).
+    const wantsStream = clientWantsStreaming(ctx.adapterContext);
+    if (!wantsStream && clockConfig.holdNonStreaming !== true) {
+        return null;
+    }
+    const seed = extractCapturedChatSeed(record.capturedChatRequest);
+    if (!seed) {
+        return null;
+    }
+    const tasks = await listClockTasks(sessionId, clockConfig);
+    const at = nowMs();
+    const nextDueAtMs = findNextUndeliveredDueAtMs(tasks, at);
+    if (!nextDueAtMs) {
+        return null;
+    }
+    // Wait until the "due window" is reached (now >= dueAt - dueWindowMs).
+    const thresholdMs = nextDueAtMs - clockConfig.dueWindowMs;
+    const inDueWindow = at >= thresholdMs;
+    if (inDueWindow) {
+        try {
+            const probe = await reserveDueTasksForRequest({
+                reservationId: `${ctx.requestId}:clock_auto_probe`,
+                sessionId,
+                config: clockConfig,
+                requestId: ctx.requestId
+            });
+            if (!probe.reservation || !Array.isArray(probe.reservation.taskIds) || probe.reservation.taskIds.length === 0) {
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    else {
+        const remainingMs = thresholdMs - at;
+        if (clockConfig.holdMaxMs >= 0 && remainingMs > clockConfig.holdMaxMs) {
+            return null;
+        }
+        logClock('hold_start', { sessionId, nextDueAtMs, thresholdMs });
+        while (nowMs() < thresholdMs) {
+            const state = resolveClientConnectionState(ctx.adapterContext.clientConnectionState);
+            if (state?.disconnected === true) {
+                return null;
+            }
+            const remaining = thresholdMs - nowMs();
+            await sleep(computeHoldSleepMs(remaining));
+            // Best-effort: if tasks were cleared/cancelled while holding, stop holding.
+            try {
+                const refreshed = await listClockTasks(sessionId, clockConfig);
+                const refreshedNext = findNextUndeliveredDueAtMs(refreshed, nowMs());
+                if (!refreshedNext) {
+                    return null;
+                }
+            }
+            catch {
+                // ignore refresh errors; keep holding
+            }
+        }
+    }
+    return {
+        flowId: FLOW_ID,
+        finalize: async () => ({
+            chatResponse: ctx.base,
+            execution: {
+                flowId: FLOW_ID,
+                followup: {
+                    requestIdSuffix: ':clock_hold_followup',
+                    entryEndpoint: ctx.entryEndpoint,
+                    injection: {
+                        ops: [
+                            { op: 'append_assistant_message', required: false },
+                            { op: 'append_user_text', text: 'continue' }
+                        ]
+                    },
+                    metadata: {
+                        ...(connectionState ? { clientConnectionState: connectionState } : {}),
+                        __rt: {
+                            clockFollowupInjectReminders: true
+                        }
+                    }
+                }
+            }
+        })
+    };
+};
+registerServerToolHandler('clock_auto', handler, { trigger: 'auto', hook: { phase: 'post', priority: 50 } });

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/clock.d.ts

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