@jsonstudio/llms 0.6.954 → 0.6.1164

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

@@ -0,0 +1,333 @@
+import { createHash } from 'node:crypto';
+import { registerServerToolHandler } from '../registry.js';
+import { cloneJson } from '../server-side-tools.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
+const FLOW_ID = 'recursive_detection_guard';
+const CONSECUTIVE_TRIGGER_COUNT = 10;
+const sessionStates = new Map();
+const DEBUG_RECURSIVE_DETECTION = String(process.env.ROUTECODEX_RECURSIVE_DETECTION_DEBUG || '').trim() === '1';
+function debugLog(message, extra) {
+    if (!DEBUG_RECURSIVE_DETECTION) {
+        return;
+    }
+    try {
+        // eslint-disable-next-line no-console
+        console.log(`[recursive-detection][debug] ${message}${extra ? ` ${JSON.stringify(extra)}` : ''}`);
+    }
+    catch {
+        /* ignore logging failures */
+    }
+}
+function getRecursiveDetectionConfig() {
+    const enabled = String(process.env.ROUTECODEX_RECURSIVE_DETECTION_ENABLED ?? '').trim().toLowerCase() !== 'false';
+    return {
+        enabled,
+        ttlMs: 5 * 60 * 1000,
+        maxSessions: 2000
+    };
+}
+function shouldSkipFollowup(adapterContext) {
+    const record = adapterContext;
+    const loopState = record ? record.serverToolLoopState : undefined;
+    if (loopState && typeof loopState === 'object' && !Array.isArray(loopState)) {
+        return true;
+    }
+    const raw = record ? record.serverToolFollowup : undefined;
+    if (raw === true) {
+        return true;
+    }
+    if (typeof raw === 'string') {
+        const normalized = raw.trim().toLowerCase();
+        return normalized === '1' || normalized === 'true';
+    }
+    return false;
+}
+function resolveSessionKey(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return 'default';
+    }
+    const record = adapterContext;
+    const sessionId = typeof record.sessionId === 'string'
+        ? record.sessionId.trim()
+        : (typeof record.session_id === 'string' ? record.session_id.trim() : '');
+    const conversationId = typeof record.conversationId === 'string'
+        ? record.conversationId.trim()
+        : (typeof record.conversation_id === 'string' ? record.conversation_id.trim() : '');
+    const requestId = typeof record.requestId === 'string' ? record.requestId.trim() : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
+    if (conversationId) {
+        return `conversation:${conversationId}`;
+    }
+    if (requestId) {
+        return `request:${requestId}`;
+    }
+    return 'default';
+}
+function normalizeToolName(name) {
+    return typeof name === 'string' ? name.trim().toLowerCase() : '';
+}
+function sha256(value) {
+    try {
+        return createHash('sha256').update(value).digest('hex');
+    }
+    catch {
+        return '';
+    }
+}
+function stableStringify(value) {
+    if (value === null)
+        return 'null';
+    const t = typeof value;
+    if (t === 'string')
+        return JSON.stringify(value);
+    if (t === 'number')
+        return Number.isFinite(value) ? String(value) : 'null';
+    if (t === 'boolean')
+        return value ? 'true' : 'false';
+    if (t === 'bigint')
+        return JSON.stringify(String(value));
+    if (t === 'undefined' || t === 'function' || t === 'symbol')
+        return 'null';
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        const keys = Object.keys(record).sort();
+        const parts = [];
+        for (const key of keys) {
+            const v = record[key];
+            if (v === undefined)
+                continue;
+            parts.push(`${JSON.stringify(key)}:${stableStringify(v)}`);
+        }
+        return `{${parts.join(',')}}`;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return 'null';
+    }
+}
+function normalizeToolArgs(toolCall) {
+    const raw = typeof toolCall.arguments === 'string' ? toolCall.arguments : '';
+    if (!raw || !raw.trim())
+        return '{}';
+    try {
+        const parsed = JSON.parse(raw);
+        return stableStringify(parsed);
+    }
+    catch {
+        return raw.trim();
+    }
+}
+function buildCallSignature(toolCall) {
+    const toolName = normalizeToolName(toolCall.name);
+    const args = normalizeToolArgs(toolCall);
+    return sha256(`${toolName}\n${args}`);
+}
+function cleanupSessions(now, config) {
+    const cutoff = now - config.ttlMs;
+    if (sessionStates.size > config.maxSessions) {
+        for (const [key, state] of sessionStates.entries()) {
+            if (!state || state.updatedAt <= cutoff) {
+                sessionStates.delete(key);
+            }
+        }
+        return;
+    }
+    for (const [key, state] of sessionStates.entries()) {
+        if (!state || state.updatedAt <= cutoff) {
+            sessionStates.delete(key);
+        }
+    }
+}
+function injectBlockedToolResult(base, toolCall, options) {
+    const cloned = cloneJson(base);
+    const existingOutputs = Array.isArray(cloned.tool_outputs)
+        ? cloned.tool_outputs
+        : [];
+    const payload = {
+        ok: false,
+        blocked: true,
+        reason: 'RECURSIVE_TOOL_CALL_DETECTED',
+        rule: {
+            kind: 'consecutive_same_tool_and_args',
+            consecutive: CONSECUTIVE_TRIGGER_COUNT
+        },
+        tool: toolCall.name,
+        signature: options.signature
+    };
+    cloned.tool_outputs = [
+        ...existingOutputs,
+        {
+            tool_call_id: toolCall.id,
+            name: toolCall.name,
+            content: JSON.stringify(payload)
+        }
+    ];
+    return cloned;
+}
+function buildSingleToolCallAssistantMessage(toolCall) {
+    return {
+        role: 'assistant',
+        content: null,
+        tool_calls: [
+            {
+                id: toolCall.id,
+                type: 'function',
+                function: {
+                    name: toolCall.name,
+                    arguments: typeof toolCall.arguments === 'string' ? toolCall.arguments : ''
+                }
+            }
+        ]
+    };
+}
+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() : 'tool';
+        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;
+}
+function hasAssistantMessageFromChatLike(chatResponse) {
+    if (!chatResponse || typeof chatResponse !== 'object') {
+        return false;
+    }
+    const choices = Array.isArray(chatResponse.choices)
+        ? chatResponse.choices
+        : [];
+    if (!choices.length) {
+        return false;
+    }
+    const first = choices[0];
+    if (!first || typeof first !== 'object' || Array.isArray(first)) {
+        return false;
+    }
+    const message = first.message;
+    return Boolean(message && typeof message === 'object' && !Array.isArray(message));
+}
+const handler = async (ctx) => {
+    const config = getRecursiveDetectionConfig();
+    if (!config.enabled) {
+        return null;
+    }
+    const now = Date.now();
+    cleanupSessions(now, config);
+    const sessionKey = resolveSessionKey(ctx.adapterContext);
+    // 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);
+        return null;
+    }
+    const existing = sessionStates.get(sessionKey) ?? { updatedAt: now, consecutiveCount: 0 };
+    // Any interruption (no tool calls) resets the counter.
+    if (!ctx.toolCalls || !ctx.toolCalls.length) {
+        if (existing.signature || existing.consecutiveCount) {
+            sessionStates.delete(sessionKey);
+        }
+        return null;
+    }
+    let state = { ...existing, updatedAt: now };
+    for (const toolCall of ctx.toolCalls) {
+        const signature = buildCallSignature(toolCall);
+        if (state.signature && state.signature === signature) {
+            state.consecutiveCount += 1;
+        }
+        else {
+            state.signature = signature;
+            state.consecutiveCount = 1;
+        }
+        state.updatedAt = now;
+        debugLog('observe', {
+            sessionKey,
+            toolName: toolCall.name,
+            consecutiveCount: state.consecutiveCount
+        });
+        if (state.consecutiveCount < CONSECUTIVE_TRIGGER_COUNT) {
+            continue;
+        }
+        // Triggered: reset counter immediately (including "trigger info sent").
+        sessionStates.delete(sessionKey);
+        // Must send a followup request to provider (not a direct client warning).
+        if (!ctx.capabilities.reenterPipeline) {
+            return null;
+        }
+        const patched = injectBlockedToolResult(ctx.base, toolCall, { signature });
+        // Fail-closed: if we cannot build a followup request, do not intercept.
+        const captured = ctx.adapterContext && typeof ctx.adapterContext === 'object'
+            ? ctx.adapterContext.capturedChatRequest
+            : undefined;
+        const seed = extractCapturedChatSeed(captured);
+        if (!seed) {
+            return null;
+        }
+        if (!hasAssistantMessageFromChatLike(patched)) {
+            return null;
+        }
+        const toolMessages = buildToolMessages(patched);
+        if (!toolMessages.length) {
+            return null;
+        }
+        const reminder = `请停下来检查你的任务，你已经反复进行了调用，是否考虑别的方式处理，如果无法处理请停下来，报告问题。` +
+            `（触发条件：同一工具同一参数连续 ${CONSECUTIVE_TRIGGER_COUNT} 次：${toolCall.name}）` +
+            `请不要在回复中提及“检测器/守卫/servertool”，也不要继续调用该工具，除非用户明确要求且参数发生变化。`;
+        return {
+            flowId: FLOW_ID,
+            finalize: async () => ({
+                chatResponse: patched,
+                execution: {
+                    flowId: FLOW_ID,
+                    followup: {
+                        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 }
+                            ]
+                        }
+                    }
+                }
+            })
+        };
+    }
+    sessionStates.set(sessionKey, state);
+    return null;
+};
+registerServerToolHandler('recursive_detection_guard', handler, { trigger: 'auto' });

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

@@ -1,9 +1,7 @@
 import { registerServerToolHandler } from '../registry.js';
-import { cloneJson } from '../server-side-tools.js';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync } from '../../router/virtual-router/sticky-session-store.js';
 import { isCompactionRequest } from './compaction-detect.js';
-import { buildResponsesRequestFromChat, captureResponsesContext, buildChatRequestFromResponses } from '../../conversion/responses/responses-openai-bridge.js';
-import { buildAnthropicRequestFromOpenAIChat } from '../../conversion/codecs/anthropic-openai-codec.js';
+import { extractCapturedChatSeed } from './followup-request-builder.js';
 const STOPMESSAGE_DEBUG = (process.env.ROUTECODEX_STOPMESSAGE_DEBUG || '').trim() === '1';
 function debugLog(message, extra) {
     if (!STOPMESSAGE_DEBUG) {
@@ -115,32 +113,31 @@ const handler = async (ctx) => {
         return null;
     }
     const entryEndpoint = resolveEntryEndpoint(record);
-    const followupPayload = buildStopMessageFollowupPayload(captured, text, ctx.base, entryEndpoint);
-    if (!followupPayload) {
-        debugLog('skip_failed_build_followup', {
-            stickyKey
-        });
+    const seed = extractCapturedChatSeed(captured);
+    if (!seed) {
+        debugLog('skip_failed_build_followup', { stickyKey });
         return null;
     }
-    const followupMetadata = {
-        serverToolFollowup: true,
-        stream: false,
-        preserveRouteHint: false,
-        disableStickyRoutes: true,
-        serverToolOriginalEntryEndpoint: entryEndpoint,
-        ...(connectionState ? { clientConnectionState: connectionState } : {})
-    };
+    const assistantMessage = extractAssistantMessageForFollowup(ctx.base);
     return {
-        chatResponse: ctx.base,
-        execution: {
-            flowId: FLOW_ID,
-            followup: {
-                requestIdSuffix: ':stop_followup',
-                payload: followupPayload,
-                entryEndpoint,
-                metadata: followupMetadata
+        flowId: FLOW_ID,
+        finalize: async () => ({
+            chatResponse: ctx.base,
+            execution: {
+                flowId: FLOW_ID,
+                followup: {
+                    requestIdSuffix: ':stop_followup',
+                    entryEndpoint,
+                    injection: {
+                        ops: [
+                            { op: 'append_assistant_message', required: false },
+                            { op: 'append_user_text', text }
+                        ]
+                    },
+                    metadata: (connectionState ? { clientConnectionState: connectionState } : {})
+                }
             }
-        }
+        })
     };
 };
 registerServerToolHandler('stop_message_auto', handler, { trigger: 'auto' });
@@ -214,168 +211,43 @@ function isStopFinishReason(base) {
     }
     return true;
 }
-function getCapturedRequest(adapterContext) {
-    if (!adapterContext || typeof adapterContext !== 'object') {
+function extractAssistantMessageForFollowup(chatResponse) {
+    if (!chatResponse || typeof chatResponse !== 'object' || Array.isArray(chatResponse)) {
         return null;
     }
-    const captured = adapterContext.capturedChatRequest;
-    if (!captured || typeof captured !== 'object' || Array.isArray(captured)) {
+    const choices = Array.isArray(chatResponse.choices)
+        ? chatResponse.choices
+        : [];
+    if (!choices.length) {
         return null;
     }
-    return captured;
-}
-function extractChatSeedFromCapturedRequest(source) {
-    const model = typeof source.model === 'string' && source.model.trim()
-        ? source.model.trim()
-        : undefined;
-    const rawMessages = Array.isArray(source.messages)
-        ? source.messages
-        : null;
-    if (rawMessages) {
-        const tools = Array.isArray(source.tools)
-            ? cloneJson(source.tools)
-            : undefined;
-        return {
-            ...(model ? { model } : {}),
-            messages: cloneJson(rawMessages),
-            ...(tools ? { tools } : {})
-        };
+    const first = choices[0];
+    if (!first || typeof first !== 'object' || Array.isArray(first)) {
+        return null;
     }
-    const rawInput = Array.isArray(source.input)
-        ? source.input
-        : null;
-    if (rawInput) {
-        try {
-            const ctx = captureResponsesContext(source);
-            if (!ctx.isResponsesPayload) {
-                return null;
-            }
-            const rebuilt = buildChatRequestFromResponses(source, ctx).request;
-            const rebuiltModel = typeof rebuilt.model === 'string' && rebuilt.model.trim().length ? String(rebuilt.model).trim() : model;
-            const rebuiltMessages = Array.isArray(rebuilt.messages) ? rebuilt.messages : [];
-            const rebuiltTools = Array.isArray(rebuilt.tools) ? rebuilt.tools : undefined;
-            return {
-                ...(rebuiltModel ? { model: rebuiltModel } : {}),
-                messages: cloneJson(rebuiltMessages),
-                ...(rebuiltTools ? { tools: cloneJson(rebuiltTools) } : {})
-            };
-        }
-        catch {
-            return null;
-        }
+    const message = first.message;
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return null;
     }
-    return null;
-}
-function buildStopMessageFollowupPayload(source, text, baseResponse, entryEndpoint) {
-    if (!source || typeof source !== 'object') {
+    const role = typeof message.role === 'string' ? String(message.role) : '';
+    if (role && role.toLowerCase() !== 'assistant') {
         return null;
     }
-    const chatSeed = extractChatSeedFromCapturedRequest(source);
-    const model = chatSeed?.model;
-    const originalMessages = chatSeed?.messages ? cloneJson(chatSeed.messages) : [];
-    const originalTools = chatSeed?.tools ? cloneJson(chatSeed.tools) : undefined;
-    const originalParameters = (() => {
-        const direct = source.parameters;
-        if (direct && typeof direct === 'object' && !Array.isArray(direct)) {
-            return cloneJson(direct);
-        }
-        // Backward/compat: captured request might be a raw `/v1/responses` payload with
-        // top-level parameters (max_output_tokens, temperature, ...), not nested under `parameters`.
-        const record = source;
-        const allowed = new Set([
-            'temperature',
-            'top_p',
-            'max_output_tokens',
-            'seed',
-            'logit_bias',
-            'user',
-            'parallel_tool_calls',
-            'tool_choice',
-            'response_format',
-            'stream'
-        ]);
-        const out = {};
-        if (record.max_output_tokens === undefined && record.max_tokens !== undefined) {
-            out.max_output_tokens = record.max_tokens;
-        }
-        for (const key of Object.keys(record)) {
-            if (!allowed.has(key))
-                continue;
-            out[key] = record[key];
-        }
-        return Object.keys(out).length ? cloneJson(out) : undefined;
-    })();
-    const parametersForFollowup = originalParameters
-        ? (() => {
-            const cloned = cloneJson(originalParameters);
-            // Followup requests are always non-streaming (servertool orchestration enforces this),
-            // so remove any inherited stream hints to avoid conflicting flags.
-            delete cloned.stream;
-            return cloned;
-        })()
-        : undefined;
-    const assistantMessage = extractAssistantMessage(baseResponse);
-    const messages = assistantMessage
-        ? [...originalMessages, assistantMessage]
-        : [...originalMessages];
-    messages.push({
-        role: 'user',
-        content: text
-    });
-    // Build canonical OpenAI Chat payload first (deep cloned).
-    const chatPayload = {
-        ...(model ? { model } : {}),
-        messages,
-        ...(originalTools ? { tools: originalTools } : {})
-    };
-    const normalizedEntry = typeof entryEndpoint === 'string' ? entryEndpoint.trim().toLowerCase() : '';
-    if (normalizedEntry.includes('/v1/responses')) {
-        return buildResponsesRequestFromChat(chatPayload, {
-            stream: false,
-            ...(parametersForFollowup ? { parameters: parametersForFollowup } : {})
-        }).request;
-    }
-    if (normalizedEntry.includes('/v1/messages')) {
-        const anthropicChatPayload = {
-            ...chatPayload,
-            ...(parametersForFollowup ? parametersForFollowup : {})
-        };
-        return buildAnthropicRequestFromOpenAIChat(anthropicChatPayload);
+    const content = message.content;
+    if (typeof content !== 'string' || !content.trim()) {
+        return null;
     }
-    const openaiChatPayload = {
-        ...chatPayload,
-        ...(parametersForFollowup ? parametersForFollowup : {})
-    };
-    return openaiChatPayload;
+    return { role: 'assistant', content: content.trim() };
 }
-function extractAssistantMessage(baseResponse) {
-    if (!baseResponse || typeof baseResponse !== 'object' || Array.isArray(baseResponse)) {
+function getCapturedRequest(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object') {
         return null;
     }
-    const base = baseResponse;
-    const choices = Array.isArray(base.choices) ? base.choices : [];
-    if (choices.length > 0) {
-        const first = choices[0] && typeof choices[0] === 'object' && !Array.isArray(choices[0])
-            ? choices[0]
-            : null;
-        const msg = first &&
-            first.message &&
-            typeof first.message === 'object' &&
-            !Array.isArray(first.message)
-            ? first.message
-            : null;
-        if (msg) {
-            return cloneJson(msg);
-        }
-    }
-    const outputText = extractResponsesOutputText(base);
-    if (outputText.length > 0) {
-        return {
-            role: 'assistant',
-            content: outputText
-        };
+    const captured = adapterContext.capturedChatRequest;
+    if (!captured || typeof captured !== 'object' || Array.isArray(captured)) {
+        return null;
     }
-    return null;
+    return captured;
 }
 function extractResponsesOutputText(base) {
     const raw = base.output_text;
@@ -481,7 +353,7 @@ function hasCompactionFlag(record) {
 }
 function resolveImplicitGeminiStopMessageSnapshot(ctx, record) {
     try {
-        const protoFromCtx = ctx.options?.providerProtocol;
+        const protoFromCtx = ctx.providerProtocol;
         const protoFromRecord = typeof record.providerProtocol === 'string' && record.providerProtocol.trim()
             ? String(record.providerProtocol).trim()
             : undefined;

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

@@ -1 +1,7 @@
-export {};
+import type { ServerSideToolEngineOptions, ServerToolBackendPlan, ServerToolBackendResult } from '../types.js';
+export declare function executeVisionBackendPlan(args: {
+    plan: Extract<ServerToolBackendPlan, {
+        kind: 'vision_analysis';
+    }>;
+    options: ServerSideToolEngineOptions;
+}): Promise<ServerToolBackendResult>;