talon-agent 4.3.1 → 4.3.2

package/src/frontend/teams/chat-discovery.ts

@@ -0,0 +1,69 @@
+/**
+ * Teams chat discovery — which group chat Talon listens to, and where in
+ * its history polling starts.
+ */
+
+import { log, logError } from "../../util/log.js";
+import type { GraphClient } from "./graph.js";
+import type { TeamsRuntime } from "./runtime.js";
+
+/**
+ * Load the stored chat, or pick one — by topic when configured, else the
+ * most recent — and persist the choice for next boot.
+ */
+export async function resolveChatId(
+  runtime: TeamsRuntime,
+  graphClient: GraphClient,
+  userId: string,
+): Promise<string> {
+  const stored = graphClient.getStoredChatId();
+  if (stored) {
+    log("teams", `Using chat: ${graphClient.getStoredChatTopic() || stored}`);
+    return stored;
+  }
+
+  log("teams", "No chat configured, discovering...");
+  const chats = await graphClient.listChats();
+
+  if (chats.length === 0) throw new Error("No chats found");
+
+  // Try to match by topic name if configured
+  let selectedChat = chats[0];
+  const { configChatTopic } = runtime;
+  if (configChatTopic) {
+    const match = chats.find((c) =>
+      c.topic?.toLowerCase().includes(configChatTopic.toLowerCase()),
+    );
+    if (match) selectedChat = match;
+    else
+      log(
+        "teams",
+        `No chat matching topic "${configChatTopic}", using most recent`,
+      );
+  }
+
+  const topic = selectedChat.topic || "(unnamed chat)";
+  graphClient.saveChatConfig(selectedChat.id, topic, userId);
+  log("teams", `Configured chat: ${topic} [${selectedChat.chatType}]`);
+  return selectedChat.id;
+}
+
+/** Start after the newest existing message so old history is never replayed. */
+export async function seedLastSeen(
+  runtime: TeamsRuntime,
+  graphClient: GraphClient,
+  chatId: string,
+): Promise<void> {
+  try {
+    const existing = await graphClient.getChatMessages(chatId, 5);
+    if (existing.length > 0) {
+      runtime.lastSeenMessageId = existing[0].id;
+      log("teams", `Seeded last message ID: ${runtime.lastSeenMessageId}`);
+    }
+  } catch (err) {
+    logError(
+      "teams",
+      `Failed to seed messages: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}

package/src/frontend/teams/commands.ts

@@ -0,0 +1,141 @@
+/**
+ * Teams slash commands — /reset, /status, /help. Each answers with a card
+ * through the webhook and ignores delivery failures; the poll loop moves on
+ * either way.
+ */
+
+import { log } from "../../util/log.js";
+import { resolveModel } from "../../core/models/catalog.js";
+import { resolveChatBackend } from "../../core/engine/backend-controller/index.js";
+import { getSessionInfo } from "../../storage/sessions.js";
+import { getChatSettings } from "../../storage/chat-settings.js";
+import { performSessionReset } from "../shared/session-status.js";
+import { buildCacheDisplay } from "../shared/status-context.js";
+import { buildAdaptiveCard } from "./formatting.js";
+import type { ChatMessage } from "./graph.js";
+import { postCard } from "./outbound.js";
+import type { TeamsRuntime } from "./runtime.js";
+
+const HELP_TEXT =
+  "**Commands:**\n- `/reset` — clear session & history\n- `/status` — session stats\n- `/help` — this message";
+
+type Fact = { title: string; value: string };
+
+function reply(
+  runtime: TeamsRuntime,
+  card: Record<string, unknown>,
+): Promise<unknown> {
+  return postCard(runtime.webhookUrl, card).catch(() => {});
+}
+
+async function handleReset(
+  runtime: TeamsRuntime,
+  msg: ChatMessage,
+  talonChatId: string,
+): Promise<void> {
+  await performSessionReset(
+    talonChatId,
+    resolveChatBackend(talonChatId, runtime.gateway.backend),
+  );
+  log("teams", `Session reset by ${msg.senderName}`);
+  await reply(runtime, buildAdaptiveCard("Session cleared."));
+}
+
+function statusFacts(runtime: TeamsRuntime, talonChatId: string): Fact[] {
+  const info = getSessionInfo(talonChatId);
+  const u = info.usage;
+  const cache = buildCacheDisplay({
+    cacheMetrics: runtime.gateway.backend?.cacheMetrics,
+    inputTokens: u.totalInputTokens,
+    cacheRead: u.totalCacheRead,
+    cacheWrite: u.totalCacheWrite,
+  });
+  const rawModel =
+    getChatSettings(talonChatId).model ?? (runtime.config.model as string);
+  const model = resolveModel(rawModel)?.displayName ?? rawModel;
+  const avgMs = info.turns > 0 ? Math.round(u.totalResponseMs / info.turns) : 0;
+  const ctxUsed = u.contextTokens || u.lastPromptTokens;
+  const ctxMax = u.contextWindow;
+  const ctxPct =
+    ctxMax > 0 ? Math.min(100, Math.round((ctxUsed / ctxMax) * 100)) : 0;
+  return [
+    { title: "Model", value: model },
+    { title: "Turns", value: String(info.turns) },
+    {
+      title: "Context",
+      value: `${(ctxUsed / 1000).toFixed(0)}K / ${(ctxMax / 1000).toFixed(0)}K (${ctxPct}%)`,
+    },
+    ...(cache ? [{ title: "Cache", value: `${cache.hitPct}% hit` }] : []),
+    { title: "Input", value: `${u.totalInputTokens.toLocaleString()} tokens` },
+    {
+      title: "Output",
+      value: `${u.totalOutputTokens.toLocaleString()} tokens`,
+    },
+    {
+      title: "Avg response",
+      value: avgMs > 0 ? `${(avgMs / 1000).toFixed(1)}s` : "—",
+    },
+  ];
+}
+
+function buildStatusCard(
+  runtime: TeamsRuntime,
+  talonChatId: string,
+): Record<string, unknown> {
+  return {
+    type: "message",
+    attachments: [
+      {
+        contentType: "application/vnd.microsoft.card.adaptive",
+        contentUrl: null,
+        content: {
+          type: "AdaptiveCard",
+          $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+          version: "1.4",
+          body: [
+            {
+              type: "TextBlock",
+              text: "**Session**",
+              wrap: true,
+              size: "Medium",
+              weight: "Bolder",
+            },
+            { type: "FactSet", facts: statusFacts(runtime, talonChatId) },
+          ],
+        },
+      },
+    ],
+  };
+}
+
+type CommandHandler = (
+  runtime: TeamsRuntime,
+  msg: ChatMessage,
+  talonChatId: string,
+) => Promise<void>;
+
+/** Exact-match table: the whole message, trimmed and lowercased, is the key. */
+export const TEAMS_COMMANDS: Record<string, CommandHandler> = Object.assign(
+  Object.create(null) as Record<string, CommandHandler>,
+  {
+    "/reset": handleReset,
+    "/status": async (runtime, _msg, talonChatId) => {
+      await reply(runtime, buildStatusCard(runtime, talonChatId));
+    },
+    "/help": async (runtime) => {
+      await reply(runtime, buildAdaptiveCard(HELP_TEXT));
+    },
+  } satisfies Record<string, CommandHandler>,
+);
+
+/** Returns true when `msg` was a slash command and has been answered. */
+export async function handleSlashCommand(
+  runtime: TeamsRuntime,
+  msg: ChatMessage,
+  talonChatId: string,
+): Promise<boolean> {
+  const handler = TEAMS_COMMANDS[msg.text.trim().toLowerCase()];
+  if (!handler) return false;
+  await handler(runtime, msg, talonChatId);
+  return true;
+}

package/src/frontend/teams/index.ts

@@ -6,29 +6,22 @@
  *                          using Chat.Read scope (no admin consent needed).
  *
  * No Azure AD app registration, no Bot Framework, no admin consent.
+ *
+ * This file is wiring only: it constructs the shared runtime (runtime.ts)
+ * and owns the frontend lifecycle. The behaviour lives in the modules —
+ * chat-discovery, poll, commands, turn, outbound.
  */
 
 import type { TalonConfig } from "../../util/config.js";
 import type { ContextManager } from "../../core/types.js";
 import type { Gateway } from "../../core/engine/gateway.js";
-import { log, logError } from "../../util/log.js";
-import { deriveNumericChatId } from "../../util/chat-id.js";
-import { resolveModel } from "../../core/models/catalog.js";
-import { toolInputToRecord } from "../../core/agent-runtime/events.js";
-import { execute } from "../../core/engine/dispatcher.js";
-import { resolveChatBackend } from "../../core/engine/backend-controller/index.js";
-import { getSessionInfo } from "../../storage/sessions.js";
-import { getChatSettings } from "../../storage/chat-settings.js";
-import { performSessionReset } from "../shared/session-status.js";
-import { createTeamsActionHandler, postToTeams } from "./actions.js";
-import { splitTeamsMessage, buildAdaptiveCard } from "./formatting.js";
-import { buildCacheDisplay } from "../shared/status-context.js";
-import {
-  initGraphClient,
-  type GraphClient,
-  type ChatMessage,
-} from "./graph.js";
-import { proxyFetch } from "./proxy-fetch.js";
+import { log } from "../../util/log.js";
+import { createTeamsActionHandler } from "./actions.js";
+import { resolveChatId, seedLastSeen } from "./chat-discovery.js";
+import { initGraphClient } from "./graph.js";
+import { sendText } from "./outbound.js";
+import { startPolling, stopPolling } from "./poll.js";
+import { createTeamsRuntime } from "./runtime.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -49,20 +42,7 @@ export function createTeamsFrontend(
   config: TalonConfig,
   gateway: Gateway,
 ): TeamsFrontend {
-  const webhookUrl = (config as Record<string, unknown>)
-    .teamsWebhookUrl as string;
-  const botDisplayName =
-    ((config as Record<string, unknown>).teamsBotDisplayName as string) || "";
-  const pollIntervalMs =
-    ((config as Record<string, unknown>).teamsGraphPollMs as number) || 10_000;
-  const configChatTopic =
-    ((config as Record<string, unknown>).teamsChatTopic as string) || "";
-
-  let graphClient: GraphClient | null = null;
-  let pollTimer: ReturnType<typeof setInterval> | null = null;
-  let lastSeenMessageId: string | null = null;
-  let myUserId: string | null = null;
-  let polling = false;
+  const runtime = createTeamsRuntime(config, gateway);
 
   const context: ContextManager = {
     acquire: (chatId: number, stringId?: string) =>
@@ -78,26 +58,7 @@ export function createTeamsFrontend(
     // Teams has no typing indicator via webhooks
     sendTyping: async () => {},
 
-    sendMessage: async (_chatId: number, text: string) => {
-      if (!text.trim()) return;
-      try {
-        const chunks = splitTeamsMessage(text);
-        for (const chunk of chunks) {
-          const card = buildAdaptiveCard(chunk);
-          await proxyFetch(webhookUrl, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(card),
-            signal: AbortSignal.timeout(15_000),
-          });
-        }
-      } catch (err) {
-        logError(
-          "teams",
-          `sendMessage failed: ${err instanceof Error ? err.message : err}`,
-        );
-      }
-    },
+    sendMessage: (_chatId: number, text: string) => sendText(runtime, text),
 
     getBridgePort: () => gateway.getPort(),
 
@@ -105,332 +66,45 @@ export function createTeamsFrontend(
       // Register action handler with the gateway
       gateway.registerFrontendHandler(
         "teams",
-        createTeamsActionHandler(webhookUrl, gateway),
+        createTeamsActionHandler(runtime.webhookUrl, gateway),
       );
       const port = await gateway.start(19876);
       log("teams", `Gateway on port ${port}`);
 
       // Authenticate with Microsoft Graph
       log("teams", "Initializing Microsoft Graph client...");
-      graphClient = await initGraphClient();
+      const graphClient = await initGraphClient();
+      runtime.graphClient = graphClient;
 
       // Get our own user ID (to filter out our own messages)
       const me = await graphClient.getMe();
-      myUserId = me.id;
+      runtime.myUserId = me.id;
       log("teams", `Authenticated as: ${me.displayName} (${me.id})`);
 
-      // Discover or load chat
-      let chatId = graphClient.getStoredChatId();
-
-      if (!chatId) {
-        log("teams", "No chat configured, discovering...");
-        const chats = await graphClient.listChats();
-
-        if (chats.length === 0) throw new Error("No chats found");
-
-        // Try to match by topic name if configured
-        let selectedChat = chats[0];
-        if (configChatTopic) {
-          const match = chats.find((c) =>
-            c.topic?.toLowerCase().includes(configChatTopic.toLowerCase()),
-          );
-          if (match) selectedChat = match;
-          else
-            log(
-              "teams",
-              `No chat matching topic "${configChatTopic}", using most recent`,
-            );
-        }
-
-        chatId = selectedChat.id;
-        const topic = selectedChat.topic || "(unnamed chat)";
-
-        graphClient.saveChatConfig(chatId, topic, myUserId);
-        log("teams", `Configured chat: ${topic} [${selectedChat.chatType}]`);
-      } else {
-        log(
-          "teams",
-          `Using chat: ${graphClient.getStoredChatTopic() || chatId}`,
-        );
-      }
-
-      // Seed lastSeenMessageId from current messages (don't process old messages)
-      try {
-        const existing = await graphClient.getChatMessages(chatId, 5);
-        if (existing.length > 0) {
-          lastSeenMessageId = existing[0].id;
-          log("teams", `Seeded last message ID: ${lastSeenMessageId}`);
-        }
-      } catch (err) {
-        logError(
-          "teams",
-          `Failed to seed messages: ${err instanceof Error ? err.message : err}`,
-        );
-      }
+      const chatId = await resolveChatId(runtime, graphClient, me.id);
+      await seedLastSeen(runtime, graphClient, chatId);
     },
 
     async start() {
-      if (!graphClient) throw new Error("Graph client not initialized");
+      if (!runtime.graphClient) throw new Error("Graph client not initialized");
 
-      const chatId = graphClient.getStoredChatId()!;
+      const chatId = runtime.graphClient.getStoredChatId()!;
 
       log("teams", "Teams frontend running");
       log("teams", `Send: Power Automate webhook`);
       log(
         "teams",
-        `Receive: Graph API chat polling every ${pollIntervalMs / 1000}s`,
+        `Receive: Graph API chat polling every ${runtime.pollIntervalMs / 1000}s`,
       );
 
-      // ── Poll loop ──────────────────────────────────────────────────────
-      async function poll(): Promise<void> {
-        if (polling) return;
-        polling = true;
-
-        try {
-          if (!graphClient) return;
-          const messages = await graphClient.getChatMessages(chatId, 20);
-
-          // Find new messages — messages are returned newest first
-          // IDs are opaque strings, so compare by createdDateTime
-          const newMessages: ChatMessage[] = [];
-          for (const msg of messages) {
-            if (lastSeenMessageId && msg.id === lastSeenMessageId) break;
-            newMessages.push(msg);
-          }
-
-          if (newMessages.length > 0) {
-            lastSeenMessageId = newMessages[0].id;
-          }
-
-          // Process in chronological order (oldest first)
-          for (const msg of newMessages.reverse()) {
-            if (!msg.text.trim()) continue;
-            if (msg.edited) continue;
-
-            // Skip bot/workflow messages by display name (echo loop prevention).
-            // We do NOT filter by user ID — the authenticated user also sends
-            // real messages that Talon should respond to.
-            if (
-              botDisplayName &&
-              msg.senderName.toLowerCase() === botDisplayName.toLowerCase()
-            ) {
-              continue;
-            }
-
-            const numericChatId = deriveNumericChatId(msg.chatId);
-            const talonChatId = `teams_chat_${msg.chatId}`;
-
-            // ── Slash commands ──
-            const trimmed = msg.text.trim().toLowerCase();
-            if (trimmed === "/reset") {
-              await performSessionReset(
-                talonChatId,
-                resolveChatBackend(talonChatId, gateway.backend),
-              );
-              log("teams", `Session reset by ${msg.senderName}`);
-              const card = buildAdaptiveCard("Session cleared.");
-              await proxyFetch(webhookUrl, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(card),
-                signal: AbortSignal.timeout(15_000),
-              }).catch(() => {});
-              continue;
-            }
-            if (trimmed === "/status") {
-              const info = getSessionInfo(talonChatId);
-              const u = info.usage;
-              const cache = buildCacheDisplay({
-                cacheMetrics: gateway.backend?.cacheMetrics,
-                inputTokens: u.totalInputTokens,
-                cacheRead: u.totalCacheRead,
-                cacheWrite: u.totalCacheWrite,
-              });
-              const rawModel =
-                getChatSettings(talonChatId).model ?? (config.model as string);
-              const model = resolveModel(rawModel)?.displayName ?? rawModel;
-              const avgMs =
-                info.turns > 0 ? Math.round(u.totalResponseMs / info.turns) : 0;
-              const ctxUsed = u.contextTokens || u.lastPromptTokens;
-              const ctxMax = u.contextWindow;
-              const ctxPct =
-                ctxMax > 0
-                  ? Math.min(100, Math.round((ctxUsed / ctxMax) * 100))
-                  : 0;
-              const card = {
-                type: "message",
-                attachments: [
-                  {
-                    contentType: "application/vnd.microsoft.card.adaptive",
-                    contentUrl: null,
-                    content: {
-                      type: "AdaptiveCard",
-                      $schema:
-                        "http://adaptivecards.io/schemas/adaptive-card.json",
-                      version: "1.4",
-                      body: [
-                        {
-                          type: "TextBlock",
-                          text: "**Session**",
-                          wrap: true,
-                          size: "Medium",
-                          weight: "Bolder",
-                        },
-                        {
-                          type: "FactSet",
-                          facts: [
-                            { title: "Model", value: model },
-                            { title: "Turns", value: String(info.turns) },
-                            {
-                              title: "Context",
-                              value: `${(ctxUsed / 1000).toFixed(0)}K / ${(ctxMax / 1000).toFixed(0)}K (${ctxPct}%)`,
-                            },
-                            ...(cache
-                              ? [
-                                  {
-                                    title: "Cache",
-                                    value: `${cache.hitPct}% hit`,
-                                  },
-                                ]
-                              : []),
-                            {
-                              title: "Input",
-                              value: `${u.totalInputTokens.toLocaleString()} tokens`,
-                            },
-                            {
-                              title: "Output",
-                              value: `${u.totalOutputTokens.toLocaleString()} tokens`,
-                            },
-                            {
-                              title: "Avg response",
-                              value:
-                                avgMs > 0
-                                  ? `${(avgMs / 1000).toFixed(1)}s`
-                                  : "—",
-                            },
-                          ],
-                        },
-                      ],
-                    },
-                  },
-                ],
-              };
-              await proxyFetch(webhookUrl, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(card),
-                signal: AbortSignal.timeout(15_000),
-              }).catch(() => {});
-              continue;
-            }
-            if (trimmed === "/help") {
-              const helpText =
-                "**Commands:**\n- `/reset` — clear session & history\n- `/status` — session stats\n- `/help` — this message";
-              const card = buildAdaptiveCard(helpText);
-              await proxyFetch(webhookUrl, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(card),
-                signal: AbortSignal.timeout(15_000),
-              }).catch(() => {});
-              continue;
-            }
-
-            log(
-              "teams",
-              `[${msg.senderName}]: ${msg.text.slice(0, 80)}${msg.text.length > 80 ? "..." : ""}`,
-            );
-
-            execute({
-              chatId: talonChatId,
-              numericChatId,
-              prompt: `[${msg.senderName}]: ${msg.text}`,
-              senderName: msg.senderName,
-              isGroup: true,
-              source: "message",
-              onEvent: async (event) => {
-                switch (event.type) {
-                  case "text_delta":
-                    log("teams", `  phase: text`);
-                    break;
-                  case "reasoning":
-                    log("teams", `  phase: thinking`);
-                    break;
-                  case "tool_call": {
-                    const input = toolInputToRecord(event.name, event.input);
-                    const detail = (input.description ??
-                      input.command ??
-                      input.action ??
-                      input.query ??
-                      input.url ??
-                      input.name ??
-                      "") as string;
-                    log(
-                      "teams",
-                      `  tool: ${event.name}${detail ? ` — ${String(detail).slice(0, 100)}` : ""}`,
-                    );
-                    break;
-                  }
-                  // Deliver assistant text (progress text before tool calls AND
-                  // the end-of-turn trailing-text fallback) to the Teams chat.
-                  // Without this, prose-only assistant turns would be silently
-                  // dropped — same scratchpad bug Telegram hit.
-                  case "assistant_message": {
-                    if (!event.text.trim()) break;
-                    try {
-                      await postToTeams(webhookUrl, event.text);
-                      gateway.incrementMessages(numericChatId);
-                    } catch (err) {
-                      // Post failures are swallowed (logged, not rethrown) —
-                      // preserves the old `onTextBlock` semantics where Teams
-                      // never propagated delivery errors back to the backend.
-                      // Returning normally lets the dispatcher resolve the ack.
-                      logError(
-                        "teams",
-                        `onEvent postToTeams failed: ${err instanceof Error ? err.message : err}`,
-                      );
-                    }
-                    break;
-                  }
-                }
-              },
-            })
-              .then(async (_result) => {
-                // No fallback delivery — turns without end_turn / send_message
-                // are intentional silent ends. Trailing prose without a tool
-                // call is scratchpad and dropped; the SDK handler emits a
-                // `scratchpad.trailing_text_dropped` metric on those.
-              })
-              .catch((err) => {
-                logError(
-                  "teams",
-                  `execute failed: ${err instanceof Error ? err.message : err}`,
-                );
-              });
-          }
-        } catch (err) {
-          logError(
-            "teams",
-            `Poll error: ${err instanceof Error ? err.message : err}`,
-          );
-        } finally {
-          polling = false;
-        }
-      }
-
-      // Initial poll, then interval
-      await poll();
-      pollTimer = setInterval(poll, pollIntervalMs);
+      await startPolling(runtime, chatId);
 
       // Hold process open
       await new Promise(() => {});
     },
 
     async stop() {
-      if (pollTimer) {
-        clearInterval(pollTimer);
-        pollTimer = null;
-      }
+      stopPolling(runtime);
       await gateway.stop();
       log("teams", "Teams frontend stopped");
     },

package/src/frontend/teams/outbound.ts

@@ -0,0 +1,44 @@
+/**
+ * Teams outbound — every card Talon sends is an Adaptive Card POSTed to the
+ * Power Automate workflow webhook. There is no other send path.
+ */
+
+import { logError } from "../../util/log.js";
+import { buildAdaptiveCard, splitTeamsMessage } from "./formatting.js";
+import { proxyFetch } from "./proxy-fetch.js";
+import type { TeamsRuntime } from "./runtime.js";
+
+/** POST one card to the webhook; the caller decides what a non-2xx means. */
+export function postCard(
+  webhookUrl: string,
+  card: Record<string, unknown>,
+): Promise<Response> {
+  return proxyFetch(webhookUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(card),
+    signal: AbortSignal.timeout(15_000),
+  });
+}
+
+/**
+ * Out-of-turn delivery (cron / pulse / heartbeat). Failures are logged and
+ * swallowed — the callers have nowhere to surface them.
+ */
+export async function sendText(
+  runtime: TeamsRuntime,
+  text: string,
+): Promise<void> {
+  if (!text.trim()) return;
+  try {
+    const chunks = splitTeamsMessage(text);
+    for (const chunk of chunks) {
+      await postCard(runtime.webhookUrl, buildAdaptiveCard(chunk));
+    }
+  } catch (err) {
+    logError(
+      "teams",
+      `sendMessage failed: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}