@agentprojectcontext/apx 1.19.1 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentprojectcontext/apx",
-  "version": "1.19.1",
+  "version": "1.20.0",
   "description": "APX — unified CLI + daemon for the Agent Project Context (APC) standard.",
   "publishConfig": {
     "access": "public"

package/src/core/messages-store.js

@@ -403,6 +403,11 @@ export function getRecentTelegramTurnsFromFs({
   all.sort((a, b) => (a.ts || "").localeCompare(b.ts || ""));
   const filtered = all
     .filter((m) => String(m.meta?.chat_id ?? "") === String(chat_id))
+    // Only conversational turns become model context. `tool` / `system`
+    // entries are kept in the store for the audit trail (and for channels
+    // that DO render tools), but replaying them as assistant messages would
+    // look like bogus answers to the model.
+    .filter((m) => m.type === "user" || m.type === "agent")
     .slice(-limit);
   return filtered.map((m) => {
     const role = m.direction === "in" ? "user" : "assistant";

package/src/daemon/plugins/telegram.js

@@ -626,10 +626,69 @@ class ChannelPoller {
       }
     }
 
-    // Fallback: super-agent
-    let saTrace = null;
+    // Fallback: super-agent — STREAMED.
+    // Each iteration's assistant text is sent to Telegram as its own message
+    // the moment the model produces it (its running commentary), so the user
+    // sees a real back-and-forth instead of one giant final dump. Tool calls
+    // are logged to the message store — visible via apx log / apx search and
+    // to channels that render tools — but NEVER sent to Telegram; tools are
+    // internal. The conversation saved on disk is the full, real exchange;
+    // Telegram is just the prose-only view of it.
     let saUsage = null;
+    let streamedCount = 0;
+    let lastStreamedText = "";
     if (!replyText && isSuperAgentEnabled(this.globalConfig)) {
+      const onEvent = async (ev) => {
+        try {
+          if (ev.type === "assistant_text" && ev.text) {
+            const piece = stripThinking(ev.text).trim();
+            if (!piece) return;
+            await this._send({ chat_id, text: piece });
+            lastStreamedText = piece;
+            streamedCount += 1;
+            appendGlobalMessage({
+              channel: "telegram",
+              direction: "out",
+              type: "agent",
+              actor_id: "apx",
+              agent_slug: "apx",
+              author: "apx",
+              body: piece,
+              meta: {
+                chat_id,
+                tg_channel: this.channel.name,
+                in_reply_to: u.update_id,
+                streamed: true,
+                iteration: ev.iteration,
+              },
+            });
+          } else if (ev.type === "tool_result" && ev.trace) {
+            // Logged for the audit trail / other channels — NOT sent to Telegram.
+            const t = ev.trace;
+            appendGlobalMessage({
+              channel: "telegram",
+              direction: "out",
+              type: "tool",
+              actor_id: t.tool,
+              author: "apx",
+              body: `${t.tool}(${JSON.stringify(t.args || {}).slice(0, 200)})`,
+              meta: {
+                chat_id,
+                tg_channel: this.channel.name,
+                in_reply_to: u.update_id,
+                tool: t.tool,
+                args: t.args,
+                result: t.result,
+                iteration: ev.iteration,
+              },
+            });
+          }
+        } catch (e) {
+          // A failed intermediate send must not abort the whole run.
+          this.log(`telegram[${this.channel.name}] stream event failed: ${e.message}`);
+        }
+      };
+
       try {
         const sa = await runSuperAgent({
           globalConfig: this.globalConfig,
@@ -640,15 +699,20 @@ class ChannelPoller {
           previousMessages,
           contextNote: `You are replying inside Telegram right now. Telegram channel="${this.channel.name}", author=${author}, chat_id=${chat_id}. Keep the reply plain-text and concise. Previous turns of this chat are included only for local conversational context; re-call tools for facts.`,
           signal: abortCtrl.signal,
+          onEvent,
         });
         replyText = sa.text;
         replyAuthor = sa.name;
-        saTrace = sa.trace;
         saUsage = sa.usage;
       } catch (e) {
         if (abortCtrl.signal.aborted) {
+          // A newer message superseded this one. Whatever streamed so far is
+          // already sent + logged; the newer message's run continues the
+          // thread from that history.
           this.log(`telegram[${this.channel.name}] request aborted for chat ${chat_id}`);
-          return; // don't send reply if aborted
+          if (chat_id) this.activeRequests.delete(chat_id);
+          stopTyping();
+          return;
         }
         this.log(`telegram[${this.channel.name}] super-agent failed: ${e.message}`);
         // Surface the failure to the user instead of silently dropping the
@@ -660,37 +724,29 @@ class ChannelPoller {
     }
 
     if (chat_id) this.activeRequests.delete(chat_id);
-    if (!replyText) {
-      stopTyping();
-      return;
-    }
 
-    // Strip <thinking>...</thinking> blocks before sending to Telegram —
-    // reasoning is noise to the chat reader. The full text (with thinking)
-    // stays in the daemon log and in messages with channel='engine' if the
-    // model produced any.
-    const clean = stripThinking(replyText);
+    // Final answer. The intermediate prose was already streamed; only send the
+    // final text if it's non-empty AND not a duplicate of the last streamed
+    // piece (the loop can end on an iteration whose text was already sent).
+    // If nothing streamed and there's no final text, send a minimal ack so the
+    // turn isn't silently empty.
+    const finalClean = replyText ? stripThinking(replyText).trim() : "";
+    let toSend = "";
+    if (finalClean && finalClean !== lastStreamedText) toSend = finalClean;
+    else if (!finalClean && streamedCount === 0) toSend = "Listo.";
 
-    // Send reply via this channel's bot
     stopTyping();
+    if (!toSend) return; // everything was already streamed — nothing left to send
+
     try {
-      await this._send({ chat_id, text: clean || replyText });
-      // Log outbound — store the cleaned text (what we actually sent). The
-      // full reasoning (if any) goes in meta_json so it's recoverable.
+      await this._send({ chat_id, text: toSend });
       const meta = {
         chat_id,
         tg_channel: this.channel.name,
         in_reply_to: u.update_id,
+        final: true,
       };
-      if (clean !== replyText) meta.thinking_stripped = true;
-      if (saTrace && saTrace.length > 0) {
-        // Compact representation: [{tool, args}] without the full result
-        // (results can be huge — keep them out of the long-lived FS log).
-        meta.tools_called = saTrace.map((t) => ({
-          tool: t.tool,
-          args: t.args,
-        }));
-      }
+      if (replyText && stripThinking(replyText) !== replyText) meta.thinking_stripped = true;
       if (saUsage) meta.usage = saUsage;
       appendGlobalMessage({
         channel: "telegram",
@@ -699,7 +755,7 @@ class ChannelPoller {
         actor_id: replyAuthor || "apx",
         agent_slug: replyAuthor || "apx",
         author: replyAuthor || "apx",
-        body: clean || replyText,
+        body: toSend,
         meta,
       });
     } catch (e) {
@@ -711,15 +767,12 @@ class ChannelPoller {
         actor_id: replyAuthor || "apx",
         agent_slug: replyAuthor || "apx",
         author: replyAuthor || "apx",
-        body: `[send_failed] ${clean || replyText}`,
+        body: `[send_failed] ${toSend}`,
         meta: {
           chat_id,
           tg_channel: this.channel.name,
           in_reply_to: u.update_id,
           send_error: e.message,
-          ...(saTrace && saTrace.length > 0
-            ? { tools_called: saTrace.map((t) => ({ tool: t.tool, args: t.args })) }
-            : {}),
           ...(saUsage ? { usage: saUsage } : {}),
         },
       });

package/src/daemon/super-agent.js

@@ -134,7 +134,7 @@ HARD RULES (do not deviate):
 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.
-18. **NO BARE ACKS AS FINAL ANSWER**: Empty acknowledgments ("ok", "entendido", "dame un minuto", "voy", "checking") are invalid as a FINAL response when a tool was needed — they will be re-prompted. EXCEPTION: a short contextual ack sent via send_telegram BEFORE another tool call is encouraged on Telegram audio inputs and on tool calls that take more than a few seconds (browser_screenshot, web_search, run_shell, long file edits). The ack must be **contextual and varied** in Spanish — e.g. "Ya te escucho 🎧", "Dame un seg, transcribiendo…", "Buscando eso ahora", "Voy a revisar el repo…", "Un momento, ejecutando…". Never reuse the exact same ack twice in a row. The ack is the FIRST tool call in the turn; the actual work follows immediately in the SAME turn (do not return without doing the work).
+18. **NO BARE ACKS**: Empty acknowledgments ("ok", "entendido", "dame un minuto", "voy", "checking", "ya te escucho", "ahora lo reviso") are never a valid message — not as a final answer and not as a standalone update. Don't announce that you're about to do something: just do it and report. The user already sees your progress step by step (each iteration's text is shown as its own message), so every line you produce must carry real content — a result, a finding, or a concrete question.
 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.
 20. **NO MANUAL SCAFFOLDING**: To register or scaffold a project, ALWAYS use add_project — it auto-creates AGENTS.md and .apc/project.json when missing (one call, atomic). NEVER write AGENTS.md, .apc/project.json, or any APC scaffold file by hand via run_shell / write_file / shell pipes. The schema must come from the official initApf scaffold, not improvised. If add_project errors, report the error to the user — don't try to work around it with shell hacks. Same for any other APC-managed file (.apc/agents/*, .apc/skills/*, etc.) — use the dedicated tool, never raw filesystem writes.
 21. **SKILLS — ON DEMAND**: The "# Available skills" section below lists every skill available to you (slug + description, NO body). When the user asks about specific APX/APC commands, project structure, agent runtimes, or anything where exact syntax or detailed behavior matches a skill description (in ANY language — match semantically, not by keyword), call load_skill({slug}) to fetch the full markdown body. If a CWD is in the contextNote, pass it as project_path so project-scoped skills resolve. If the user explicitly asks "what skills do you have?", you can either read the catalog below directly OR call list_skills to get a fresh enumeration. Do NOT load skills for trivial / unrelated questions — that wastes tokens. Don't guess CLI syntax when a skill can tell you; load it.