@agentprojectcontext/apx 1.10.4 → 1.12.0

package/src/daemon/plugins/telegram.js

@@ -28,7 +28,8 @@
 //   }
 
 import fs from "node:fs";
-import { TELEGRAM_STATE_PATH } from "../../core/config.js";
+import path from "node:path";
+import { TELEGRAM_STATE_PATH, APX_HOME } from "../../core/config.js";
 import { callEngine } from "../engines/index.js";
 import { runSuperAgent, isSuperAgentEnabled } from "../super-agent.js";
 import { stripThinking } from "../thinking.js";
@@ -39,6 +40,119 @@ import { buildAgentSystem } from "../../core/agent-system.js";
 const API_BASE = "https://api.telegram.org";
 const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
+// ---------- media sending helpers -------------------------------------------
+
+/**
+ * Send a photo to a Telegram chat.
+ * @param {string} token     Bot token
+ * @param {string|number} chatId  Telegram chat_id
+ * @param {string|Buffer} photo   Absolute file path OR Buffer of image data
+ * @param {object} [opts]
+ * @param {string} [opts.caption]
+ * @param {string} [opts.parse_mode]  "HTML" | "Markdown" | "MarkdownV2"
+ */
+export async function sendPhoto(token, chatId, photo, { caption, parse_mode } = {}) {
+  const url = `${API_BASE}/bot${token}/sendPhoto`;
+  const form = new FormData();
+  form.append("chat_id", String(chatId));
+  if (caption) form.append("caption", caption);
+  if (parse_mode) form.append("parse_mode", parse_mode);
+
+  if (typeof photo === "string" && photo.startsWith("http")) {
+    // Public URL — send as string
+    form.append("photo", photo);
+  } else {
+    // Local file path or Buffer
+    const buf = Buffer.isBuffer(photo) ? photo : fs.readFileSync(photo);
+    const name = typeof photo === "string" ? path.basename(photo) : "photo.jpg";
+    const blob = new Blob([buf], { type: name.endsWith(".png") ? "image/png" : "image/jpeg" });
+    form.append("photo", blob, name);
+  }
+
+  const res = await fetch(url, { method: "POST", body: form });
+  const json = await res.json();
+  if (!json.ok) throw new Error(`sendPhoto failed: ${json.description || res.status}`);
+  return json.result;
+}
+
+/**
+ * Send a voice message (OGG/Opus preferred by Telegram).
+ * @param {string} token
+ * @param {string|number} chatId
+ * @param {string|Buffer} audio  Path or Buffer
+ * @param {object} [opts]
+ * @param {string} [opts.caption]
+ * @param {number} [opts.duration]
+ */
+export async function sendVoice(token, chatId, audio, { caption, duration } = {}) {
+  const url = `${API_BASE}/bot${token}/sendVoice`;
+  const form = new FormData();
+  form.append("chat_id", String(chatId));
+  if (caption) form.append("caption", caption);
+  if (duration) form.append("duration", String(duration));
+
+  const buf = Buffer.isBuffer(audio) ? audio : fs.readFileSync(audio);
+  const name = typeof audio === "string" ? path.basename(audio) : "voice.ogg";
+  const blob = new Blob([buf], { type: "audio/ogg" });
+  form.append("voice", blob, name);
+
+  const res = await fetch(url, { method: "POST", body: form });
+  const json = await res.json();
+  if (!json.ok) throw new Error(`sendVoice failed: ${json.description || res.status}`);
+  return json.result;
+}
+
+/**
+ * Send an audio file (MP3, M4A, etc — shown in Telegram music player).
+ * @param {string} token
+ * @param {string|number} chatId
+ * @param {string|Buffer} audio  Path or Buffer
+ * @param {object} [opts]
+ * @param {string} [opts.caption]
+ * @param {string} [opts.title]
+ * @param {string} [opts.performer]
+ */
+export async function sendAudio(token, chatId, audio, { caption, title, performer } = {}) {
+  const url = `${API_BASE}/bot${token}/sendAudio`;
+  const form = new FormData();
+  form.append("chat_id", String(chatId));
+  if (caption) form.append("caption", caption);
+  if (title) form.append("title", title);
+  if (performer) form.append("performer", performer);
+
+  const buf = Buffer.isBuffer(audio) ? audio : fs.readFileSync(audio);
+  const name = typeof audio === "string" ? path.basename(audio) : "audio.mp3";
+  const blob = new Blob([buf], { type: "audio/mpeg" });
+  form.append("audio", blob, name);
+
+  const res = await fetch(url, { method: "POST", body: form });
+  const json = await res.json();
+  if (!json.ok) throw new Error(`sendAudio failed: ${json.description || res.status}`);
+  return json.result;
+}
+
+/**
+ * Download a file from Telegram servers.
+ * Returns the local file path where it was saved.
+ */
+async function downloadTelegramFile(token, fileId, destDir) {
+  // Step 1: get file path from Telegram
+  const infoRes = await fetch(`${API_BASE}/bot${token}/getFile?file_id=${fileId}`);
+  const infoJson = await infoRes.json();
+  if (!infoJson.ok) throw new Error(`getFile failed: ${infoJson.description}`);
+  const filePath = infoJson.result.file_path; // e.g. "photos/file_123.jpg"
+  const ext = path.extname(filePath) || ".jpg";
+  const fileName = `tg_${fileId.slice(-8)}_${Date.now()}${ext}`;
+  const localPath = path.join(destDir, fileName);
+
+  // Step 2: download
+  const dlRes = await fetch(`${API_BASE}/file/bot${token}/${filePath}`);
+  if (!dlRes.ok) throw new Error(`download failed: ${dlRes.status}`);
+  const buf = Buffer.from(await dlRes.arrayBuffer());
+  fs.writeFileSync(localPath, buf);
+  return localPath;
+}
+
 // ---------- shared state ----------------------------------------------------
 
 function loadState() {
@@ -237,7 +351,43 @@ class ChannelPoller {
         ? "@" + msg.from.username
         : `${msg.from?.first_name || ""} ${msg.from?.last_name || ""}`.trim() || "unknown";
     const chat_id = msg.chat?.id;
-    const text = msg.text || "";
+    const text = msg.text || msg.caption || "";
+
+    // ── Incoming photo handling ───────────────────────────────────────────
+    if (msg.photo && msg.photo.length > 0) {
+      // Telegram sends multiple sizes; pick the largest
+      const bestPhoto = msg.photo.reduce((a, b) => (b.file_size > a.file_size ? b : a));
+      const token = resolveBotToken(this.channel);
+      const mediaDir = path.join(APX_HOME, "media");
+      fs.mkdirSync(mediaDir, { recursive: true });
+      try {
+        const localPath = await downloadTelegramFile(token, bestPhoto.file_id, mediaDir);
+        this.log(`telegram[${this.channel.name}] photo saved: ${localPath}`);
+        appendGlobalMessage({
+          channel: "telegram",
+          direction: "in",
+          type: "photo",
+          actor_id: msg.from?.id ? String(msg.from.id) : author,
+          external_id: String(u.update_id),
+          author,
+          body: text || "[photo]",
+          meta: {
+            chat_id,
+            user_id: msg.from?.id || null,
+            message_id: msg.message_id,
+            tg_channel: this.channel.name,
+            local_path: localPath,
+            file_id: bestPhoto.file_id,
+            width: bestPhoto.width,
+            height: bestPhoto.height,
+          },
+        });
+      } catch (e) {
+        this.log(`telegram[${this.channel.name}] photo download failed: ${e.message}`);
+      }
+      // If there's a caption, continue to handle it as text; otherwise return
+      if (!text) return;
+    }
 
     // /reset or /new wipes the rolling context for this chat. We just
     // remember a marker timestamp; subsequent inbounds will only consider
@@ -488,6 +638,31 @@ class ChannelPoller {
     if (!json.ok) throw new Error(json.description || `send failed (${res.status})`);
     return json.result;
   }
+
+  /** Send a photo via this channel */
+  async _sendPhoto({ chat_id, photo, caption, parse_mode }) {
+    const token = resolveBotToken(this.channel);
+    if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
+    const target = chat_id || resolveChatId(this.channel);
+    if (!target) throw new Error(`channel ${this.channel.name}: no chat_id`);
+    return sendPhoto(token, target, photo, { caption, parse_mode });
+  }
+
+  /** Send a voice message via this channel */
+  async _sendVoice({ chat_id, audio, caption, duration }) {
+    const token = resolveBotToken(this.channel);
+    if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
+    const target = chat_id || resolveChatId(this.channel);
+    return sendVoice(token, target, audio, { caption, duration });
+  }
+
+  /** Send an audio file via this channel */
+  async _sendAudio({ chat_id, audio, caption, title, performer }) {
+    const token = resolveBotToken(this.channel);
+    if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
+    const target = chat_id || resolveChatId(this.channel);
+    return sendAudio(token, target, audio, { caption, title, performer });
+  }
 }
 
 function sleep(ms) {
@@ -557,6 +732,77 @@ export default {
         });
         return result;
       },
+
+      /**
+       * Send a photo to a Telegram chat.
+       * photo: local file path, Buffer, or public URL
+       * opts: { caption, parse_mode, channel, author }
+       */
+      async sendPhoto({ channel: channelName, chat_id, photo, caption, parse_mode, author = "apx" }) {
+        const p =
+          (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
+          pollers.find((pp) => resolveBotToken(pp.channel)) ||
+          null;
+        if (!p) throw new Error("no telegram channel available");
+        const result = await p._sendPhoto({ chat_id, photo, caption, parse_mode });
+        appendGlobalMessage({
+          channel: "telegram",
+          direction: "out",
+          type: "photo",
+          actor_id: author,
+          author,
+          body: caption || "[photo]",
+          meta: { chat_id: chat_id || resolveChatId(p.channel), tg_channel: p.channel.name },
+        });
+        return result;
+      },
+
+      /**
+       * Send a voice message (OGG/Opus preferred).
+       * audio: local file path or Buffer
+       */
+      async sendVoice({ channel: channelName, chat_id, audio, caption, duration, author = "apx" }) {
+        const p =
+          (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
+          pollers.find((pp) => resolveBotToken(pp.channel)) ||
+          null;
+        if (!p) throw new Error("no telegram channel available");
+        const result = await p._sendVoice({ chat_id, audio, caption, duration });
+        appendGlobalMessage({
+          channel: "telegram",
+          direction: "out",
+          type: "voice",
+          actor_id: author,
+          author,
+          body: caption || "[voice]",
+          meta: { chat_id: chat_id || resolveChatId(p.channel), tg_channel: p.channel.name },
+        });
+        return result;
+      },
+
+      /**
+       * Send an audio file (MP3/M4A — shown in music player).
+       * audio: local file path or Buffer
+       */
+      async sendAudio({ channel: channelName, chat_id, audio, caption, title, performer, author = "apx" }) {
+        const p =
+          (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
+          pollers.find((pp) => resolveBotToken(pp.channel)) ||
+          null;
+        if (!p) throw new Error("no telegram channel available");
+        const result = await p._sendAudio({ chat_id, audio, caption, title, performer });
+        appendGlobalMessage({
+          channel: "telegram",
+          direction: "out",
+          type: "audio",
+          actor_id: author,
+          author,
+          body: caption || title || "[audio]",
+          meta: { chat_id: chat_id || resolveChatId(p.channel), tg_channel: p.channel.name },
+        });
+        return result;
+      },
+
       pollers,
     };
   },

package/src/daemon/super-agent-tools/index.js

@@ -20,8 +20,9 @@ import setIdentity from "./tools/set-identity.js";
 import setPermissionMode from "./tools/set-permission-mode.js";
 import searchFiles from "./tools/search-files.js";
 import { createPermissionGuard } from "./helpers.js";
+import { buildBridgedTools, DEFAULT_CATEGORIES } from "./registry-bridge.js";
 
-const TOOLS = [
+const NATIVE_TOOLS = [
   listProjects,
   listAgents,
   listVaultAgents,
@@ -45,6 +46,18 @@ const TOOLS = [
   searchFiles,
 ];
 
+// Registry-backed bridges. Categories can be overridden per-process via env
+// APX_BRIDGE_CATEGORIES (comma-separated), e.g. "browser,fetch,search".
+// Default: browser, fetch, search, glob, grep (see registry-bridge.js).
+function resolveBridgeCategories() {
+  const env = (process.env.APX_BRIDGE_CATEGORIES || "").trim();
+  if (!env) return DEFAULT_CATEGORIES;
+  return new Set(env.split(",").map(s => s.trim()).filter(Boolean));
+}
+
+const BRIDGED_TOOLS = buildBridgedTools({ categories: resolveBridgeCategories() });
+const TOOLS = [...NATIVE_TOOLS, ...BRIDGED_TOOLS];
+
 export const TOOL_SCHEMAS = TOOLS.map((tool) => tool.schema);
 
 export function makeToolHandlers(ctx) {
@@ -56,3 +69,8 @@ export function makeToolHandlers(ctx) {
   };
   return Object.fromEntries(TOOLS.map((tool) => [tool.name, tool.makeHandler(toolCtx)]));
 }
+
+// Diagnostic helper — useful for `apx daemon status` or debug logging.
+export function listBridgedToolNames() {
+  return BRIDGED_TOOLS.map(t => t.name);
+}

package/src/daemon/super-agent-tools/registry-bridge.js

@@ -0,0 +1,122 @@
+// daemon/super-agent-tools/registry-bridge.js
+//
+// Generic bridge that exposes registry-backed HTTP tools (browser, fetch,
+// search, glob, grep, etc.) to the super-agent — no per-tool import boilerplate.
+//
+// How it works:
+//   1. Read TOOL_DEFINITIONS from daemon/tools/registry.js
+//   2. Drop entries whose names collide with native super-agent tools (those
+//      win — they touch in-process state directly).
+//   3. For each remaining entry, produce { name, schema, makeHandler } in the
+//      exact shape index.js expects, so they slot into TOOL_SCHEMAS alongside
+//      the native ones.
+//   4. The generated handler POSTs/GETs to the daemon's own HTTP server on
+//      127.0.0.1:<port>. Yes, the super-agent talks to its own daemon — that
+//      keeps the bridge dead-simple, lets the engine adapter format tool
+//      schemas uniformly, and reuses the exact code path external callers hit.
+//
+// Net result: adding a tool = adding one entry to registry.js. No file in
+// super-agent-tools/tools/, no import in index.js.
+
+import { TOOL_DEFINITIONS } from "../tools/registry.js";
+
+// Native handlers in super-agent-tools/tools/ that own these names. The bridge
+// MUST skip them or the registry version (HTTP roundtrip) would shadow the
+// native one with possibly different semantics.
+const NATIVE_NAMES = new Set([
+  "list_projects", "list_agents", "list_vault_agents", "import_agent",
+  "add_project", "list_mcps", "read_agent_memory",
+  "list_files", "read_file", "write_file", "edit_file", "search_files",
+  "run_shell", "tail_messages", "search_messages",
+  "call_agent", "call_mcp", "call_runtime",
+  "send_telegram", "set_identity", "set_permission_mode",
+]);
+
+// Default allow-list of categories the bridge will expose. The NATIVE_NAMES
+// filter handles duplicates inside these categories (e.g. "file" contains
+// both read_file [native] and glob [bridged]). Anything outside is ignored
+// — "shell"/"mcp"/"memory"/"session" have different semantics handled
+// natively. Override with env APX_BRIDGE_CATEGORIES.
+const DEFAULT_CATEGORIES = new Set(["browser", "fetch", "search", "file"]);
+
+function buildSchema(entry) {
+  return {
+    type: "function",
+    function: {
+      name: entry.name,
+      description: entry.description,
+      parameters: entry.parameters || { type: "object", properties: {} },
+    },
+  };
+}
+
+function buildHandler(entry) {
+  return ({ globalConfig }) => async (args = {}) => {
+    const port = globalConfig?.port || process.env.APX_PORT || 7430;
+    const method = String(entry.endpoint?.method || "POST").toUpperCase();
+    let url = `http://127.0.0.1:${port}${entry.endpoint?.path || ""}`;
+
+    const opts = {
+      method,
+      headers: { "content-type": "application/json" },
+    };
+
+    if (method === "GET" || method === "HEAD") {
+      const qs = new URLSearchParams();
+      for (const [k, v] of Object.entries(args)) {
+        if (v === undefined || v === null) continue;
+        qs.set(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+      }
+      const q = qs.toString();
+      if (q) url += (url.includes("?") ? "&" : "?") + q;
+    } else {
+      opts.body = JSON.stringify(args);
+    }
+
+    let res, text;
+    try {
+      res = await fetch(url, opts);
+      text = await res.text();
+    } catch (e) {
+      return { error: `bridge fetch failed: ${e.message}`, url };
+    }
+
+    let parsed;
+    try { parsed = JSON.parse(text); }
+    catch { parsed = { raw: text }; }
+
+    if (!res.ok) {
+      return {
+        error: parsed?.error || `HTTP ${res.status}`,
+        status: res.status,
+        ...(typeof parsed === "object" ? parsed : {}),
+      };
+    }
+    return parsed;
+  };
+}
+
+/**
+ * Returns an array of tool objects in the shape super-agent-tools/index.js
+ * expects: { name, schema, makeHandler }.
+ *
+ * @param {object} opts
+ * @param {Set<string>=} opts.categories   override DEFAULT_CATEGORIES
+ * @param {Set<string>=} opts.skipNames    extra names to skip in addition to NATIVE_NAMES
+ */
+export function buildBridgedTools(opts = {}) {
+  const categories = opts.categories instanceof Set ? opts.categories : DEFAULT_CATEGORIES;
+  const skipNames = opts.skipNames instanceof Set ? opts.skipNames : new Set();
+
+  return TOOL_DEFINITIONS
+    .filter(e => categories.has(e.category))
+    .filter(e => !NATIVE_NAMES.has(e.name) && !skipNames.has(e.name))
+    .filter(e => e.endpoint?.path)
+    .map(entry => ({
+      name: entry.name,
+      schema: buildSchema(entry),
+      makeHandler: buildHandler(entry),
+    }));
+}
+
+export { NATIVE_NAMES, DEFAULT_CATEGORIES };

package/src/daemon/super-agent.js

@@ -60,7 +60,9 @@ HARD RULES (do not deviate):
 14. VAULT RULE: When the user wants a new existing agent/template, call list_vault_agents first. If a suitable vault agent exists, import_agent into the chosen project. If none fits, say briefly what is missing.
 15. NO-PENDING RULE: never say "give me a second", "I will do it", or "I will try later" as a final answer. Either call the tool in this same turn or say what blocks you.
 16. IDENTITY RULE: when the user asks you to change your name, call yourself something, or update your personality/language, call set_identity and persist the change. Then confirm with your new name.
-17. ROUTINES RULE: NEVER create a routine in the default project (id=0). Routines MUST be tied to a specific registered project. Before adding a routine, call list_projects to find the correct project id or name. Then pass --project <id|name> to apx routine add. If no project fits, ask the user which project to use. Creating routines in project 0/default mixes unrelated projects' schedules and corrupts state.`;
+17. ROUTINES RULE: NEVER create a routine in the default project (id=0). Routines MUST be tied to a specific registered project. Before adding a routine, call list_projects to find the correct project id or name. Then pass --project <id|name> to apx routine add. If no project fits, ask the user which project to use. Creating routines in project 0/default mixes unrelated projects' schedules and corrupts state.
+18. **NO EMPTY RESPONSES**: Never respond with only text when you have tools available and the user is asking you to DO something. Call the tool FIRST, then explain. Never say "I'll do X" without immediately calling the tool. Empty acknowledgments ("ok", "entendido", "dame un minuto", "voy", "checking", "stand by") without a tool call are invalid responses — they will be re-prompted and waste a turn.
+19. **CWD RULE**: When the channel context includes a "CWD: <path>" line, that is the user's current working directory. References to "este directorio", "este proyecto", "esta carpeta", "acá", "aquí", "this directory", "this project", "current dir/folder" all mean that exact CWD path. Use it as the path argument directly — DO NOT ask the user "what's the path?" when CWD is already given. Example: if user says "agregá este proyecto a la lista", call add_project({path: <CWD>}) immediately.`;
 
 function isShortConfirmation(text) {
   return /^(yes|y|si|si dale|dale|ok|okay|confirm|confirmed|go|proceed|do it)\b/i
@@ -75,6 +77,26 @@ function lastAssistantAskedForConfirmation(messages) {
   return false;
 }
 
+/**
+ * Returns true if the model response looks like a pure acknowledgment
+ * with no actual content — the classic "ghost response" anti-pattern.
+ */
+function isGhostResponse(text) {
+  const t = String(text || "").trim();
+  if (t.length > 200) return false; // long responses are probably real
+  return /^(ok|okay|got it|understood|sure|of course|on it|dale|entendido|claro|voy|ya lo hago|dame un (segundo|momento)|un momento|let me|i (will|can|shall)|i'm (going|about)|give me a|ahora lo|enseguida|checking|looking|fetching|working on|stand by|please wait|un seg|dame sec)[\s.,!]*/i
+    .test(t);
+}
+
+/**
+ * Returns true if the user's prompt looks like an instruction to act
+ * rather than just a question or statement.
+ */
+function looksLikeActionRequest(text) {
+  const t = String(text || "").trim().toLowerCase();
+  return /\b(list|show|find|get|fetch|search|run|execute|create|add|make|start|stop|delete|update|send|check|read|write|look|tell me|dame|mostra|busca|ejecuta|crea|agrega|mandá|revisá|corré|borrá|arrancá)\b/.test(t);
+}
+
 export function isSuperAgentEnabled(cfg) {
   return !!(cfg && cfg.super_agent && cfg.super_agent.enabled && cfg.super_agent.model);
 }
@@ -144,12 +166,18 @@ export async function runSuperAgent({
 
   for (let iter = 0; iter < MAX_TOOL_ITERS; iter++) {
     await emitProgress(onEvent, { type: "model_start", iteration: iter + 1 });
+    // On the first iteration, force a tool call. This prevents the model from
+    // returning a bare acknowledgment ("ok", "dame un segundo") instead of
+    // acting on an action request. On later iterations (after tool results
+    // have been fed back) tool_choice is "auto" so the model can produce its
+    // final text summary.
     const result = await callEngine({
       modelId: activeModel,
       system,
       messages: conversation,
       config: globalConfig,
       tools: TOOL_SCHEMAS,
+      toolChoice: iter === 0 ? "required" : "auto",
       maxTokens: 1024,
     });
     totalUsage.input_tokens += result.usage?.input_tokens || 0;
@@ -172,6 +200,20 @@ export async function runSuperAgent({
     }
 
     if (!toolCalls || toolCalls.length === 0) {
+      // Ghost-response detection: if the model returned a pure acknowledgment
+      // (no tool calls, no real content) on the FIRST iteration in response to
+      // what looks like an action request, inject a re-prompt.
+      if (iter === 0 && isGhostResponse(lastText) && looksLikeActionRequest(prompt)) {
+        await emitProgress(onEvent, { type: "ghost_response_detected", text: lastText });
+        conversation.push({ role: "assistant", content: lastText });
+        conversation.push({
+          role: "user",
+          content:
+            "Remember: you must execute the action, not just confirm it. " +
+            "Call the tool now — action first, report after.",
+        });
+        continue; // give the model one more chance
+      }
       // Final answer — clean up any stray fence markers just in case
       lastText = cleanTextOfPseudoToolCalls(lastText) || lastText;
       break;