@jsonstudio/llms 0.6.1892 → 0.6.2172

package/dist/servertool/handlers/clock.js

@@ -6,6 +6,7 @@ import { cancelClockTask, clearClockTasks, listClockTasks, resolveClockConfig, p
 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';
 const FLOW_ID = 'clock_flow';
 let fallbackClockToolCallSeq = 0;
 function ensureClockToolCall(toolCall, requestId) {
@@ -86,13 +87,6 @@ function parseToolArguments(toolCall) {
         return {};
     }
 }
-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 injectClockToolOutput(base, toolCall, content) {
     const cloned = cloneJson(base);
     const existingOutputs = Array.isArray(cloned.tool_outputs)
@@ -236,6 +230,7 @@ function normalizeScheduleItems(parsed) {
         items.push({
             dueAtMs,
             task,
+            setBy: 'agent',
             ...(tool ? { tool } : {}),
             ...(argsObj ? { arguments: argsObj } : {}),
             ...(recurrenceParsed.recurrence ? { recurrence: recurrenceParsed.recurrence } : {})
@@ -259,6 +254,8 @@ function mapTaskForTool(t) {
     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 } : {}),
@@ -274,7 +271,7 @@ const handler = async (ctx) => {
         return null;
     }
     const rt = readRuntimeMetadata(ctx.adapterContext);
-    const sessionId = resolveSessionId(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);
@@ -388,7 +385,7 @@ const handler = async (ctx) => {
         return respond({
             ok: false,
             action,
-            message: 'clock requires sessionId (x-session-id header or metadata.sessionId).'
+            message: 'clock requires session scope (sessionId/conversationId or clockDaemonId).'
         });
     }
     if (action === 'list') {

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

@@ -252,13 +252,34 @@ const handler = async (ctx) => {
     // Treat followup hops as an interruption: do not count them, and clear any ongoing streak
     // so that post-followup calls always restart from 0.
     if (shouldSkipFollowup(ctx.adapterContext)) {
-        sessionStates.delete(sessionKey);
+        const prev = sessionStates.get(sessionKey);
+        if (prev) {
+            sessionStates.set(sessionKey, {
+                ...prev,
+                updatedAt: now,
+                signature: undefined,
+                consecutiveCount: 0
+            });
+        }
         return null;
     }
-    const existing = sessionStates.get(sessionKey) ?? { updatedAt: now, consecutiveCount: 0 };
+    const existing = sessionStates.get(sessionKey) ?? { updatedAt: now, consecutiveCount: 0, triggerCount: 0 };
     // Any interruption (no tool calls) resets the counter.
     if (!ctx.toolCalls || !ctx.toolCalls.length) {
-        if (existing.signature || existing.consecutiveCount) {
+        if (existing.signature || existing.consecutiveCount || existing.triggerCount) {
+            if (existing.triggerCount > 0) {
+                sessionStates.set(sessionKey, {
+                    ...existing,
+                    updatedAt: now,
+                    signature: undefined,
+                    consecutiveCount: 0
+                });
+            }
+            else {
+                sessionStates.delete(sessionKey);
+            }
+        }
+        else {
             sessionStates.delete(sessionKey);
         }
         return null;
@@ -282,8 +303,21 @@ const handler = async (ctx) => {
         if (state.consecutiveCount < CONSECUTIVE_TRIGGER_COUNT) {
             continue;
         }
-        // Triggered: reset counter immediately (including "trigger info sent").
-        sessionStates.delete(sessionKey);
+        const triggerCount = (state.triggerCount || 0) + 1;
+        const escalatedStop = triggerCount >= 2;
+        // Triggered: clear streak immediately; escalate on second trigger.
+        // After escalated stop, clear state so next execution starts fresh.
+        if (escalatedStop) {
+            sessionStates.delete(sessionKey);
+        }
+        else {
+            sessionStates.set(sessionKey, {
+                updatedAt: now,
+                signature: undefined,
+                consecutiveCount: 0,
+                triggerCount
+            });
+        }
         // Must send a followup request to provider (not a direct client warning).
         if (!ctx.capabilities.reenterPipeline) {
             return null;
@@ -304,9 +338,19 @@ const handler = async (ctx) => {
         if (!toolMessages.length) {
             return null;
         }
-        const reminder = `请停下来检查你的任务，你已经反复进行了调用，是否考虑别的方式处理，如果无法处理请停下来，报告问题。` +
-            `（触发条件：同一工具同一参数连续 ${CONSECUTIVE_TRIGGER_COUNT} 次：${toolCall.name}）` +
-            `请不要在回复中提及“检测器/守卫/servertool”，也不要继续调用该工具，除非用户明确要求且参数发生变化。`;
+        const reminder = escalatedStop
+            ? `再次检测到同一循环（同一工具同一参数连续 ${CONSECUTIVE_TRIGGER_COUNT} 次：${toolCall.name}）。` +
+                `现在停止该工具链路并直接报告阻塞点，等待用户处理后再继续。`
+            : `检测到循环调用（同一工具同一参数连续 ${CONSECUTIVE_TRIGGER_COUNT} 次：${toolCall.name}）。` +
+                `请先简短提醒风险并清理当前循环计数，然后继续自动执行；若再次出现同样循环，立即停止并报告阻塞。`;
+        const ops = [
+            { op: 'inject_system_text', text: reminder },
+            { op: 'append_assistant_message' },
+            { op: 'append_tool_messages_from_tool_outputs' }
+        ];
+        if (escalatedStop) {
+            ops.push({ op: 'drop_tool_by_name', name: toolCall.name });
+        }
         return {
             flowId: FLOW_ID,
             finalize: async () => ({
@@ -317,12 +361,7 @@ const handler = async (ctx) => {
                         requestIdSuffix: ':recursive_detection_guard_followup',
                         entryEndpoint: ctx.entryEndpoint,
                         injection: {
-                            ops: [
-                                { op: 'inject_system_text', text: reminder },
-                                { op: 'append_assistant_message' },
-                                { op: 'append_tool_messages_from_tool_outputs' },
-                                { op: 'drop_tool_by_name', name: toolCall.name }
-                            ]
+                            ops
                         }
                     }
                 }

package/dist/servertool/handlers/stop-message-auto/blocked-report.d.ts

@@ -0,0 +1,16 @@
+export interface StopMessageBlockedReport {
+    summary: string;
+    blocker: string;
+    impact?: string;
+    nextAction?: string;
+    evidence: string[];
+}
+export interface StopMessageBlockedIssueContext {
+    requestId?: string;
+    sessionId?: string;
+}
+export declare function extractBlockedReportFromMessages(messages: unknown[]): StopMessageBlockedReport | null;
+export declare function extractBlockedReportFromMessagesForTests(messages: unknown[]): StopMessageBlockedReport | null;
+export declare function createBdIssueFromBlockedReport(blockedReport: StopMessageBlockedReport, context?: StopMessageBlockedIssueContext, cwdOverride?: string): string | null;
+export declare function extractCapturedMessageText(message: unknown): string;
+export declare function extractTextFromMessageContent(content: unknown): string;

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

@@ -0,0 +1,349 @@
+import * as childProcess from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const STOP_MESSAGE_BD_CREATE_TIMEOUT_MS = 2_000;
+const STOP_MESSAGE_BLOCKED_TEXT_SCAN_LIMIT = 12;
+const STOP_MESSAGE_BLOCKED_CANDIDATE_MAX_LENGTH = 12_000;
+export function extractBlockedReportFromMessages(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return null;
+    }
+    const start = Math.max(0, messages.length - STOP_MESSAGE_BLOCKED_TEXT_SCAN_LIMIT);
+    for (let idx = messages.length - 1; idx >= start; idx -= 1) {
+        const text = extractCapturedMessageText(messages[idx]);
+        if (!text) {
+            continue;
+        }
+        const blockedReport = extractBlockedReportFromText(text);
+        if (blockedReport) {
+            return blockedReport;
+        }
+    }
+    return null;
+}
+export function extractBlockedReportFromMessagesForTests(messages) {
+    return extractBlockedReportFromMessages(messages);
+}
+export function createBdIssueFromBlockedReport(blockedReport, context, cwdOverride) {
+    const cwd = resolveBdWorkingDirectoryForStopMessage(cwdOverride);
+    const title = buildBlockedIssueTitle(blockedReport);
+    const description = buildBlockedIssueDescription(blockedReport, context);
+    const acceptance = buildBlockedIssueAcceptance(blockedReport);
+    try {
+        const result = childProcess.spawnSync('bd', [
+            '--no-db',
+            'create',
+            '--json',
+            '-t',
+            'bug',
+            '-p',
+            '0',
+            '--title',
+            title,
+            '--description',
+            description,
+            '--acceptance',
+            acceptance
+        ], {
+            cwd,
+            encoding: 'utf8',
+            timeout: STOP_MESSAGE_BD_CREATE_TIMEOUT_MS,
+            maxBuffer: 1024 * 1024
+        });
+        if (result.error || result.status !== 0) {
+            return null;
+        }
+        return parseCreatedIssueId(result.stdout);
+    }
+    catch {
+        return null;
+    }
+}
+export function extractCapturedMessageText(message) {
+    if (!message) {
+        return '';
+    }
+    if (typeof message === 'string') {
+        return message.trim();
+    }
+    if (typeof message !== 'object' || Array.isArray(message)) {
+        return '';
+    }
+    const record = message;
+    const contentText = extractTextFromMessageContent(record.content);
+    if (contentText) {
+        return contentText;
+    }
+    const inputText = extractTextFromMessageContent(record.input);
+    if (inputText) {
+        return inputText;
+    }
+    const outputText = extractTextFromMessageContent(record.output);
+    if (outputText) {
+        return outputText;
+    }
+    const argumentsText = toNonEmptyText(record.arguments);
+    return argumentsText;
+}
+export function extractTextFromMessageContent(content) {
+    if (typeof content === 'string') {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    const chunks = [];
+    for (const item of content) {
+        if (typeof item === 'string') {
+            if (item.trim())
+                chunks.push(item.trim());
+            continue;
+        }
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        const record = item;
+        const type = toNonEmptyText(record.type).toLowerCase();
+        if (type === 'text' || type === 'output_text' || type === 'input_text' || !type) {
+            const text = toNonEmptyText(record.text);
+            if (text) {
+                chunks.push(text);
+            }
+            continue;
+        }
+        const fallbackText = toNonEmptyText(record.content) || toNonEmptyText(record.value);
+        if (fallbackText) {
+            chunks.push(fallbackText);
+        }
+    }
+    return chunks.join('\n').trim();
+}
+function extractBlockedReportFromText(text) {
+    const trimmed = typeof text === 'string' ? text.trim() : '';
+    if (!trimmed) {
+        return null;
+    }
+    const candidates = [];
+    const pushCandidate = (candidate) => {
+        const normalized = candidate.trim();
+        if (!normalized || normalized.length > STOP_MESSAGE_BLOCKED_CANDIDATE_MAX_LENGTH) {
+            return;
+        }
+        if (candidates.includes(normalized)) {
+            return;
+        }
+        candidates.push(normalized);
+    };
+    pushCandidate(trimmed);
+    for (const codeBlock of extractJsonCodeBlocks(trimmed)) {
+        pushCandidate(codeBlock);
+    }
+    for (const objectText of extractBalancedJsonObjectStrings(trimmed)) {
+        if (objectText.includes('"type"') && objectText.toLowerCase().includes('"blocked"')) {
+            pushCandidate(objectText);
+        }
+    }
+    for (const candidate of candidates) {
+        let parsed;
+        try {
+            parsed = JSON.parse(candidate);
+        }
+        catch {
+            continue;
+        }
+        const report = normalizeBlockedReport(parsed);
+        if (report) {
+            return report;
+        }
+    }
+    return null;
+}
+function normalizeBlockedReport(value) {
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const report = normalizeBlockedReport(entry);
+            if (report) {
+                return report;
+            }
+        }
+        return null;
+    }
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const record = value;
+    const type = toNonEmptyText(record.type).toLowerCase();
+    if (type !== 'blocked') {
+        return null;
+    }
+    const summary = toNonEmptyText(record.summary) ||
+        toNonEmptyText(record.title) ||
+        toNonEmptyText(record.problem);
+    const blocker = toNonEmptyText(record.blocker) ||
+        toNonEmptyText(record.reason) ||
+        toNonEmptyText(record.blocked_by);
+    if (!summary || !blocker) {
+        return null;
+    }
+    const impact = toNonEmptyText(record.impact) || toNonEmptyText(record.effect);
+    const nextAction = toNonEmptyText(record.next_action) ||
+        toNonEmptyText(record.nextAction) ||
+        toNonEmptyText(record.next_step);
+    const evidence = normalizeBlockedEvidence(record.evidence);
+    return {
+        summary: summary.slice(0, 1_000),
+        blocker: blocker.slice(0, 1_000),
+        ...(impact ? { impact: impact.slice(0, 1_000) } : {}),
+        ...(nextAction ? { nextAction: nextAction.slice(0, 1_000) } : {}),
+        evidence
+    };
+}
+function normalizeBlockedEvidence(raw) {
+    if (Array.isArray(raw)) {
+        const normalized = raw
+            .map((entry) => toNonEmptyText(entry))
+            .filter((entry) => entry.length > 0)
+            .map((entry) => entry.slice(0, 800));
+        return normalized.slice(0, 8);
+    }
+    const single = toNonEmptyText(raw);
+    return single ? [single.slice(0, 800)] : [];
+}
+function extractJsonCodeBlocks(text) {
+    const candidates = [];
+    const regex = /```(?:json)?\s*([\s\S]*?)```/gi;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        const body = (match[1] || '').trim();
+        if (!body) {
+            continue;
+        }
+        candidates.push(body);
+    }
+    return candidates;
+}
+function extractBalancedJsonObjectStrings(text) {
+    const results = [];
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let idx = 0; idx < text.length; idx += 1) {
+        const ch = text[idx];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === '{') {
+            if (depth === 0) {
+                start = idx;
+            }
+            depth += 1;
+            continue;
+        }
+        if (ch === '}') {
+            if (depth <= 0) {
+                continue;
+            }
+            depth -= 1;
+            if (depth === 0 && start >= 0) {
+                results.push(text.slice(start, idx + 1));
+                start = -1;
+            }
+        }
+    }
+    return results;
+}
+function resolveBdWorkingDirectoryForStopMessage(cwdOverride) {
+    const fromOverride = toNonEmptyText(cwdOverride);
+    if (fromOverride) {
+        return path.resolve(fromOverride);
+    }
+    const fromEnv = toNonEmptyText(process.env.ROUTECODEX_STOPMESSAGE_BD_WORKDIR);
+    if (fromEnv) {
+        return path.resolve(fromEnv);
+    }
+    const cwd = process.cwd();
+    return findBdProjectRootForStopMessage(cwd) || cwd;
+}
+function findBdProjectRootForStopMessage(startDirectory) {
+    let current = path.resolve(startDirectory);
+    while (true) {
+        const beadFile = path.join(current, '.beads', 'issues.jsonl');
+        if (fs.existsSync(beadFile)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function buildBlockedIssueTitle(report) {
+    const base = report.summary.trim() || report.blocker.trim() || 'stopMessage blocked';
+    const cleaned = base.replace(/\s+/g, ' ').slice(0, 120);
+    return `[stopMessage] ${cleaned}`.trim();
+}
+function buildBlockedIssueDescription(report, context) {
+    const lines = [
+        '自动建单来源：stop_message_auto 结构化 blocked 报告',
+        '',
+        `Summary: ${report.summary}`,
+        `Blocker: ${report.blocker}`,
+        `Impact: ${report.impact || 'n/a'}`,
+        `Next Action: ${report.nextAction || 'n/a'}`,
+        '',
+        `RequestId: ${context?.requestId || 'n/a'}`,
+        `SessionId: ${context?.sessionId || 'n/a'}`,
+        '',
+        'Evidence:',
+        ...(report.evidence.length > 0 ? report.evidence.map((entry) => `- ${entry}`) : ['- n/a']),
+        '',
+        'Notes:',
+        '- 本 issue 由系统在 stopMessage 检测到结构化阻塞后自动创建。',
+        '- 请按 blocker/next action 先解除阻塞，再恢复执行。'
+    ];
+    return lines.join('\n');
+}
+function buildBlockedIssueAcceptance(report) {
+    const next = report.nextAction || '执行可验证的解阻动作并记录结果';
+    return [
+        `1. 明确并确认 blocker：${report.blocker}`,
+        `2. 完成解阻动作：${next}`,
+        '3. 验证 stopMessage followup 可继续推进'
+    ].join('\n');
+}
+function parseCreatedIssueId(stdout) {
+    if (typeof stdout !== 'string') {
+        return null;
+    }
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        const id = toNonEmptyText(parsed.id);
+        return id || null;
+    }
+    catch {
+        const match = trimmed.match(/\b[a-z]+-\d+(?:\.\d+)?\b/i);
+        return match ? match[0] : null;
+    }
+}
+function toNonEmptyText(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : '';
+}

package/dist/servertool/handlers/stop-message-auto/iflow-followup.d.ts

@@ -0,0 +1,23 @@
+export interface StopMessageAutoResponseSnapshot {
+    providerProtocol?: string;
+    finishReason?: string;
+    assistantText?: string;
+    reasoningText?: string;
+    responseExcerpt?: string;
+}
+export declare function renderStopMessageAutoFollowupViaIflow(args: {
+    baseStopMessageText: string;
+    candidateFollowupText: string;
+    responseSnapshot: StopMessageAutoResponseSnapshot;
+    requestId?: string;
+    sessionId?: string;
+    providerKey?: string;
+    model?: string;
+    usedRepeats: number;
+    maxRepeats: number;
+}): string | null;
+export declare function extractStopMessageAutoResponseSnapshot(base: unknown, adapterContext: unknown): StopMessageAutoResponseSnapshot;
+export declare function extractResponsesOutputText(base: {
+    [key: string]: unknown;
+}): string;
+export declare function hasToolLikeOutput(value: unknown): boolean;