open-agents-ai 0.187.235 → 0.187.237

package/dist/index.js

@@ -271575,6 +271575,7 @@ ${sr.result.output}`;
             }
             if (completed)
               break;
+            this.littlemanObserve(messages2, turn);
             const currentRepScore = this.detectRepetition(toolCallLog);
             if (currentRepScore > 0.4 && toolCallLog.length >= 4) {
               const { repetitionWindow } = this.contextLimits();
@@ -271957,7 +271958,7 @@ ${result.output}`;
                     turn,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
-                  output = `[Output externalized — ${result.output.length} chars, ${lineCount} lines]
+                  output = `[${tc.name} succeeded — output externalized: ${result.output.length} chars, ${lineCount} lines]
 Handle: ${handleId}
 Preview: ${preview}...
 Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or  memex_retrieve(id="${handleId}")`;
@@ -272380,7 +272381,7 @@ ${errOutput}`;
 ${result.output}`, "utf-8");
         } catch {
         }
-        return `[Output externalized — ${result.output.length} chars, ${lineCount} lines]
+        return `[${toolName} succeeded — output externalized: ${result.output.length} chars, ${lineCount} lines]
 Handle: ${handleId}
 Preview: ${preview}...
 Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or  memex_retrieve(id="${handleId}")`;
@@ -272882,6 +272883,99 @@ ${newerSummary}`;
 
 ${trimmedNew}`;
       }
+      // -------------------------------------------------------------------------
+      // Littleman Observer — parallel meta-analysis of the main loop
+      // -------------------------------------------------------------------------
+      // Inspired by Hannover's fireCompanionObserver (src/buddy/observer.ts).
+      // Runs after each tool turn to detect when the model has lost track of
+      // what happened and inject corrections before the next inference.
+      //
+      // This is the architectural fix for the "I see both tools have been failing"
+      // regression: instead of only fixing the data the model sees (mask/summary),
+      // we add a second analysis path that catches mismatches in real-time.
+      /** Track recent tool outcomes for the littleman observer */
+      _littlemanToolOutcomes = [];
+      /**
+       * Littleman observer: post-turn meta-analysis.
+       *
+       * Examines the last few messages looking for contradictions between
+       * actual tool outcomes and the model's stated understanding. When it
+       * detects the model claiming failure after success (or vice versa),
+       * it injects a corrective message.
+       *
+       * Also detects repeated actions — when the model re-does something
+       * that already succeeded, the littleman nudges it to move on.
+       */
+      littlemanObserve(messages2, turn) {
+        if (this.options.modelTier === "large")
+          return;
+        const recent = messages2.slice(-6);
+        for (const msg of recent) {
+          if (msg.role === "tool" && typeof msg.content === "string") {
+            const isError2 = msg.content.startsWith("Error:") || /^(FAIL|ERR!|TypeError)/i.test(msg.content);
+            const succeeded = !isError2;
+            const preview = msg.content.slice(0, 80);
+            let toolName = "unknown";
+            if (msg.tool_call_id) {
+              for (const m2 of recent) {
+                if (m2.tool_calls) {
+                  for (const tc of m2.tool_calls) {
+                    if (tc.id === msg.tool_call_id) {
+                      toolName = tc.function.name;
+                    }
+                  }
+                }
+              }
+            }
+            if (!this._littlemanToolOutcomes.some((o2) => o2.turn === turn && o2.tool === toolName)) {
+              this._littlemanToolOutcomes.push({ turn, tool: toolName, succeeded, preview });
+            }
+          }
+        }
+        while (this._littlemanToolOutcomes.length > 20)
+          this._littlemanToolOutcomes.shift();
+        const lastAssistant = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
+        if (lastAssistant && typeof lastAssistant.content === "string") {
+          const text = lastAssistant.content.toLowerCase();
+          const claimsFailure = /(?:fail|error|didn't work|not working|unable to|cannot|couldn't|both .* fail|tools? (?:have |has )?been fail)/i.test(text);
+          if (claimsFailure) {
+            const recentOutcomes = this._littlemanToolOutcomes.slice(-4);
+            const successes = recentOutcomes.filter((o2) => o2.succeeded);
+            if (successes.length >= 1) {
+              const successList = successes.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
+              this.pendingUserMessages.push(`[LITTLEMAN] Correction: your recent tools DID succeed. Do not retry them.
+Successful results: ${successList}
+Build on these results instead of retrying. What is your NEXT step toward the goal?`);
+              this.emit({
+                type: "status",
+                content: `Littleman: corrected false failure claim (${successes.length} tools succeeded)`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
+        }
+        const lastToolCalls = recent.filter((m2) => m2.role === "assistant" && m2.tool_calls?.length).flatMap((m2) => m2.tool_calls ?? []);
+        for (const tc of lastToolCalls) {
+          const name10 = tc.function.name;
+          let args = {};
+          try {
+            args = JSON.parse(tc.function.arguments);
+          } catch {
+          }
+          const argsKey = name10 === "shell" ? String(args.command ?? "").slice(0, 60) : name10 === "web_fetch" ? String(args.url ?? "").slice(0, 80) : String(args.path ?? args.url ?? args.query ?? "").slice(0, 60);
+          const prior = this._littlemanToolOutcomes.find((o2) => o2.succeeded && o2.tool === name10 && o2.preview.includes(argsKey.slice(0, 30)) && o2.turn < turn);
+          if (prior) {
+            this.pendingUserMessages.push(`[LITTLEMAN] You already ran ${name10} successfully on turn ${prior.turn} with similar arguments. Result was: ${prior.preview.slice(0, 100)}
+Do NOT re-run it. Use the result you already have and proceed to the next step.`);
+            this.emit({
+              type: "status",
+              content: `Littleman: prevented redundant ${name10} call (succeeded on turn ${prior.turn})`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            break;
+          }
+        }
+      }
       /**
        * Infer what the model should do next from the most recent messages.
        * Analyzes the last few tool calls, errors, and assistant text to produce
@@ -273030,18 +273124,37 @@ ${pathKeep}${omitted}` };
               return { ...msg, content: `[directory listing: ${lines} entries — top entries preserved]
 ${dirKeep}${omitted}` };
             }
-            case "web_fetch":
-              return { ...msg, content: `[web page content: ${content.length} chars — omitted for compaction]` };
-            case "web_search":
-              return { ...msg, content: `[search results: ${lines} results — omitted for compaction]` };
+            case "web_fetch": {
+              const webPreview = contentLines.slice(0, 5).join("\n");
+              const webOmitted = lines > 5 ? `
+[... ${lines - 5} more lines omitted for compaction]` : "";
+              return { ...msg, content: `[web_fetch succeeded: ${content.length} chars, ${lines} lines — preview preserved]
+${webPreview}${webOmitted}` };
+            }
+            case "web_search": {
+              const searchPreview = contentLines.slice(0, 5).join("\n");
+              const searchOmitted = lines > 5 ? `
+[... ${lines - 5} more results omitted]` : "";
+              return { ...msg, content: `[web_search succeeded: ${lines} results — top results preserved]
+${searchPreview}${searchOmitted}` };
+            }
             case "shell":
-            case "background_run":
+            case "background_run": {
               if (/PASS|FAIL|error|warning/i.test(content))
                 return msg;
-              return { ...msg, content: `[command output: ${lines} lines, ${content.length} chars — omitted for compaction]` };
+              const cmdPreview = contentLines.slice(0, 5).join("\n");
+              const cmdOmitted = lines > 5 ? `
+[... ${lines - 5} more lines omitted for compaction]` : "";
+              return { ...msg, content: `[shell succeeded: ${lines} lines, ${content.length} chars — preview preserved]
+${cmdPreview}${cmdOmitted}` };
+            }
             default:
               if (content.length > 2e3) {
-                return { ...msg, content: `[${toolName ?? "tool"} output: ${content.length} chars — omitted for compaction]` };
+                const genPreview = contentLines.slice(0, 3).join("\n");
+                const genOmitted = lines > 3 ? `
+[... ${lines - 3} more lines omitted]` : "";
+                return { ...msg, content: `[${toolName ?? "tool"} succeeded: ${content.length} chars — preview preserved]
+${genPreview}${genOmitted}` };
               }
               return msg;
           }
@@ -273141,19 +273254,45 @@ ${headContent}${sigLines ? "\n[key signatures]: " + sigLines : ""}`;
                 const cmd = String(tc.args.command || "").slice(0, 100);
                 const hasError = content.startsWith("Error:") || /FAIL|ERR!/i.test(content);
                 const hasPass = /PASS|passed|✓|success/i.test(content);
+                const hasMaskedSuccess = /^\[shell succeeded:|^\[.+ succeeded —/.test(content);
                 let outcome;
                 if (hasError) {
                   const errorLines = content.split("\n").filter((l2) => /error|FAIL|✗|×|ERR!/i.test(l2)).slice(0, 3);
                   outcome = errorLines.length > 0 ? errorLines.join("; ").slice(0, 200) : content.slice(0, 200);
                   errors.push(`\`${cmd}\`: ${outcome.slice(0, 150)}`);
-                } else if (hasPass) {
-                  outcome = "passed";
+                } else if (hasPass || hasMaskedSuccess) {
+                  const previewLines = content.split("\n").slice(1, 4).join(" ").trim();
+                  outcome = previewLines ? `succeeded: ${previewLines.slice(0, 120)}` : "succeeded";
                 } else {
                   outcome = content.slice(0, 150);
                 }
                 commandResults.push({ cmd, outcome });
                 break;
               }
+              case "web_fetch": {
+                const url = String(tc.args.url || "").slice(0, 120);
+                if (content.startsWith("Error:")) {
+                  const errMsg = content.slice(0, 200);
+                  errors.push(`web_fetch \`${url}\`: ${errMsg}`);
+                  commandResults.push({ cmd: `web_fetch ${url}`, outcome: errMsg });
+                } else {
+                  const preview = content.split("\n").slice(0, 3).join(" ").trim().slice(0, 150);
+                  commandResults.push({ cmd: `web_fetch ${url}`, outcome: `succeeded: ${preview || `${content.length} chars`}` });
+                }
+                break;
+              }
+              case "web_search": {
+                const query = String(tc.args.query || "").slice(0, 80);
+                if (content.startsWith("Error:")) {
+                  errors.push(`web_search "${query}": ${content.slice(0, 200)}`);
+                  commandResults.push({ cmd: `web_search "${query}"`, outcome: content.slice(0, 200) });
+                } else {
+                  const resultCount = (content.match(/\n/g) || []).length;
+                  const preview = content.split("\n").slice(0, 2).join(" ").trim().slice(0, 100);
+                  commandResults.push({ cmd: `web_search "${query}"`, outcome: `${resultCount} results: ${preview}` });
+                }
+                break;
+              }
               case "grep_search": {
                 const pattern = String(tc.args.pattern || "");
                 const matchCount = (content.match(/\n/g) || []).length;
@@ -292355,11 +292494,11 @@ ${CONTENT_BG_SEQ}`);
               self2.cycleFocus();
               return;
             }
-            if (key?.ctrl && key?.shift && key?.name === "b") {
-              self2.armBlockSelection();
+            if (key?.ctrl && key?.shift && key?.name === "c") {
+              self2.copySelection();
               return;
             }
-            if (s2 === "\x1B[66;6u") {
+            if (key?.ctrl && key?.shift && key?.name === "b") {
               self2.armBlockSelection();
               return;
             }
@@ -292475,6 +292614,8 @@ ${CONTENT_BG_SEQ}`);
         di.on("shiftdown", () => self2.scrollContentDown(3));
         di.on("tab-empty", () => self2.cycleFocus());
         di.on("ctrl-backslash", () => self2.cycleFocus());
+        di.on("ctrl-shift-c", () => self2.copySelection());
+        di.on("ctrl-shift-b", () => self2.armBlockSelection());
         di.on("up", () => {
           if (self2._suggestions.length > 0) {
             self2.suggestUp();
@@ -315053,8 +315194,28 @@ var init_direct_input = __esm({
               return;
             }
             return;
-          case "u":
+          case "u": {
+            const parts = params.split(";");
+            const codepoint = parseInt(parts[0] ?? "0");
+            const modifiers = parseInt(parts[1] ?? "1");
+            const hasCtrl = modifiers - 1 & 4;
+            const hasShift = modifiers - 1 & 1;
+            if (hasCtrl && hasShift) {
+              if (codepoint === 67) {
+                this.emit("ctrl-shift-c");
+                return;
+              }
+              if (codepoint === 66) {
+                this.emit("ctrl-shift-b");
+                return;
+              }
+              if (codepoint === 86) {
+                this.emit("ctrl-shift-v");
+                return;
+              }
+            }
             return;
+          }
         }
       }
       /** Handle SS3 sequence: \x1BO {final} (some terminals use this for arrows/Home/End) */
@@ -323553,6 +323714,201 @@ function handleVersion(res) {
 function handleMetrics(res) {
   textResponse(res, 200, formatMetrics(), "text/plain; version=0.0.4; charset=utf-8");
 }
+function handleHelp(req2, res) {
+  const version4 = getVersion3();
+  const host = req2.headers.host ?? "localhost:11435";
+  const base3 = `http://${host}`;
+  const help = {
+    name: "Open Agents",
+    version: version4,
+    description: "AI coding agent powered entirely by open-weight models. OpenAI-compatible API with full agentic tool-calling, text selection, MCP integration, and multi-model orchestration. No API keys required for local use.",
+    quickstart: {
+      chat: `curl ${base3}/v1/chat/completions -d '{"model":"auto","messages":[{"role":"user","content":"Hello"}]}'`,
+      models: `curl ${base3}/v1/models`,
+      stream: `curl ${base3}/v1/chat/completions -d '{"model":"auto","stream":true,"messages":[{"role":"user","content":"List files in the project"}]}'`,
+      run_task: `curl -X POST ${base3}/v1/run -d '{"task":"Fix the failing tests","model":"auto"}'`
+    },
+    endpoints: {
+      discovery: {
+        "GET /help": "This guide — human and agent-friendly API reference",
+        "GET /docs": "Interactive Swagger UI (browser)",
+        "GET /openapi.json": "Full OpenAPI 3.0 specification (machine-readable)",
+        "GET /health": "Liveness probe",
+        "GET /health/ready": "Readiness probe (checks backend reachability)",
+        "GET /version": "Package version, Node.js version, platform",
+        "GET /metrics": "Prometheus-format metrics"
+      },
+      inference: {
+        "GET /v1/models": "List all available models (local + sponsored, with prefixes)",
+        "POST /v1/chat/completions": "OpenAI-compatible chat completion (supports streaming via stream:true)",
+        "POST /v1/embeddings": "Generate embeddings",
+        "POST /v1/generate": "Ollama-compatible text generation",
+        "GET /api/tags": "Ollama-compatible model listing",
+        "POST /api/chat": "Ollama-compatible chat",
+        "POST /api/embed": "Ollama-compatible embeddings"
+      },
+      agentic: {
+        "POST /v1/chat": "Stateful agentic chat — full tool access (file_read, shell, grep, etc.), SSE streaming",
+        "GET /v1/chat/sessions": "List active chat sessions",
+        "POST /v1/run": "Spawn autonomous task execution",
+        "GET /v1/runs": "List all runs",
+        "GET /v1/runs/:id": "Get run status and details",
+        "GET /v1/runs/:id/output": "Get run output/logs",
+        "DELETE /v1/runs/:id": "Cancel a running task"
+      },
+      tools_and_skills: {
+        "GET /v1/tools": "List available agentic tools",
+        "GET /v1/skills": "List available skills (slash commands)",
+        "GET /v1/skills/:name": "Get skill details and content",
+        "GET /v1/commands": "List slash commands",
+        "POST /v1/commands/:cmd": "Execute a slash command",
+        "GET /v1/agents": "List available agent types"
+      },
+      mcp: {
+        "GET /v1/mcps": "List connected MCP (Model Context Protocol) servers",
+        "GET /v1/mcps/:name": "Get MCP server details and available tools",
+        "POST /v1/mcps/:name/call": "Call a tool on an MCP server — body: {tool, args}"
+      },
+      memory: {
+        "GET /v1/memory": "Memory system summary",
+        "POST /v1/memory/search": "Search episodic memory",
+        "POST /v1/memory/write": "Write to memory store",
+        "GET /v1/memory/episodes": "List stored episodes",
+        "GET /v1/memory/failures": "List failure patterns"
+      },
+      workspace: {
+        "GET /v1/files": "List directory contents (query: ?path=src/)",
+        "POST /v1/files/read": "Read file content — body: {path}",
+        "GET /v1/system": "OS info, GPU detection, installed tools",
+        "GET /v1/context": "Current conversation context",
+        "POST /v1/context/compact": "Compact session history"
+      },
+      config: {
+        "GET /v1/config": "Current daemon configuration",
+        "PATCH /v1/config": "Update configuration (admin scope required)",
+        "GET /v1/config/model": "Current model",
+        "PUT /v1/config/model": "Set model — body: {model}",
+        "GET /v1/config/endpoint": "Current backend endpoint",
+        "PUT /v1/config/endpoint": "Set backend endpoint — body: {endpoint}"
+      },
+      monitoring: {
+        "GET /v1/events": "Server-Sent Events stream (task lifecycle, todo changes)",
+        "GET /v1/usage": "Token usage summary",
+        "GET /v1/audit": "Query audit log (query: ?since=, ?action=, ?limit=)",
+        "GET /v1/cost": "Cost tracking per endpoint"
+      },
+      voice_and_vision: {
+        "POST /v1/voice/tts": "Text-to-speech synthesis",
+        "POST /v1/voice/asr": "Automatic speech recognition",
+        "POST /v1/vision/describe": "Describe an image (vision pipeline)"
+      }
+    },
+    mcp_integration: {
+      description: "Open Agents can act as an MCP client — connect to external MCP servers and expose their tools through the /v1/mcps/* endpoints. Any AI agent or IDE that speaks the Model Context Protocol can discover and invoke these tools remotely.",
+      discovery: `curl ${base3}/v1/mcps`,
+      call_tool: `curl -X POST ${base3}/v1/mcps/YOUR_SERVER/call -d '{"tool":"tool_name","args":{"key":"value"}}'`
+    },
+    for_ai_agents: {
+      description: "If you are an AI agent or coding assistant consuming this API, here is how to get started:",
+      steps: [
+        `1. GET ${base3}/v1/models — discover available models`,
+        `2. POST ${base3}/v1/chat/completions — send messages (OpenAI-compatible format)`,
+        `3. GET ${base3}/v1/tools — see what agentic tools are available`,
+        `4. POST ${base3}/v1/chat — use the agentic chat endpoint for tool-calling tasks`,
+        `5. GET ${base3}/v1/mcps — discover connected MCP servers and their tools`,
+        `6. GET ${base3}/v1/skills — browse available skills for specialized tasks`
+      ],
+      tips: [
+        "Set stream:true in chat requests for real-time token streaming via SSE",
+        "Use model:'auto' to let the server pick the best available model",
+        "The /v1/chat endpoint supports full agentic tool-calling (file I/O, shell, grep, etc.)",
+        "Use /v1/events for real-time notifications of task progress and system events",
+        "Bearer tokens are optional for localhost access; required for remote/LAN access"
+      ]
+    },
+    authentication: {
+      local: "No authentication required for loopback (127.0.0.1) access",
+      remote: "Set OA_API_KEY or OA_API_KEYS env var; pass as Authorization: Bearer <key>",
+      scopes: {
+        read: "GET endpoints — model listing, file browsing, status queries",
+        run: "POST endpoints — task execution, chat, tool invocation",
+        admin: "Config writes, profile management, audit access"
+      }
+    },
+    links: {
+      docs: `${base3}/docs`,
+      openapi: `${base3}/openapi.json`,
+      health: `${base3}/health`,
+      web_ui: base3
+    }
+  };
+  const accept = req2.headers.accept ?? "";
+  if (accept.includes("text/plain") || accept.includes("text/markdown")) {
+    const md = renderHelpMarkdown(help);
+    textResponse(res, 200, md, "text/plain; charset=utf-8");
+  } else {
+    jsonResponse(res, 200, help);
+  }
+}
+function renderHelpMarkdown(help) {
+  const h = help;
+  const version4 = h.version;
+  const base3 = h.links?.web_ui ?? "http://localhost:11435";
+  const qs = h.quickstart;
+  const agents = h.for_ai_agents;
+  let out = `# Open Agents v${version4}
+
+`;
+  out += `${h.description}
+
+`;
+  out += `## Quick Start
+
+`;
+  for (const [label, cmd] of Object.entries(qs)) {
+    out += `  ${label}:
+    ${cmd}
+
+`;
+  }
+  out += `## Endpoints
+
+`;
+  const endpoints = h.endpoints;
+  for (const [category, routes] of Object.entries(endpoints)) {
+    out += `### ${category}
+`;
+    for (const [route, desc] of Object.entries(routes)) {
+      out += `  ${route.padEnd(36)} ${desc}
+`;
+    }
+    out += `
+`;
+  }
+  out += `## For AI Agents
+
+`;
+  for (const step of agents.steps) out += `  ${step}
+`;
+  out += `
+`;
+  for (const tip of agents.tips) out += `  - ${tip}
+`;
+  out += `
+`;
+  out += `## Links
+
+`;
+  out += `  Interactive docs:  ${base3}/docs
+`;
+  out += `  OpenAPI spec:      ${base3}/openapi.json
+`;
+  out += `  Web UI:            ${base3}
+`;
+  out += `  Health check:      ${base3}/health
+`;
+  return out;
+}
 async function handleV1Models(res, ollamaUrl) {
   try {
     const models = await fetchAggregatedModels();
@@ -325169,6 +325525,10 @@ async function handleRequest(req2, res, ollamaUrl, verbose) {
       handleMetrics(res);
       return;
     }
+    if (pathname === "/help" && method === "GET") {
+      handleHelp(req2, res);
+      return;
+    }
     if (pathname === "/openapi.json" && method === "GET") {
       jsonResponse(res, 200, getOpenApiSpec());
       return;

package/dist/scripts/.env

@@ -0,0 +1,14 @@
+SCRAPE_API_KEY=948a46e9c7b94025aba48cf43f823950
+SCRAPE_BIND=0.0.0.0
+SCRAPE_PORT=8130
+SCRAPE_REQUIRE_AUTH=0
+SCRAPE_MAX_CONCURRENCY=4
+SCRAPE_QUEUE_TIMEOUT_S=0
+SCRAPE_RATE_LIMIT_RPS=60
+SCRAPE_RATE_LIMIT_BURST=180
+SCRAPE_RATE_LIMIT_LOCAL_BYPASS=1
+SCRAPE_RATE_LIMIT_DISABLED=0
+SCRAPE_RATE_LIMIT_WHITELIST=
+SCRAPE_FILE_TTL_S=900
+SCRAPE_FRAME_KEEPALIVE_S=45
+SCRAPE_HEADLESS_DEFAULT=1

package/dist/scripts/.scrape_setup_complete

@@ -0,0 +1 @@
+ok

package/package.json

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