@agentprojectcontext/apx 1.73.1 → 1.74.0

package/package.json

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

package/src/core/channels/telegram/ask-callbacks.js

@@ -181,6 +181,7 @@ export async function runResumedTurn(self, ctx) {
   let replyText;
   let replyAuthor;
   let saUsage = null;
+  let saModel = null;
   try {
     const sa = await runTelegramSuperAgent(self, {
       chat_id,
@@ -216,10 +217,12 @@ export async function runResumedTurn(self, ctx) {
     replyText = sa.text;
     replyAuthor = sa.name || agentDisplay;
     saUsage = sa.usage;
+    saModel = sa.model || state.model || null;
   } catch (e) {
     self.log(`telegram[${self.channel.name}] ask resume failed: ${e.message}`);
     replyText = telegramErrorText(self, e);
     replyAuthor = agentDisplay;
+    saModel = state.model || null;
   }
 
   stopTyping();
@@ -231,6 +234,7 @@ export async function runResumedTurn(self, ctx) {
     replyActorId: SUPERAGENT_ACTOR_ID,
     replyKind: "superagent",
     saUsage,
+    saModel,
     streamedCount: state.streamedCount,
     lastStreamedText: state.lastStreamedText,
     agentDisplay,

package/src/core/channels/telegram/dispatch.js

@@ -226,6 +226,8 @@ export async function handleUpdate(self, u) {
     let replyAuthor;
     let replyActorId = SUPERAGENT_ACTOR_ID;   // stable id: super_agent | agent slug
     let replyKind = "superagent";             // actor_kind: superagent | agent
+    let replyModel = null;                    // model that actually produced the reply
+    let replyUsage = null;                    // token accounting for this turn
     const projectCfg = target.config || self.globalConfig;
     // Display name for the super-agent persona on this channel (from identity.json).
     const agentDisplay = resolveAgentName(self.globalConfig);
@@ -254,6 +256,10 @@ export async function handleUpdate(self, u) {
           replyAuthor = agent.slug;
           replyActorId = agent.slug;
           replyKind = "agent";
+          // Fully-qualified id from the agent card (provider:model) — callEngine
+          // resolves it internally and doesn't hand it back.
+          replyModel = agent.fields.Model;
+          replyUsage = result.usage || null;
         } catch (e) {
           self.log(`telegram[${self.channel.name}] agent reply failed: ${e.message}`);
           replyText = t("telegram.error_agent", {
@@ -263,6 +269,8 @@ export async function handleUpdate(self, u) {
           replyAuthor = agentDisplay;
           replyActorId = SUPERAGENT_ACTOR_ID;
           replyKind = "superagent";
+          replyModel = null;
+          replyUsage = null;
         }
       } else {
         self.log(
@@ -276,7 +284,6 @@ export async function handleUpdate(self, u) {
     // calls are logged but never sent (internal). The streamed turn + its final
     // send live in ./reply.js so this dispatcher and the ask-flow resume
     // (_runResumedTurn in the host poller) share ONE reply path — no drift.
-    let saUsage = null;
     let streamedCount = 0;
     let lastStreamedText = "";
     if (!replyText && isSuperAgentEnabled(self.globalConfig)) {
@@ -327,7 +334,8 @@ export async function handleUpdate(self, u) {
         replyAuthor = sa.name || agentDisplay;
         replyActorId = SUPERAGENT_ACTOR_ID;
         replyKind = "superagent";
-        saUsage = sa.usage;
+        replyUsage = sa.usage;
+        replyModel = sa.model || state.model || null;
 
         // ── ask_questions integration ────────────────────────────────────
         // If the super-agent ended this turn by calling ask_questions, hand off
@@ -374,6 +382,7 @@ export async function handleUpdate(self, u) {
         replyAuthor = agentDisplay;
         replyActorId = SUPERAGENT_ACTOR_ID;
         replyKind = "superagent";
+        replyModel = state.model || null;
       }
     }
 
@@ -386,7 +395,8 @@ export async function handleUpdate(self, u) {
       replyAuthor,
       replyActorId,
       replyKind,
-      saUsage,
+      saUsage: replyUsage,
+      saModel: replyModel,
       streamedCount,
       lastStreamedText,
       agentDisplay,

package/src/core/channels/telegram/reply.js

@@ -23,12 +23,19 @@ import { buildTelegramMeta, resolveBotToken } from "./helpers.js";
  * (audit trail / other channels — never sent to Telegram). Returns the handler
  * plus a live `state` the caller reads AFTER the run to drive the final send.
  *
- * @returns {{ onEvent: Function, state: { streamedCount: number, lastStreamedText: string } }}
+ * `state.model` tracks the model actually answering RIGHT NOW (it can rotate
+ * mid-turn on a fallback), so every record this handler writes is stamped with
+ * the model that produced it — not with the one the turn happened to end on.
+ *
+ * @returns {{ onEvent: Function, state: { streamedCount: number, lastStreamedText: string, model: string } }}
  */
 export function buildStreamHandler(self, { chat_id, update_id, agentDisplay }) {
-  const state = { streamedCount: 0, lastStreamedText: "", sentHeadsUp: false };
+  const state = { streamedCount: 0, lastStreamedText: "", sentHeadsUp: false, model: "" };
   const onEvent = async (ev) => {
     try {
+      if ((ev.type === "model_start" || ev.type === "model_routed" || ev.type === "final_wrapup") && ev.model) {
+        state.model = ev.model;
+      }
       if (ev.type === "tool_start" && !state.sentHeadsUp && state.streamedCount === 0) {
         state.sentHeadsUp = true;
         const heads = t("telegram.heads_up", { lang: resolveLang(self.globalConfig) });
@@ -42,7 +49,7 @@ export function buildStreamHandler(self, { chat_id, update_id, agentDisplay }) {
           agent_slug: SUPERAGENT_ACTOR_ID,
           author: agentDisplay,
           body: heads,
-          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, heads_up: true },
+          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, heads_up: true, ...(state.model ? { model: state.model } : {}) },
         });
         return;
       }
@@ -61,7 +68,7 @@ export function buildStreamHandler(self, { chat_id, update_id, agentDisplay }) {
           agent_slug: SUPERAGENT_ACTOR_ID,
           author: agentDisplay,
           body: piece,
-          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, streamed: true, iteration: ev.iteration },
+          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, streamed: true, iteration: ev.iteration, ...(state.model ? { model: state.model } : {}) },
         });
       } else if (ev.type === "tool_result" && ev.trace) {
         // Logged for the audit trail / other channels — NOT sent to Telegram.
@@ -74,7 +81,7 @@ export function buildStreamHandler(self, { chat_id, update_id, agentDisplay }) {
           actor_kind: "tool",
           author: agentDisplay,
           body: `${tr.tool}(${JSON.stringify(tr.args || {}).slice(0, 200)})`,
-          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, tool: tr.tool, args: tr.args, result: tr.result, iteration: ev.iteration },
+          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, tool: tr.tool, args: tr.args, result: tr.result, iteration: ev.iteration, ...(state.model ? { model: state.model } : {}) },
         });
       } else if (ev.type === "engine_failed") {
         // A model in the fallback chain errored; the loop is rotating to the
@@ -175,6 +182,7 @@ export async function runFollowupTurn(self, {
     let replyText;
     let replyAuthor;
     let saUsage = null;
+    let saModel = null;
     try {
       const sa = await runTelegramSuperAgent(self, {
         chat_id,
@@ -191,10 +199,12 @@ export async function runFollowupTurn(self, {
       replyText = sa.text;
       replyAuthor = sa.name || agentDisplay;
       saUsage = sa.usage;
+      saModel = sa.model || state.model || null;
     } catch (e) {
       self.log(`telegram[${self.channel.name}] a2a followup failed: ${e.message}`);
       replyText = telegramErrorText(self, e);
       replyAuthor = agentDisplay;
+      saModel = state.model || null;
     }
     stopTyping();
     await sendFinalReply(self, {
@@ -205,6 +215,7 @@ export async function runFollowupTurn(self, {
       replyActorId: SUPERAGENT_ACTOR_ID,
       replyKind: "superagent",
       saUsage,
+      saModel,
       streamedCount: state.streamedCount,
       lastStreamedText: state.lastStreamedText,
       agentDisplay,
@@ -233,7 +244,7 @@ export function telegramErrorText(self, e) {
  */
 export async function sendFinalReply(self, {
   chat_id, update_id, replyText, replyAuthor, replyActorId, replyKind,
-  saUsage = null, streamedCount = 0, lastStreamedText = "", agentDisplay,
+  saUsage = null, saModel = null, streamedCount = 0, lastStreamedText = "", agentDisplay,
   extraMeta = {},
 }) {
   const finalClean = replyText ? stripThinking(replyText).trim() : "";
@@ -255,6 +266,7 @@ export async function sendFinalReply(self, {
     const meta = { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, final: true, ...extraMeta };
     if (replyText && stripThinking(replyText) !== replyText) meta.thinking_stripped = true;
     if (saUsage) meta.usage = saUsage;
+    if (saModel) meta.model = saModel;
     appendGlobalMessage({
       channel: CHANNELS.TELEGRAM,
       direction: "out",
@@ -277,7 +289,7 @@ export async function sendFinalReply(self, {
       agent_slug: actorId,
       author: replyAuthor || agentDisplay,
       body: `[send_failed] ${toSend}`,
-      meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, send_error: e.message, ...(saUsage ? { usage: saUsage } : {}) },
+      meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, send_error: e.message, ...(saUsage ? { usage: saUsage } : {}), ...(saModel ? { model: saModel } : {}) },
     });
   }
 }

package/src/core/net/ipv4-first.js

@@ -0,0 +1,32 @@
+// Prefer IPv4 for all outbound connections made by this process.
+//
+// Some networks — notably machines on Tailscale, or misconfigured dual-stack
+// setups — advertise an IPv6 route that black-holes. A dual-stack host such as
+// api.telegram.org then resolves to an unreachable AAAA address, and Node's
+// fetch/undici stalls on it with ETIMEDOUT instead of falling back to the
+// reachable IPv4 the way `curl` does. The symptom is every daemon outbound
+// `fetch` failing ("fetch failed") — Telegram long-poll, some LLM providers —
+// while the shell and `curl -4` work fine.
+//
+// Forcing ipv4first + disabling Happy-Eyeballs family auto-selection makes
+// `fetch` use the reachable A record. On a healthy IPv6 network this is a no-op
+// preference (IPv4 is still universally reachable); opt out with
+// APX_NET_IPV4_FIRST=0 if you specifically need IPv6-first.
+import dns from "node:dns";
+import net from "node:net";
+
+if (process.env.APX_NET_IPV4_FIRST !== "0") {
+  // Available on Node ≥17; guarded for older runtimes.
+  try {
+    dns.setDefaultResultOrder("ipv4first");
+  } catch {
+    /* older node — ignore */
+  }
+  // Available on Node ≥18.13; disabling it stops undici from racing an
+  // unreachable IPv6 address and timing out before it tries IPv4.
+  try {
+    net.setDefaultAutoSelectFamily?.(false);
+  } catch {
+    /* older node — ignore */
+  }
+}

package/src/core/stores/messages.js

@@ -643,12 +643,18 @@ export function listGlobalThreads({ channels, _globalMessagesDir } = {}) {
 }
 
 // Read one channel+day thread shaped for the web chat viewer:
-// { id, channel, messages: [{ role, content, ts }] } — or null when missing.
+// { id, channel, messages: [{ role, content, ts, … }] } — or null when missing.
 // Tool records are INCLUDED (role:"tool" with structured tool/args/result from
 // meta) so the web viewer can render tool executions the same way the live
 // stream does. They're persisted by every channel (e.g. telegram reply.js) but
 // never sent to the channel itself; dropping them here is what made Telegram
 // tool calls invisible in the web chat even though they were on disk.
+//
+// Assistant rows also carry their ATTRIBUTION — which agent answered
+// (agent/agent_name/actor_kind) and on which model, plus the turn's token
+// usage. All of it is already on disk in `meta`; dropping it here is what made
+// a reloaded thread render "0 tok" with no model, even though the live stream
+// showed both.
 export function readGlobalThread({ channel, date, _globalMessagesDir } = {}) {
   if (!CHANNEL_NAME_RE.test(String(channel || ""))) return null;
   if (!/^\d{4}-\d{2}-\d{2}$/.test(String(date || ""))) return null;
@@ -668,10 +674,21 @@ export function readGlobalThread({ channel, date, _globalMessagesDir } = {}) {
           result: r.meta?.result,
         };
       }
+      if (r.type === "user") {
+        return { role: "user", content: r.body || "", ts: r.ts };
+      }
+      const usage = r.meta?.usage;
       return {
-        role: r.type === "user" ? "user" : "assistant",
+        role: "assistant",
         content: r.body || "",
         ts: r.ts,
+        // Stable id of who answered (super_agent | project-agent slug) plus the
+        // display name that was shown on the channel.
+        ...(r.agent_slug || r.actor_id ? { agent: r.agent_slug || r.actor_id } : {}),
+        ...(r.author ? { agent_name: r.author } : {}),
+        ...(r.actor_kind ? { actor_kind: r.actor_kind } : {}),
+        ...(r.meta?.model ? { model: r.meta.model } : {}),
+        ...(usage && typeof usage === "object" ? { usage } : {}),
       };
     });
   return { id: date, channel, messages };

package/src/host/daemon/api/super-agent.js

@@ -44,12 +44,21 @@ function logInspectorDecision(trace, { trace_id, channel } = {}) {
 // the human surfaces (web big chat + sidebar) — not generic "api"/automation
 // callers. Best-effort: a logging failure never breaks the reply.
 const WEB_LOGGED_CHANNELS = new Set([CHANNELS.WEB, CHANNELS.WEB_SIDEBAR]);
-function logWebTurn(channel, { prompt, replyText }) {
+function logWebTurn(channel, { prompt, replyText, name, model, usage }) {
   if (!WEB_LOGGED_CHANNELS.has(channel)) return;
   try {
     appendGlobalMessage({ channel, direction: "in", type: "user", author: "user", body: prompt });
     if (replyText) {
-      appendGlobalMessage({ channel, direction: "out", type: "agent", body: replyText });
+      // Attribution rides along on the record: which model answered and what the
+      // turn cost. Without it a reloaded thread renders "0 tok" and no model.
+      appendGlobalMessage({
+        channel,
+        direction: "out",
+        type: "agent",
+        author: name || undefined,
+        body: replyText,
+        meta: { ...(model ? { model } : {}), ...(usage ? { usage } : {}) },
+      });
     }
   } catch {
     /* best-effort */
@@ -146,7 +155,12 @@ export function register(app, { projects, registries, plugins, project, config }
 
     // Web/TUI channels receive a "confirmation_required" SSE event and respond
     // via POST /super-agent/confirm/:correlationId (see api/confirm.js).
-    const requestConfirmation = createWebConfirmAdapter({ onEvent });
+    // Non-interactive callers (e.g. `apx exec`, which streams only to render a
+    // progress indicator) send `confirm: false` to opt out: they have no way to
+    // answer the round-trip, so they fall back to the default permission policy —
+    // exactly matching the blocking POST /super-agent/chat endpoint's semantics.
+    const requestConfirmation =
+      req.body?.confirm === false ? undefined : createWebConfirmAdapter({ onEvent });
 
     try {
       const saResult = await runSuperAgent({
@@ -168,13 +182,22 @@ export function register(app, { projects, registries, plugins, project, config }
         skipSkillsHint: inspectorOn,
       });
       projects.rebuild(p.id);
-      logWebTurn(ctx.channel, { prompt, replyText: saResult.text });
+      logWebTurn(ctx.channel, {
+        prompt,
+        replyText: saResult.text,
+        name: saResult.name,
+        model: saResult.model,
+        usage: saResult.usage,
+      });
       send({
         type: "final",
         result: {
           text: saResult.text,
           usage: saResult.usage,
+          // `name` is the agent persona; `model` is the engine that answered
+          // (it can differ from the configured one after a routing fallback).
           name: saResult.name,
+          model: saResult.model,
           trace: saResult.trace,
         },
       });
@@ -270,11 +293,18 @@ export function register(app, { projects, registries, plugins, project, config }
         skipSkillsHint: inspectorOn,
       });
       projects.rebuild(p.id);
-      logWebTurn(ctx.channel, { prompt, replyText: saResult.text });
+      logWebTurn(ctx.channel, {
+        prompt,
+        replyText: saResult.text,
+        name: saResult.name,
+        model: saResult.model,
+        usage: saResult.usage,
+      });
       res.json({
         text: saResult.text,
         usage: saResult.usage,
         name: saResult.name,
+        model: saResult.model,
         trace: saResult.trace,
       });
     } catch (e) {

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

@@ -104,6 +104,10 @@ export function register(app, { projects, plugins, registries }) {
       const channel = body.channel || "voice";
       let suggestions = [];
       let toolsUsed = [];
+      // Attribution for the persisted turn (see the appendGlobalMessage below).
+      let replyModel = null;
+      let replyUsage = null;
+      let replyName = null;
 
       const channelCtx = buildVoiceChannelContext(channel, {
         projectId: body.projectId,
@@ -125,6 +129,9 @@ export function register(app, { projects, plugins, registries }) {
             previousMessages,
           });
           const raw = (result?.text || "").trim();
+          replyModel = result?.model || null;
+          replyUsage = result?.usage || null;
+          replyName = result?.name || null;
           // Surface the tools the agent actually executed this turn so
           // the overlay can show "lo que APX hizo" instead of echoing
           // the transcript. Dedup by name (a list_tasks before+after
@@ -188,7 +195,19 @@ export function register(app, { projects, plugins, registries }) {
         const logCh = channelCtx.channel || channel;
         if (logCh && logCh !== "api") {
           appendGlobalMessage({ channel: logCh, direction: "in", type: "user", author: "user", body: userText });
-          if (replyText) appendGlobalMessage({ channel: logCh, direction: "out", type: "agent", body: replyText });
+          if (replyText) {
+            appendGlobalMessage({
+              channel: logCh,
+              direction: "out",
+              type: "agent",
+              author: replyName || undefined,
+              body: replyText,
+              meta: {
+                ...(replyModel ? { model: replyModel } : {}),
+                ...(replyUsage ? { usage: replyUsage } : {}),
+              },
+            });
+          }
         }
       } catch { /* best-effort */ }
 

package/src/host/daemon/index.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 // APX daemon entry point. Boots config + projects + Express + plugins.
+// Must run before any outbound fetch — see the module header for why.
+import "#core/net/ipv4-first.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";

package/src/host/daemon/plugins/desktop/index.js

@@ -199,9 +199,20 @@ async function _handleMessage({ ws, text, previousMessages }, { projects, config
       }
     }
 
-    // Persist assistant response
+    // Persist assistant response, stamped with the model that answered and the
+    // turn's token usage so the web thread viewer can attribute it.
     try {
-      await appendGlobalMessage({ channel: CHANNEL, direction: "out", type: "agent", body: finalText });
+      await appendGlobalMessage({
+        channel: CHANNEL,
+        direction: "out",
+        type: "agent",
+        author: result?.name || undefined,
+        body: finalText,
+        meta: {
+          ...(result?.model ? { model: result.model } : {}),
+          ...(result?.usage ? { usage: result.usage } : {}),
+        },
+      });
     } catch {}
 
   } catch (e) {

package/src/interfaces/cli/commands/exec.js

@@ -58,6 +58,69 @@ export function resolveExecChannel(args) {
   return CHANNELS.CLI;
 }
 
+// Braille spinner frames for the live "pensando…" indicator.
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+
+/**
+ * A single-line progress indicator drawn on stderr while the super-agent turn
+ * runs, so `apx exec` never looks frozen. Renders only on an interactive stderr
+ * (TTY); when piped/redirected it is a no-op so stdout stays clean for scripts.
+ * Set APX_NO_SPINNER=1 to disable.
+ */
+function createExecStatus() {
+  const active =
+    process.stderr.isTTY && process.env.APX_NO_SPINNER !== "1" && !process.env.NO_COLOR;
+  let label = "pensando…";
+  let frame = 0;
+  let timer = null;
+  const t0 = Date.now();
+
+  const draw = () => {
+    const secs = Math.floor((Date.now() - t0) / 1000);
+    process.stderr.write(`\r\x1b[2K${dim(SPINNER[frame])} ${label} ${dim(secs + "s")}`);
+    frame = (frame + 1) % SPINNER.length;
+  };
+
+  return {
+    start() {
+      if (!active || timer) return;
+      draw();
+      timer = setInterval(draw, 90);
+      timer.unref?.();
+    },
+    set(next) {
+      if (next) label = next;
+    },
+    clear() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      if (active) process.stderr.write("\r\x1b[2K");
+    },
+  };
+}
+
+/** Map a stream event to the label shown next to the spinner. */
+function labelForEvent(event) {
+  switch (event?.type) {
+    case "skill_inspector":
+      return "cargando skills…";
+    case "model_routed":
+    case "model_start": {
+      const m = event.model || event.to || event.engine;
+      return m ? `pensando… ${dim(m)}` : "pensando…";
+    }
+    case "tool_start":
+      return `${event.trace?.tool || event.tool || "herramienta"}…`;
+    case "tool_result":
+      return "pensando…";
+    default:
+      return null;
+  }
+}
+
 async function readPromptFromStdin() {
   const fs = await import("node:fs");
   if (process.stdin.isTTY) return "";
@@ -99,11 +162,26 @@ export async function cmdExec(args) {
   if (args.flags["max-tokens"]) body.maxTokens = parseInt(args.flags["max-tokens"], 10);
 
   if (useSuperAgent) {
-    const result = await http.post(`/projects/${pid}/super-agent/chat`, body);
-    process.stdout.write(result.text + "\n");
+    // Stream the turn so we can render a live progress indicator instead of a
+    // silent hang. `confirm: false` opts out of the interactive confirmation
+    // round-trip (which the CLI can't answer), keeping the same semantics as the
+    // blocking POST /super-agent/chat endpoint.
+    const status = createExecStatus();
+    status.start();
+    let result;
+    try {
+      result = await http.streamPost(
+        `/projects/${pid}/super-agent/chat/stream`,
+        { ...body, confirm: false },
+        (event) => status.set(labelForEvent(event))
+      );
+    } finally {
+      status.clear();
+    }
+    process.stdout.write((result?.text ?? "") + "\n");
     if (process.stderr.isTTY || args.flags.verbose) {
       process.stderr.write(
-        `\n— ${result.name || "super-agent"} | model=${result.trace ? "tools" : "engine"} | in=${result.usage?.input_tokens || "?"} out=${result.usage?.output_tokens || "?"}${result.model ? ` | ${result.model}` : ""}\n`
+        `\n— ${result?.name || "super-agent"} | model=${result?.trace ? "tools" : "engine"} | in=${result?.usage?.input_tokens || "?"} out=${result?.usage?.output_tokens || "?"}${result?.model ? ` | ${result.model}` : ""}\n`
       );
     }
     return;