@agentprojectcontext/apx 1.80.2 → 1.89.1

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

@@ -11,6 +11,7 @@ import {
 import { readProjectContext } from "#core/apc/context-copy.js";
 import { appendProjectNote } from "#core/apc/notes.js";
 import { runDeckExec, copyToClipboard } from "../deck-exec.js";
+import { asyncRoute } from "./shared.js";
 
 function safePluginStatus(plugins) {
   if (!plugins || typeof plugins.status !== "function") return {};
@@ -51,7 +52,7 @@ export function register(api, ctx) {
   // Persists the user's enable/disable choice for an external widget into the
   // global config under `deck.widget_overrides[id]`. No-op for unknown widget
   // ids so the deck UI can stay forward-compatible.
-  api.patch("/deck/widgets/:id", async (req, res) => {
+  api.patch("/deck/widgets/:id", asyncRoute(async (req, res) => {
     const id = req.params.id;
     if (!TOGGLEABLE_WIDGETS.has(id)) {
       return res.status(404).json({ error: `unknown widget: ${id}` });
@@ -86,13 +87,13 @@ export function register(api, ctx) {
     } catch (e) {
       return res.status(500).json({ error: e?.message || "config persistence failed" });
     }
-  });
+  }));
 
   // POST /projects/:pid/context/copy
   //
   // Reads the project's AGENTS.md + .apc/memory.md, concatenates them with a
   // small header per file, and ships the result to the daemon-host clipboard.
-  api.post("/projects/:pid/context/copy", async (req, res) => {
+  api.post("/projects/:pid/context/copy", asyncRoute(async (req, res) => {
     const project = ctx.project ? ctx.project(req, res) : null;
     if (!project) return; // project() already 404'd
     try {
@@ -103,10 +104,10 @@ export function register(api, ctx) {
     } catch (e) {
       res.status(500).json({ error: e?.message || String(e) });
     }
-  });
+  }));
 
   // POST /projects/:pid/notes  body: { body: "...", title?: "..." }
-  api.post("/projects/:pid/notes", async (req, res) => {
+  api.post("/projects/:pid/notes", asyncRoute(async (req, res) => {
     const project = ctx.project ? ctx.project(req, res) : null;
     if (!project) return;
     const { body, title } = req.body || {};
@@ -122,14 +123,14 @@ export function register(api, ctx) {
     } catch (e) {
       res.status(500).json({ error: e?.message || String(e) });
     }
-  });
+  }));
 
   // POST /deck/exec
   //
   // Light-touch action runner for the deck buttons. Companion clients can't
   // shell out arbitrary commands — body picks from a whitelist of "intent"
   // verbs and the server picks the OS command. See deck-exec.js for the kinds.
-  api.post("/deck/exec", async (req, res) => {
+  api.post("/deck/exec", asyncRoute(async (req, res) => {
     const { kind, target, app: appHint, text } = req.body || {};
     if (!kind || typeof kind !== "string") {
       return res.status(400).json({ error: "kind required" });
@@ -140,5 +141,5 @@ export function register(api, ctx) {
     } catch (e) {
       res.status(400).json({ error: e?.message || String(e) });
     }
-  });
+  }));
 }

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

@@ -0,0 +1,33 @@
+// The delivery queue over HTTP — a read-only window onto what agents have left
+// waiting for Manu, and what has been crossed off.
+//
+//   GET /projects/:pid/deliveries[?status=pending|notified|held|answered]
+//   GET /deliveries                — every project's queue, newest first
+//
+// The queue is WRITTEN by the routine runner (core/stores/deliveries.js); this
+// only surfaces it, so a panel can show it piling up and being resolved.
+import { listDeliveries } from "#core/stores/deliveries.js";
+
+export function register(api, { projects, project }) {
+  api.get("/projects/:pid/deliveries", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const status = req.query.status || undefined;
+    const limit = Math.min(500, Number(req.query.limit) || 100);
+    res.json(listDeliveries(p.storagePath, { status, limit }));
+  });
+
+  api.get("/deliveries", (req, res) => {
+    const status = req.query.status || undefined;
+    const out = [];
+    for (const entry of projects.list()) {
+      const pr = projects.get(entry.id);
+      if (!pr?.storagePath) continue;
+      for (const d of listDeliveries(pr.storagePath, { status })) {
+        out.push({ ...d, project_id: d.project_id ?? entry.id, project_name: entry.name || entry.path });
+      }
+    }
+    out.sort((a, b) => String(b.created_at || b.ts || "").localeCompare(String(a.created_at || a.ts || "")));
+    res.json(out.slice(0, Math.min(1000, Number(req.query.limit) || 200)));
+  });
+}

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

@@ -19,6 +19,7 @@ import {
   autostartInstall,
   autostartUninstall,
 } from "#core/desktop/autostart.js";
+import { asyncRoute } from "./shared.js";
 import {
   isDesktopRunning,
   startDesktopDetached,
@@ -41,7 +42,7 @@ export function register(api, { plugins, config }) {
 
   // POST /desktop/start — launch the floating window (detached Electron). Same
   // helper the CLI's `apx desktop start` uses. No-op-safe if already running.
-  api.post("/desktop/start", async (_req, res) => {
+  api.post("/desktop/start", asyncRoute(async (_req, res) => {
     try {
       const r = await startDesktopDetached({ port: config?.port });
       if (!r.ok) return res.status(500).json({ ok: false, error: r.error });
@@ -49,7 +50,7 @@ export function register(api, { plugins, config }) {
     } catch (e) {
       res.status(500).json({ ok: false, error: e.message });
     }
-  });
+  }));
 
   // POST /desktop/stop — terminate the running window (SIGTERM). `stopped` is
   // false when nothing was running.
@@ -76,7 +77,7 @@ export function register(api, { plugins, config }) {
       .catch((e) => res.status(500).json({ ok: false, error: e.message }));
   });
 
-  api.post("/desktop/message", async (req, res) => {
+  api.post("/desktop/message", asyncRoute(async (req, res) => {
     const { text, previousMessages = [] } = req.body || {};
     if (!text) return res.status(400).json({ error: "text required" });
     // Respond immediately — the real reply goes over WebSocket.
@@ -94,7 +95,7 @@ export function register(api, { plugins, config }) {
         })
         .catch(() => {});
     }
-  });
+  }));
 
   // ── Autostart-at-login (per-user, no sudo) ──────────────────────────────
   // Reads/toggles the same launchd plist / Windows Run / .desktop entry the

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

@@ -17,24 +17,33 @@ import {
 } from "#core/memory/embed-engines/index.js";
 import { embedOne } from "#core/memory/embeddings.js";
 import { reindexMemory } from "#core/memory/index.js";
+import { asyncRoute } from "./shared.js";
 
 export function register(api) {
-  api.get("/embeddings/providers", async (_req, res) => {
+  api.get("/embeddings/providers", asyncRoute(async (_req, res) => {
     try {
       const cfg = readConfig();
       const embedCfg = embeddingsConfig(cfg);
+      // The embedder a real call lands on RIGHT NOW — not the first engine that
+      // merely has a key. This is what makes "gemini has a key but is rate-limited
+      // so we're actually on ollama" visible instead of a lie. One probe per load.
+      let active_embedder = "";
+      try {
+        active_embedder = (await embedOne("probe", { globalConfig: cfg })).embedder;
+      } catch { /* leave blank on probe failure */ }
       res.json({
         configured_provider: embedCfg.provider || "auto",
         mode: resolveMode(embedCfg),
         order: resolveChainOrder(embedCfg),
+        active_embedder,
         engines: await listAvailableEmbedEngines(cfg),
       });
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
-  });
+  }));
 
-  api.post("/embeddings/test", async (req, res) => {
+  api.post("/embeddings/test", asyncRoute(async (req, res) => {
     try {
       const { text, provider } = req.body || {};
       const sample = typeof text === "string" && text.trim()
@@ -52,14 +61,14 @@ export function register(api) {
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
-  });
+  }));
 
-  api.post("/embeddings/reindex", async (_req, res) => {
+  api.post("/embeddings/reindex", asyncRoute(async (_req, res) => {
     try {
       const result = await reindexMemory({ config: readConfig() });
       res.json({ ok: true, ...result });
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
-  });
+  }));
 }

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

@@ -1,8 +1,8 @@
 // GET  /engines            — list engine adapter ids known to core/engines.
 // GET  /engines/presets     — curated catalog (known models, defaults) per engine.
 // 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";
+// POST /engines/test        — one-shot "is this wired up?" message to one model.
+import { ENGINE_IDS, callEngine } from "#core/engines/index.js";
 import { listModels } from "#core/engines/catalog.js";
 import { ENGINE_PRESETS } from "#core/engines/presets.js";
 import { asyncRoute } from "./shared.js";
@@ -28,11 +28,62 @@ export function register(api, { config }) {
     res.json({ engine, models: out.models.sort((x, y) => x.localeCompare(y)) });
   }));
 
-  // Legacy GET (Ollama, no auth) — kept for back-compat.
-  api.get("/engines/models", asyncRoute(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 });
+  // One message in, one reply out. Deliberately NOT the agent path: no history,
+  // no tools, no skills, no memory — just enough to prove the credentials, the
+  // endpoint and the model id all work together.
+  //
+  // Substitution is caught by `served_model` (the gateway's own `model` /
+  // `modelVersion` field), not by asking the weights to name themselves.
+  // Self-identification is colour: models guess, and a distilled model will
+  // happily claim to be Claude. The prompt still asks, but tells it to say
+  // "I don't know" rather than invent an id.
+  const TEST_SYSTEM = [
+    "You are answering a one-off connection test from an admin panel.",
+    "Reply in at most two short sentences: which model you are, and what you are doing right now.",
+    "If you do not know your exact model id, say so instead of guessing.",
+    "Answer in the language of the user's message.",
+  ].join(" ");
+
+  // What the gateway says it served. OpenAI-shaped bodies use `model`; Gemini
+  // uses `modelVersion`. Missing is fine — streaming adapters leave `raw` null.
+  function servedModelOf(out) {
+    const raw = out?.raw;
+    if (!raw || typeof raw !== "object") return null;
+    for (const key of ["model", "modelVersion"]) {
+      const v = raw[key];
+      if (typeof v === "string" && v.trim()) return v.trim();
+    }
+    return null;
+  }
+
+  api.post("/engines/test", asyncRoute(async (req, res) => {
+    const b = req.body || {};
+    const provider = String(b.provider || "").trim();
+    const model = String(b.model || "").trim();
+    const message = String(b.message || "").trim();
+    if (!provider) return res.status(400).json({ error: "provider requerido" });
+    if (!model) return res.status(400).json({ error: "model requerido" });
+
+    const started = Date.now();
+    try {
+      const out = await callEngine({
+        modelId: `${provider}:${model}`,
+        system: TEST_SYSTEM,
+        messages: [{ role: "user", content: message || "¿Andás?" }],
+        config,
+        temperature: 0.3,
+        maxTokens: 300,
+      });
+      res.json({
+        provider,
+        model,
+        served_model: servedModelOf(out),
+        text: out?.text || "",
+        usage: out?.usage || null,
+        ms: Date.now() - started,
+      });
+    } catch (e) {
+      res.status(502).json({ error: e?.message || "la llamada falló", ms: Date.now() - started });
+    }
   }));
 }