@agentprojectcontext/apx 1.25.0 → 1.27.1

package/src/host/daemon/api/engines.js

@@ -0,0 +1,80 @@
+// GET  /engines            — list engine adapter ids known to core/engines.
+// POST /engines/models      — live model catalog from a provider.
+// GET  /engines/models      — legacy (Ollama only, no auth).
+import { ENGINE_IDS } from "../../../core/engines/index.js";
+import { fetchJsonWithTimeout } from "../../../core/engines/_health.js";
+
+const DEFAULT_BASE = {
+  openai:     "https://api.openai.com/v1",
+  groq:       "https://api.groq.com/openai/v1",
+  openrouter: "https://openrouter.ai/api/v1",
+  gemini:     "https://generativelanguage.googleapis.com/v1beta/openai",
+  anthropic:  "https://api.anthropic.com/v1",
+  ollama:     "http://localhost:11434",
+};
+
+// Returns { models } or { error }. Reads the right /models endpoint per engine.
+async function listModels(engine, baseUrl, apiKey) {
+  const base = String(baseUrl || DEFAULT_BASE[engine] || "").replace(/\/$/, "");
+
+  if (engine === "ollama") {
+    const b = base || process.env.OLLAMA_HOST || "http://localhost:11434";
+    const r = await fetchJsonWithTimeout(`${b}/api/tags`, { timeoutMs: 2500 });
+    if (!r.ok) return { error: r.reason || "no se pudo contactar Ollama" };
+    const list = Array.isArray(r.json?.models) ? r.json.models : [];
+    return { models: list.map((m) => m?.name).filter((n) => typeof n === "string" && n) };
+  }
+
+  if (engine === "anthropic") {
+    if (!apiKey) return { error: "falta api_key" };
+    const b = base || DEFAULT_BASE.anthropic;
+    const r = await fetchJsonWithTimeout(`${b}/models?limit=100`, {
+      timeoutMs: 5000,
+      headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" },
+    });
+    if (!r.ok) return { error: r.reason || `HTTP ${r.status}` };
+    const data = Array.isArray(r.json?.data) ? r.json.data : [];
+    return { models: data.map((m) => m?.id).filter(Boolean) };
+  }
+
+  // openai-compatible family: openai, groq, openrouter, gemini, azure, custom
+  if (!apiKey) return { error: "falta api_key" };
+  if (!base) return { error: "falta base_url" };
+  const r = await fetchJsonWithTimeout(`${base}/models`, {
+    timeoutMs: 5000,
+    headers: { authorization: `Bearer ${apiKey}` },
+  });
+  if (!r.ok) return { error: r.reason || `HTTP ${r.status}` };
+  const data = Array.isArray(r.json?.data)
+    ? r.json.data
+    : Array.isArray(r.json?.models)
+      ? r.json.models
+      : [];
+  return { models: data.map((m) => m?.id || m?.name).filter(Boolean) };
+}
+
+export function register(app, { config }) {
+  app.get("/engines", (_req, res) => res.json({ engines: ENGINE_IDS }));
+
+  app.post("/engines/models", async (req, res) => {
+    const b = req.body || {};
+    const engine = String(b.engine || "").toLowerCase();
+    if (!engine) return res.status(400).json({ models: [], error: "engine requerido" });
+    // api_key: prefer the one typed by the user (unsaved provider), else the
+    // stored secret for that provider slug. The key never leaves the daemon.
+    const slug = b.slug || engine;
+    const stored = config?.engines?.[slug]?.api_key;
+    const apiKey = b.api_key || stored || "";
+    const out = await listModels(engine, b.base_url, apiKey);
+    if (out.error) return res.status(502).json({ engine, models: [], error: out.error });
+    res.json({ engine, models: out.models.sort((x, y) => x.localeCompare(y)) });
+  });
+
+  // Legacy GET (Ollama, no auth) — kept for back-compat.
+  app.get("/engines/models", async (req, res) => {
+    const engine = String(req.query.engine || "").toLowerCase();
+    const out = await listModels(engine, String(req.query.base_url || ""), "");
+    if (out.error) return res.status(502).json({ engine, models: [], error: out.error });
+    res.json({ engine, models: out.models });
+  });
+}

package/src/host/daemon/api/exec.js

@@ -0,0 +1,193 @@
+// Per-agent one-shot / multi-turn LLM endpoints. These do NOT run the
+// super-agent tool loop — they go straight to the model with the agent's
+// system prompt. The super-agent endpoints live in api/super-agent.js.
+//
+//   POST /projects/:pid/agents/:slug/exec     one-shot, no history
+//   POST /projects/:pid/agents/:slug/chat     append to (or start) a conversation
+import { callEngine } from "../../../core/engines/index.js";
+import { readAgents } from "../../../core/parser.js";
+import { buildAgentSystem } from "../../../core/agent-system.js";
+import {
+  startConversation,
+  appendTurn,
+  readConversation,
+  setStatus,
+} from "../conversations.js";
+
+export function register(app, { projects, project, config }) {
+  app.post("/projects/:pid/agents/:slug/exec", async (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const {
+      prompt,
+      model: modelOverride,
+      temperature,
+      maxTokens,
+    } = req.body || {};
+    if (!prompt) return res.status(400).json({ error: "prompt required" });
+    const agents = readAgents(p.path);
+    const agent = agents.find((a) => a.slug === req.params.slug);
+    if (!agent) return res.status(404).json({ error: "agent not found" });
+    const modelId = modelOverride || agent.fields.Model;
+    if (!modelId)
+      return res
+        .status(400)
+        .json({ error: "agent has no model and none provided" });
+
+    try {
+      const system = buildAgentSystem(p, agent, { invocation: "engine" });
+      const conv = startConversation({
+        storagePath: p.storagePath,
+        agentSlug: agent.slug,
+        engine: modelId,
+        system,
+      });
+      appendTurn({ filePath: conv.path, role: "user", content: prompt });
+
+      const result = await callEngine({
+        modelId,
+        system,
+        messages: [{ role: "user", content: prompt }],
+        config: p.config || config,
+        temperature,
+        maxTokens,
+      });
+
+      appendTurn({
+        filePath: conv.path,
+        role: "assistant",
+        content: result.text,
+      });
+      setStatus(conv.path, "closed");
+
+      p.logMessage({
+        agent_slug: agent.slug,
+        channel: "engine",
+        direction: "in",
+        author: "user",
+        body: prompt,
+        meta: { conversation: conv.id },
+      });
+      p.logMessage({
+        agent_slug: agent.slug,
+        channel: "engine",
+        direction: "out",
+        type: "agent",
+        actor_id: agent.slug,
+        actor_kind: "agent",
+        author: agent.slug,
+        body: result.text,
+        meta: { conversation: conv.id, usage: result.usage },
+      });
+
+      projects.rebuild(p.id);
+      res.json({
+        conversation: { id: conv.id, filename: conv.filename, path: conv.path },
+        text: result.text,
+        usage: result.usage,
+        engine: modelId,
+      });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post("/projects/:pid/agents/:slug/chat", async (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const {
+      prompt,
+      conversation_id,
+      model: modelOverride,
+      temperature,
+      maxTokens,
+    } = req.body || {};
+    if (!prompt) return res.status(400).json({ error: "prompt required" });
+    const agents = readAgents(p.path);
+    const agent = agents.find((a) => a.slug === req.params.slug);
+    if (!agent) return res.status(404).json({ error: "agent not found" });
+    const modelId = modelOverride || agent.fields.Model;
+    if (!modelId)
+      return res
+        .status(400)
+        .json({ error: "agent has no model and none provided" });
+
+    try {
+      let convPath;
+      let convId;
+      let history = [];
+      let compactSummary = null;
+
+      if (conversation_id) {
+        const existing = readConversation(
+          p.storagePath,
+          agent.slug,
+          conversation_id
+        );
+        if (!existing)
+          return res
+            .status(404)
+            .json({ error: `conversation ${conversation_id} not found` });
+        convPath = existing.path;
+        convId = conversation_id;
+        // Inject compact summary into system instead of replaying it as a turn.
+        const compactTurn = existing.turns.find((t) => t.role === "compact");
+        if (compactTurn) {
+          compactSummary = compactTurn.content
+            .replace(/^\[Compacted \d+ turns.*?\]\n\n?/, "")
+            .trim();
+        }
+        history = existing.turns
+          .filter((t) => t.role === "user" || t.role === "assistant")
+          .map((t) => ({ role: t.role, content: t.content }));
+      }
+
+      const extraParts = compactSummary
+        ? [`## Previous Conversation Context (Compacted)\n${compactSummary}`]
+        : [];
+      const system = buildAgentSystem(p, agent, {
+        invocation: "engine",
+        extraParts,
+      });
+
+      if (!conversation_id) {
+        const conv = startConversation({
+          storagePath: p.storagePath,
+          agentSlug: agent.slug,
+          engine: modelId,
+          system,
+        });
+        convPath = conv.path;
+        convId = conv.id;
+      }
+
+      appendTurn({ filePath: convPath, role: "user", content: prompt });
+      history.push({ role: "user", content: prompt });
+
+      const result = await callEngine({
+        modelId,
+        system,
+        messages: history,
+        config: p.config || config,
+        temperature,
+        maxTokens,
+      });
+      appendTurn({
+        filePath: convPath,
+        role: "assistant",
+        content: result.text,
+      });
+      projects.rebuild(p.id);
+
+      res.json({
+        conversation_id: convId,
+        text: result.text,
+        usage: result.usage,
+        engine: modelId,
+        compacted: !!compactSummary,
+      });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+}

package/src/host/daemon/api/health.js

@@ -0,0 +1,10 @@
+// GET /health — unauthenticated; everything else requires the bearer token.
+export function register(app, { version, startedAt }) {
+  app.get("/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      version,
+      uptime_s: Math.round((Date.now() - startedAt) / 1000),
+    });
+  });
+}

package/src/host/daemon/api/identity.js

@@ -0,0 +1,36 @@
+// GET   /identity            full identity.json
+// PATCH /identity            { agent_name?, owner_name?, personality?, owner_context?, language?, timezone? }
+import { readIdentity, writeIdentity } from "../../../core/identity.js";
+
+const ALLOWED_KEYS = new Set([
+  "agent_name",
+  "owner_name",
+  "personality",
+  "owner_context",
+  "language",
+  "timezone",
+]);
+
+export function register(app) {
+  app.get("/identity", (_req, res) => {
+    res.json(readIdentity() || {});
+  });
+
+  app.patch("/identity", (req, res) => {
+    const body = req.body || {};
+    const patch = {};
+    for (const [k, v] of Object.entries(body)) {
+      if (!ALLOWED_KEYS.has(k)) continue;
+      if (v === null || typeof v === "string") patch[k] = v ?? "";
+    }
+    if (!Object.keys(patch).length) {
+      return res.status(400).json({ error: "no editable fields in body" });
+    }
+    try {
+      const out = writeIdentity(patch);
+      res.json(out);
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+}

package/src/host/daemon/api/mcps.js

@@ -0,0 +1,205 @@
+// MCP server registration per project. Reads/writes the three APX-owned scopes
+// (apc = .apc/mcps.json, runtime = <storagePath>/mcps.json, global =
+// ~/.apx/mcps.json) and exposes tool calls through the registry cache.
+//   GET    /projects/:pid/mcps
+//   POST   /projects/:pid/mcps?scope=shared|runtime|global    (default: shared)
+//   DELETE /projects/:pid/mcps/:name?scope=…                   (default: shared)
+//   GET    /projects/:pid/mcps/check
+//   POST   /projects/:pid/mcps/:name/call
+import fs from "node:fs";
+import path from "node:path";
+import {
+  readApfMcps,
+  writeApfMcps,
+  readRuntimeMcps,
+  writeRuntimeMcps,
+  readGlobalMcps,
+  writeGlobalMcps,
+  runtimeMcpsPath,
+  globalMcpsPath,
+  SOURCES,
+} from "../../../core/mcp/sources.js";
+
+// scope alias used by API/CLI -> internal source id used in entry metadata
+const SCOPE_TO_SOURCE = {
+  shared: "apc",       // .apc/mcps.json
+  runtime: "runtime",  // ~/.apx/projects/<apxId>/mcps.json
+  global: "global",    // ~/.apx/mcps.json
+};
+
+function readScope(scope, projectEntry) {
+  if (scope === "runtime") return readRuntimeMcps(projectEntry.storagePath);
+  if (scope === "global") return readGlobalMcps();
+  return readApfMcps(projectEntry.path); // shared / default
+}
+
+function writeScope(scope, projectEntry, json) {
+  if (scope === "runtime") {
+    if (!projectEntry.storagePath) {
+      throw new Error("runtime scope requires a project with storagePath");
+    }
+    return writeRuntimeMcps(projectEntry.storagePath, json);
+  }
+  if (scope === "global") return writeGlobalMcps(json);
+  return writeApfMcps(projectEntry.path, json);
+}
+
+function normalizeScope(raw) {
+  if (!raw) return "shared";
+  const s = String(raw).toLowerCase();
+  if (s === "apc") return "shared"; // friendly alias
+  if (!(s in SCOPE_TO_SOURCE)) {
+    return null;
+  }
+  return s;
+}
+
+export function register(app, { projects, registries, project }) {
+  app.get("/projects/:pid/mcps", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    res.json(registries.for(p).list());
+  });
+
+  app.post("/projects/:pid/mcps", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const scope = normalizeScope(req.query?.scope);
+    if (scope === null) {
+      return res.status(400).json({ error: `unknown scope "${req.query?.scope}" (use shared|runtime|global)` });
+    }
+    const { name, command, args, env, url, headers, enabled } = req.body || {};
+    if (!name) return res.status(400).json({ error: "name required" });
+    if (!command && !url)
+      return res.status(400).json({ error: "either command or url required" });
+
+    let json;
+    try {
+      json = readScope(scope, p);
+    } catch (e) {
+      return res.status(400).json({ error: e.message });
+    }
+    json.mcpServers = json.mcpServers || {};
+    const existing = json.mcpServers[name] || {};
+    json.mcpServers[name] = {
+      ...existing,
+      ...(command !== undefined ? { command } : {}),
+      ...(args !== undefined ? { args } : {}),
+      ...(env !== undefined ? { env } : {}),
+      ...(url !== undefined ? { url } : {}),
+      ...(headers !== undefined ? { headers } : {}),
+      ...(enabled !== undefined ? { enabled } : {}),
+    };
+    try {
+      writeScope(scope, p, json);
+    } catch (e) {
+      return res.status(400).json({ error: e.message });
+    }
+    registries.for(p).evict(name);
+    projects.rebuild(p.id);
+    const entry = registries.for(p).getByName(name);
+    res.status(201).json(entry);
+  });
+
+  app.delete("/projects/:pid/mcps/:name", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const scope = normalizeScope(req.query?.scope);
+    if (scope === null) {
+      return res.status(400).json({ error: `unknown scope "${req.query?.scope}" (use shared|runtime|global)` });
+    }
+    let json;
+    try {
+      json = readScope(scope, p);
+    } catch (e) {
+      return res.status(400).json({ error: e.message });
+    }
+    if (!json.mcpServers || !(req.params.name in (json.mcpServers || {}))) {
+      // Not present in the requested scope. Surface a helpful message if it
+      // lives in another scope/source.
+      const all = registries.for(p).list();
+      const m = all.find((x) => x.name === req.params.name);
+      if (m) {
+        const ownerSource = m.source;
+        const ownerScope = ownerSource === "apc"
+          ? "shared"
+          : ownerSource === "runtime"
+          ? "runtime"
+          : ownerSource === "global"
+          ? "global"
+          : null;
+        if (ownerScope && ownerScope !== scope) {
+          return res.status(409).json({
+            error: `MCP "${req.params.name}" lives in scope "${ownerScope}", not "${scope}". Re-run with --scope ${ownerScope}.`,
+          });
+        }
+        if (!ownerScope) {
+          return res.status(409).json({
+            error: `MCP "${req.params.name}" comes from "${ownerSource}" config — not APX-owned, cannot be removed by apx. Edit ${
+              SOURCES.find((s) => s.id === ownerSource)?.file
+            } directly.`,
+          });
+        }
+      }
+      return res.status(404).end();
+    }
+    delete json.mcpServers[req.params.name];
+    try {
+      writeScope(scope, p, json);
+    } catch (e) {
+      return res.status(400).json({ error: e.message });
+    }
+    registries.for(p).evict(req.params.name);
+    projects.rebuild(p.id);
+    res.status(204).end();
+  });
+
+  app.get("/projects/:pid/mcps/check", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const reg = registries.for(p);
+    res.json({
+      sources: SOURCES.map((s) => {
+        let abs;
+        let present;
+        if (s.id === "runtime") {
+          abs = runtimeMcpsPath(p.storagePath);
+          present = !!(abs && fs.existsSync(abs));
+        } else if (s.id === "global") {
+          abs = globalMcpsPath();
+          present = fs.existsSync(abs);
+        } else {
+          abs = path.join(p.path, s.file);
+          present = fs.existsSync(abs);
+        }
+        return {
+          id: s.id,
+          file: s.file,
+          path: abs,
+          scope: s.scope || "project",
+          present,
+        };
+      }),
+      entries: reg.list().map((m) => ({
+        name: m.name,
+        source: m.source,
+        transport: m.transport,
+        enabled: m.enabled,
+      })),
+      conflicts: reg.conflicts(),
+    });
+  });
+
+  app.post("/projects/:pid/mcps/:name/call", async (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { tool, params } = req.body || {};
+    if (!tool) return res.status(400).json({ error: "tool required" });
+    try {
+      const result = await registries.for(p).call(req.params.name, tool, params);
+      res.json({ result });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+}

package/src/host/daemon/api/messages.js

@@ -0,0 +1,83 @@
+// Project messages (~/.apx/projects/<id>/messages/*.jsonl) and global channels
+// (~/.apx/messages/<channel>/*.jsonl).
+//
+//   GET  /projects/:pid/messages
+//   POST /projects/:pid/messages
+//   GET  /projects/:pid/messages/search
+//   GET  /messages/global
+import {
+  readGlobalMessages,
+  readProjectMessages,
+  searchProjectMessages,
+} from "../../../core/messages-store.js";
+
+export function register(app, { project }) {
+  app.get("/projects/:pid/messages", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { agent, channel, since, limit = "100" } = req.query;
+    const rows = readProjectMessages(p.storagePath, {
+      channel: channel || undefined,
+      agent_slug: agent || undefined,
+      since: since || undefined,
+      limit: Math.min(parseInt(limit, 10) || 100, 1000),
+    });
+    res.json(rows);
+  });
+
+  app.post("/projects/:pid/messages", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const {
+      channel,
+      direction,
+      type,
+      actor_id,
+      agent_slug,
+      body,
+      meta = {},
+      author = null,
+    } = req.body || {};
+    if (!channel || !direction || !body)
+      return res.status(400).json({ error: "channel, direction, body required" });
+    if (!["in", "out"].includes(direction))
+      return res.status(400).json({ error: "direction must be in|out" });
+    const r = p.logMessage({
+      agent_slug: agent_slug || null,
+      channel,
+      direction,
+      type,
+      actor_id,
+      author,
+      body,
+      meta,
+    });
+    res.status(201).json({ ok: true, ts: r.ts });
+  });
+
+  app.get("/projects/:pid/messages/search", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { q, limit = "50" } = req.query;
+    if (!q) return res.status(400).json({ error: "q required" });
+    res.json(
+      searchProjectMessages(
+        p.storagePath,
+        q,
+        Math.min(parseInt(limit, 10) || 50, 500)
+      )
+    );
+  });
+
+  // Cross-project channels (telegram, direct, …)
+  app.get("/messages/global", (req, res) => {
+    const { channel, limit = "100", since } = req.query;
+    const lim = Math.min(parseInt(limit, 10) || 100, 1000);
+    const rows = readGlobalMessages({
+      channel: channel || undefined,
+      limit: lim,
+      since,
+    });
+    res.json(rows);
+  });
+}