@agentprojectcontext/apx 1.42.0 → 1.42.2

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

@@ -0,0 +1,204 @@
+// Shared Telegram super-agent reply path. Both the inbound dispatcher
+// (handleUpdate) and the ask-flow resume (_runResumedTurn in the host poller)
+// drive the SAME streamed turn through these helpers, so behavior — autonomy
+// budget, streaming, never-silent floor, localized errors, rich channelMeta —
+// can't drift between the two entry points. It did drift: the resume path was a
+// stale hand-rolled copy that missed maxIters, streaming and i18n. One source
+// of truth fixes that for good.
+import { runSuperAgent } from "#core/agent/super-agent.js";
+import { TELEGRAM_TOOL_ITERS } from "#core/agent/constants.js";
+import { stripThinking } from "#core/util/thinking.js";
+import { appendGlobalMessage } from "#core/stores/messages.js";
+import { CHANNELS } from "#core/constants/channels.js";
+import { SUPERAGENT_ACTOR_ID } from "#core/identity/index.js";
+import { createTelegramConfirmAdapter } from "#core/confirmation/adapters/telegram.js";
+import { getConfirmationStore as getConfirmStore } from "#core/confirmation/pending-store.js";
+import { t, resolveLang } from "#core/i18n/index.js";
+import { buildTelegramMeta, resolveBotToken } from "./helpers.js";
+
+/**
+ * Build the streaming event handler for a Telegram super-agent turn. Sends a
+ * one-shot localized heads-up the moment real work starts (first tool), streams
+ * each assistant-text iteration as its own chat message, and logs tool calls
+ * (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 } }}
+ */
+export function buildStreamHandler(self, { chat_id, update_id, agentDisplay }) {
+  const state = { streamedCount: 0, lastStreamedText: "", sentHeadsUp: false };
+  const onEvent = async (ev) => {
+    try {
+      if (ev.type === "tool_start" && !state.sentHeadsUp && state.streamedCount === 0) {
+        state.sentHeadsUp = true;
+        const heads = t("telegram.heads_up", { lang: resolveLang(self.globalConfig) });
+        await self._send({ chat_id, text: heads });
+        appendGlobalMessage({
+          channel: CHANNELS.TELEGRAM,
+          direction: "out",
+          type: "agent",
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
+          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 },
+        });
+        return;
+      }
+      if (ev.type === "assistant_text" && ev.text) {
+        const piece = stripThinking(ev.text).trim();
+        if (!piece) return;
+        await self._send({ chat_id, text: piece });
+        state.lastStreamedText = piece;
+        state.streamedCount += 1;
+        appendGlobalMessage({
+          channel: CHANNELS.TELEGRAM,
+          direction: "out",
+          type: "agent",
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
+          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 },
+        });
+      } else if (ev.type === "tool_result" && ev.trace) {
+        // Logged for the audit trail / other channels — NOT sent to Telegram.
+        const tr = ev.trace;
+        appendGlobalMessage({
+          channel: CHANNELS.TELEGRAM,
+          direction: "out",
+          type: "tool",
+          actor_id: tr.tool,
+          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 },
+        });
+      } else if (ev.type === "engine_failed") {
+        // A model in the fallback chain errored; the loop is rotating to the
+        // next one. Log so a mid-turn provider failure is diagnosable.
+        self.log(`telegram[${self.channel.name}] engine_failed: ${ev.model || "?"} (${ev.reason || "?"}) → ${ev.retry_with || "end of chain"}`);
+      } else if (ev.type === "model_routed" || ev.type === "model_retry") {
+        self.log(`telegram[${self.channel.name}] ${ev.type}: model=${ev.model || "?"}${ev.reason ? ` reason=${ev.reason}` : ""}${ev.from_fallback ? " (fallback)" : ""}`);
+      }
+    } catch (e) {
+      // A failed intermediate send must not abort the whole run.
+      self.log(`telegram[${self.channel.name}] stream event failed: ${e.message}`);
+    }
+  };
+  return { onEvent, state };
+}
+
+/**
+ * Run the super-agent for a Telegram turn with the canonical channel config:
+ * the autonomy budget (telegram_max_iters → TELEGRAM_TOOL_ITERS), rich
+ * channelMeta (project pin + route), the confirmation adapter, and streaming.
+ * The single place this call is configured — change it once, both entry points
+ * inherit it. Throws on failure (caller decides abort-vs-error handling).
+ */
+export function runTelegramSuperAgent(self, {
+  chat_id, prompt, previousMessages, target, author, relationshipBlock,
+  allowedTools, contextNote, signal, onEvent,
+}) {
+  const confirmAdapter = createTelegramConfirmAdapter({
+    token: resolveBotToken(self.channel),
+    chatId: chat_id,
+    pendingStore: getConfirmStore(),
+  });
+  return runSuperAgent({
+    globalConfig: self.globalConfig,
+    projects: self.projects,
+    plugins: self.plugins,
+    registries: self.registries,
+    prompt,
+    previousMessages,
+    channel: CHANNELS.TELEGRAM,
+    relationshipBlock,
+    allowedTools,
+    contextNote: contextNote || undefined,
+    channelMeta: buildTelegramMeta({
+      channelName: self.channel.name,
+      author,
+      chatId: chat_id,
+      target,
+      routeToAgent: self.channel.route_to_agent,
+    }),
+    signal,
+    onEvent,
+    requestConfirmation: confirmAdapter.requestConfirmation,
+    // Autonomy budget: Telegram is the "do the whole task for me" surface, so it
+    // gets a real multi-step budget instead of the conversational default (which
+    // cut tasks off after ~9 actions to ask "continue?"). Tunable via
+    // config.super_agent.telegram_max_iters.
+    maxIters: Number(self.globalConfig?.super_agent?.telegram_max_iters) || TELEGRAM_TOOL_ITERS,
+  });
+}
+
+/** Localized "couldn't reply" text for a failed super-agent turn (model itself
+ * failed, so it can't author this — templated, but follows the user's language). */
+export function telegramErrorText(self, e) {
+  return t("telegram.error_generic", {
+    lang: resolveLang(self.globalConfig),
+    vars: { error: e?.message || "internal error" },
+  });
+}
+
+/**
+ * Send the final reply for a turn and log it. The intermediate prose was already
+ * streamed, so we only send `replyText` if it's non-empty AND not a duplicate of
+ * the last streamed piece. Never ends on silence: a turn that streamed/acted but
+ * produced no closing gets a neutral "continue?"; a pure chit-chat turn that did
+ * nothing gets a short ack. Caller stops the typing indicator before calling.
+ */
+export async function sendFinalReply(self, {
+  chat_id, update_id, replyText, replyAuthor, replyActorId, replyKind,
+  saUsage = null, streamedCount = 0, lastStreamedText = "", agentDisplay,
+  extraMeta = {},
+}) {
+  const finalClean = replyText ? stripThinking(replyText).trim() : "";
+  let toSend = "";
+  if (finalClean && finalClean !== lastStreamedText) {
+    toSend = finalClean;
+  } else if (!finalClean) {
+    const lang = resolveLang(self.globalConfig);
+    toSend = streamedCount === 0
+      ? t("telegram.fallback_listo", { lang })
+      : t("telegram.fallback_continue", { lang });
+  }
+  if (!toSend) return; // everything was already streamed — nothing left to send
+
+  const actorId = replyActorId || SUPERAGENT_ACTOR_ID;
+  const kind = replyKind || "superagent";
+  try {
+    await self._send({ chat_id, text: toSend });
+    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;
+    appendGlobalMessage({
+      channel: CHANNELS.TELEGRAM,
+      direction: "out",
+      type: "agent",
+      actor_id: actorId,
+      actor_kind: kind,
+      agent_slug: actorId,
+      author: replyAuthor || agentDisplay,
+      body: toSend,
+      meta,
+    });
+  } catch (e) {
+    self.log(`telegram[${self.channel.name}] send-back error: ${e.message}`);
+    appendGlobalMessage({
+      channel: CHANNELS.TELEGRAM,
+      direction: "out",
+      type: "agent",
+      actor_id: actorId,
+      actor_kind: kind,
+      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 } : {}) },
+    });
+  }
+}

package/src/core/config/index.js

@@ -57,6 +57,11 @@ const DEFAULT_CONFIG = {
     system: "",                         // optional override; defaults in src/core/agent/prompts/
     permission_mode: PERMISSION_MODES.AUTOMATICO,       // total | automatico | permiso
     allowed_tools: [],                   // used by permission_mode="permiso"
+    // Per-turn tool-loop budget for the Telegram super-agent. Higher = more
+    // autonomous (chains explore→edit→verify→close before replying); lower =
+    // snappier but more "want me to continue?" hand-backs. 0/unset → built-in
+    // default (TELEGRAM_TOOL_ITERS in src/core/agent/constants.js).
+    telegram_max_iters: 0,
     // Model fallback: ordered list. Each item carries its own provider
     // prefix; the array order IS the attempt order. The router tries the
     // primary (super_agent.model) first, then walks this list, skipping

package/src/core/confirmation/adapters/telegram.js

@@ -24,7 +24,10 @@
 // keyboard but before the user tapped, pendingStore.wasKnown() detects the
 // SQLite row with no memory entry and we show "Expirado" instead of an error.
 
-const API_BASE = "https://api.telegram.org";
+// Raw Bot API calls go through the shared client so endpoint boilerplate lives
+// in one place (these used to be hand-rolled fetch calls duplicated here).
+import { sendMessage, answerCallbackQuery as apiAnswerCallbackQuery, editMessageReplyMarkup } from "#core/channels/telegram/api.js";
+
 const TIMEOUT_MS = 60_000; // 60 s — long enough for a human, short enough to not block forever
 
 /**
@@ -81,51 +84,31 @@ export function createTelegramConfirmAdapter({ token, chatId, pendingStore }) {
 
 async function sendConfirmKeyboard(token, chatId, description, correlationId, timeoutMs) {
   const timeoutSec = Math.round(timeoutMs / 1000);
-  await fetch(`${API_BASE}/bot${token}/sendMessage`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      chat_id: chatId,
-      text:
-        `⚠️ *Confirm action*\n\n${escapeMarkdown(description)}\n\n` +
-        `_Expires in ${timeoutSec}s. No response → cancelled._`,
-      parse_mode: "Markdown",
-      reply_markup: {
-        inline_keyboard: [[
-          { text: "✅ Yes", callback_data: `apx:confirm:${correlationId}:yes` },
-          { text: "❌ No",  callback_data: `apx:confirm:${correlationId}:no` },
-        ]],
-      },
-    }),
+  await sendMessage(token, chatId, {
+    text:
+      `⚠️ *Confirm action*\n\n${escapeMarkdown(description)}\n\n` +
+      `_Expires in ${timeoutSec}s. No response → cancelled._`,
+    parse_mode: "Markdown",
+    reply_markup: {
+      inline_keyboard: [[
+        { text: "✅ Yes", callback_data: `apx:confirm:${correlationId}:yes` },
+        { text: "❌ No",  callback_data: `apx:confirm:${correlationId}:no` },
+      ]],
+    },
   });
 }
 
+// best-effort — Telegram gives only ~30s to answer; after that it's already cleared
 async function answerCallbackQuery(token, callbackQueryId, text) {
   try {
-    await fetch(`${API_BASE}/bot${token}/answerCallbackQuery`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ callback_query_id: callbackQueryId, text }),
-    });
-  } catch {
-    // best-effort — Telegram gives only 30s to answer; after that it's already cleared
-  }
+    await apiAnswerCallbackQuery(token, callbackQueryId, text);
+  } catch { /* best-effort */ }
 }
 
 async function editMessageButtons(token, chatId, messageId, inlineKeyboard) {
   try {
-    await fetch(`${API_BASE}/bot${token}/editMessageReplyMarkup`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({
-        chat_id: chatId,
-        message_id: messageId,
-        reply_markup: { inline_keyboard: inlineKeyboard },
-      }),
-    });
-  } catch {
-    // best-effort
-  }
+    await editMessageReplyMarkup(token, chatId, messageId, { inline_keyboard: inlineKeyboard });
+  } catch { /* best-effort */ }
 }
 
 // Escape Markdown special chars so description text doesn't break Telegram markup.

package/src/core/i18n/en.js

@@ -4,4 +4,8 @@ export default {
   "telegram.reset_ack": "Done, context cleared. Starting fresh. What do you need?",
   "telegram.fallback_listo": "Done.",
   "telegram.fallback_continue": "Made some headway. Want me to keep going?",
+  // Host-emitted error floors (the model itself failed, so it can't author
+  // these — they stay templated, but at least follow the user's language).
+  "telegram.error_agent": "⚠️ The agent hit an error ({error}).",
+  "telegram.error_generic": "⚠️ Couldn't reply right now ({error}).",
 };

package/src/core/i18n/es.js

@@ -6,4 +6,8 @@ export default {
   "telegram.reset_ack": "Listo, contexto borrado. Arranco un hilo nuevo, ¿qué necesitás?",
   "telegram.fallback_listo": "Listo.",
   "telegram.fallback_continue": "Avancé con eso. ¿Querés que siga?",
+  // Pisos de error emitidos por el host (el modelo falló, no puede redactarlos
+  // él mismo — quedan fijos, pero al menos respetan el idioma del usuario).
+  "telegram.error_agent": "⚠️ El agente tuvo un error ({error}).",
+  "telegram.error_generic": "⚠️ No pude responder ahora mismo ({error}).",
 };

package/src/core/i18n/pt.js

@@ -4,4 +4,8 @@ export default {
   "telegram.reset_ack": "Pronto, contexto limpo. Começando do zero — do que você precisa?",
   "telegram.fallback_listo": "Pronto.",
   "telegram.fallback_continue": "Avancei com isso. Quer que eu continue?",
+  // Pisos de erro emitidos pelo host (o modelo falhou, não pode redigi-los —
+  // ficam fixos, mas ao menos seguem o idioma do usuário).
+  "telegram.error_agent": "⚠️ O agente encontrou um erro ({error}).",
+  "telegram.error_generic": "⚠️ Não consegui responder agora ({error}).",
 };

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

@@ -140,7 +140,12 @@ async function _handleMessage({ ws, text, previousMessages }, { projects, config
       channel: CHANNELS.DESKTOP,
       ...(slashed.handled ? { contextNote: slashed.contextNote } : {}),
       channelMeta: { voice: true }, // desktop module is voice-first → spoken mode
-      previousMessages: history.slice(0, -1),
+      // WS path: history was just appended with the current user turn (line 87),
+      // so drop it. HTTP path: `previousMessages` came in already excluding the
+      // current user turn (the renderer slices it off before POSTing), so
+      // dropping again would silently strip the last assistant reply — making
+      // every turn look like a fresh conversation to the model.
+      previousMessages: ws ? history.slice(0, -1) : history,
       overrideModel: cfg.model || null,
       signal: controller.signal,
       onToken: (chunk) => { liveBuf += chunk; },