talon-agent 4.3.1 → 4.3.3

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}`,
+    );
+  }
+}

package/src/frontend/teams/poll.ts

@@ -0,0 +1,101 @@
+/**
+ * Teams poll loop — Graph API chat polling is the whole receive side (no
+ * Bot Framework, no inbound endpoint). Each tick fetches the newest
+ * messages, cuts at the last one seen, and hands the rest — oldest first —
+ * to the slash-command router or a model turn.
+ */
+
+import { log, logError } from "../../util/log.js";
+import { handleSlashCommand } from "./commands.js";
+import type { ChatMessage } from "./graph.js";
+import type { TeamsRuntime } from "./runtime.js";
+import { runTurn } from "./turn.js";
+
+/**
+ * Messages arrive newest first; everything before `lastSeenId` is new. IDs
+ * are opaque strings, so this is a cut at the seen id, not a comparison.
+ */
+export function selectNewMessages(
+  messages: ChatMessage[],
+  lastSeenId: string | null,
+): ChatMessage[] {
+  const fresh: ChatMessage[] = [];
+  for (const msg of messages) {
+    if (lastSeenId && msg.id === lastSeenId) break;
+    fresh.push(msg);
+  }
+  return fresh;
+}
+
+// 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.
+function isBotEcho(runtime: TeamsRuntime, msg: ChatMessage): boolean {
+  return (
+    !!runtime.botDisplayName &&
+    msg.senderName.toLowerCase() === runtime.botDisplayName.toLowerCase()
+  );
+}
+
+async function handleMessage(
+  runtime: TeamsRuntime,
+  msg: ChatMessage,
+): Promise<void> {
+  const talonChatId = `teams_chat_${msg.chatId}`;
+  if (await handleSlashCommand(runtime, msg, talonChatId)) return;
+
+  log(
+    "teams",
+    `[${msg.senderName}]: ${msg.text.slice(0, 80)}${msg.text.length > 80 ? "..." : ""}`,
+  );
+  runTurn(runtime, msg, talonChatId);
+}
+
+async function poll(runtime: TeamsRuntime, chatId: string): Promise<void> {
+  if (runtime.polling) return;
+  runtime.polling = true;
+
+  try {
+    if (!runtime.graphClient) return;
+    const messages = await runtime.graphClient.getChatMessages(chatId, 20);
+    const newMessages = selectNewMessages(messages, runtime.lastSeenMessageId);
+
+    if (newMessages.length > 0) {
+      runtime.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;
+      if (isBotEcho(runtime, msg)) continue;
+      await handleMessage(runtime, msg);
+    }
+  } catch (err) {
+    logError(
+      "teams",
+      `Poll error: ${err instanceof Error ? err.message : err}`,
+    );
+  } finally {
+    runtime.polling = false;
+  }
+}
+
+/** Initial poll, then the interval; the timer lives on the runtime so stop can clear it. */
+export async function startPolling(
+  runtime: TeamsRuntime,
+  chatId: string,
+): Promise<void> {
+  await poll(runtime, chatId);
+  runtime.pollTimer = setInterval(
+    () => void poll(runtime, chatId),
+    runtime.pollIntervalMs,
+  );
+}
+
+export function stopPolling(runtime: TeamsRuntime): void {
+  if (runtime.pollTimer) {
+    clearInterval(runtime.pollTimer);
+    runtime.pollTimer = null;
+  }
+}

package/src/frontend/teams/runtime.ts

@@ -0,0 +1,51 @@
+/**
+ * Teams frontend runtime — the state every module shares.
+ *
+ * `createTeamsFrontend` used to hold all of this as closure variables, with
+ * the poll loop and the slash commands nested inside `.start`. It is now one
+ * explicit object, constructed once, that each module (chat-discovery,
+ * poll, commands, turn, outbound) takes as its first parameter.
+ */
+
+import type { TalonConfig } from "../../util/config.js";
+import type { Gateway } from "../../core/engine/gateway.js";
+import type { GraphClient } from "./graph.js";
+
+export type TeamsRuntime = {
+  readonly config: TalonConfig;
+  readonly gateway: Gateway;
+  /** Power Automate workflow webhook URL every outbound card is POSTed to. */
+  readonly webhookUrl: string;
+  /** Display name the workflow posts under — its messages are skipped. */
+  readonly botDisplayName: string;
+  readonly pollIntervalMs: number;
+  /** Optional topic substring used to pick the chat on first run. */
+  readonly configChatTopic: string;
+  graphClient: GraphClient | null;
+  pollTimer: ReturnType<typeof setInterval> | null;
+  /** Newest message id already handled — the poll loop cuts at it. */
+  lastSeenMessageId: string | null;
+  myUserId: string | null;
+  /** Re-entrancy guard: a slow poll never overlaps the next tick. */
+  polling: boolean;
+};
+
+export function createTeamsRuntime(
+  config: TalonConfig,
+  gateway: Gateway,
+): TeamsRuntime {
+  const raw = config as Record<string, unknown>;
+  return {
+    config,
+    gateway,
+    webhookUrl: raw.teamsWebhookUrl as string,
+    botDisplayName: (raw.teamsBotDisplayName as string) || "",
+    pollIntervalMs: (raw.teamsGraphPollMs as number) || 10_000,
+    configChatTopic: (raw.teamsChatTopic as string) || "",
+    graphClient: null,
+    pollTimer: null,
+    lastSeenMessageId: null,
+    myUserId: null,
+    polling: false,
+  };
+}