@charzhu/openjaw-agent 0.3.1 → 0.3.2

package/dist/main.js

@@ -131,7 +131,8 @@ function loadAgentConfig() {
       copilot_oauth_client_id: parsedLlm?.copilot_oauth_client_id ?? DEFAULT_CONFIG.llm.copilot_oauth_client_id,
       context_compression: parsedLlm?.context_compression,
       compression_threshold: parsedLlm?.compression_threshold,
-      compression_model: parsedLlm?.compression_model
+      compression_model: parsedLlm?.compression_model,
+      max_tool_rounds: parsedLlm?.max_tool_rounds
     },
     telegram: parsed?.telegram ?? void 0,
     feishu: parsed?.feishu ?? void 0,
@@ -2641,7 +2642,8 @@ var init_copilot = __esm({
             messages.push({
               role: "assistant",
               content: msg.content,
-              ...toolCalls?.length ? { tool_calls: toolCalls } : {}
+              ...toolCalls?.length ? { tool_calls: toolCalls } : {},
+              ...msg.reasoningOpaque ? { reasoning_opaque: msg.reasoningOpaque } : {}
             });
           } else {
             for (const result of msg.results) {
@@ -2671,11 +2673,12 @@ var init_copilot = __esm({
           messages: this.buildChatMessages(options),
           tools: options.tools.length > 0 ? options.tools.map(toChatTool) : void 0,
           tool_choice: options.tools.length > 0 ? "auto" : void 0,
-          temperature: this.config.temperature
+          temperature: this.config.temperature,
+          stream: true
         };
         const res = await fetch(`${await this.baseUrl(options.signal)}/chat/completions`, {
           method: "POST",
-          headers: await this.headers(options),
+          headers: { ...await this.headers(options), Accept: "text/event-stream" },
           body: JSON.stringify(requestBody),
           signal: options.signal
         });
@@ -2683,19 +2686,85 @@ var init_copilot = __esm({
           const detail = await res.text();
           throw new Error(`GitHub Copilot chat error: ${res.status} ${detail}`);
         }
-        const data = await res.json();
-        const choice = data.choices?.[0];
-        if (!choice?.message) throw new Error("No response from GitHub Copilot");
-        const toolCalls = (choice.message.tool_calls ?? []).map((tc) => ({
-          id: tc.id,
-          name: tc.function.name,
-          input: safeJsonParse(tc.function.arguments)
-        }));
+        if (!res.body) throw new Error("GitHub Copilot chat: no response body for stream");
+        let text = null;
+        let finishReason;
+        let reasoningOpaque;
+        let promptTokens;
+        let completionTokens;
+        const toolSlots = [];
+        const lastSlotByIndex = /* @__PURE__ */ new Map();
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buf += decoder.decode(value, { stream: true });
+          let nl;
+          while ((nl = buf.indexOf("\n")) !== -1) {
+            const rawLine = buf.slice(0, nl).trim();
+            buf = buf.slice(nl + 1);
+            if (!rawLine.startsWith("data:")) continue;
+            const payload = rawLine.slice(5).trim();
+            if (payload === "[DONE]") continue;
+            let evt;
+            try {
+              evt = JSON.parse(payload);
+            } catch {
+              continue;
+            }
+            const choice = evt.choices?.[0];
+            if (choice) {
+              const delta = choice.delta;
+              if (delta) {
+                if (typeof delta.content === "string") text = (text ?? "") + delta.content;
+                if (typeof delta.reasoning_opaque === "string") {
+                  reasoningOpaque = (reasoningOpaque ?? "") + delta.reasoning_opaque;
+                }
+                const deltaToolCalls = delta.tool_calls;
+                for (const tc of deltaToolCalls ?? []) {
+                  const idx = typeof tc.index === "number" ? tc.index : 0;
+                  const fn = tc.function;
+                  const startsNewCall = typeof tc.id === "string" || typeof fn?.name === "string";
+                  let slot;
+                  if (startsNewCall) {
+                    slot = { args: "" };
+                    if (typeof tc.id === "string") slot.id = tc.id;
+                    if (fn?.name) slot.name = fn.name;
+                    toolSlots.push(slot);
+                    lastSlotByIndex.set(idx, slot);
+                  } else {
+                    slot = lastSlotByIndex.get(idx) ?? { args: "" };
+                    if (!lastSlotByIndex.has(idx)) {
+                      toolSlots.push(slot);
+                      lastSlotByIndex.set(idx, slot);
+                    }
+                  }
+                  if (typeof fn?.arguments === "string") slot.args += fn.arguments;
+                }
+              }
+              if (typeof choice.finish_reason === "string") finishReason = choice.finish_reason;
+              if (typeof choice.reasoning_opaque === "string") {
+                reasoningOpaque = choice.reasoning_opaque;
+              }
+              const msg = choice.message;
+              if (typeof msg?.reasoning_opaque === "string") reasoningOpaque = msg.reasoning_opaque;
+            }
+            const usage2 = evt.usage;
+            if (usage2) {
+              promptTokens = usage2.prompt_tokens;
+              completionTokens = usage2.completion_tokens;
+            }
+          }
+        }
+        const toolCalls = toolSlots.filter((slot) => slot.id && slot.name).map((slot) => ({ id: slot.id, name: slot.name, input: safeJsonParse(slot.args) }));
         return {
-          text: choice.message.content,
+          text,
           toolCalls,
-          stopReason: toolCalls.length > 0 ? "tool_use" : choice.finish_reason === "length" ? "max_tokens" : "end",
-          usage: this.usage(data.usage?.prompt_tokens, data.usage?.completion_tokens)
+          stopReason: toolCalls.length > 0 ? "tool_use" : finishReason === "length" ? "max_tokens" : "end",
+          usage: this.usage(promptTokens, completionTokens),
+          reasoningOpaque
         };
       }
       buildResponsesInput(options) {
@@ -3963,13 +4032,13 @@ function selectToolsForRequest(params) {
     addByName(name);
   }
   const relevantCategories = categoriesForMessage(userMessage);
-  for (const tool of allTools) {
-    if (selected.size >= maxTools) break;
+  const relevantTools = allTools.map((tool, index) => ({ index, score: toolRelevanceScore(tool.name, userMessage), tool })).filter(({ tool }) => {
     const cat = categoryForTool(tool.name);
-    if (cat === "mcp") continue;
-    if (relevantCategories.has(cat)) {
-      selected.set(tool.name, tool);
-    }
+    return cat !== "mcp" && relevantCategories.has(cat) && !selected.has(tool.name);
+  }).sort((a, b) => b.score - a.score || a.index - b.index);
+  for (const { tool } of relevantTools) {
+    if (selected.size >= maxTools) break;
+    selected.set(tool.name, tool);
   }
   if (selected.size < maxTools && relevantCategories.size === 0) {
     for (const tool of allTools) {
@@ -4000,6 +4069,20 @@ function categoriesForMessage(message) {
   }
   return categories;
 }
+function preloadRelevantCategoriesForRequest(loader, message) {
+  if (typeof loader.loadCategory !== "function") return [];
+  const loaded = [];
+  for (const category of categoriesForMessage(message)) {
+    if (category === "mcp" || category === "meta" || category === "skill") continue;
+    const added = loader.loadCategory(category);
+    if (added > 0) loaded.push(category);
+  }
+  return loaded;
+}
+function toolOutputLooksFailed(output) {
+  if (!output) return false;
+  return /^\s*\{?"?(error|success)"?\s*:\s*("|false)/i.test(output) || /\b(error|not found|enoent|failed)\b/i.test(output.slice(0, 300));
+}
 function normalizeCategory(value) {
   const normalized = value.toLowerCase();
   if (["browser", "email", "teams", "office", "wechat", "memory", "files", "system"].includes(normalized)) {
@@ -4020,6 +4103,20 @@ function categoryForTool(toolName) {
   if (toolName.startsWith("system_") || toolName.startsWith("clipboard_") || ["code_execute", "web_fetch", "web_search", "web_extract", "notify", "sleep", "ask_user", "config"].includes(toolName)) return "system";
   return "mcp";
 }
+function toolRelevanceScore(toolName, message) {
+  const lower = message.toLowerCase();
+  const name = toolName.toLowerCase();
+  if (/https?:\/\//i.test(message) && ["web_extract", "web_fetch", "web_search"].includes(name)) return 150;
+  if (/(?:^|[\s"'`])(?:~|\.\.?|[A-Za-z]:)?[\\/][^\s"'`]+|\b[\w.-]+\.(html?|md|txt|json|ya?ml|ts|tsx|js|jsx|py|csv|xlsx?|pptx?|pdf)\b/i.test(message) && ["file_read", "file_info", "file_list"].includes(name)) return 145;
+  if (/\b(repo|repository|source code|github|codebase)\b/.test(lower) && ["system_run", "code_execute", "grep", "glob", "web_extract", "web_fetch", "file_read"].includes(name)) return 140;
+  if (/https?:\/\//i.test(message) && ["browser_navigate", "browser_extract", "browser_snapshot"].includes(name)) return 135;
+  if (/\b(powerpoint|pptx?|presentation|slides?|deck)\b/.test(lower) && ["powerpoint_focus", "powerpoint_new_presentation", "powerpoint_new_slide", "powerpoint_read_content", "powerpoint_send_keys", "powerpoint_screenshot"].includes(name)) return 130;
+  if (/\b(powerpoint|pptx?|presentation|slides?|deck)\b/.test(lower) && name.startsWith("powerpoint_")) return 85;
+  if (/\b(excel|spreadsheet|xlsx?|csv|data analysis)\b/.test(lower) && ["excel_focus", "excel_new_workbook", "excel_read_content", "excel_enter_value", "excel_enter_formula"].includes(name)) return 95;
+  if (/\b(word|docx?|document|report)\b/.test(lower) && ["word_focus", "word_new_document", "word_read_content", "word_insert_text", "word_save"].includes(name)) return 95;
+  if (name === "openjaw_load_tools" || name === "invoke_skill") return 90;
+  return 0;
+}
 var DEFAULT_OPENAI_MAX_TOOLS, MCP_AUTO_GROW_HARD_CAP, BUILTIN_HEADROOM, FOUNDATION_TOOL_NAMES, PROFILE_CATEGORIES, CATEGORY_KEYWORDS;
 var init_tool_exposure = __esm({
   "src/tool-exposure.ts"() {
@@ -4043,10 +4140,10 @@ var init_tool_exposure = __esm({
     CATEGORY_KEYWORDS = [
       { category: "email", patterns: [/\b(email|mail|outlook|inbox|calendar|schedule|meeting|invite|today|tomorrow)\b/i] },
       { category: "teams", patterns: [/\b(teams|chat|channel|message|dm|meeting|standup|today|mention)\b/i] },
-      { category: "browser", patterns: [/\b(browser|page|website|web|navigate|click|screenshot|snapshot|console|image|search online)\b/i] },
-      { category: "files", patterns: [/\b(file|folder|directory|read|write|edit|grep|glob|find in repo|codebase)\b/i] },
+      { category: "browser", patterns: [/\b(browser|page|website|web|navigate|click|screenshot|snapshot|console|image|search online)\b/i, /https?:\/\//i] },
+      { category: "files", patterns: [/\b(file|folder|directory|read|write|edit|grep|glob|find in repo|codebase|source code|repo|repository|downloads?)\b/i, /(?:^|[\s"'`])(?:~|\.\.?|[A-Za-z]:)?[\\/][^\s"'`]+/i, /\b[\w.-]+\.(html?|md|txt|json|ya?ml|ts|tsx|js|jsx|py|csv|xlsx?|pptx?|pdf)\b/i] },
       { category: "system", patterns: [/\b(shell|command|terminal|run|execute|clipboard|notify|sleep|web search|fetch url|extract url|read url|article|docs?|paper|source page|news|latest|headlines|current events|breaking news)\b/i] },
-      { category: "office", patterns: [/\b(word|excel|powerpoint|spreadsheet|document|presentation|slide)\b/i] },
+      { category: "office", patterns: [/\b(word|excel|powerpoint|pptx?|spreadsheet|document|presentation|slide|deck)\b/i] },
       { category: "wechat", patterns: [/\b(wechat|weixin)\b/i] },
       { category: "memory", patterns: [/\b(memory|remember|recall|todo|preference)\b/i] }
     ];
@@ -4058,8 +4155,245 @@ var init_tool_exposure = __esm({
     __name(rememberLoadedToolExposure, "rememberLoadedToolExposure");
     __name(selectToolsForRequest, "selectToolsForRequest");
     __name(categoriesForMessage, "categoriesForMessage");
+    __name(preloadRelevantCategoriesForRequest, "preloadRelevantCategoriesForRequest");
+    __name(toolOutputLooksFailed, "toolOutputLooksFailed");
     __name(normalizeCategory, "normalizeCategory");
     __name(categoryForTool, "categoryForTool");
+    __name(toolRelevanceScore, "toolRelevanceScore");
+  }
+});
+
+// src/turn-control.ts
+var DEFAULT_MAX_TOOL_ROUNDS, IterationBudget;
+var init_turn_control = __esm({
+  "src/turn-control.ts"() {
+    "use strict";
+    DEFAULT_MAX_TOOL_ROUNDS = 100;
+    IterationBudget = class {
+      static {
+        __name(this, "IterationBudget");
+      }
+      used = 0;
+      graceUsed = false;
+      max;
+      constructor(max = DEFAULT_MAX_TOOL_ROUNDS) {
+        this.max = Math.max(1, Math.floor(max));
+      }
+      get remaining() {
+        return Math.max(0, this.max - this.used);
+      }
+      get consumed() {
+        return this.used;
+      }
+      /** True while there is budget (or the one-time grace round) left to run. */
+      canContinue() {
+        return this.remaining > 0 || !this.graceUsed;
+      }
+      /** True only when the budget is spent and we are on the grace round. */
+      isGraceRound() {
+        return this.remaining === 0 && !this.graceUsed;
+      }
+      /** Consume one round. Returns false if nothing (not even grace) is left. */
+      consume() {
+        if (this.remaining > 0) {
+          this.used += 1;
+          return true;
+        }
+        if (!this.graceUsed) {
+          this.graceUsed = true;
+          return true;
+        }
+        return false;
+      }
+      /** Give a round back (e.g. a round that made no model-visible progress). */
+      refund() {
+        if (this.used > 0) this.used -= 1;
+      }
+    };
+  }
+});
+
+// src/tool-guardrails.ts
+function isNoProgressTracked(toolName) {
+  if (MUTATING_TOOLS.has(toolName)) return false;
+  if (toolName.startsWith("powerpoint_") || toolName.startsWith("word_") || toolName.startsWith("excel_")) {
+    return false;
+  }
+  return true;
+}
+function signatureOf(toolName, args) {
+  return `${toolName}\0${canonicalJson(args ?? {})}`;
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`).join(",")}}`;
+}
+function hashOutput(output) {
+  let h = 2166136261;
+  const s = output ?? "";
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+function appendGuardrailGuidance(result, decision) {
+  if (decision.action !== "warn" && decision.action !== "halt" || !decision.message) return result;
+  const label = decision.action === "halt" ? "Tool loop hard stop" : "Tool loop warning";
+  return `${result || ""}
+
+[${label}: ${decision.code}; count=${decision.count}; ${decision.message}]`;
+}
+function blockedToolResult(decision) {
+  return JSON.stringify({ error: decision.message, guardrail: { code: decision.code, action: decision.action } });
+}
+var DEFAULT_GUARDRAIL_THRESHOLDS, MUTATING_TOOLS, ToolLoopGuardrails;
+var init_tool_guardrails = __esm({
+  "src/tool-guardrails.ts"() {
+    "use strict";
+    DEFAULT_GUARDRAIL_THRESHOLDS = {
+      hardStopEnabled: true,
+      exactFailureWarnAfter: 2,
+      exactFailureBlockAfter: 5,
+      sameToolFailureWarnAfter: 3,
+      sameToolFailureHaltAfter: 8,
+      noProgressWarnAfter: 2,
+      noProgressBlockAfter: 5
+    };
+    MUTATING_TOOLS = /* @__PURE__ */ new Set([
+      "file_write",
+      "file_edit",
+      "file_delete",
+      "notify",
+      "ask_user",
+      "memory_append",
+      "memory_save"
+    ]);
+    __name(isNoProgressTracked, "isNoProgressTracked");
+    __name(signatureOf, "signatureOf");
+    __name(canonicalJson, "canonicalJson");
+    __name(hashOutput, "hashOutput");
+    ToolLoopGuardrails = class {
+      static {
+        __name(this, "ToolLoopGuardrails");
+      }
+      t;
+      exactFailure = /* @__PURE__ */ new Map();
+      sameToolFailure = /* @__PURE__ */ new Map();
+      noProgress = /* @__PURE__ */ new Map();
+      haltDecision = null;
+      constructor(thresholds = {}) {
+        this.t = { ...DEFAULT_GUARDRAIL_THRESHOLDS, ...thresholds };
+      }
+      /** Set once a block/halt has fired; the loop reads this to stop the turn. */
+      get halted() {
+        return this.haltDecision;
+      }
+      /**
+       * Consult before (re-)executing a tool call. Returns `block` if this exact
+       * call has already failed/no-progressed past the hard-stop threshold, so the
+       * loop can skip execution and tell the model to change strategy.
+       */
+      before(toolName, args) {
+        if (!this.t.hardStopEnabled) return { action: "allow", toolName };
+        const sig = signatureOf(toolName, args);
+        const exact = this.exactFailure.get(sig) ?? 0;
+        if (exact >= this.t.exactFailureBlockAfter) {
+          return this.recordHalt({
+            action: "block",
+            code: "repeated_exact_failure_block",
+            message: `Blocked ${toolName}: the same tool call failed ${exact} times with identical arguments. Stop retrying it unchanged; change strategy or explain the blocker.`,
+            toolName,
+            count: exact
+          });
+        }
+        if (isNoProgressTracked(toolName)) {
+          const rec = this.noProgress.get(sig);
+          if (rec && rec.count >= this.t.noProgressBlockAfter) {
+            return this.recordHalt({
+              action: "block",
+              code: "idempotent_no_progress_block",
+              message: `Blocked ${toolName}: this call returned the same result ${rec.count} times. Stop repeating it unchanged; use the result already provided or try a different approach.`,
+              toolName,
+              count: rec.count
+            });
+          }
+        }
+        return { action: "allow", toolName };
+      }
+      /**
+       * Record the outcome after a tool call. Returns a `warn` to append to the
+       * tool result, or a `halt` to stop the turn. `failed` is derived by the
+       * caller from the output shape (reuse tool-exposure's toolOutputLooksFailed).
+       */
+      after(toolName, args, output, failed) {
+        const sig = signatureOf(toolName, args);
+        if (failed) {
+          const exact = (this.exactFailure.get(sig) ?? 0) + 1;
+          this.exactFailure.set(sig, exact);
+          this.noProgress.delete(sig);
+          const same = (this.sameToolFailure.get(toolName) ?? 0) + 1;
+          this.sameToolFailure.set(toolName, same);
+          if (this.t.hardStopEnabled && same >= this.t.sameToolFailureHaltAfter) {
+            return this.recordHalt({
+              action: "halt",
+              code: "same_tool_failure_halt",
+              message: `Stopped ${toolName}: it failed ${same} times this turn. Stop retrying the same failing tool path and choose a different approach.`,
+              toolName,
+              count: same
+            });
+          }
+          if (exact >= this.t.exactFailureWarnAfter) {
+            return {
+              action: "warn",
+              code: "repeated_exact_failure_warning",
+              message: `${toolName} has failed ${exact} times with identical arguments. This looks like a loop; inspect the error and change strategy instead of retrying it unchanged.`,
+              toolName,
+              count: exact
+            };
+          }
+          if (same >= this.t.sameToolFailureWarnAfter) {
+            return {
+              action: "warn",
+              code: "same_tool_failure_warning",
+              message: `${toolName} has failed ${same} times this turn. This looks like a loop. Do not switch to text-only replies; keep using tools, but inspect the latest error and verify your assumptions before retrying.`,
+              toolName,
+              count: same
+            };
+          }
+          return { action: "allow", toolName, count: exact };
+        }
+        this.exactFailure.delete(sig);
+        this.sameToolFailure.delete(toolName);
+        if (!isNoProgressTracked(toolName)) {
+          this.noProgress.delete(sig);
+          return { action: "allow", toolName };
+        }
+        const hash3 = hashOutput(output);
+        const prev = this.noProgress.get(sig);
+        const count = prev && prev.hash === hash3 ? prev.count + 1 : 1;
+        this.noProgress.set(sig, { hash: hash3, count });
+        if (count >= this.t.noProgressWarnAfter) {
+          return {
+            action: "warn",
+            code: "idempotent_no_progress_warning",
+            message: `${toolName} returned the same result ${count} times. Use the result already provided or change the approach instead of repeating it unchanged.`,
+            toolName,
+            count
+          };
+        }
+        return { action: "allow", toolName, count };
+      }
+      recordHalt(decision) {
+        this.haltDecision = decision;
+        return decision;
+      }
+    };
+    __name(appendGuardrailGuidance, "appendGuardrailGuidance");
+    __name(blockedToolResult, "blockedToolResult");
   }
 });
 
@@ -4612,6 +4946,8 @@ var init_agent_loop = __esm({
     init_telemetry();
     init_context_compressor();
     init_tool_exposure();
+    init_turn_control();
+    init_tool_guardrails();
     init_provider_auth();
     init_connect();
     AgentLoop = class {
@@ -5132,15 +5468,25 @@ ${summary}
           const MAX_SAME_ACTIONS = 3;
           let previousCacheReadTokens = 0;
           let maxTokensContinuations = 0;
+          const budget = new IterationBudget(this.config.llm.max_tool_rounds ?? DEFAULT_MAX_TOOL_ROUNDS);
+          const guardrails = new ToolLoopGuardrails();
           for (let step = 0; ; step++) {
             if (signal.aborted) {
               yield { type: "answer", content: "[Interrupted by user]" };
               return;
             }
+            const forceFinalSummary = budget.isGraceRound();
+            if (!budget.consume()) {
+              const reason = "max_iterations";
+              yield { type: "answer", content: `[Reached the maximum of ${budget.max} tool rounds. Stopping.]`, exitReason: reason };
+              return;
+            }
             let responseText = null;
             const responseToolCalls = [];
             let responseStopReason = "end";
+            let responseReasoningOpaque;
             let responseUsage;
+            preloadRelevantCategoriesForRequest(this.toolRegistry, userMessage);
             const allTools = this.toolRegistry.listTools();
             const exposure = selectToolsForRequest({
               config: this.config,
@@ -5148,7 +5494,13 @@ ${summary}
               userMessage,
               state: this._toolExposureState
             });
-            const tools = exposure.tools;
+            const tools = forceFinalSummary ? [] : exposure.tools;
+            if (forceFinalSummary) {
+              messages.push({
+                role: "user",
+                content: "[System: You've reached the maximum number of tool-calling rounds. Do not call any more tools. Summarize what you accomplished, what is still incomplete, and any blocker, as your final answer.]"
+              });
+            }
             const chatOptions = {
               systemPrompt,
               messages,
@@ -5231,6 +5583,7 @@ ${summary}
                 responseToolCalls.push(...response.toolCalls);
                 responseStopReason = response.stopReason;
                 responseUsage = response.usage;
+                responseReasoningOpaque = response.reasoningOpaque;
               }
             } catch (apiError) {
               const errMsg = apiError instanceof Error ? apiError.message : String(apiError);
@@ -5357,10 +5710,11 @@ ${summary}
               this.conversationHistory.push({ role: "assistant", content: responseText });
               this.session.messages = this.conversationHistory;
               saveSession(this.session);
+              const exitReason = forceFinalSummary ? "max_iterations" : "completed";
               if (!this.provider.chatStream) {
-                yield { type: "answer", content: responseText ?? "" };
+                yield { type: "answer", content: responseText ?? "", exitReason };
               } else {
-                yield { type: "answer", content: "" };
+                yield { type: "answer", content: "", exitReason };
               }
               if (this._toolRoundsInRun >= 1 || responseText && responseText.length > 200) {
                 void this.postTurnMemorySave(systemPrompt, messages, tools, signal);
@@ -5392,7 +5746,8 @@ ${summary}
             messages.push({
               role: "assistant",
               content: responseText,
-              toolCalls: validToolCalls
+              toolCalls: validToolCalls,
+              reasoningOpaque: responseReasoningOpaque
             });
             const computerCalls = validToolCalls.filter((tc) => tc.name === "computer");
             const otherCalls = validToolCalls.filter((tc) => tc.name !== "computer");
@@ -5400,6 +5755,10 @@ ${summary}
               if (signal.aborted) {
                 return { id: tc.id, name: tc.name, output: "[Interrupted]", imageData: void 0 };
               }
+              const pre = guardrails.before(tc.name, tc.input);
+              if (pre.action === "block") {
+                return { id: tc.id, name: tc.name, output: blockedToolResult(pre), imageData: void 0 };
+              }
               let output;
               let imageData2;
               try {
@@ -5456,7 +5815,12 @@ ${summary}
                 }
               } catch {
               }
-              const outputStr = typeof output === "string" ? output : JSON.stringify(output ?? { error: "No output" });
+              let outputStr = typeof output === "string" ? output : JSON.stringify(output ?? { error: "No output" });
+              const failed = toolOutputLooksFailed(outputStr);
+              const verdict = guardrails.after(tc.name, tc.input, outputStr, failed);
+              if (verdict.action === "warn" || verdict.action === "halt") {
+                outputStr = appendGuardrailGuidance(outputStr, verdict);
+              }
               return { id: tc.id, name: tc.name, output: outputStr, imageData: imageData2 };
             }, "executeOne");
             const results = [];
@@ -5516,6 +5880,15 @@ ${summary}
             this.conversationHistory = [...messages];
             this.session.messages = this.conversationHistory;
             saveSession(this.session);
+            if (guardrails.halted) {
+              const reason = "guardrail_halt";
+              yield {
+                type: "answer",
+                content: `[Stopped: ${guardrails.halted.message ?? "tool loop detected"}]`,
+                exitReason: reason
+              };
+              return;
+            }
             if (this._toolRoundsInRun > 0 && this._toolRoundsInRun % 5 === 0) {
               messages.push({
                 role: "user",
@@ -46378,7 +46751,7 @@ var init_overlayStore = __esm({
     $overlayState = atom2(buildOverlayState());
     $isBlocked = computed2(
       $overlayState,
-      ({ agents, approval, clarify, confirm, mcpHub, modelPicker, pager, picker, secret, skillsHub, sudo }) => Boolean(agents || approval || clarify || confirm || mcpHub || modelPicker || pager || picker || secret || skillsHub || sudo)
+      ({ agents, approval, clarify, confirm, mcpHub, pager, picker, secret, skillsHub, sudo }) => Boolean(agents || approval || clarify || confirm || mcpHub || pager || picker || secret || skillsHub || sudo)
     );
     patchOverlayState = /* @__PURE__ */ __name((next) => $overlayState.set(typeof next === "function" ? next($overlayState.get()) : { ...$overlayState.get(), ...next }), "patchOverlayState");
     resetFlowOverlays = /* @__PURE__ */ __name(() => $overlayState.set({