@agentprojectcontext/apx 1.0.3

package/src/daemon/super-agent.js

@@ -0,0 +1,188 @@
+// Super-agent: a daemon-level agent that responds on Telegram when no
+// per-project agent is configured. Has native function-calling tools to
+// inspect projects/agents/MCPs and to call agents and MCPs directly.
+//
+// Config:
+//   {
+//     "super_agent": {
+//       "enabled": true,
+//       "model": "ollama:qwen2.5:14b",   // must support tool use
+//       "name": "apx",
+//       "system": "..."                   // optional; defaults below
+//     }
+//   }
+import { callEngine } from "./engines/index.js";
+import { TOOL_SCHEMAS, makeToolHandlers } from "./super-agent-tools.js";
+import {
+  extractPseudoToolCalls,
+  cleanTextOfPseudoToolCalls,
+} from "./tool-call-parser.js";
+
+const MAX_TOOL_ITERS = 6;
+
+const DEFAULT_SYSTEM = `You are the **APX dispatcher** — the daemon-level agent that runs above all APC projects.
+
+You HAVE tools. THE FIRST THING you do for any factual question is call a tool. Do not ask the user to specify a project unless the tool itself fails.
+
+Available tools:
+- list_projects, list_agents, list_mcps         — discovery (call WITHOUT project to get all of them across every registered project; specify project only to filter)
+- read_agent_memory                              — what an agent knows
+- list_files, read_file                          — inspect any project
+- tail_messages, search_messages                 — see history
+- call_agent                                     — delegate to a project agent
+- call_mcp                                       — call an MCP tool
+- call_runtime                                   — spawn claude-code/codex/opencode/aider
+- send_telegram                                  — send a message
+- set_identity                                   — update agent name, personality, owner, language (persists to disk)
+
+HARD RULES (do not deviate):
+1. NEVER invent project names, agent slugs, model ids, MCP names or paths. ALWAYS look them up via list_* first.
+2. If the user says "los agentes" / "lista" / "qué hay" without specifying a project, that means **all of them** — call the tool WITHOUT a project argument and the result will include every project.
+3. NEVER answer "specify a project" — instead, just call the tool with no argument and you'll get the full picture.
+4. If a tool result has an error, retry with different arguments before falling back to asking the user.
+5. Don't ask permission — the operator left you unrestricted.
+6. Default language: es-AR. Plain text, no markdown formatting (Telegram doesn't render it).
+7. Stay brief: under 6 sentences unless asked for detail.
+8. You DO see recent prior turns of this chat as previous messages when applicable. **Use them ONLY to disambiguate references** (e.g. "el primero" → first project mentioned earlier). For ANY factual data — agent details, MCP details, file contents, memory — RE-CALL the tool. Past turns are context, not a cache. Models change, agents change, files change.
+9. /reset or /new from the user means "forget previous turns and answer this one fresh" — if you see those prefixes the operator already cleared the context for you.
+10. DISPATCH RULE: when the user says things like "que <agente> haga X", "iniciá una sesión con Claude/Codex", "que <agente> arranque <runtime>", "andá a <runtime> y hacé X" — that is a call_runtime request. Look up the agent slug with list_agents if needed, then call call_runtime({agent: <slug>, runtime: 'claude-code'|'codex'|'opencode'|'aider', prompt: <user's request>}). The agent's declared model (in AGENTS.md) is IGNORED in this case; the runtime supplies the model. Memory + skills of the agent become the system prompt of the runtime. Don't ask "are you sure?" — just dispatch.
+11. IDENTITY RULE: when the user asks you to change your name ("llamame X", "call yourself X", "tu nombre es X"), or update your personality/language, call set_identity immediately and persist the change. Then confirm with your new name.`;
+
+export function isSuperAgentEnabled(cfg) {
+  return !!(cfg && cfg.super_agent && cfg.super_agent.enabled && cfg.super_agent.model);
+}
+
+export async function runSuperAgent({
+  globalConfig,
+  projects,
+  plugins,
+  registries,
+  prompt,
+  contextNote = "",
+  previousMessages = [],
+}) {
+  if (!isSuperAgentEnabled(globalConfig)) {
+    throw new Error("super-agent not enabled (set super_agent.enabled and .model in ~/.apx/config.json)");
+  }
+  const sa = globalConfig.super_agent;
+
+  // Tiny project hint — JUST names + ids, no detail. The model is expected to
+  // call list_agents / list_mcps / read_agent_memory / etc. for everything
+  // else. Keeping this short forces actual tool use instead of letting the
+  // model answer from a cached snapshot.
+  const projectIndex = projects
+    .list()
+    .map((p) => `  ${p.id}: "${p.name}" (${p.path})`)
+    .join("\n");
+
+  const system = [
+    sa.system || DEFAULT_SYSTEM,
+    contextNote,
+    "# Registered projects (just the index — call tools for details)",
+    projectIndex || "(no projects registered)",
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+
+  // Build tools and handler map
+  const handlers = makeToolHandlers({
+    projects,
+    plugins,
+    registries,
+    globalConfig,
+  });
+
+  // Agent loop: call model → if tool_calls, execute and feed back; repeat.
+  // Inject any prior turns the caller passed (e.g. recent Telegram history)
+  // so the model has multi-turn context.
+  const conversation = [...previousMessages, { role: "user", content: prompt }];
+  const trace = [];
+  let totalUsage = { input_tokens: 0, output_tokens: 0 };
+  let lastText = "";
+
+  for (let iter = 0; iter < MAX_TOOL_ITERS; iter++) {
+    const result = await callEngine({
+      modelId: sa.model,
+      system,
+      messages: conversation,
+      config: globalConfig,
+      tools: TOOL_SCHEMAS,
+      maxTokens: 1024,
+    });
+    totalUsage.input_tokens += result.usage?.input_tokens || 0;
+    totalUsage.output_tokens += result.usage?.output_tokens || 0;
+    lastText = result.text || "";
+
+    let toolCalls = result.tool_calls || (result.message && result.message.tool_calls) || null;
+
+    // Some models (qwen2.5 in particular) emit tool calls as plain text
+    // instead of using the structured field. If we don't find structured
+    // tool_calls, scan the text for the pseudo-format and treat them the
+    // same. We also clean the visible text so the leftover `_icall()` and
+    // {"name":...} junk never reaches the user as a final answer.
+    if ((!toolCalls || toolCalls.length === 0) && lastText) {
+      const pseudo = extractPseudoToolCalls(lastText);
+      if (pseudo.length > 0) {
+        toolCalls = pseudo;
+        lastText = cleanTextOfPseudoToolCalls(lastText);
+      }
+    }
+
+    if (!toolCalls || toolCalls.length === 0) {
+      // Final answer — clean up any stray fence markers just in case
+      lastText = cleanTextOfPseudoToolCalls(lastText) || lastText;
+      break;
+    }
+
+    // Append the assistant turn (with its tool_calls) and execute each call.
+    conversation.push({
+      role: "assistant",
+      content: result.text || "",
+      tool_calls: toolCalls,
+    });
+
+    for (const tc of toolCalls) {
+      const fn = tc.function || tc; // some adapters bury it deeper
+      const name = fn.name;
+      let args = fn.arguments;
+      if (typeof args === "string") {
+        try { args = JSON.parse(args); } catch { args = {}; }
+      }
+      args = args || {};
+
+      let toolResult;
+      try {
+        const handler = handlers[name];
+        if (!handler) {
+          toolResult = { error: `unknown tool: ${name}` };
+        } else {
+          toolResult = await handler(args);
+        }
+      } catch (e) {
+        toolResult = { error: e.message };
+      }
+
+      trace.push({ tool: name, args, result: summarizeForTrace(toolResult) });
+
+      conversation.push({
+        role: "tool",
+        tool_name: name,
+        content: JSON.stringify(toolResult),
+      });
+    }
+  }
+
+  return {
+    text: lastText,
+    usage: totalUsage,
+    name: sa.name || "apx",
+    trace,
+  };
+}
+
+function summarizeForTrace(r) {
+  if (r === null || r === undefined) return r;
+  const s = JSON.stringify(r);
+  if (s.length <= 400) return r;
+  return s.slice(0, 380) + "…(truncated)";
+}

package/src/daemon/thinking.js

@@ -0,0 +1,45 @@
+// Thinking-block utilities.
+//
+// Several modern LLMs (qwen3.x, deepseek-r1, gpt-o*, claude with extended
+// thinking) emit reasoning blocks delimited by <think>...</think> or
+// <thinking>...</thinking>. APX wants to:
+//
+//   - Keep the reasoning on terminal/local channels (chat REPL, daemon log)
+//     because it's useful for the operator.
+//   - Strip it from Telegram and other channels where it's just noise.
+//
+// `splitThinking(text)` splits an LLM response into:
+//   { thinking: string, answer: string }
+//
+// `stripThinking(text)` is a one-line helper that just returns the answer.
+// `formatForChannel(text, channel)` renders for a channel: telegram → answer,
+// terminal/log/cli → "<thinking>...</thinking>\n\n<answer>".
+
+const THINK_RE = /<(?:think|thinking)>([\s\S]*?)<\/(?:think|thinking)>/gi;
+
+export function splitThinking(text) {
+  if (!text || typeof text !== "string") return { thinking: "", answer: text || "" };
+  const blocks = [];
+  let answer = text.replace(THINK_RE, (_, inner) => {
+    blocks.push(inner.trim());
+    return "";
+  });
+  // Some models emit reasoning before the closing tag of the doc itself —
+  // collapse leading/trailing whitespace so the answer is clean.
+  answer = answer.replace(/^[\s\n]+/, "").replace(/[\s\n]+$/, "");
+  return { thinking: blocks.join("\n\n"), answer };
+}
+
+export function stripThinking(text) {
+  return splitThinking(text).answer;
+}
+
+export function formatForChannel(text, channel) {
+  const { thinking, answer } = splitThinking(text);
+  // Channels where reasoning would be noise to a human operator
+  const STRIP_FOR = new Set(["telegram", "slack", "discord", "sms", "email"]);
+  if (STRIP_FOR.has(channel)) return answer;
+  // Local channels — keep the thinking visible for debugging
+  if (!thinking) return answer;
+  return `<thinking>\n${thinking}\n</thinking>\n\n${answer}`;
+}

package/src/daemon/tool-call-parser.js

@@ -0,0 +1,116 @@
+// Pseudo-tool-call parser.
+//
+// Some models — qwen2.5:14b under Ollama is the canonical offender — emit
+// "tool calls as text" instead of using the structured `tool_calls` field of
+// the chat API. The output looks like:
+//
+//   <tool_call>
+//   {"name": "list_agents", "arguments": {"project": "X"}}
+//   </tool_call>
+//   <tool_call>
+//   {"name": "send_telegram", "arguments": {"text": "..."}}
+//   </tool_call>
+//
+// or sometimes prefixed with `_icall()` or wrapped in fenced code blocks.
+//
+// `extractPseudoToolCalls(text)` finds those patterns and returns an array of
+// `{ id, function: { name, arguments } }` objects shaped like real Ollama
+// tool_calls — so the agent loop can treat them identically.
+//
+// `cleanTextOfPseudoToolCalls(text)` returns the input text minus the
+// pseudo-tool-call blocks, so the loop never sends them as plain text to the
+// user when the model fell back to this mode.
+
+let counter = 0;
+function nextId() {
+  return `pseudo_${Date.now().toString(36)}_${counter++}`;
+}
+
+// Find a balanced JSON object starting at index `i` of `s`. Returns
+// { ok: true, end: <index after closing brace> } or { ok: false }.
+function readBalancedJson(s, i) {
+  if (s[i] !== "{") return { ok: false };
+  let depth = 0;
+  let inStr = false;
+  let escape = false;
+  for (let p = i; p < s.length; p++) {
+    const c = s[p];
+    if (escape) { escape = false; continue; }
+    if (inStr) {
+      if (c === "\\") escape = true;
+      else if (c === '"') inStr = false;
+      continue;
+    }
+    if (c === '"') { inStr = true; continue; }
+    if (c === "{") depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) return { ok: true, end: p + 1 };
+    }
+  }
+  return { ok: false };
+}
+
+// Walk the text looking for `{` characters that start an object containing
+// keys "name" and "arguments". Tolerant: accepts whatever wrapper text comes
+// before/after.
+export function extractPseudoToolCalls(text) {
+  if (!text || typeof text !== "string") return [];
+  const out = [];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== "{") continue;
+    const balanced = readBalancedJson(text, i);
+    if (!balanced.ok) continue;
+    const candidate = text.slice(i, balanced.end);
+    let parsed;
+    try {
+      parsed = JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+    if (
+      parsed &&
+      typeof parsed === "object" &&
+      typeof parsed.name === "string" &&
+      "arguments" in parsed &&
+      typeof parsed.arguments === "object" &&
+      parsed.arguments !== null &&
+      !Array.isArray(parsed.arguments)
+    ) {
+      out.push({
+        id: nextId(),
+        function: {
+          name: parsed.name,
+          arguments: parsed.arguments,
+        },
+        _pseudo: true,
+        _raw: candidate,
+      });
+      i = balanced.end - 1;
+    }
+  }
+  return out;
+}
+
+// Remove the parts of `text` that match pseudo-tool-call blocks plus any
+// trivial wrappers (<tool_call>, ```tool_use, _icall(), etc.) that often sit
+// around them. Used to clean up final answers that the model emitted with
+// leftover textual tool-call gunk.
+export function cleanTextOfPseudoToolCalls(text) {
+  if (!text || typeof text !== "string") return text;
+
+  // Strip explicit XML-like fences first
+  let out = text.replace(/<\/?tool_call>/gi, "");
+  out = out.replace(/<\/?tool_use>/gi, "");
+  out = out.replace(/_icall\(\s*\)/g, "");
+  out = out.replace(/```tool_(?:call|use)\s*([\s\S]*?)```/gi, "");
+
+  // Now drop balanced JSON objects that were tool-call-shaped
+  const calls = extractPseudoToolCalls(out);
+  for (const c of calls) {
+    out = out.replace(c._raw, "");
+  }
+  // Tidy up whitespace & blank lines
+  out = out.replace(/\n{3,}/g, "\n\n").trim();
+  return out;
+}

package/src/daemon/wakeup.js

@@ -0,0 +1,92 @@
+// Wake-up message — sent via Telegram once per daemon restart (with cooldown).
+import fetch from "node-fetch";
+import { readIdentity, writeIdentity } from "../core/identity.js";
+import { resolveProvider, getAdapter } from "./engines/index.js";
+
+const WAKEUP_COOLDOWN_MS = 30 * 60 * 1000; // 30 min
+
+// Detect preferred language from identity, then fall back to system LANG env.
+function detectLanguage(identity) {
+  if (identity.language) return identity.language;
+  const lang = process.env.LANG || process.env.LC_MESSAGES || process.env.LC_ALL || "";
+  const code = lang.split(/[_\.]/)[0].toLowerCase();
+  const map = {
+    es: "Spanish (Español)",
+    en: "English",
+    fr: "French (Français)",
+    pt: "Portuguese (Português)",
+    de: "German (Deutsch)",
+    it: "Italian (Italiano)",
+    nl: "Dutch (Nederlands)",
+    ru: "Russian (Русский)",
+    ja: "Japanese (日本語)",
+    zh: "Chinese (中文)",
+    ko: "Korean (한국어)",
+    ar: "Arabic (العربية)",
+  };
+  return map[code] || "Spanish (Español)"; // default es-AR like the super-agent
+}
+
+async function generateMessage(identity, engineConfig) {
+  try {
+    const { provider, model } = resolveProvider("ollama:qwen2.5:14b");
+    const engine = getAdapter(provider);
+    const language = detectLanguage(identity);
+    const result = await engine.chat({
+      system: `You are ${identity.agent_name}, an AI agent assistant. Your personality: ${identity.personality || "direct, curious, helpful"}. Your owner is ${identity.owner_name}. Context: ${identity.owner_context || "AI developer"}.`,
+      messages: [
+        {
+          role: "user",
+          content:
+            `Write a short, creative wake-up message to send when you first come online. ` +
+            `Write it in ${language}. ` +
+            `Be yourself — direct, slightly witty, concrete. 2-3 sentences max. ` +
+            `Mention who you are, who you're here for, and one thing you're ready to help with. ` +
+            `No emojis. No greetings like 'Hello!' or 'Hola!' — start differently.`,
+        },
+      ],
+      model,
+      config: engineConfig?.engines?.ollama || {},
+      maxTokens: 150,
+    });
+    return result.text?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function sendTelegram(token, chatId, text) {
+  const url = `https://api.telegram.org/bot${token}/sendMessage`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: chatId, text }),
+  });
+  const json = await res.json();
+  if (!json.ok) throw new Error(json.description || "telegram send failed");
+  return json;
+}
+
+export async function triggerWakeup(config, log) {
+  const identity = readIdentity();
+  if (!identity) return;
+
+  const tg = config.telegram;
+  if (!tg?.enabled || !tg?.bot_token || !tg?.chat_id) return;
+
+  // Cooldown check
+  if (identity.last_wakeup) {
+    const elapsed = Date.now() - new Date(identity.last_wakeup).getTime();
+    if (elapsed < WAKEUP_COOLDOWN_MS) return;
+  }
+
+  try {
+    const message = await generateMessage(identity, config);
+    const text = message || `${identity.agent_name} online. Ready.`;
+    await sendTelegram(tg.bot_token, tg.chat_id, text);
+    writeIdentity({ last_wakeup: new Date().toISOString() });
+    log?.(`wakeup: sent to Telegram chat ${tg.chat_id}`);
+  } catch (e) {
+    log?.(`wakeup: failed — ${e.message}`);
+  }
+}

package/src/mcp/index.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+// APX MCP Server — exposes APX daemon capabilities via MCP stdio transport.
+// Usage: npx -y apx-mcp   (run from inside an APC project directory)
+//
+// Tool surface:
+//   agent_list        — list agents in the current project
+//   agent_exec        — quick one-shot LLM call via apx exec
+//   agent_run         — launch a full runtime session
+//   memory_read       — read an agent's memory.md
+//   memory_append     — append a fact to agent memory
+//   messages_tail     — recent messages (all channels or filtered)
+//   session_list      — list sessions for an agent
+//   mcp_list          — list project+global MCPs
+//   mcp_call          — call a project MCP tool
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { findApfRoot } from "../core/parser.js";
+import { ensureDaemon, http } from "../cli/http.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PORT = parseInt(process.env.APX_PORT || "7430", 10);
+
+// ---------------------------------------------------------------------------
+// Resolve current project
+// ---------------------------------------------------------------------------
+
+async function resolveProject() {
+  const cwd = process.env.APX_PROJECT_ROOT || process.cwd();
+  const root = findApfRoot(cwd);
+  if (!root) throw new Error(`No APC project found at or above: ${cwd}`);
+
+  // Ensure daemon is running and project is registered.
+  await ensureDaemon({ silent: true });
+  const projects = await http.get("/projects");
+  const match = projects.find((p) => path.resolve(p.path) === path.resolve(root));
+  if (match) return match;
+
+  // Register if not yet known.
+  const created = await http.post("/projects", { path: root });
+  return created;
+}
+
+// ---------------------------------------------------------------------------
+// Build MCP server
+// ---------------------------------------------------------------------------
+
+const server = new McpServer({
+  name: "apx",
+  version: "0.1.0",
+});
+
+// agent_list
+server.tool(
+  "agent_list",
+  "List all agents defined in the current APC project.",
+  {},
+  async () => {
+    const proj = await resolveProject();
+    const agents = await http.get(`/projects/${proj.id}/agents`);
+    const rows = agents.map(
+      (a) => `${a.slug}  role=${a.role || "—"}  model=${a.model || "—"}`
+    );
+    return { content: [{ type: "text", text: rows.join("\n") || "(no agents)" }] };
+  }
+);
+
+// agent_exec
+server.tool(
+  "agent_exec",
+  "Quick one-shot LLM call to an agent (apx exec). Returns the agent's response text.",
+  {
+    slug: z.string().describe("Agent slug"),
+    prompt: z.string().describe("Prompt to send"),
+    engine: z.string().optional().describe("Engine override (default: agent's model)"),
+  },
+  async ({ slug, prompt, engine }) => {
+    const proj = await resolveProject();
+    const body = { prompt };
+    if (engine) body.engine = engine;
+    const result = await http.post(`/projects/${proj.id}/agents/${slug}/exec`, body);
+    return { content: [{ type: "text", text: result.output || JSON.stringify(result) }] };
+  }
+);
+
+// agent_run
+server.tool(
+  "agent_run",
+  "Launch a full runtime session for an agent (apx run). Returns the session result.",
+  {
+    slug: z.string().describe("Agent slug"),
+    prompt: z.string().describe("Prompt / task for the agent"),
+    runtime: z.string().optional().describe("Runtime: claude-code | codex (default: claude-code)"),
+  },
+  async ({ slug, prompt, runtime }) => {
+    const proj = await resolveProject();
+    const body = { prompt, runtime: runtime || "claude-code" };
+    const result = await http.post(`/projects/${proj.id}/agents/${slug}/runtime`, body);
+    return { content: [{ type: "text", text: result.output || JSON.stringify(result) }] };
+  }
+);
+
+// memory_read
+server.tool(
+  "memory_read",
+  "Read an agent's persistent memory.",
+  {
+    slug: z.string().describe("Agent slug"),
+  },
+  async ({ slug }) => {
+    const proj = await resolveProject();
+    const mem = await http.get(`/projects/${proj.id}/agents/${slug}/memory`);
+    return { content: [{ type: "text", text: mem.body_md || "(empty)" }] };
+  }
+);
+
+// memory_append
+server.tool(
+  "memory_append",
+  "Append a durable fact to an agent's memory (non-destructive).",
+  {
+    slug: z.string().describe("Agent slug"),
+    fact: z.string().describe("Fact to append"),
+  },
+  async ({ slug, fact }) => {
+    const proj = await resolveProject();
+    await http.put(`/projects/${proj.id}/agents/${slug}/memory`, { append: fact });
+    return { content: [{ type: "text", text: "OK" }] };
+  }
+);
+
+// messages_tail
+server.tool(
+  "messages_tail",
+  "Tail recent messages for the project (all channels or filtered).",
+  {
+    channel: z.string().optional().describe("Channel filter: runtime | telegram | exec | a2a"),
+    agent: z.string().optional().describe("Filter by agent slug"),
+    limit: z.number().optional().describe("Max messages (default 50)"),
+  },
+  async ({ channel, agent, limit }) => {
+    const proj = await resolveProject();
+    const qs = new URLSearchParams();
+    if (channel) qs.set("channel", channel);
+    if (agent) qs.set("agent", agent);
+    if (limit) qs.set("limit", String(limit));
+    const msgs = await http.get(`/projects/${proj.id}/messages?${qs}`);
+    const rows = (msgs.messages || msgs).map(
+      (m) => `[${m.ts}] ${m.channel}/${m.direction} ${m.author || ""}: ${m.body}`
+    );
+    return { content: [{ type: "text", text: rows.join("\n") || "(no messages)" }] };
+  }
+);
+
+// session_list
+server.tool(
+  "session_list",
+  "List recent sessions for an agent.",
+  {
+    slug: z.string().describe("Agent slug"),
+    limit: z.number().optional().describe("Max sessions (default 20)"),
+  },
+  async ({ slug, limit }) => {
+    const proj = await resolveProject();
+    const qs = limit ? `?limit=${limit}` : "";
+    const sessions = await http.get(`/projects/${proj.id}/agents/${slug}/sessions${qs}`);
+    const rows = (sessions.sessions || sessions).map(
+      (s) => `${s.filename}  started=${s.started_at || "—"}  title=${s.title || "—"}`
+    );
+    return { content: [{ type: "text", text: rows.join("\n") || "(no sessions)" }] };
+  }
+);
+
+// mcp_list
+server.tool(
+  "mcp_list",
+  "List MCP servers available in this project (from .apc/mcps.json, .cursor/mcp.json, ~/.apx/mcp.json, etc.).",
+  {},
+  async () => {
+    const proj = await resolveProject();
+    const mcps = await http.get(`/projects/${proj.id}/mcps`);
+    const rows = (mcps.mcps || mcps).map(
+      (m) => `${m.name}  source=${m.source}  transport=${m.transport}  enabled=${m.enabled}`
+    );
+    return { content: [{ type: "text", text: rows.join("\n") || "(no MCPs)" }] };
+  }
+);
+
+// mcp_call
+server.tool(
+  "mcp_call",
+  "Call a tool on a project MCP server.",
+  {
+    server: z.string().describe("MCP server name"),
+    tool: z.string().describe("Tool name"),
+    args: z.record(z.unknown()).optional().describe("Tool arguments as JSON object"),
+  },
+  async ({ server: serverName, tool, args }) => {
+    const proj = await resolveProject();
+    const result = await http.post(
+      `/projects/${proj.id}/mcps/${encodeURIComponent(serverName)}/call`,
+      { tool, args: args || {} }
+    );
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+
+const transport = new StdioServerTransport();
+await server.connect(transport);