@agentprojectcontext/apx 1.10.3 → 1.11.0

package/src/core/runtime-skills/openrouter.md

@@ -0,0 +1,54 @@
+---
+name: openrouter
+description: "Activate ONLY when the user explicitly mentions OpenRouter, OPENROUTER_API_KEY, OpenRouter models, installing OpenRouter provider config, or using OpenRouter with APX, OpenCode, LiteLLM, or an OpenAI-compatible client."
+homepage: https://openrouter.ai/docs
+---
+# OpenRouter
+
+Use this skill only for OpenRouter install/config, model listing, or usage through APX/OpenCode or
+OpenAI-compatible clients.
+
+## Verify before acting
+
+OpenRouter is an API/provider, not a local coding runtime by itself. First identify which client
+will use it: APX engine, OpenCode provider, LiteLLM, OpenAI SDK, or another OpenAI-compatible tool.
+
+Do not expose keys. Check only presence:
+
+```bash
+test -n "$OPENROUTER_API_KEY" && echo "OPENROUTER_API_KEY present"
+```
+
+## OpenAI-compatible base URL
+
+Typical API settings:
+
+```bash
+OPENAI_BASE_URL=https://openrouter.ai/api/v1
+OPENROUTER_API_KEY=...
+```
+
+Use the selected client's current docs/help before writing config.
+
+## APX guidance
+
+If configuring APX engine/provider, inspect current config schema first:
+
+```bash
+apx config --help
+apx status
+```
+
+Then update only non-secret project-safe settings. Keep API keys in user config or environment, not
+in `.apc/` or git.
+
+## OpenCode guidance
+
+If using OpenRouter via OpenCode, inspect provider commands first:
+
+```bash
+opencode providers
+opencode models
+```
+
+Then configure OpenRouter through OpenCode's current provider flow.

package/src/core/scaffold.js

@@ -87,7 +87,7 @@ function buildSkillMd(content) {
   const frontmatter = [
     "---",
     "name: apx",
-    "description: APX CLI skill. Activate when: user asks to run or coordinate agents, use MCP tools from .apc/mcps.json, install agents from a team workspace, or explicitly mentions apx commands. Do NOT activate just because .apc/ exists — that is handled by the apc-context skill. Activate on: 'apx run', 'apx exec', 'run an agent', 'coordinate agents', 'MCP not working', 'install agent', 'team agents', 'apx memory', 'daemon'.",
+    "description: \"APX CLI skill. Activate when: user asks to run or coordinate agents, use MCP tools from .apc/mcps.json, install agents from a team workspace, or explicitly mentions apx commands. Do NOT activate just because .apc/ exists — that is handled by the apc-context skill. Activate on: 'apx run', 'apx exec', 'run an agent', 'coordinate agents', 'MCP not working', 'install agent', 'team agents', 'apx memory', 'daemon'.\"",
     "homepage: https://github.com/agentprojectcontext/apx",
     "---",
     "",
@@ -95,6 +95,19 @@ function buildSkillMd(content) {
   return frontmatter + content;
 }
 
+function readRuntimeSkillFiles() {
+  const skillsDir = path.join(__dirname, "runtime-skills");
+  if (!fs.existsSync(skillsDir)) return [];
+
+  return fs.readdirSync(skillsDir)
+    .filter((name) => name.endsWith(".md"))
+    .sort()
+    .map((name) => ({
+      slug: path.basename(name, ".md"),
+      md: fs.readFileSync(path.join(skillsDir, name), "utf8").trim(),
+    }));
+}
+
 // Install APX + APC context skills into IDE rule files. Returns an array of result objects.
 // targetIds: array of target ids to install; null = all project targets.
 export function installIdeSkills(root, targetIds = null) {
@@ -159,6 +172,7 @@ export function installGlobalSkills() {
     skills.push({ slug: "apx", md: buildSkillMd(fs.readFileSync(apxSrc, "utf8").trim()) });
   if (fs.existsSync(apcSrc))
     skills.push({ slug: "apc-context", md: buildApcContextSkillMd(fs.readFileSync(apcSrc, "utf8").trim()) });
+  skills.push(...readRuntimeSkillFiles());
 
   for (const base of GLOBAL_SKILL_DIRS) {
     for (const { slug, md } of skills) {

package/src/daemon/api.js

@@ -3,6 +3,12 @@ import fs from "node:fs";
 import path from "node:path";
 import { execFile } from "node:child_process";
 import express from "express";
+import { buildBrowserRouter } from "./tools/browser.js";
+import { buildFetchRouter } from "./tools/fetch.js";
+import { buildSearchRouter } from "./tools/search.js";
+import { buildRegistryRouter } from "./tools/registry.js";
+import { buildGlobRouter } from "./tools/glob.js";
+import { buildGrepRouter } from "./tools/grep.js";
 import { readApfMcps, writeApfMcps, SOURCES } from "./mcp-sources.js";
 import { callEngine, ENGINE_IDS } from "./engines/index.js";
 import { getRuntime, RUNTIME_IDS } from "./runtimes/index.js";
@@ -58,6 +64,18 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
   const app = express();
   app.use(express.json({ limit: "2mb" }));
 
+  // ---- Tool routers (fetch / browser / search / glob / grep / registry) ----
+  // fetch  = native HTTP, no Chromium  → fast, cheap, default for REST/HTML
+  // browser = Puppeteer-backed         → heavy, lazy-launched, for JS-rendered pages
+  app.use("/tools/fetch",   buildFetchRouter(express));
+  app.use("/tools/browser", buildBrowserRouter(express));
+  app.use("/tools/search",  buildSearchRouter(express));
+  app.use("/tools/glob",    buildGlobRouter(express));
+  app.use("/tools/grep",    buildGrepRouter(express));
+  // Registry MUST be mounted after specific routers so /:name wildcard
+  // doesn't shadow /tools/browser, /tools/fetch, /tools/search, etc.
+  app.use("/tools", buildRegistryRouter(express, { projects, registries }));
+
   // ---- Health -------------------------------------------------------
   app.get("/health", (_req, res) => {
     res.json({
@@ -399,6 +417,60 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
     }
   });
 
+  // POST /telegram/send_photo  { chat_id?, photo (path|url), caption?, channel? }
+  app.post("/telegram/send_photo", async (req, res) => {
+    const { chat_id, photo, caption, parse_mode, channel } = req.body || {};
+    if (!photo) return res.status(400).json({ error: "photo required (path or url)" });
+    if (!telegram) return res.status(503).json({ error: "telegram plugin not loaded" });
+    try {
+      const r = await telegram.sendPhoto({ chat_id, photo, caption, parse_mode, channel });
+      res.status(202).json({ ok: true, message_id: r?.message_id });
+    } catch (e) {
+      res.status(502).json({ error: e.message });
+    }
+  });
+
+  // POST /telegram/send_voice  { chat_id?, audio (path), caption?, duration?, channel? }
+  app.post("/telegram/send_voice", async (req, res) => {
+    const { chat_id, audio, caption, duration, channel } = req.body || {};
+    if (!audio) return res.status(400).json({ error: "audio required (path)" });
+    if (!telegram) return res.status(503).json({ error: "telegram plugin not loaded" });
+    try {
+      const r = await telegram.sendVoice({ chat_id, audio, caption, duration, channel });
+      res.status(202).json({ ok: true, message_id: r?.message_id });
+    } catch (e) {
+      res.status(502).json({ error: e.message });
+    }
+  });
+
+  // POST /telegram/send_audio  { chat_id?, audio (path), caption?, title?, performer?, channel? }
+  app.post("/telegram/send_audio", async (req, res) => {
+    const { chat_id, audio, caption, title, performer, channel } = req.body || {};
+    if (!audio) return res.status(400).json({ error: "audio required (path)" });
+    if (!telegram) return res.status(503).json({ error: "telegram plugin not loaded" });
+    try {
+      const r = await telegram.sendAudio({ chat_id, audio, caption, title, performer, channel });
+      res.status(202).json({ ok: true, message_id: r?.message_id });
+    } catch (e) {
+      res.status(502).json({ error: e.message });
+    }
+  });
+
+  // POST /telegram/notify  — alias for /telegram/send for proactive daemon notifications
+  // Any internal daemon code (routines, error handlers, MCP failure hooks) can POST here
+  // to push a message to the user without waiting for a user-initiated request.
+  app.post("/telegram/notify", async (req, res) => {
+    const { chat_id, text, channel } = req.body || {};
+    if (!text) return res.status(400).json({ error: "text required" });
+    if (!telegram) return res.status(503).json({ error: "telegram plugin not loaded" });
+    try {
+      const r = await telegram.send({ chat_id, text, channel });
+      res.status(202).json({ ok: true, message_id: r.message_id, via: "notify" });
+    } catch (e) {
+      res.status(502).json({ error: e.message });
+    }
+  });
+
   // ---- Plugins -----------------------------------------------------
   app.get("/plugins", (_req, res) => {
     if (!plugins) return res.json({});
@@ -1174,6 +1246,163 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
     }
   });
 
+  // ---- Session search (cross-agent, cross-conversation) ------------
+  // GET /sessions/search?q=...&project=...&limit=20
+  // Searches session files (.apc/agents/{slug}/sessions/*.md) and
+  // conversation files (~/.apx/.../conversations/*.md) by text content.
+  app.get("/sessions/search", (req, res) => {
+    const { q, project: projectRef, limit = "20" } = req.query;
+    if (!q) return res.status(400).json({ error: "q required" });
+    const lim = Math.min(parseInt(limit, 10) || 20, 200);
+    const needle = q.toLowerCase();
+
+    // Resolve project (or search all)
+    const allProjects = projects.list();
+    const targetProjects = (() => {
+      if (projectRef != null) {
+        const ref = String(projectRef);
+        const found = allProjects.find((p) => String(p.id) === ref || p.path === path.resolve(ref));
+        return found ? [projects.get(found.id)] : [];
+      }
+      return allProjects.map((p) => projects.get(p.id)).filter(Boolean);
+    })();
+
+    const matches = [];
+
+    for (const p of targetProjects) {
+      if (!p) continue;
+
+      // 1. Search session files in project (.apc/agents/{slug}/sessions/)
+      const sessionAgentsDir = path.join(p.path, ".apc", "agents");
+      if (fs.existsSync(sessionAgentsDir)) {
+        for (const slug of fs.readdirSync(sessionAgentsDir)) {
+          const sessionsDir = path.join(sessionAgentsDir, slug, "sessions");
+          if (!fs.existsSync(sessionsDir)) continue;
+          for (const f of fs.readdirSync(sessionsDir).filter((x) => x.endsWith(".md"))) {
+            const filePath = path.join(sessionsDir, f);
+            try {
+              const text = fs.readFileSync(filePath, "utf8");
+              if (text.toLowerCase().includes(needle)) {
+                // Find matching excerpt
+                const lines = text.split("\n");
+                const matchLine = lines.findIndex((l) => l.toLowerCase().includes(needle));
+                const excerpt = lines.slice(Math.max(0, matchLine - 1), matchLine + 3).join("\n");
+                matches.push({
+                  type: "session",
+                  project: p.id,
+                  agent: slug,
+                  filename: f,
+                  path: filePath,
+                  excerpt: excerpt.slice(0, 300),
+                });
+                if (matches.length >= lim) break;
+              }
+            } catch {}
+          }
+          if (matches.length >= lim) break;
+        }
+      }
+
+      if (matches.length >= lim) break;
+
+      // 2. Search conversation files in daemon storage (~/.apx/.../conversations/)
+      const convAgentsDir = path.join(p.storagePath, "agents");
+      if (fs.existsSync(convAgentsDir)) {
+        for (const slug of fs.readdirSync(convAgentsDir)) {
+          const convDir = path.join(convAgentsDir, slug, "conversations");
+          if (!fs.existsSync(convDir)) continue;
+          for (const f of fs.readdirSync(convDir).filter((x) => x.endsWith(".md"))) {
+            const filePath = path.join(convDir, f);
+            try {
+              const text = fs.readFileSync(filePath, "utf8");
+              if (text.toLowerCase().includes(needle)) {
+                const lines = text.split("\n");
+                const matchLine = lines.findIndex((l) => l.toLowerCase().includes(needle));
+                const excerpt = lines.slice(Math.max(0, matchLine - 1), matchLine + 3).join("\n");
+                matches.push({
+                  type: "conversation",
+                  project: p.id,
+                  agent: slug,
+                  filename: f,
+                  path: filePath,
+                  excerpt: excerpt.slice(0, 300),
+                });
+                if (matches.length >= lim) break;
+              }
+            } catch {}
+          }
+          if (matches.length >= lim) break;
+        }
+      }
+
+      if (matches.length >= lim) break;
+    }
+
+    res.json({ q, count: matches.length, results: matches });
+  });
+
+  // POST /sessions/:id/compact
+  // Shortcut: resolves which project/agent owns the session file,
+  // then delegates to the existing compactConversation logic.
+  // Body: { project?, model? }
+  app.post("/sessions/:id/compact", async (req, res) => {
+    const { id } = req.params;
+    const { model: modelOverride, project: projectRef } = req.body || {};
+
+    // Find which project/agent owns this session ID
+    const allProjects = projectRef != null
+      ? (() => {
+          const ref = String(projectRef);
+          const found = projects.list().find((p) => String(p.id) === ref || p.path === path.resolve(ref));
+          return found ? [projects.get(found.id)] : [];
+        })()
+      : projects.list().map((p) => projects.get(p.id)).filter(Boolean);
+
+    let found = null;
+    const filename = id.endsWith(".md") ? id : `${id}.md`;
+
+    for (const p of allProjects) {
+      if (!p) continue;
+      // Search in daemon conversation storage
+      const agentsDir = path.join(p.storagePath, "agents");
+      if (fs.existsSync(agentsDir)) {
+        for (const slug of fs.readdirSync(agentsDir)) {
+          const f = path.join(agentsDir, slug, "conversations", filename);
+          if (fs.existsSync(f)) {
+            found = { p, slug };
+            break;
+          }
+        }
+      }
+      if (found) break;
+    }
+
+    if (!found) {
+      return res.status(404).json({ error: `session/conversation "${id}" not found` });
+    }
+
+    const { p, slug } = found;
+    const { readAgents: _readAgents } = await import("../core/parser.js");
+    const agents = _readAgents(p.path);
+    const agent = agents.find((a) => a.slug === slug);
+    const modelId = modelOverride || agent?.fields?.Model;
+    if (!modelId) return res.status(400).json({ error: "agent has no model; pass model in body" });
+
+    try {
+      const { compactConversation } = await import("./compact.js");
+      const result = await compactConversation({
+        storagePath: p.storagePath,
+        agentSlug: slug,
+        filename,
+        modelId,
+        config: p.config || config,
+      });
+      res.json(result);
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
   // ---- Admin --------------------------------------------------------
   app.post("/admin/shutdown", (_req, res) => {
     res.json({ ok: true });

package/src/daemon/engines/anthropic.js

@@ -11,7 +11,7 @@ function getKey(config) {
 export default {
   id: "anthropic",
 
-  async chat({ system, messages, model, temperature = 1.0, maxTokens = 1024, config = {} }) {
+  async chat({ system, messages, model, temperature = 1.0, maxTokens = 1024, config = {}, tools, toolChoice }) {
     const key = getKey(config);
     if (!key) throw new Error("anthropic: no api_key (set ANTHROPIC_API_KEY or engines.anthropic.api_key)");
     if (!model) throw new Error("anthropic: model required");
@@ -27,6 +27,18 @@ export default {
     };
     if (system) body.system = system;
 
+    // Tool use support — pass tools array and optional tool_choice.
+    // toolChoice="required" → { type: "any" } forces at least one tool call per turn,
+    // preventing the model from giving an empty acknowledgment instead of acting.
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      if (toolChoice === "required" || toolChoice === "any") {
+        body.tool_choice = { type: "any" };
+      } else if (toolChoice && typeof toolChoice === "object") {
+        body.tool_choice = toolChoice;
+      }
+    }
+
     const res = await fetch(API_BASE, {
       method: "POST",
       headers: {
@@ -42,12 +54,18 @@ export default {
         `anthropic ${res.status}: ${json?.error?.message || JSON.stringify(json)}`
       );
     }
+
+    // Extract text blocks; also capture tool_use blocks for callers that need them
     const text = (json.content || [])
       .filter((b) => b.type === "text")
       .map((b) => b.text)
       .join("");
+    const toolUses = (json.content || []).filter((b) => b.type === "tool_use");
+
     return {
       text,
+      tool_uses: toolUses.length > 0 ? toolUses : undefined,
+      stop_reason: json.stop_reason,
       usage: {
         input_tokens: json.usage?.input_tokens || 0,
         output_tokens: json.usage?.output_tokens || 0,

package/src/daemon/engines/index.js

@@ -46,7 +46,7 @@ export function getAdapter(provider) {
   return a;
 }
 
-export async function callEngine({ modelId, system, messages, config, temperature, maxTokens, tools }) {
+export async function callEngine({ modelId, system, messages, config, temperature, maxTokens, tools, toolChoice }) {
   const { provider, model } = resolveProvider(modelId);
   const adapter = getAdapter(provider);
   const providerCfg =
@@ -58,6 +58,7 @@ export async function callEngine({ modelId, system, messages, config, temperatur
     temperature,
     maxTokens,
     tools,
+    toolChoice,
     config: providerCfg,
   });
 }

package/src/daemon/engines/openai.js

@@ -10,7 +10,7 @@ function getKey(config) {
 export default {
   id: "openai",
 
-  async chat({ system, messages, model, temperature = 1.0, maxTokens = 1024, config = {} }) {
+  async chat({ system, messages, model, temperature = 1.0, maxTokens = 1024, config = {}, tools, toolChoice }) {
     const key = getKey(config);
     if (!key) throw new Error("openai: no api_key (set OPENAI_API_KEY or engines.openai.api_key)");
     if (!model) throw new Error("openai: model required");
@@ -31,6 +31,20 @@ export default {
       max_tokens: maxTokens,
     };
 
+    // Tool use support
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      // toolChoice="required" forces the model to call at least one tool,
+      // preventing empty acknowledgment responses.
+      if (toolChoice === "required") {
+        body.tool_choice = "required";
+      } else if (toolChoice === "any") {
+        body.tool_choice = "required"; // OpenAI uses "required" for "any"
+      } else if (toolChoice && typeof toolChoice === "object") {
+        body.tool_choice = toolChoice;
+      }
+    }
+
     const res = await fetch(API_BASE, {
       method: "POST",
       headers: {
@@ -45,9 +59,15 @@ export default {
         `openai ${res.status}: ${json?.error?.message || JSON.stringify(json)}`
       );
     }
-    const text = json.choices?.[0]?.message?.content || "";
+
+    const choice = json.choices?.[0];
+    const text = choice?.message?.content || "";
+    const toolCalls = choice?.message?.tool_calls;
+
     return {
       text,
+      tool_calls: toolCalls?.length > 0 ? toolCalls : undefined,
+      finish_reason: choice?.finish_reason,
       usage: {
         input_tokens: json.usage?.prompt_tokens || 0,
         output_tokens: json.usage?.completion_tokens || 0,