openzoo 0.48.3 → 0.48.5

package/lib/grokui.mjs

@@ -112,6 +112,16 @@ workspace folder, not their real project. Same one-line-no-prose reply format:
                                                        text — web search only gives you short
                                                        snippets; use FETCH when asked to
                                                        "read" or quote something specific
+  MCP: <url>                                          list the tools an MCP server exposes
+  MCP: <url> | <tool> | {"arg": "value"}              CALL one of them, for real
+                                                       An MCP endpoint speaks JSON-RPC over
+                                                       POST. FETCH does a GET, so it will
+                                                       always come back 405 Method Not
+                                                       Allowed — that is NOT a broken URL and
+                                                       NOT a reason to curl it or write your
+                                                       own client. Use this directive; it
+                                                       does the initialize handshake, holds
+                                                       the session, and calls the tool.
   RUN: <shell command>                                run a REAL shell command in this
                                                        thread's directory — by default this
                                                        pauses and waits for the user to
@@ -301,6 +311,35 @@ function newGroupThread(names) {
 const BIND_CHUNK_BYTES = 512 * 1024;
 // Chained auto-run commands per user message. Each hop is a paid call.
 const AUTO_MAX_STEPS = Number(process.env.OZ_AUTO_MAX_STEPS || 8);
+
+// Injected fresh on every AUTO turn, never persisted into the thread.
+//
+// The auto loop only continues while directives keep parsing, so a reply that
+// merely OFFERS ends the run — auto silently degrades to ask the moment the
+// model hedges. Observed live: "If you want, I can rewrite the prompt with
+// these fixes folded in", "Spawned mcp-integration — working on it" with
+// nothing spawned, and a user reduced to answering "no, this... impl all".
+// Models are trained to close on a consent question; in auto that instinct is
+// the bug. The system prompt is frozen into a thread at creation, so an
+// existing thread can only be reached by a per-turn message.
+const AUTO_DIRECTIVE = `AUTO MODE IS ON for this thread.
+
+Do the work in this turn. Do not ask whether to proceed, do not offer to do it,
+do not say what you are "about to" do and stop. The user has already consented
+by enabling auto — a question back to them is a dropped turn, and they must
+type "yes" to get what they already asked for.
+
+Concretely, NEVER end a turn with any of: "If you want, I can…", "Should I…?",
+"Let me know and I'll…", "Ready to proceed?", or a plan with no directive after
+it. If you catch yourself writing one, emit the RUN/WRITE/READ/SERVE/FETCH line
+instead — that IS the answer.
+
+Announcing an action does not perform it. "Spawned X", "working on it" and
+"kicked that off" are false unless the directive line is in this same reply.
+If a task needs several commands, emit the FIRST one now; you get its real
+output back and continue from there. Only stop to ask when the next step is
+genuinely destructive and irreversible, or when you truly cannot proceed
+without a fact only the user has.`;
 async function bindThread(t) {
   // Only bind what's NEW since the last successful bind, continuing the
   // existing context_id — previously this rebuilt and re-sent the WHOLE
@@ -507,12 +546,127 @@ async function tryDirective(reply, originId) {
           .replace(/<[^>]+>/g, ' ').replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&')
           .replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/\s+/g, ' ').trim();
       }
+      // A 405 on an MCP endpoint is not a broken URL, and a model cannot tell
+      // the difference — it retries the same GET, then gives up and hand-rolls
+      // a client. Say what actually happened and point at the directive that
+      // works. MEASURED: three wasted turns curling /api/mcp before the user
+      // had to intervene with "stop hitting /api/mcp as a curl".
+      if (r.status === 405 && /\/mcp\/?$/.test(url)) {
+        return `${url} (405): that is an MCP endpoint, not a web page — it speaks `
+          + `JSON-RPC over POST and rejects the GET that FETCH does. Use the MCP `
+          + `directive instead:\n  MCP: ${url}\nto list its tools, then\n  `
+          + `MCP: ${url} | <tool> | {"arg": "value"}\nto call one.`;
+      }
       return `${url} (${r.status}):\n${text.slice(0, 8000)}${text.length > 8000 ? '\n…(truncated)' : ''}`;
     } catch (e) { return `Couldn't fetch ${url}: ${e.message}`; }
   }
+
+  const mcpD = /^MCP:\s*(\S+)\s*(?:\|\s*([^|]+?)\s*(?:\|\s*([\s\S]+))?)?$/m.exec(reply);
+  if (mcpD) {
+    const [, url, tool, argsRaw] = mcpD;
+    let args = {};
+    if (argsRaw) {
+      const fenced = /```[\w-]*\n([\s\S]*?)```/.exec(argsRaw);
+      try { args = JSON.parse((fenced ? fenced[1] : argsRaw).trim()); }
+      catch (e) { return `MCP: couldn't parse the arguments as JSON — ${e.message}`; }
+    }
+    return await mcpDirective(url.trim(), tool?.trim(), args);
+  }
   return null;
 }
 
+// ---------------------------------------------------------------------------
+// MCP client — streamable-http, written against fetch on purpose.
+//
+// grokui runs STANDALONE from /opt/grokui/grokui.mjs, which has no
+// node_modules beside it, so importing @modelcontextprotocol/sdk would break
+// the copy that boxes actually execute. The wire protocol is small: POST
+// JSON-RPC, accept both JSON and SSE, carry the session id the server hands
+// back on initialize.
+//
+// This exists because bots were told to "install an MCP" and had no way to
+// speak to one. FETCH does a GET; every MCP endpoint answers GET with 405, so
+// the model saw a dead URL, retried, then wrote its own Python client.
+let mcpId = 0;
+
+async function mcpRpc(url, method, params, session, notify = false) {
+  const id = notify ? undefined : ++mcpId;
+  const r = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      // BOTH are required. Servers negotiate between a plain JSON reply and an
+      // SSE stream, and offering only one gets a 406 from spec-strict servers.
+      accept: 'application/json, text/event-stream',
+      'mcp-protocol-version': '2025-06-18',
+      ...(session ? { 'mcp-session-id': session } : {}),
+    },
+    body: JSON.stringify(notify ? { jsonrpc: '2.0', method, params } : { jsonrpc: '2.0', id, method, params }),
+  });
+  const sid = r.headers.get('mcp-session-id') || session;
+  const body = await r.text();
+  if (notify) return { status: r.status, session: sid, json: null };
+
+  let json = null;
+  if ((r.headers.get('content-type') || '').includes('text/event-stream')) {
+    // SSE frames: take the last `data:` payload that carries a result/error.
+    for (const line of body.split(/\r?\n/)) {
+      if (!line.startsWith('data:')) continue;
+      try {
+        const j = JSON.parse(line.slice(5).trim());
+        if (j && (j.result !== undefined || j.error !== undefined)) json = j;
+      } catch { /* keep-alive or partial frame */ }
+    }
+  } else {
+    try { json = JSON.parse(body); } catch { /* non-JSON error page */ }
+  }
+  return { status: r.status, session: sid, json, raw: body };
+}
+
+async function mcpDirective(url, tool, args) {
+  try {
+    const init = await mcpRpc(url, 'initialize', {
+      protocolVersion: '2025-06-18',
+      capabilities: {},
+      clientInfo: { name: 'openzoo-grokui', version: '1' },
+    });
+    if (init.json?.error) return `MCP ${url}: initialize failed — ${JSON.stringify(init.json.error)}`;
+    if (!init.json) return `MCP ${url}: no JSON-RPC reply (HTTP ${init.status})\n${(init.raw || '').slice(0, 600)}`;
+    const session = init.session;
+    // Required by spec before any other request; skipping it makes some
+    // servers reject everything after initialize.
+    await mcpRpc(url, 'notifications/initialized', {}, session, true).catch(() => {});
+
+    const server = init.json.result?.serverInfo;
+    const banner = `MCP ${url}${server ? ` — ${server.name} ${server.version || ''}`.trimEnd() : ''}`;
+
+    if (!tool) {
+      const list = await mcpRpc(url, 'tools/list', {}, session);
+      if (list.json?.error) return `${banner}\ntools/list failed — ${JSON.stringify(list.json.error)}`;
+      const tools = list.json?.result?.tools || [];
+      if (!tools.length) return `${banner}\n(no tools)`;
+      const lines = tools.map((t) => {
+        const req = t.inputSchema?.required || [];
+        const props = Object.keys(t.inputSchema?.properties || {});
+        const sig = props.map((p) => (req.includes(p) ? p : `${p}?`)).join(', ');
+        return `  ${t.name}(${sig})\n      ${(t.description || '').split('\n')[0].slice(0, 160)}`;
+      });
+      return `${banner}\n${tools.length} tools:\n${lines.join('\n')}\n\n`
+        + `Call one with:  MCP: ${url} | <tool> | {"arg": "value"}`;
+    }
+
+    const call = await mcpRpc(url, 'tools/call', { name: tool, arguments: args }, session);
+    if (call.json?.error) return `${banner}\n${tool} failed — ${JSON.stringify(call.json.error)}`;
+    const res = call.json?.result;
+    const out = (res?.content || [])
+      .map((c) => (c.type === 'text' ? c.text : `[${c.type}]`))
+      .join('\n') || JSON.stringify(res ?? call.raw);
+    return `${banner}\n$ ${tool}\n${out.slice(0, 6000)}${out.length > 6000 ? '\n…(truncated)' : ''}`;
+  } catch (e) {
+    return `MCP ${url}: ${e.message}`;
+  }
+}
+
 // onEvent (optional) gets live progress for whoever's actually watching this
 // call: {type:'start',name,color} when a bot begins its turn, {type:'delta',
 // name,color,delta} per streamed token, {type:'final',name,color,text} once
@@ -575,10 +729,16 @@ async function runTurn(threadId, userText, onEvent, images) {
   t.status = 'thinking';
   let reply = '';
   onEvent?.({ type: 'start', name: t.name, color: t.color });
+  // Transient: the nudge is appended for THIS call only and never pushed into
+  // t.messages, so it can't accumulate across a chained auto run or get bound
+  // into the thread's context.
+  const callMsgs = t.runMode === 'auto'
+    ? [...t.messages, { role: 'system', content: AUTO_DIRECTIVE }]
+    : t.messages;
   try {
     reply = onEvent
-      ? (await brainStream(t.messages, (delta) => onEvent({ type: 'delta', name: t.name, color: t.color, delta }), t.contextId)).trim()
-      : (await brain(t.messages, t.contextId)).trim();
+      ? (await brainStream(callMsgs, (delta) => onEvent({ type: 'delta', name: t.name, color: t.color, delta }), t.contextId)).trim()
+      : (await brain(callMsgs, t.contextId)).trim();
   } catch (e) {
     reply = `error: ${e.message}`;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.3",
+  "version": "0.48.5",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",