@agentprojectcontext/apx 1.10.4 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentprojectcontext/apx",
-  "version": "1.10.4",
+  "version": "1.11.0",
   "description": "APX — unified CLI + daemon for the Agent Project Context (APC) standard.",
   "publishConfig": {
     "access": "public"
@@ -35,6 +35,10 @@
     "express": "^4.21.0",
     "node-fetch": "^3.3.2"
   },
+  "optionalDependencies": {
+    "fast-glob": "^3.3.2",
+    "puppeteer": "^22.0.0"
+  },
   "devDependencies": {
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",

package/src/cli/commands/search.js

@@ -0,0 +1,62 @@
+// cli/commands/search.js
+// `apx search "query"` — web search from the terminal.
+// Uses the daemon's tools/search.js module directly (no HTTP roundtrip,
+// no need to have `apx daemon start` running).
+
+import { webSearch } from "../../daemon/tools/search.js";
+
+const DIM   = "\x1b[2m";
+const BOLD  = "\x1b[1m";
+const BLUE  = "\x1b[34m";
+const CYAN  = "\x1b[36m";
+const RESET = "\x1b[0m";
+
+export async function cmdSearch(args) {
+  const query = (args._ || []).join(" ").trim();
+  if (!query) {
+    console.error("apx search: missing <query>");
+    console.error("usage: apx search \"<query>\" [--mode auto|ddg|brave|browser] [-n N]");
+    process.exit(1);
+  }
+
+  const mode  = args.flags?.mode || "auto";
+  const limit = parseInt(args.flags?.n || args.flags?.limit || "5", 10) || 5;
+  const json  = !!args.flags?.json;
+
+  process.stderr.write(`${DIM}Searching... (${mode})${RESET}\n`);
+
+  let r;
+  try {
+    r = await webSearch({ query, mode, limit });
+  } catch (e) {
+    console.error(`${DIM}error:${RESET} ${e.message}`);
+    process.exit(1);
+  }
+
+  if (json) {
+    console.log(JSON.stringify(r, null, 2));
+    return;
+  }
+
+  const results = r.results || [];
+  if (results.length === 0) {
+    console.log(`${DIM}(no results from ${r.mode})${RESET}`);
+    if (r.raw_excerpt) console.log(`${DIM}excerpt:${RESET} ${r.raw_excerpt.slice(0, 400)}…`);
+    return;
+  }
+
+  console.log(`${DIM}${results.length} result${results.length === 1 ? "" : "s"} via ${r.mode}${RESET}\n`);
+  results.forEach((item, i) => {
+    const num = `[${i + 1}]`;
+    const title = item.title || "(no title)";
+    console.log(`${BOLD}${num} ${title}${RESET}  ${DIM}— ${hostname(item.url)}${RESET}`);
+    if (item.snippet) console.log(`    ${item.snippet}`);
+    console.log(`    ${BLUE}${item.url}${RESET}`);
+    if (i < results.length - 1) console.log("");
+  });
+}
+
+function hostname(url) {
+  try { return new URL(url).hostname.replace(/^www\./, ""); }
+  catch { return url; }
+}

package/src/cli/index.js

@@ -54,6 +54,7 @@ import {
   cmdTelegramSetup,
 } from "./commands/telegram.js";
 import { cmdMessagesTail, cmdMessagesSearch, cmdMessagesChat } from "./commands/messages.js";
+import { cmdSearch } from "./commands/search.js";
 import { cmdExec } from "./commands/exec.js";
 import {
   cmdChat,
@@ -653,6 +654,21 @@ const HELP_TOPICS = new Map(Object.entries({
     options: [["--project <name|id|path>", "Pin command to a specific project."]],
     examples: ["apx messages search \"deploy\""],
   }),
+  search: topic({
+    title: "apx search",
+    summary: "Web search from the terminal (DuckDuckGo / Brave / Puppeteer fallback).",
+    usage: ["apx search \"<query>\" [--mode auto|ddg|brave|browser] [-n N] [--json]"],
+    options: [
+      ["--mode <m>", "auto (default) | ddg | brave | browser. Brave needs BRAVE_API_KEY."],
+      ["-n N",       "Number of results (default 5, max 20)."],
+      ["--json",     "Output raw JSON instead of the formatted list."],
+    ],
+    examples: [
+      "apx search \"agent project context\"",
+      "apx search \"node 22 release notes\" --mode ddg -n 10",
+      "apx search \"weather buenos aires\" --json",
+    ],
+  }),
   "messages chat": topic({
     title: "apx messages chat",
     summary: "Print APX messages as a chat transcript with user, agent, tool, or system type.",
@@ -1129,6 +1145,7 @@ function buildHelp(version) {
     hCmd("apx code",                   36, "APX terminal coding assistant"),
     hCmd("apx exec <agent> \"prompt\"",36, "one-shot agent call  --model <id>  --max-tokens N"),
     hCmd("apx chat <agent>",           36, "interactive agent REPL  --conversation <id>"),
+    hCmd("apx search \"query\"",       36, "web search (ddg | brave | browser)  --mode <m>  -n N"),
     hCmd("apx conversations list",     36, "stored exec/chat conversations for <agent>"),
     hCmd("apx conversations get",      36, "<agent> <id>"),
 
@@ -1433,6 +1450,10 @@ async function dispatch(cmd, rest) {
         await cmdExec(parseArgs(rest));
         break;
 
+      case "search":
+        await cmdSearch(parseArgs(rest));
+        break;
+
       case "chat":
         await cmdChat(parseArgs(rest));
         break;

package/src/core/agent-system.js

@@ -1,6 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
 
+// ---------------------------------------------------------------------------
+// Anti-ghost-response rules injected into every agent system prompt.
+// Prevents agents from saying "Ok, I'll do that" and then doing nothing.
+// ---------------------------------------------------------------------------
+const ACTION_DISCIPLINE_RULES = `## Action Discipline (mandatory)
+- NEVER acknowledge an action without executing it in the same turn. If you are going to do something, call the tool FIRST, then report the result.
+- NEVER use empty acknowledgments like "Ok", "Got it", "Sure", "Understood", "On it", "Give me a moment", "I'll do that now" as standalone responses when a tool call is expected. These are invalid responses.
+- Action first, report after. Produce the tool call in the same response as your acknowledgment.
+- If you cannot execute the action (missing permission, unclear params, tool not available), explain WHY — do not promise and disappear.
+- If the user asks you to do multiple things, do them all in the same turn using sequential tool calls if needed.`;
+
 function listField(value) {
   if (Array.isArray(value)) return value.map(String).map((s) => s.trim()).filter(Boolean);
   return String(value || "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -66,6 +77,10 @@ export function buildAgentSystem(project, agent, {
     if (ep) parts.push(ep);
   }
 
+  // Always append action discipline rules last so they are close to the end
+  // of the system prompt and harder for the model to "forget".
+  parts.push(ACTION_DISCIPLINE_RULES);
+
   return parts.join("\n\n");
 }
 

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,