@jsonstudio/llms 0.6.954 → 0.6.1172

package/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/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/dist/servertool/handlers/apply-patch-guard.js

@@ -1,269 +1,5 @@
 import { registerServerToolHandler } from '../registry.js';
-import { cloneJson } from '../server-side-tools.js';
-import { validateToolCall } from '../../tools/tool-registry.js';
-import { buildEntryAwareFollowupPayload, extractCapturedChatSeed } from './followup-request-builder.js';
-const FLOW_ID = 'apply_patch_guard';
 const handler = async (ctx) => {
-    const toolCall = ctx.toolCall;
-    if (!toolCall) {
-        return null;
-    }
-    if (!ctx.options.reenterPipeline) {
-        return null;
-    }
-    const rawArgs = typeof toolCall.arguments === 'string' ? toolCall.arguments : '';
-    const validation = validateToolCall('apply_patch', rawArgs);
-    if (validation?.ok) {
-        return null;
-    }
-    const reason = typeof validation?.reason === 'string' && validation.reason.trim()
-        ? validation.reason.trim()
-        : 'unknown';
-    const snippet = rawArgs && rawArgs.trim().length
-        ? rawArgs.trim().slice(0, 200).replace(/\s+/g, ' ')
-        : '';
-    const isExecCommandShape = extractLikelyExecCommandShape(rawArgs);
-    // For obviously wrong shapes (e.g. exec_command-like payload passed into apply_patch),
-    // do NOT attempt a followup "recovery" loop. Return a plain assistant message instead.
-    if (isExecCommandShape && (reason === 'missing_changes' || reason === 'missing_payload' || reason === 'invalid_json')) {
-        const patched = injectApplyPatchHardFailureMessage(ctx.base, toolCall, {
-            reason,
-            snippet,
-            rawArgs
-        });
-        return {
-            chatResponse: patched,
-            execution: { flowId: FLOW_ID }
-        };
-    }
-    const patched = injectApplyPatchRejectedToolResult(ctx.base, toolCall, {
-        reason,
-        snippet,
-        rawArgs
-    });
-    const followupPayload = buildToolFollowupPayload(ctx.adapterContext, patched, ctx.options.entryEndpoint || ctx.adapterContext?.entryEndpoint || '/v1/chat/completions');
-    if (!followupPayload) {
-        // Fail-closed: if we cannot perform reenter, do not intercept.
-        // (This should be rare because HubPipeline always provides capturedChatRequest.)
-        return null;
-    }
-    return {
-        chatResponse: patched,
-        execution: {
-            flowId: FLOW_ID,
-            followup: {
-                requestIdSuffix: ':apply_patch_guard_followup',
-                payload: followupPayload
-            }
-        }
-    };
+    return null;
 };
 registerServerToolHandler('apply_patch', handler);
-function injectApplyPatchHardFailureMessage(base, toolCall, options) {
-    const cloned = cloneJson(base);
-    const choices = Array.isArray(cloned.choices)
-        ? cloned.choices
-        : [];
-    if (!choices.length) {
-        return cloned;
-    }
-    const first = choices[0];
-    if (!first || typeof first !== 'object' || Array.isArray(first)) {
-        return cloned;
-    }
-    const message = first.message;
-    if (!message || typeof message !== 'object' || Array.isArray(message)) {
-        return cloned;
-    }
-    // Replace tool-call response with a plain assistant message.
-    const guidance = buildApplyPatchGuidance(options.rawArgs);
-    const text = `[apply_patch rejected] reason=${options.reason}` +
-        (options.snippet ? ` args=${options.snippet}` : '') +
-        `\n\n${guidance}`;
-    message.content = text;
-    if (Object.prototype.hasOwnProperty.call(message, 'tool_calls')) {
-        delete message.tool_calls;
-    }
-    if (typeof first.finish_reason === 'string' && first.finish_reason === 'tool_calls') {
-        first.finish_reason = 'stop';
-    }
-    // Remove tool_outputs to avoid confusing clients that don't implement tool loops.
-    if (Object.prototype.hasOwnProperty.call(cloned, 'tool_outputs')) {
-        delete cloned.tool_outputs;
-    }
-    return cloned;
-}
-function injectApplyPatchRejectedToolResult(base, toolCall, options) {
-    const cloned = cloneJson(base);
-    const existingOutputs = Array.isArray(cloned.tool_outputs)
-        ? cloned.tool_outputs
-        : [];
-    const payload = {
-        ok: false,
-        tool: 'apply_patch',
-        reason: options.reason,
-        ...(options.snippet ? { argsSnippet: options.snippet } : {}),
-        guidance: buildApplyPatchGuidance(options.rawArgs)
-    };
-    cloned.tool_outputs = [
-        ...existingOutputs,
-        {
-            tool_call_id: toolCall.id,
-            name: 'apply_patch',
-            content: JSON.stringify(payload)
-        }
-    ];
-    return cloned;
-}
-function buildApplyPatchGuidance(rawArgs) {
-    const base = 'apply_patch 参数预检失败。请改用统一 diff（*** Begin Patch ... *** End Patch），' +
-        '或使用结构化 JSON：{ file, changes:[{ file, kind, target/anchor, lines/newText, ... }] }。';
-    const schemaHint = extractLikelyExecCommandShape(rawArgs);
-    if (schemaHint) {
-        return (base +
-            '\n\n' +
-            '你传入的参数看起来像 exec_command（例如包含 "command"/"cmd" 字段），但工具名是 apply_patch。\n' +
-            'apply_patch 必须提供非空的 "changes" 数组；如果你需要执行命令请改用 exec_command（注意：禁止通过 shell 写文件）。');
-    }
-    // User-requested hint (directory deletion is not supported via delete_file).
-    // Heuristic: detect delete_file with a directory-like target (trailing slash).
-    const hintTarget = extractDeleteFileTarget(rawArgs);
-    if (!hintTarget) {
-        return base;
-    }
-    return (base +
-        '\n\n' +
-        `- {"changes":[{"kind":"delete_file","target":"${hintTarget}"}]} ❌ 仍会 invalid_file（因为是目录）\n\n` +
-        '如果你真要删目录：请用 exec_command（例如 rm -rf tmp web-container-manager），或者用 apply_patch 逐个删目录下的文件（更安全、可审计）。');
-}
-function extractDeleteFileTarget(rawArgs) {
-    if (!rawArgs || typeof rawArgs !== 'string') {
-        return null;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(rawArgs);
-    }
-    catch {
-        return null;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return null;
-    }
-    const record = parsed;
-    const changes = Array.isArray(record.changes) ? record.changes : [];
-    for (const change of changes) {
-        if (!change || typeof change !== 'object' || Array.isArray(change))
-            continue;
-        const c = change;
-        const kind = typeof c.kind === 'string' ? c.kind.trim().toLowerCase() : '';
-        if (kind !== 'delete_file')
-            continue;
-        const target = typeof c.target === 'string' ? c.target.trim() : '';
-        if (!target)
-            continue;
-        if (target.endsWith('/')) {
-            return target;
-        }
-    }
-    return null;
-}
-function extractLikelyExecCommandShape(rawArgs) {
-    if (!rawArgs || typeof rawArgs !== 'string') {
-        return false;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(rawArgs);
-    }
-    catch {
-        return false;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return false;
-    }
-    const record = parsed;
-    const command = record.command;
-    const cmd = record.cmd;
-    if (typeof command === 'string' && command.trim()) {
-        return true;
-    }
-    if (typeof cmd === 'string' && cmd.trim()) {
-        return true;
-    }
-    return false;
-}
-function buildToolFollowupPayload(adapterContext, chatResponse, entryEndpoint) {
-    const captured = adapterContext && typeof adapterContext === 'object'
-        ? adapterContext.capturedChatRequest
-        : undefined;
-    const seed = extractCapturedChatSeed(captured);
-    if (!seed) {
-        return null;
-    }
-    const assistantMessage = extractAssistantMessage(chatResponse);
-    if (!assistantMessage) {
-        return null;
-    }
-    const toolMessages = buildToolMessages(chatResponse);
-    if (!toolMessages.length) {
-        return null;
-    }
-    const reconstructed = [...seed.messages, assistantMessage, ...toolMessages];
-    return buildEntryAwareFollowupPayload({
-        entryEndpoint,
-        model: seed.model,
-        messages: reconstructed,
-        ...(seed.tools ? { tools: seed.tools } : {}),
-        ...(seed.parameters ? { parameters: seed.parameters } : {})
-    });
-}
-function extractAssistantMessage(chatResponse) {
-    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;
-    return cloneJson(message);
-}
-function buildToolMessages(chatResponse) {
-    const toolOutputs = Array.isArray(chatResponse.tool_outputs)
-        ? chatResponse.tool_outputs
-        : [];
-    const messages = [];
-    for (const entry of toolOutputs) {
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
-            continue;
-        const record = entry;
-        const toolCallId = typeof record.tool_call_id === 'string' ? record.tool_call_id : undefined;
-        if (!toolCallId)
-            continue;
-        const name = typeof record.name === 'string' && record.name.trim() ? record.name.trim() : 'apply_patch';
-        const rawContent = record.content;
-        let contentText;
-        if (typeof rawContent === 'string') {
-            contentText = rawContent;
-        }
-        else {
-            try {
-                contentText = JSON.stringify(rawContent ?? {});
-            }
-            catch {
-                contentText = String(rawContent ?? '');
-            }
-        }
-        messages.push({
-            role: 'tool',
-            tool_call_id: toolCallId,
-            name,
-            content: contentText
-        });
-    }
-    return messages;
-}

package/dist/servertool/handlers/clock-auto.d.ts

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

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

@@ -0,0 +1,160 @@
+import { registerServerToolHandler } from '../registry.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { findNextUndeliveredDueAtMs, listClockTasks, normalizeClockConfig, startClockDaemonIfNeeded } from '../clock/task-store.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 isStopFinishReason(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()
+            : '';
+        if (!finishReason || finishReason === 'tool_calls') {
+            return false;
+        }
+        if (finishReason !== 'stop' && finishReason !== 'length') {
+            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;
+        }
+        return true;
+    }
+    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;
+    }
+    return true;
+}
+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;
+    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 (!isStopFinishReason(ctx.base)) {
+        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 clockConfig = normalizeClockConfig(record.clock);
+    if (!clockConfig) {
+        return null;
+    }
+    await startClockDaemonIfNeeded(clockConfig);
+    const sessionId = resolveSessionId(ctx.adapterContext);
+    if (!sessionId) {
+        return null;
+    }
+    const seed = extractCapturedChatSeed(record.capturedChatRequest);
+    if (!seed) {
+        return null;
+    }
+    const tasks = await listClockTasks(sessionId, clockConfig);
+    const at = Date.now();
+    const nextDueAtMs = findNextUndeliveredDueAtMs(tasks, at);
+    if (!nextDueAtMs) {
+        return null;
+    }
+    // Wait until the "due window" is reached (now >= dueAt - dueWindowMs).
+    const thresholdMs = nextDueAtMs - clockConfig.dueWindowMs;
+    while (Date.now() < thresholdMs) {
+        const state = resolveClientConnectionState(ctx.adapterContext.clientConnectionState);
+        if (state?.disconnected === true) {
+            return null;
+        }
+        const remaining = thresholdMs - Date.now();
+        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, Date.now());
+            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 } : {})
+                }
+            }
+        })
+    };
+};
+registerServerToolHandler('clock_auto', handler, { trigger: 'auto' });

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

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