iosm-cli 0.2.8 → 0.2.9

package/dist/core/agent-session.js

@@ -90,6 +90,108 @@ function deriveOrchestrationDisplayText(promptTextWithoutDirective) {
     }
     return task;
 }
+function extractAssistantProtocolText(message) {
+    const parts = [];
+    for (const content of message.content) {
+        if (content.type === "text" && typeof content.text === "string" && content.text.trim()) {
+            parts.push(content.text.trim());
+            continue;
+        }
+        if (content.type !== "thinking")
+            continue;
+        const record = content;
+        const thinking = record.thinking;
+        if (typeof thinking === "string" && thinking.trim()) {
+            parts.push(thinking.trim());
+        }
+    }
+    return parts.join("\n\n").trim();
+}
+function extractAssistantVisibleText(message) {
+    return message.content
+        .filter((content) => content.type === "text")
+        .map((content) => content.text.trim())
+        .filter((text) => text.length > 0)
+        .join("\n\n")
+        .trim();
+}
+function isNonActionableVisibleAssistantText(text) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return true;
+    return /^\[\s*output\s+truncated[^\]]*\]?\s*\.?$/i.test(trimmed);
+}
+function detectPromptProtocolIssue(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    const hasToolCallOpenBlock = /(^|\n)\s*<\s*tool_call\b/i.test(trimmed);
+    const hasToolCallCloseTag = /<\/\s*tool_call\s*>/i.test(trimmed);
+    const hasFunctionBlock = /(^|\n)\s*<\s*function\s*=\s*[A-Za-z0-9._:-]+/i.test(trimmed);
+    const hasParameterBlock = /(^|\n)\s*<\s*parameter\s*=\s*[A-Za-z0-9._:-]+\s*>/i.test(trimmed);
+    // Flag only executable-looking pseudo markup; don't treat inline explanatory mentions as protocol issues.
+    const hasToolCallMarkup = (hasToolCallOpenBlock && (hasToolCallCloseTag || hasFunctionBlock || hasParameterBlock)) ||
+        (hasFunctionBlock && hasParameterBlock);
+    const hasDelegateTaskMarkup = /<\s*delegate_task\b/i.test(trimmed) && /<\/\s*delegate_task\s*>/i.test(trimmed);
+    if (!hasToolCallMarkup && !hasDelegateTaskMarkup)
+        return undefined;
+    return {
+        hasToolCallMarkup,
+        hasDelegateTaskMarkup,
+    };
+}
+function buildPromptProtocolCorrectionPrompt(input) {
+    const reasons = [
+        input.issue.hasToolCallMarkup ? "raw <tool_call>/<function=...> markup" : undefined,
+        input.issue.hasDelegateTaskMarkup ? "raw <delegate_task> blocks" : undefined,
+    ].filter((item) => typeof item === "string");
+    const boundedOriginal = input.originalPrompt.length > 2_000
+        ? `${input.originalPrompt.slice(0, 2_000).trimEnd()}...`
+        : input.originalPrompt;
+    return [
+        "[TOOL_PROTOCOL_CORRECTION]",
+        `Previous assistant output included ${reasons.join(" and ")} in plain text.`,
+        "These XML-like blocks are not executable tool calls.",
+        "Retry now and follow this protocol exactly:",
+        "1) Do not output XML/pseudo-call tags (<tool_call>, <function=...>, <delegate_task>).",
+        "2) If a tool is needed, emit real structured tool calls only.",
+        "3) Prefer structured tools when available instead of ad-hoc pseudo calls.",
+        "4) If no tool is needed, provide a direct normal answer.",
+        input.hasPriorToolActivity
+            ? "5) Continue from the current in-memory state; avoid repeating already completed tool steps unless necessary."
+            : undefined,
+        "Execute the original user request now.",
+        "<original_user_request>",
+        boundedOriginal,
+        "</original_user_request>",
+        "[/TOOL_PROTOCOL_CORRECTION]",
+    ]
+        .filter((line) => typeof line === "string")
+        .join("\n");
+}
+function buildPromptSilentStopRecoveryPrompt(input) {
+    const boundedOriginal = input.originalPrompt.length > 2_000
+        ? `${input.originalPrompt.slice(0, 2_000).trimEnd()}...`
+        : input.originalPrompt;
+    return [
+        "[ASSISTANT_STALL_RECOVERY]",
+        "Previous assistant output ended with stop but produced no visible text and no executable tool calls.",
+        "Retry now and continue the same request.",
+        "1) Do not return an empty response.",
+        "2) If a tool is needed, emit real structured tool calls.",
+        "3) If no tool is needed, provide a direct answer.",
+        input.hasPriorToolActivity
+            ? "4) Continue from the current in-memory state; avoid repeating already completed tool steps unless necessary."
+            : undefined,
+        "Execute the original user request now.",
+        "<original_user_request>",
+        boundedOriginal,
+        "</original_user_request>",
+        "[/ASSISTANT_STALL_RECOVERY]",
+    ]
+        .filter((line) => typeof line === "string")
+        .join("\n");
+}
 function buildSubagentOrchestrationDirective(text) {
     const block = parseOrchestrateBlock(text);
     if (block) {
@@ -147,6 +249,7 @@ function buildMetaProfileOrchestrationDirective(text) {
 // ============================================================================
 /** Standard thinking levels */
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
+const MAX_PROMPT_PROTOCOL_AUTO_REPAIR_ATTEMPTS = 2;
 /** Thinking levels including xhigh (for supported models) */
 const THINKING_LEVELS_WITH_XHIGH = ["off", "minimal", "low", "medium", "high", "xhigh"];
 // ============================================================================
@@ -195,6 +298,7 @@ export class AgentSession {
         this._hooksConfig = emptyHooksConfig();
         this._pendingHookNotices = [];
         this._sessionTraceEnabled = isSessionTraceEnabled();
+        this._protocolAutoRepairActive = false;
         // Track last assistant message for auto-compaction check
         this._lastAssistantMessage = undefined;
         this._lastTaskPlanSignature = undefined;
@@ -1126,13 +1230,88 @@ export class AgentSession {
                 this.agent.setSystemPrompt(this._baseSystemPrompt);
             }
         }
-        await this.agent.prompt(messages);
-        await this.waitForRetry();
+        const enableProtocolAutoRepair = !options?.skipProtocolAutoRepair && !this._protocolAutoRepairActive;
+        let protocolToolCallsStarted = 0;
+        let latestAssistantProtocolText = "";
+        let latestAssistantMessage;
+        let latestAssistantVisibleText = "";
+        const unsubscribeProtocolMonitor = enableProtocolAutoRepair
+            ? this.subscribe((event) => {
+                if (event.type === "tool_execution_start") {
+                    protocolToolCallsStarted += 1;
+                    return;
+                }
+                if (event.type === "message_end" && event.message.role === "assistant") {
+                    latestAssistantMessage = event.message;
+                    latestAssistantProtocolText = extractAssistantProtocolText(latestAssistantMessage);
+                    latestAssistantVisibleText = extractAssistantVisibleText(latestAssistantMessage);
+                }
+            })
+            : undefined;
+        try {
+            await this.agent.prompt(messages);
+            await this.waitForRetry();
+        }
+        finally {
+            unsubscribeProtocolMonitor?.();
+        }
         this._appendSessionTrace({
             type: "prompt_dispatched",
             messageCount: messages.length,
             text: promptText,
         });
+        if (enableProtocolAutoRepair) {
+            let nextIssue = detectPromptProtocolIssue(latestAssistantProtocolText);
+            let nextSilentStopWithoutOutput = !nextIssue &&
+                latestAssistantMessage?.stopReason === "stop" &&
+                !latestAssistantMessage.content.some((part) => part.type === "toolCall") &&
+                isNonActionableVisibleAssistantText(latestAssistantVisibleText);
+            if (nextIssue || nextSilentStopWithoutOutput) {
+                this._protocolAutoRepairActive = true;
+                try {
+                    for (let repairAttempt = 1; repairAttempt <= MAX_PROMPT_PROTOCOL_AUTO_REPAIR_ATTEMPTS && (nextIssue || nextSilentStopWithoutOutput); repairAttempt += 1) {
+                        const hasPriorToolActivity = protocolToolCallsStarted > 0 || repairAttempt > 1;
+                        const correctionPrompt = nextIssue
+                            ? buildPromptProtocolCorrectionPrompt({
+                                originalPrompt: expandedText,
+                                issue: nextIssue,
+                                hasPriorToolActivity,
+                            })
+                            : buildPromptSilentStopRecoveryPrompt({
+                                originalPrompt: expandedText,
+                                hasPriorToolActivity,
+                            });
+                        this._appendSessionTrace({
+                            type: "prompt_protocol_auto_repair",
+                            originalPrompt: expandedText,
+                            issue: nextIssue ?? { silentStopWithoutOutput: true },
+                            hasPriorToolActivity,
+                            repairAttempt,
+                            maxRepairAttempts: MAX_PROMPT_PROTOCOL_AUTO_REPAIR_ATTEMPTS,
+                        });
+                        await this.prompt(correctionPrompt, {
+                            expandPromptTemplates: false,
+                            skipIosmAutopilot: true,
+                            skipOrchestrationDirective: true,
+                            skipProtocolAutoRepair: true,
+                            source: inputSource,
+                        });
+                        const repairedAssistant = this._findLastAssistantMessage();
+                        const repairedProtocolText = repairedAssistant ? extractAssistantProtocolText(repairedAssistant) : "";
+                        const repairedVisibleText = repairedAssistant ? extractAssistantVisibleText(repairedAssistant) : "";
+                        nextIssue = detectPromptProtocolIssue(repairedProtocolText);
+                        nextSilentStopWithoutOutput =
+                            !nextIssue &&
+                                repairedAssistant?.stopReason === "stop" &&
+                                !repairedAssistant.content.some((part) => part.type === "toolCall") &&
+                                isNonActionableVisibleAssistantText(repairedVisibleText);
+                    }
+                }
+                finally {
+                    this._protocolAutoRepairActive = false;
+                }
+            }
+        }
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -2411,6 +2590,13 @@ export class AgentSession {
                         return this._toolPermissionHandler ? this._toolPermissionHandler(request) : true;
                     },
                 },
+                dbRun: {
+                    resolveRuntimeConfig: () => this.settingsManager.getDbToolsSettings(),
+                    permissionGuard: async (request) => {
+                        evaluatePreToolHooks(request);
+                        return this._toolPermissionHandler ? this._toolPermissionHandler(request) : true;
+                    },
+                },
             });
         this._baseToolRegistry = new Map(Object.entries(baseTools).map(([name, tool]) => [name, tool]));
         const extensionsResult = this._resourceLoader.getExtensions();