open-agents-ai 0.187.10 → 0.187.11

package/dist/index.js

@@ -264641,7 +264641,7 @@ var init_agent_types = __esm({
       model: "inherit",
       isolation: "none",
       canSpawnAgents: false,
-      systemPromptAddition: "You are a planning agent. Analyze the codebase and produce a structured implementation plan. You can ONLY read files \u2014 you CANNOT make changes. Your output should include: files to modify, specific changes, rationale, and potential risks."
+      systemPromptAddition: 'You are a planning agent. Analyze the codebase and produce a structured implementation plan. You can ONLY read files \u2014 you CANNOT make changes.\n\nWhen you call task_complete, include a JSON plan in your summary using this structure:\n```json\n{"task":"the task description","approach":"1-2 sentence strategy","estimatedTurns":5,"steps":[{"step":1,"action":"what to do","tool":"which_tool","target":"file_or_resource","expectedOutcome":"what should happen","risk":"low|medium|high"}]}\n```\n\nRules:\n- Be specific about files and tools\n- Include verification steps (tests, validation)\n- Flag high-risk steps (file deletion, config changes)\n- Each step should map to a single tool call'
     };
     COORDINATOR_AGENT = {
       type: "coordinator",
@@ -264933,9 +264933,189 @@ var init_coordinator = __esm({
 });
 
 // packages/orchestrator/dist/self-critique.js
+function buildPlanPrompt(task) {
+  return `## Plan Mode Active
+
+You are in PLAN MODE. Generate a structured plan for this task WITHOUT executing it.
+
+**Task**: ${task}
+
+Output a JSON plan with this structure:
+{
+  "task": "the task description",
+  "approach": "1-2 sentence high-level strategy",
+  "estimatedTurns": <number>,
+  "steps": [
+    {
+      "step": 1,
+      "action": "What to do",
+      "tool": "which_tool_to_use",
+      "target": "file or resource",
+      "expectedOutcome": "What should happen",
+      "risk": "low|medium|high"
+    }
+  ]
+}
+
+Rules:
+- Be specific about files and tools
+- Include verification steps (tests, validation)
+- Flag high-risk steps (file deletion, config changes)
+- Keep the plan actionable \u2014 each step should be a single tool call`;
+}
+function buildCritiquePrompt(plan) {
+  const principlesList = Object.values(CRITIQUE_PRINCIPLES).map((p2, i2) => `${i2 + 1}. **${p2.name}**: ${p2.description}`).join("\n");
+  return `## Self-Critique Mode
+
+Review this plan against these principles:
+
+${principlesList}
+
+**Plan to critique**:
+${JSON.stringify(plan, null, 2)}
+
+For each principle, rate 1-5 and explain. Output JSON:
+{
+  "scores": { "safety": <1-5>, "completeness": <1-5>, "efficiency": <1-5>, "correctness": <1-5>, "ordering": <1-5> },
+  "issues": ["issue 1", "issue 2"],
+  "suggestions": ["suggestion 1"]
+}
+
+If any score < 3, the plan needs revision.`;
+}
+function buildMetaCritiquePrompt(critique) {
+  return `## Meta-Critique Mode
+
+Was your critique thorough? Review your own evaluation:
+
+${JSON.stringify(critique, null, 2)}
+
+Ask yourself:
+- Did I miss any risks?
+- Were my scores justified?
+- Did I consider edge cases?
+
+Output JSON:
+{
+  "quality": <1-5>,
+  "thorough": <boolean>,
+  "missed": ["any missed concerns"]
+}
+
+If quality < 4, re-critique with more depth.`;
+}
+function parsePlan(text) {
+  const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) || text.match(/(\{[\s\S]*"steps"[\s\S]*\})/);
+  if (!jsonMatch)
+    return null;
+  try {
+    const parsed = JSON.parse(jsonMatch[1].trim());
+    if (!parsed.steps || !Array.isArray(parsed.steps))
+      return null;
+    return {
+      task: parsed.task || "",
+      approach: parsed.approach || "",
+      estimatedTurns: parsed.estimatedTurns || parsed.steps.length,
+      steps: parsed.steps.map((s2, i2) => ({
+        step: s2.step || i2 + 1,
+        action: s2.action || "",
+        tool: s2.tool,
+        target: s2.target,
+        expectedOutcome: s2.expectedOutcome || s2.expected_outcome || "",
+        risk: s2.risk || "low"
+      }))
+    };
+  } catch {
+    return null;
+  }
+}
+function parseCritique(text) {
+  const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) || text.match(/(\{[\s\S]*"scores"[\s\S]*\})/);
+  if (!jsonMatch)
+    return null;
+  try {
+    const parsed = JSON.parse(jsonMatch[1].trim());
+    if (!parsed.scores)
+      return null;
+    const scores = parsed.scores;
+    const values = Object.values(scores);
+    const avg = values.reduce((a2, b) => a2 + b, 0) / values.length;
+    return {
+      scores,
+      issues: parsed.issues || [],
+      suggestions: parsed.suggestions || [],
+      pass: values.every((v) => v >= 3),
+      averageScore: Math.round(avg * 10) / 10
+    };
+  } catch {
+    return null;
+  }
+}
+function parseMetaCritique(text) {
+  const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) || text.match(/(\{[\s\S]*"quality"[\s\S]*\})/);
+  if (!jsonMatch)
+    return null;
+  try {
+    const parsed = JSON.parse(jsonMatch[1].trim());
+    return {
+      quality: parsed.quality || 3,
+      thorough: parsed.thorough ?? true,
+      missed: parsed.missed || []
+    };
+  } catch {
+    return null;
+  }
+}
+function getPlanModeConfig(modelTier) {
+  switch (modelTier) {
+    case "large":
+      return { ...DEFAULT_PLAN_MODE_CONFIG, maxRevisions: 3, enableMetaCritique: true };
+    case "medium":
+      return { ...DEFAULT_PLAN_MODE_CONFIG, maxRevisions: 2, enableMetaCritique: true };
+    case "small":
+      return { ...DEFAULT_PLAN_MODE_CONFIG, maxRevisions: 1, enableMetaCritique: false };
+    default:
+      return DEFAULT_PLAN_MODE_CONFIG;
+  }
+}
+var CRITIQUE_PRINCIPLES, DEFAULT_PLAN_MODE_CONFIG;
 var init_self_critique = __esm({
   "packages/orchestrator/dist/self-critique.js"() {
     "use strict";
+    CRITIQUE_PRINCIPLES = {
+      safety: {
+        name: "SAFETY",
+        description: "Does any step risk data loss, irreversible changes, or security issues?",
+        weight: 2
+        // Critical — double weight
+      },
+      completeness: {
+        name: "COMPLETENESS",
+        description: "Does the plan address the full task? Are there missing steps?",
+        weight: 1
+      },
+      efficiency: {
+        name: "EFFICIENCY",
+        description: "Are there unnecessary steps? Could steps be combined or parallelized?",
+        weight: 1
+      },
+      correctness: {
+        name: "CORRECTNESS",
+        description: "Will each step produce the expected output? Are there logical errors?",
+        weight: 1.5
+      },
+      ordering: {
+        name: "ORDERING",
+        description: "Are steps in the right dependency order? Would reordering improve the plan?",
+        weight: 1
+      }
+    };
+    DEFAULT_PLAN_MODE_CONFIG = {
+      maxRevisions: 3,
+      minAverageScore: 3,
+      enableMetaCritique: true,
+      metaCritiqueThreshold: 4
+    };
   }
 });
 
@@ -304986,6 +305166,8 @@ function buildTools(repoRoot, config, contextWindowSize, modelTier) {
     // MCP tools (dynamic — from connected MCP servers, WO-MCP-01)
     ..._mcpTools.map(adaptTool6),
     createSubAgentTool(config, repoRoot, contextWindowSize),
+    // Self-critique plan mode (WO-TP2)
+    createPlanModeTool(config, repoRoot, contextWindowSize),
     createTaskCompleteTool(modelTier)
   ];
 }
@@ -305073,6 +305255,195 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
     }
   };
 }
+function createPlanModeTool(config, repoRoot, ctxWindowSize) {
+  return {
+    name: "enter_plan_mode",
+    description: "Generate a self-critiqued implementation plan before executing complex tasks. Spawns a read-only plan agent to analyze the codebase, then runs a critique loop against safety/completeness/correctness/efficiency/ordering principles. Returns an approved structured plan with steps, tools, targets, and risk levels. Use this BEFORE making changes to complex multi-file tasks.",
+    parameters: {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "The task to plan (e.g. 'Add authentication middleware to all API routes')"
+        },
+        max_revisions: {
+          type: "number",
+          description: "Maximum critique-revision cycles (default: tier-dependent, 1-3)"
+        }
+      },
+      required: ["task"]
+    },
+    async execute(args) {
+      const task = String(args["task"] ?? "");
+      if (!task) {
+        return { success: false, output: "", error: "task is required" };
+      }
+      const modelTier = getModelTier(config.model);
+      const planConfig = getPlanModeConfig(modelTier);
+      const maxRevisions = typeof args["max_revisions"] === "number" ? args["max_revisions"] : planConfig.maxRevisions;
+      let planAgentOutput = "";
+      try {
+        const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+        const planRunner = new AgenticRunner(backend, {
+          maxTurns: 15,
+          maxTokens: 8192,
+          temperature: 0,
+          requestTimeoutMs: config.timeoutMs,
+          taskTimeoutMs: config.timeoutMs * 2,
+          compactionThreshold: 24e3,
+          contextWindowSize: ctxWindowSize ?? 0,
+          modelTier
+        });
+        const planTools = [
+          new FileReadTool(repoRoot),
+          new GrepSearchTool(repoRoot),
+          new GlobFindTool(repoRoot),
+          new ListDirectoryTool(repoRoot)
+        ].map(adaptTool6);
+        planTools.push(createTaskCompleteTool(modelTier));
+        for (const t2 of planTools)
+          planRunner.registerTool(t2);
+        const planPrompt = buildPlanPrompt(task);
+        const result = await planRunner.run(planPrompt);
+        planAgentOutput = result.summary || "";
+      } catch (err) {
+        return {
+          success: false,
+          output: "",
+          error: `Plan agent failed: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+      if (!planAgentOutput) {
+        return { success: false, output: "", error: "Plan agent returned empty output" };
+      }
+      let plan = parsePlan(planAgentOutput);
+      if (!plan) {
+        return {
+          success: true,
+          output: `[Plan generated but not in JSON format \u2014 returning raw analysis]
+
+${planAgentOutput}`
+        };
+      }
+      const critiques = [];
+      let approved = false;
+      let reason = "";
+      for (let revision = 0; revision < maxRevisions; revision++) {
+        const critiquePrompt = buildCritiquePrompt(plan);
+        let critiqueText = "";
+        try {
+          const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+          const response = await backend.chatCompletion({
+            messages: [
+              { role: "system", content: "You are a code review expert. Evaluate the plan critically." },
+              { role: "user", content: critiquePrompt }
+            ],
+            tools: [],
+            temperature: 0,
+            maxTokens: 2048,
+            timeoutMs: config.timeoutMs
+          });
+          critiqueText = response.choices?.[0]?.message?.content ?? "";
+        } catch {
+          reason = "Critique call failed \u2014 auto-approved";
+          approved = true;
+          break;
+        }
+        const critique = parseCritique(critiqueText);
+        if (!critique) {
+          reason = "Critique parse failed \u2014 auto-approved";
+          approved = true;
+          break;
+        }
+        critiques.push(critique);
+        if (critique.pass && critique.averageScore >= planConfig.minAverageScore) {
+          approved = true;
+          reason = `Critique passed: avg ${critique.averageScore}/5, all scores \u2265 3`;
+          break;
+        }
+        if (revision < maxRevisions - 1) {
+          try {
+            const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+            const revisionResponse = await backend.chatCompletion({
+              messages: [
+                { role: "system", content: "You are a software architect. Revise this plan based on the critique." },
+                {
+                  role: "user",
+                  content: `Original plan:
+${JSON.stringify(plan, null, 2)}
+
+Critique issues:
+${critique.issues.map((i2, idx) => `${idx + 1}. ${i2}`).join("\n")}
+
+Suggestions:
+${critique.suggestions.map((s2, idx) => `${idx + 1}. ${s2}`).join("\n")}
+
+Revise the plan to address these issues. Output the revised plan as JSON.`
+                }
+              ],
+              tools: [],
+              temperature: 0,
+              maxTokens: 4096,
+              timeoutMs: config.timeoutMs
+            });
+            const revisedText = revisionResponse.choices?.[0]?.message?.content ?? "";
+            const revisedPlan = parsePlan(revisedText);
+            if (revisedPlan)
+              plan = revisedPlan;
+          } catch {
+          }
+        }
+      }
+      if (!approved) {
+        reason = `Max revisions (${maxRevisions}) reached \u2014 best effort plan (avg score: ${critiques[critiques.length - 1]?.averageScore ?? "?"}/5)`;
+      }
+      let metaCritiqueNote = "";
+      if (planConfig.enableMetaCritique && critiques.length > 0 && approved) {
+        try {
+          const lastCritique = critiques[critiques.length - 1];
+          const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+          const metaResponse = await backend.chatCompletion({
+            messages: [
+              { role: "system", content: "You are a meta-evaluator. Assess the quality of the following critique." },
+              { role: "user", content: buildMetaCritiquePrompt(lastCritique) }
+            ],
+            tools: [],
+            temperature: 0,
+            maxTokens: 1024,
+            timeoutMs: config.timeoutMs
+          });
+          const metaText = metaResponse.choices?.[0]?.message?.content ?? "";
+          const meta = parseMetaCritique(metaText);
+          if (meta) {
+            metaCritiqueNote = `
+Meta-critique: quality ${meta.quality}/5, thorough: ${meta.thorough}`;
+            if (meta.missed.length > 0)
+              metaCritiqueNote += `, missed: ${meta.missed.join("; ")}`;
+          }
+        } catch {
+        }
+      }
+      const output = [
+        `# Plan: ${plan.task || task}`,
+        `**Status**: ${approved ? "APPROVED" : "BEST EFFORT"} \u2014 ${reason}`,
+        `**Approach**: ${plan.approach}`,
+        `**Estimated turns**: ${plan.estimatedTurns}`,
+        `**Critique iterations**: ${critiques.length}`,
+        metaCritiqueNote,
+        "",
+        "## Steps",
+        ...plan.steps.map((s2) => `${s2.step}. [${s2.risk.toUpperCase()}] ${s2.action}` + (s2.tool ? ` \u2192 \`${s2.tool}\`` : "") + (s2.target ? ` on \`${s2.target}\`` : "") + `
+   Expected: ${s2.expectedOutcome}`),
+        "",
+        "## Plan JSON",
+        "```json",
+        JSON.stringify(plan, null, 2),
+        "```"
+      ].filter(Boolean).join("\n");
+      return { success: true, output };
+    }
+  };
+}
 function gatherMemorySnippets(root) {
   const snippets = [];
   const dirs = [
@@ -310052,6 +310423,7 @@ var init_interactive = __esm({
     "use strict";
     init_dist7();
     init_dist7();
+    init_dist7();
     init_dist4();
     init_dist();
     init_listen();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.10",
+  "version": "0.187.11",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",