@danieltmn/tamnora 0.21.2 → 0.23.0

package/harness/packages/server/src/lib/channels/telegram/run.js

@@ -0,0 +1,206 @@
+// El turno del agente en Telegram: armar las tools, correr el run y editar el
+// mensaje con el progreso. También el resumen de la conversación.
+
+import { randomUUID } from 'node:crypto';
+import { runAgent, createTools, resolveMode } from '../../core.js';
+import { resolveExistingDir } from '../../workspace.js';
+import {
+  combineToolset,
+  composeAgentMessages,
+  buildUserMessage,
+  resolveProviderFor,
+  toolCallPayload,
+} from '../../agentRun.js';
+import { createRulesInjector } from '../../rules.js';
+import { edit, send, tg } from './api.js';
+import { completionFooter } from './text.js';
+import { permissionMessage, permissionKeyboard } from './permissions.js';
+import { enviarCaptura, enviarNotaDeVoz } from './media.js';
+import { activeSessionId, projectLabel, sendProjectPicker } from './projects.js';
+
+const RESUME_INSTRUCTION =
+  'Resumí la conversación para la persona: qué se pidió, qué se hizo, decisiones tomadas, archivos o comandos relevantes y el estado actual. Sé claro y conciso, en español, sin markdown pesado.';
+
+/** Resumen de la conversación de una sesión (sin tocar el historial). */
+export async function resumirSesion(T, sessionId) {
+  const messages = T.ctx.store.getMessages(sessionId);
+  if (!messages.length) throw new Error('La conversación está vacía.');
+  const session = T.ctx.store.getSession(sessionId);
+  const providerId = session?.provider || T.ctx.effectiveProviderId();
+  const model = session?.model || T.ctx.effectiveModel();
+  if (!model) throw new Error('Falta el modelo.');
+  const transcript = messages
+    .map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
+    .join('\n');
+  const { provider, config } = resolveProviderFor(T.ctx, providerId);
+  const result = await runAgent({
+    provider,
+    config,
+    model,
+    messages: [
+      { role: 'system', content: RESUME_INSTRUCTION },
+      { role: 'user', content: transcript.slice(0, 60000) },
+    ],
+    tools: [],
+  });
+  const summary = result.content?.trim();
+  if (!summary) throw new Error('El modelo no devolvió un resumen.');
+  return { summary };
+}
+
+export async function run(T, chatId, input, images = []) {
+  const sessionId = activeSessionId(T, chatId);
+  if (!sessionId) {
+    T.pendingInputs.set(String(chatId), { input, images });
+    return sendProjectPicker(T, chatId);
+  }
+  const session = T.ctx.store.getSession(sessionId);
+  const providerId = session.provider || T.ctx.effectiveProviderId();
+  const model = session.model || T.ctx.effectiveModel();
+  if (!model) {
+    await send(T, chatId, 'Falta el modelo. Usá /model <id> o configurá uno en Ajustes.');
+    return;
+  }
+  const mode = resolveMode(T.ctx.effectiveMode());
+  const cwd = resolveExistingDir(session.cwd || T.ctx.cwd);
+  const history = T.ctx.store.getMessages(sessionId);
+
+  let mcp = null;
+  try {
+    mcp = await T.ctx.getMcp();
+  } catch {
+    mcp = null;
+  }
+
+  const onAsk = async (name, args) => {
+    // "Permitir todo" activa el auto-approve de la sesión (compartido con la
+    // consola): a partir de ahí no se vuelve a preguntar.
+    if (T.ctx.isAutoApprove?.(sessionId)) return true;
+    const askId = randomUUID();
+    T.askSessions.set(askId, sessionId);
+    await send(T, chatId, permissionMessage(projectLabel(session), name, args), {
+      reply_markup: permissionKeyboard(askId),
+    });
+    return T.ctx.approvals.ask(askId, { sessionId, name, args });
+  };
+
+  const local = createTools({
+    root: cwd,
+    enabled: mode.tools ?? undefined,
+    permissions: T.ctx.config.permissions,
+    yes: false,
+    onAsk,
+    mcp,
+    mcpMode: T.ctx.effectiveMcpMode(),
+    mcpPinned: T.ctx.effectiveMcpPinned(),
+  });
+  const exposeAdmin = !mode.tools;
+  const admin = T.ctx.agentTools;
+  const { definitions, execute } = combineToolset({
+    local,
+    admin,
+    plugins: exposeAdmin ? T.ctx.plugins : null,
+    exposeAdmin,
+    approve: onAsk,
+  });
+  const { provider, config } = resolveProviderFor(T.ctx, providerId);
+  const userMessage = buildUserMessage(input, images);
+  const messages = await composeAgentMessages({ ctx: T.ctx, cwd, mode, history, userMessage });
+
+  const controller = new AbortController();
+  T.controllers.set(String(chatId), controller);
+  T.ownSessions.add(sessionId);
+  const startedAt = Date.now();
+  const message = await send(T, chatId, '.');
+  let full = '';
+  let activity = '';
+  let lastEdit = 0;
+
+  const render = () => {
+    const body = full.trim();
+    const suffix = activity ? `\n\n- ${activity}` : '';
+    return `${body || '.'}${suffix}`;
+  };
+
+  try {
+    await tg(T.token, 'sendChatAction', { chat_id: chatId, action: 'typing' }).catch(() => null);
+    const result = await runAgent({
+      provider,
+      config,
+      model,
+      messages,
+      tools: definitions,
+      execute,
+      toolContext: { cwd, sessionId },
+      onLifecycle: createRulesInjector({ cwd, patterns: T.ctx.config.rules ?? [] }) ?? undefined,
+      redactExtra: T.ctx.secretExtra?.() ?? [],
+      signal: controller.signal,
+      maxRounds: T.ctx.effectiveMaxRounds?.() ?? T.ctx.config.maxRounds,
+      maxTokens: T.ctx.effectiveMaxTokens?.() ?? 0,
+      maxDurationMs: T.ctx.effectiveMaxDurationMs?.() ?? 0,
+      maxOutputTokens: T.ctx.effectiveMaxOutputTokens?.() ?? T.ctx.config.maxOutputTokens ?? 0,
+      promptCaching: T.ctx.effectivePromptCaching?.() ?? T.ctx.config.promptCaching === true,
+      onEvent(event) {
+        if (event.type === 'text') {
+          full = event.full;
+        } else if (event.type === 'tool_call') {
+          activity = `${event.name} ${toolCallPayload(event).summary}`.trim();
+          if (event.name === 'speak') {
+            enviarNotaDeVoz(T, chatId, event.args?.texto, {
+              voice: event.args?.voice,
+              rate: event.args?.rate,
+              pitch: event.args?.pitch,
+            });
+          }
+        } else if (event.type === 'tool_result') {
+          activity = `${event.name} V`;
+          if (event.name === 'screenshot' && event.meta?.screenshot?.name) {
+            enviarCaptura(T, chatId, event.meta.screenshot.name, event.meta.screenshot.url);
+          }
+        } else {
+          return;
+        }
+        const now = Date.now();
+        if (now - lastEdit > 1200) {
+          lastEdit = now;
+          edit(T, chatId, message.message_id, render());
+        }
+      },
+    });
+    const newMessages = result.messages.slice(messages.length);
+    const toolCalls = newMessages.filter((m) => m.role === 'tool').length;
+    const durationMs = Date.now() - startedAt;
+    let body = result.content?.trim() || full.trim();
+    if (!body) {
+      if (result.stopReason === 'no_progress') {
+        body = '✓ El agente se quedó repitiendo las mismas herramientas sin avanzar.';
+      } else if (result.stopReason === 'budget') {
+        body = '✓ El agente alcanzó el presupuesto de tokens/tiempo sin respuesta final.';
+      } else if (result.stopReason === 'max_rounds') {
+        body = `✓ El agente alcanzó el máximo de rondas (${result.rounds}) sin respuesta final.${
+          toolCalls ? ` Hizo ${toolCalls} herramientas.` : ''
+        }`;
+      } else if (toolCalls) {
+        body = 'V El agente terminó sus herramientas, pero no devolvió un mensaje final.';
+      } else {
+        body = '(sin texto)';
+      }
+    }
+    const footer = completionFooter(result.stopReason, result.rounds, toolCalls, durationMs);
+    await edit(T, chatId, message.message_id, `${body}\n\n- ${footer}`);
+    T.ctx.store.addMessages(sessionId, newMessages);
+    T.ctx.store.touchSession(sessionId, { provider: providerId, model });
+  } catch (error) {
+    await edit(
+      T,
+      chatId,
+      message.message_id,
+      error?.name === 'AbortError' ? 'Cancelado.' : `Error: ${error?.message ?? error}`,
+    );
+  } finally {
+    T.controllers.delete(String(chatId));
+    T.ownSessions.delete(sessionId);
+    mcp?.close?.();
+  }
+}
+

package/harness/packages/server/src/lib/channels/telegram/text.js

@@ -0,0 +1,57 @@
+// Helpers de texto: lo que describe al usuario qué está pidiendo el agente y
+// cómo se resume un turno. Puro, sin estado del canal.
+
+function humanSize(bytes) {
+  const n = Number(bytes) || 0;
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+function oneLine(value, max = 400) {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 1).trimEnd()}…` : text;
+}
+
+/**
+ * Explica en una frase qué va a hacer el agente si se aprueba el permiso, en
+ * vez de volcar el JSON crudo (que para `write` mostraba medio archivo).
+ */
+export function describePermission(name, args = {}) {
+  const a = args && typeof args === 'object' ? args : {};
+  switch (name) {
+    case 'bash':
+      return { action: 'ejecutar un comando en el proyecto', detail: oneLine(a.command, 700) };
+    case 'write':
+      return {
+        action: `escribir el archivo ${a.path ?? '(sin ruta)'}`,
+        detail: a.content ? `Contenido: ${humanSize(Buffer.byteLength(String(a.content)))}` : '',
+      };
+    case 'edit':
+      return {
+        action: `editar el archivo ${a.path ?? '(sin ruta)'}`,
+        detail: a.oldString ? `Reemplaza: "${oneLine(a.oldString, 100)}"` : '',
+      };
+    case 'git_commit':
+      return { action: 'hacer un commit', detail: oneLine(a.message, 200) };
+    case 'screenshot':
+      return { action: 'sacar una captura de la página', detail: oneLine(a.url, 200) };
+    case 'console_errors':
+      return { action: 'revisar la consola de una página', detail: oneLine(a.url, 200) };
+    case 'fetch_url':
+      return { action: 'consultar una URL', detail: oneLine(a.url, 200) };
+    case 'read':
+      return { action: `leer ${oneLine(a.path, 120) || 'un archivo'}`, detail: '' };
+    default:
+      return { action: `usar la herramienta "${name}"`, detail: oneLine(JSON.stringify(a), 200) };
+  }
+}
+
+/** Linea de cierre del turno (rondas, herramientas, duración). */
+export function completionFooter(stopReason, rounds, toolCalls, durationMs) {
+  const parts = [`${rounds ?? '?'} ronda${rounds === 1 ? '' : 's'}`];
+  if (toolCalls) parts.push(`${toolCalls} herramienta${toolCalls === 1 ? '' : 's'}`);
+  if (durationMs > 0) parts.push(durationMs >= 1000 ? `${(durationMs / 1000).toFixed(1)}s` : `${durationMs}ms`);
+  const maxed = ['max_rounds', 'no_progress', 'budget'].includes(stopReason);
+  return `${maxed ? '⚠ corte de seguridad' : '✓ terminado'} · ${parts.join(' · ')}`;
+}