@jsonstudio/rcc 0.90.876 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/followup-request-builder.js

@@ -1,6 +1,26 @@
 import { buildChatRequestFromResponses, captureResponsesContext } from '../../conversion/responses/responses-openai-bridge.js';
 import { cloneJson } from '../server-side-tools.js';
 import { trimOpenAiMessagesForFollowup } from './followup-message-trimmer.js';
+import { REASONING_STOP_TOOL_DEF } from './reasoning-stop-state.js';
+function resolveFollowupModel(seedModel, adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return typeof seedModel === 'string' && seedModel.trim() ? seedModel.trim() : '';
+    }
+    const record = adapterContext;
+    const candidates = [
+        record.assignedModelId,
+        record.modelId,
+        seedModel,
+        record.model,
+        record.originalModelId
+    ];
+    for (const value of candidates) {
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return '';
+}
 function extractResponsesTopLevelParameters(record) {
     const allowed = new Set([
         'temperature',
@@ -292,81 +312,37 @@ function compactToolContentInMessages(source, options) {
     }
     return messages;
 }
-function buildStandardFollowupTools() {
-    // Keep this list minimal and stable. Used only as a best-effort fallback when a followup hop
-    // would otherwise have no tools at all (which can cause tool-based clients to "break" mid-session).
-    return [
-        {
-            type: 'function',
-            function: {
-                name: 'shell',
-                description: 'Runs a shell command and returns its output.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        command: { oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }] },
-                        workdir: { type: 'string' }
-                    },
-                    required: ['command'],
-                    additionalProperties: false
-                }
-            }
-        },
-        {
-            type: 'function',
-            function: {
-                name: 'exec_command',
-                description: 'Execute a command in a PTY and return output.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        cmd: { type: 'string' },
-                        workdir: { type: 'string' },
-                        timeout_ms: { type: 'number' },
-                        max_output_tokens: { type: 'number' },
-                        yield_time_ms: { type: 'number' }
-                    },
-                    required: ['cmd'],
-                    additionalProperties: false
-                }
-            }
-        },
-        {
-            type: 'function',
-            function: {
-                name: 'review',
-                description: 'Independent reviewer handoff. Reviewer must first verify code against the current request (target files + relevant tests/commands + evidence), then provide actionable suggestions. Do not stop immediately after this tool.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        goal: { type: 'string' },
-                        context: { type: 'string' },
-                        focus: { type: 'string' }
-                    },
-                    required: ['goal', 'context', 'focus'],
-                    additionalProperties: false
-                }
-            }
-        },
-        {
-            type: 'function',
-            function: {
-                name: 'apply_patch',
-                description: 'Apply a patch to repository files.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        patch: { type: 'string' }
-                    },
-                    required: ['patch'],
-                    additionalProperties: false
-                }
-            }
+function shouldIncludeReasoningStopToolFromOps(ops) {
+    if (!Array.isArray(ops) || ops.length === 0) {
+        return false;
+    }
+    for (const op of ops) {
+        if (!op || typeof op !== 'object') {
+            continue;
         }
-    ];
+        if (op.op !== 'append_user_text' && op.op !== 'inject_system_text') {
+            continue;
+        }
+        const text = typeof op.text === 'string'
+            ? String(op.text).trim().toLowerCase()
+            : '';
+        if (!text) {
+            continue;
+        }
+        if (text.includes('reasoning.stop') || text.includes('stopless')) {
+            return true;
+        }
+    }
+    return false;
 }
-function ensureStandardToolsIfMissing(current) {
+function ensureStandardToolsIfMissing(current, options) {
     const existing = Array.isArray(current) ? cloneJson(current) : [];
+    if (!existing.length) {
+        // Do not synthesize a fake fallback tool surface for followup hops.
+        // Followups must preserve the real client tool set; otherwise provider-specific
+        // schema incompatibilities and fake "tool missing/tool exists" states appear.
+        return existing;
+    }
     const seen = new Set();
     for (const tool of existing) {
         if (!tool || typeof tool !== 'object' || Array.isArray(tool))
@@ -376,15 +352,8 @@ function ensureStandardToolsIfMissing(current) {
         if (name)
             seen.add(name);
     }
-    for (const tool of buildStandardFollowupTools()) {
-        const fn = tool.function;
-        const name = fn && typeof fn === 'object' && typeof fn.name === 'string' ? String(fn.name).trim() : '';
-        if (!name)
-            continue;
-        if (seen.has(name))
-            continue;
-        existing.push(tool);
-        seen.add(name);
+    if (options?.includeReasoningStopTool === true && !seen.has('reasoning.stop')) {
+        existing.push(cloneJson(REASONING_STOP_TOOL_DEF));
     }
     return existing;
 }
@@ -405,7 +374,8 @@ export function buildServerToolFollowupChatPayloadFromInjection(args) {
     if (!seed) {
         return null;
     }
-    if (!seed.model || typeof seed.model !== 'string' || !seed.model.trim()) {
+    const followupModel = resolveFollowupModel(seed.model, args.adapterContext);
+    if (!followupModel) {
         return null;
     }
     let messages = Array.isArray(seed.messages) ? cloneJson(seed.messages) : [];
@@ -413,16 +383,55 @@ export function buildServerToolFollowupChatPayloadFromInjection(args) {
     // Followup is a normal request hop: inherit tool schema from the captured request and
     // let compat/tool-governance apply standard sanitization rules.
     let tools = Array.isArray(seed.tools) ? cloneJson(seed.tools) : undefined;
-    const parameters = seed.parameters ? cloneJson(seed.parameters) : undefined;
+    const includeReasoningStopTool = shouldIncludeReasoningStopToolFromOps(ops)
+        || Boolean(Array.isArray(tools)
+            && tools.some((tool) => {
+                if (!tool || typeof tool !== 'object' || Array.isArray(tool)) {
+                    return false;
+                }
+                const fn = tool.function;
+                const name = fn && typeof fn === 'object' && typeof fn.name === 'string'
+                    ? String(fn.name).trim().toLowerCase()
+                    : '';
+                return name === 'reasoning.stop';
+            }));
+    let parameters = seed.parameters ? cloneJson(seed.parameters) : undefined;
     for (const op of ops) {
         if (!op || typeof op !== 'object')
             continue;
+        if (op.op === 'replace_tools') {
+            const nextTools = Array.isArray(op.tools)
+                ? cloneJson(op.tools)
+                : [];
+            tools = nextTools;
+            continue;
+        }
         if (op.op === 'preserve_tools') {
             // No-op: tools are preserved by default. Kept for backward compatibility.
             continue;
         }
         if (op.op === 'ensure_standard_tools') {
-            tools = ensureStandardToolsIfMissing(tools);
+            tools = ensureStandardToolsIfMissing(tools, { includeReasoningStopTool });
+            continue;
+        }
+        if (op.op === 'force_tool_choice') {
+            const rawValue = op.value;
+            if (!parameters) {
+                parameters = {};
+            }
+            if (rawValue === undefined) {
+                delete parameters.tool_choice;
+            }
+            else {
+                parameters.tool_choice = cloneJson(rawValue);
+                if (rawValue
+                    && typeof rawValue === 'object'
+                    && !Array.isArray(rawValue)
+                    && typeof rawValue.type === 'string'
+                    && String(rawValue.type).trim().toLowerCase() === 'function') {
+                    parameters.parallel_tool_calls = false;
+                }
+            }
             continue;
         }
         if (op.op === 'trim_openai_messages') {
@@ -439,6 +448,32 @@ export function buildServerToolFollowupChatPayloadFromInjection(args) {
             messages = compactToolContentInMessages(messages, { maxChars });
             continue;
         }
+        if (op.op === 'append_tool_if_missing') {
+            const toolName = typeof op.toolName === 'string'
+                ? String(op.toolName).trim()
+                : '';
+            const toolDef = op.toolDefinition;
+            if (!toolName || !toolDef || typeof toolDef !== 'object' || Array.isArray(toolDef)) {
+                continue;
+            }
+            // Check if tool already exists
+            const exists = Array.isArray(tools) && tools.some((t) => {
+                if (!t || typeof t !== 'object' || Array.isArray(t))
+                    return false;
+                const fn = t.function;
+                const name = fn && typeof fn === 'object' && typeof fn.name === 'string'
+                    ? String(fn.name).trim()
+                    : '';
+                return name === toolName;
+            });
+            if (!exists) {
+                if (!Array.isArray(tools)) {
+                    tools = [];
+                }
+                tools.push(toolDef);
+            }
+            continue;
+        }
         if (op.op === 'append_assistant_message') {
             const required = op.required !== false;
             const msg = extractAssistantMessageFromChatLike(args.chatResponse);
@@ -491,7 +526,7 @@ export function buildServerToolFollowupChatPayloadFromInjection(args) {
         }
     }
     return {
-        model: seed.model,
+        model: followupModel,
         messages,
         ...(tools ? { tools } : {}),
         ...(parameters ? { parameters } : {})

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/memory-appender.d.ts

@@ -0,0 +1,6 @@
+interface AppendLearningOptions {
+    learning: string;
+    cwd: string;
+}
+export declare function appendLearningToMemory(options: AppendLearningOptions): void;
+export {};

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/memory-appender.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const MAX_LEARNING_LENGTH = 500;
+export function appendLearningToMemory(options) {
+    const { learning, cwd } = options;
+    if (!learning || learning.trim().length === 0) {
+        return;
+    }
+    const trimmedLearning = learning.trim().slice(0, MAX_LEARNING_LENGTH);
+    const memoryPath = path.join(cwd, 'MEMORY.md');
+    // Check if MEMORY.md exists
+    if (!fs.existsSync(memoryPath)) {
+        return;
+    }
+    // Read existing content
+    const existingContent = fs.readFileSync(memoryPath, 'utf-8');
+    // Dedup: check if similar learning already exists (simple substring match)
+    const normalizedLearning = trimmedLearning.toLowerCase().replace(/\s+/g, ' ');
+    const normalizedExisting = existingContent.toLowerCase().replace(/\s+/g, ' ');
+    if (normalizedExisting.includes(normalizedLearning.slice(0, 50))) {
+        return;
+    }
+    // Format new entry
+    const date = new Date().toISOString().split('T')[0];
+    const newEntry = `\n- ${date}: ${trimmedLearning}\n  Tags: reasoning-stop, learning, auto-captured\n`;
+    // Find insertion point (after header if exists)
+    const lines = existingContent.split('\n');
+    let insertIndex = 0;
+    // Skip header lines (lines starting with #)
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].startsWith('#') || lines[i].trim() === '') {
+            insertIndex = i + 1;
+        }
+        else {
+            break;
+        }
+    }
+    // Insert new entry
+    lines.splice(insertIndex, 0, newEntry);
+    // Write back
+    fs.writeFileSync(memoryPath, lines.join('\n'), 'utf-8');
+}

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/reasoning-only-continue.js

@@ -1,6 +1,6 @@
 import { registerServerToolHandler } from '../registry.js';
 import { isStopEligibleForServerTool } from '../stop-gateway-context.js';
-import { extractStopMessageAutoResponseSnapshot } from './stop-message-auto/iflow-followup.js';
+import { extractStopMessageAutoResponseSnapshot } from './stop-message-auto/ai-followup.js';
 import { stripReasoningTransportNoise } from '../../conversion/shared/reasoning-normalizer.js';
 const FLOW_ID = 'reasoning_only_continue_flow';
 const HOOK_ID = 'reasoning_only_continue';