talon-agent 1.33.0 → 1.34.1

package/src/core/weaver/warp-resolver.ts

@@ -0,0 +1,123 @@
+/**
+ * WarpResolver — turns an incoming turn into the model/backend binding
+ * (the warp) it will run on.
+ *
+ * Owns the whole resolution ladder so the Weaver never sees a partial
+ * state: active-model resolution, the send-time null-model guard, and
+ * the per-run override (triggers/cron) with its fall-back-to-chat-model
+ * safety. The result is a discriminated union — either a bound warp or
+ * a refusal with the user-facing message to deliver — so callers can't
+ * forget to handle the "no model" case.
+ */
+
+import type { ModelRef } from "../agent-runtime/model-ref.js";
+import { logDebug, logWarn } from "../../util/log.js";
+
+export type WarpResolverDeps = {
+  /**
+   * Walks the 5-step active-model resolution chain for the chat. When
+   * `model`/`ref` are both `null` (catalog-driven backend with no
+   * per-chat pick and no operator default) the turn is refused — see
+   * `resolve()`.
+   */
+  resolveActiveModel: (chatId: string) => Promise<{
+    model: string | null;
+    ref: ModelRef | null;
+    backendId: string;
+  }>;
+  /**
+   * Validates + materialises an explicit per-run model id against the
+   * chat's backend. Returns `null` when the id isn't selectable, so
+   * the resolver falls back to the chat model. Restricted to the
+   * chat's own backend so the session still resumes.
+   */
+  resolveModelOverride?: (
+    chatId: string,
+    modelId: string,
+  ) => Promise<ModelRef | null>;
+};
+
+export type ResolveWarpInput = {
+  chatId: string;
+  /** Optional per-run model override (triggers/cron). */
+  modelOverride?: string;
+  /** Turn source, used only for override logging. */
+  source: string;
+  /** Request id for log correlation. */
+  reqId: string;
+};
+
+export type WarpResolution =
+  | {
+      ok: true;
+      /** The ModelRef the turn runs on (post-override). */
+      ref: ModelRef;
+      backendId: string;
+      /** A per-run override was applied for this turn. */
+      overridden: boolean;
+    }
+  | {
+      ok: false;
+      backendId: string;
+      /** User-facing refusal ("use /model to pick one"). */
+      message: string;
+    };
+
+export async function resolveWarp(
+  deps: WarpResolverDeps,
+  input: ResolveWarpInput,
+): Promise<WarpResolution> {
+  const { chatId, modelOverride, source, reqId } = input;
+
+  // Send-time null-model guard. When the active-model resolver returns
+  // no usable model, refuse to call the backend — it would either error
+  // opaquely or run on the wrong default.
+  const { model, ref, backendId } = await deps.resolveActiveModel(chatId);
+  if (model === null || ref === null) {
+    logWarn(
+      "dispatcher",
+      `[${reqId}] refusing query: no model resolved (chat=${chatId}, backend=${backendId})`,
+    );
+    return {
+      ok: false,
+      backendId,
+      message:
+        `No model selected for backend \`${backendId}\`. ` +
+        `Use /model to pick one — or set ` +
+        `\`backendDefaults.${backendId}\` in talon.json to apply a ` +
+        `default for all chats on this backend.`,
+    };
+  }
+
+  // Per-run model override (triggers/cron). Resolve against the chat's
+  // backend; on success swap the ref for this turn only, on failure fall
+  // back to the chat model so a stale override never kills the run.
+  let runRef = ref;
+  if (modelOverride && deps.resolveModelOverride) {
+    try {
+      const overrideRef = await deps.resolveModelOverride(
+        chatId,
+        modelOverride,
+      );
+      if (overrideRef) {
+        runRef = overrideRef;
+        logDebug(
+          "dispatcher",
+          `[${reqId}] model override → ${modelOverride} (${source})`,
+        );
+      } else {
+        logWarn(
+          "dispatcher",
+          `[${reqId}] model override "${modelOverride}" not resolvable on backend ${backendId}; using chat model`,
+        );
+      }
+    } catch (err) {
+      logWarn(
+        "dispatcher",
+        `[${reqId}] model override resolution threw: ${err instanceof Error ? err.message : String(err)}; using chat model`,
+      );
+    }
+  }
+
+  return { ok: true, ref: runRef, backendId, overridden: runRef !== ref };
+}

package/src/core/weaver/weaver.ts

@@ -1,18 +1,43 @@
+/**
+ * Weaver — the turn orchestrator. `runTurn` serializes each turn onto
+ * its chat's Thread (per-chat FIFO, cross-chat parallel) and drives the
+ * turn lifecycle by composing the weaver's single-purpose collaborators:
+ *
+ *   - `resolveWarp` (warp-resolver.ts) — model/backend binding + the
+ *     null-model guard and per-run override fallback;
+ *   - `startTypingLoop` (typing-loop.ts) — keeps the frontend's typing
+ *     indicator alive for the duration of the turn;
+ *   - `prefetchMemory` (memory-prefetch.ts) — optional fail-closed
+ *     palace pre-retrieval for live user messages;
+ *   - `carryTurnEvents` (shuttle.ts) — pumps the backend's AgentEvent
+ *     stream into the frontend sink, settles delivery acks, captures
+ *     the result and rethrows error terminators.
+ *
+ * The Weaver itself only sequences those stages and brackets them with
+ * the Thread's execution context — it holds no per-chat state (that's
+ * the Thread's) and no policy of its own beyond ordering.
+ */
+
 import { randomBytes } from "node:crypto";
-import type {
-  Backend,
-  RetrievedMemory,
-} from "../agent-runtime/capabilities.js";
-import { AgentRunError, type AgentResult } from "../agent-runtime/events.js";
+import type { Backend } from "../agent-runtime/capabilities.js";
+import type { AgentResult } from "../agent-runtime/events.js";
 import type { ModelRef } from "../agent-runtime/model-ref.js";
-import { maybeStartDream } from "../background/dream.js";
 import type { MemoryRetriever } from "../memory/retrieval.js";
 import type { ContextManager, ExecuteParams, ExecuteResult } from "../types.js";
 import { log, logDebug, logWarn } from "../../util/log.js";
 import { Loom } from "./loom.js";
+import { prefetchMemory } from "./memory-prefetch.js";
+import { carryTurnEvents } from "./shuttle.js";
 import type { Thread, ThreadSnapshot } from "./thread.js";
+import { startTypingLoop } from "./typing-loop.js";
+import { resolveWarp } from "./warp-resolver.js";
 
 export type WeaverDeps = {
+  /**
+   * Read fresh per call so backend swaps (chat-role rebinds or
+   * per-chat overrides via the controller) take effect on the next
+   * query without a dispatcher re-init.
+   */
   getBackend: (chatId?: string) => Backend;
   resolveActiveModel: (chatId: string) => Promise<{
     model: string | null;
@@ -26,6 +51,14 @@ export type WeaverDeps = {
   context: ContextManager;
   sendTyping: (chatId: number, stringId?: string) => Promise<void>;
   onActivity: () => void;
+  /**
+   * Optional fire-and-forget hook invoked at the start of every turn,
+   * after the warp is bound and before the backend is called. The
+   * composition root wires background work here (e.g. dream memory
+   * consolidation) so the Weaver stays ignorant of those subsystems.
+   * Must not throw and must not block — it is called synchronously.
+   */
+  onTurnStart?: () => void;
   /**
    * Optional memory pre-retrieval (Phase B). Called for `source: "message"`
    * turns after model/backend resolution and context acquisition, before
@@ -38,6 +71,7 @@ export type WeaverDeps = {
 export class Weaver {
   readonly loom: Loom;
   private readonly deps: WeaverDeps;
+  private activeCount = 0;
 
   constructor(deps: WeaverDeps, loom = new Loom()) {
     this.deps = deps;
@@ -49,6 +83,7 @@ export class Weaver {
     return thread.enqueue(() => this.run(thread, params));
   }
 
+  /** Number of turns currently running (not queued) across all chats. */
   getActiveCount(): number {
     return this.activeCount;
   }
@@ -59,14 +94,9 @@ export class Weaver {
    * frontends. Reading is side-effect free.
    */
   snapshot(): ThreadSnapshot[] {
-    return this.loom
-      .chatIds()
-      .map((id) => this.loom.get(id)?.describe())
-      .filter((s): s is ThreadSnapshot => s !== undefined);
+    return this.loom.snapshot();
   }
 
-  private activeCount = 0;
-
   private async run(
     thread: Thread,
     params: ExecuteParams,
@@ -83,95 +113,32 @@ export class Weaver {
     thread: Thread,
     params: ExecuteParams,
   ): Promise<ExecuteResult> {
-    const {
-      getBackend,
-      resolveActiveModel,
-      resolveModelOverride,
-      context,
-      sendTyping,
-      onActivity,
-      retrieveMemory,
-    } = this.deps;
-    // Read the backend fresh per call so backend swaps (chat-role
-    // rebinds or per-chat overrides via the controller) take effect on
-    // the next query without a dispatcher re-init.
-    const backend = getBackend(params.chatId);
+    const { context, onActivity, retrieveMemory } = this.deps;
+    const backend = this.deps.getBackend(params.chatId);
     const reqId = randomBytes(4).toString("hex");
 
-    // Send-time null-model guard. When the active-model resolver
-    // returns no usable model (catalog-driven backend with no per-chat
-    // pick and no operator default), refuse to call the backend — it
-    // would either error opaquely or run on the wrong default. Reply
-    // with a clear "use /model to pick one" message routed through the
-    // same event sink the backend would use for output (as an
-    // `assistant_message` event, so the frontend delivers it normally).
-    const {
-      model: resolvedModel,
-      ref: resolvedRef,
-      backendId,
-    } = await resolveActiveModel(params.chatId);
-    if (resolvedModel === null || resolvedRef === null) {
-      const message =
-        `No model selected for backend \`${backendId}\`. ` +
-        `Use /model to pick one — or set ` +
-        `\`backendDefaults.${backendId}\` in talon.json to apply a ` +
-        `default for all chats on this backend.`;
-      logWarn(
-        "dispatcher",
-        `[${reqId}] refusing query: no model resolved (chat=${params.chatId}, backend=${backendId})`,
-      );
+    const warp = await resolveWarp(this.deps, {
+      chatId: params.chatId,
+      modelOverride: params.modelOverride,
+      source: params.source,
+      reqId,
+    });
+    if (!warp.ok) {
+      // Refusals are delivered through the same event sink the backend
+      // would use for output (as an `assistant_message` event, so the
+      // frontend delivers it normally).
       try {
-        await params.onEvent?.({ type: "assistant_message", text: message });
+        await params.onEvent?.({
+          type: "assistant_message",
+          text: warp.message,
+        });
       } catch (err) {
         logWarn(
           "dispatcher",
           `onEvent(no-model) threw: ${err instanceof Error ? err.message : String(err)}`,
         );
       }
-      return {
-        text: message,
-        durationMs: 0,
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        bridgeMessageCount: context.getMessageCount(
-          params.numericChatId,
-          params.chatId,
-        ),
-      };
-    }
-
-    // Per-run model override (triggers/cron). Resolve against the chat's
-    // backend; on success swap the ref for this turn only, on failure fall
-    // back to the chat model so a stale override never kills the run. The
-    // override is restricted to the chat's own backend, so the session still
-    // resumes — only the model changes.
-    let runRef = resolvedRef;
-    if (params.modelOverride && resolveModelOverride) {
-      try {
-        const overrideRef = await resolveModelOverride(
-          params.chatId,
-          params.modelOverride,
-        );
-        if (overrideRef) {
-          runRef = overrideRef;
-          logDebug(
-            "dispatcher",
-            `[${reqId}] model override → ${params.modelOverride} (${params.source})`,
-          );
-        } else {
-          logWarn(
-            "dispatcher",
-            `[${reqId}] model override "${params.modelOverride}" not resolvable on backend ${backendId}; using chat model`,
-          );
-        }
-      } catch (err) {
-        logWarn(
-          "dispatcher",
-          `[${reqId}] model override resolution threw: ${err instanceof Error ? err.message : String(err)}; using chat model`,
-        );
-      }
+      return this.emptyResult(warp.message, params);
     }
 
     // Bind the warp — record the model/backend actually resolved for this turn
@@ -179,158 +146,105 @@ export class Weaver {
     // last turn (per-chat rebind, per-run override, or config drift) is logged
     // rather than passing silently.
     const { drifted, previous } = thread.bindWarp({
-      model: runRef.id,
-      backendId,
-      overridden: runRef !== resolvedRef,
+      model: warp.ref.id,
+      backendId: warp.backendId,
+      overridden: warp.overridden,
       boundAt: Date.now(),
     });
     if (drifted && previous) {
       logDebug(
         "dispatcher",
-        `[${reqId}] warp drift chat=${params.chatId}: ${previous.backendId}/${previous.model} → ${backendId}/${runRef.id}`,
+        `[${reqId}] warp drift chat=${params.chatId}: ${previous.backendId}/${previous.model} → ${warp.backendId}/${warp.ref.id}`,
       );
     }
 
-    // Dream check — fire-and-forget background memory consolidation if due
-    maybeStartDream();
+    this.deps.onTurnStart?.();
 
     logDebug(
       "dispatcher",
       `[${reqId}] ${params.source} chat=${params.chatId} started (active=${this.activeCount})`,
     );
     context.acquire(params.numericChatId, params.chatId);
-
-    let typingTimer: ReturnType<typeof setInterval> | undefined;
+    const stopTyping = startTypingLoop(
+      this.deps.sendTyping,
+      params.numericChatId,
+      params.chatId,
+    );
     try {
-      await sendTyping(params.numericChatId, params.chatId).catch(
-        (err: unknown) => {
-          logWarn(
-            "dispatcher",
-            `sendTyping failed: ${err instanceof Error ? err.message : String(err)}`,
-          );
-        },
-      );
-      typingTimer = setInterval(() => {
-        sendTyping(params.numericChatId, params.chatId).catch(
-          (err: unknown) => {
-            logWarn(
-              "dispatcher",
-              `sendTyping interval failed: ${err instanceof Error ? err.message : String(err)}`,
-            );
-          },
-        );
-      }, 4000);
-
-      // Consume the backend's native `AgentEvent` stream and forward
-      // every event straight to the frontend's `onEvent` sink (no
-      // callback bridge). Capture the `completed` event's `AgentResult`
-      // for the dispatcher's return value, and rethrow an `error`
-      // terminator as `AgentRunError` so callers' catch paths keep
-      // working. Events are awaited in stream order so a consumer that
-      // needs serial delivery gets it.
       if (!backend.chat) {
         throw new Error(
           `Backend "${backend.id}" has no chat capability — cannot run a turn.`,
         );
       }
 
-      // Phase B memory pre-retrieval: only for live user messages, only when
-      // a retriever dep is wired, and strictly fail-closed — a broken palace
-      // must never block chat delivery. The result is dynamic turn context
-      // passed through ChatRunParams; it never touches the frozen prompt.
-      let retrievedMemory: RetrievedMemory | undefined;
-      if (retrieveMemory && params.source === "message") {
-        try {
-          retrievedMemory = await retrieveMemory({
-            runKind: "chat",
-            chatId: params.chatId,
-            text: params.prompt,
-            senderName: params.senderName,
-            isGroup: params.isGroup,
-          });
-          if (retrievedMemory) {
-            logDebug(
-              "dispatcher",
-              `[${reqId}] memory pre-retrieval: ${retrievedMemory.items.length} item(s), ` +
-                `${retrievedMemory.items.reduce((n, i) => n + i.text.length, 0)} chars`,
-            );
-          }
-        } catch (err) {
-          logWarn(
-            "dispatcher",
-            `[${reqId}] memory pre-retrieval failed (running turn without it): ` +
-              (err instanceof Error ? err.message : String(err)),
-          );
-          retrievedMemory = undefined;
-        }
-      }
+      const retrievedMemory =
+        retrieveMemory && params.source === "message"
+          ? await prefetchMemory(retrieveMemory, {
+              chatId: params.chatId,
+              text: params.prompt,
+              senderName: params.senderName,
+              isGroup: params.isGroup,
+              reqId,
+            })
+          : undefined;
 
       const stream = backend.chat.runChatTurn({
         chatId: params.chatId,
-        model: runRef,
+        model: warp.ref,
         text: params.prompt,
         senderName: params.senderName,
         isGroup: params.isGroup,
         messageId: params.messageId,
         retrievedMemory,
       });
-      let agentResult: AgentResult | undefined;
-      for await (const event of stream) {
-        if (event.type === "completed") {
-          agentResult = event.result;
-        }
-
-        // The dispatcher owns `assistant_message.deliveryAck` settlement
-        // so it is ALWAYS resolved — even when no `onEvent` sink is
-        // supplied, or the sink ignores the event. Otherwise the
-        // callback-shaped backend (handler-to-events) blocks forever
-        // awaiting delivery confirmation. The frontend's job is just to
-        // deliver and throw on failure; the dispatcher maps that onto the
-        // ack (resolve on success → block delivered; reject on throw →
-        // backend retries, e.g. Codex oversized-message path).
-        if (event.type === "assistant_message" && event.deliveryAck) {
-          try {
-            await params.onEvent?.(event);
-            event.deliveryAck.resolve();
-          } catch (err) {
-            event.deliveryAck.reject(err);
-          }
-          continue;
-        }
-
-        await params.onEvent?.(event);
-        if (event.type === "error") {
-          throw new AgentRunError(event.error);
-        }
-      }
-      const result = {
-        text: agentResult?.text ?? "",
-        durationMs: agentResult?.durationMs ?? 0,
-        inputTokens: agentResult?.usage.inputTokens ?? 0,
-        outputTokens: agentResult?.usage.outputTokens ?? 0,
-        cacheRead: agentResult?.usage.cacheRead ?? 0,
-        cacheWrite: agentResult?.usage.cacheWrite ?? 0,
-      };
+      const agentResult = await carryTurnEvents(stream, params.onEvent);
 
       onActivity();
-
       logDebug(
         "dispatcher",
-        `[${reqId}] completed in ${result.durationMs}ms (in=${result.inputTokens} out=${result.outputTokens})`,
+        `[${reqId}] completed in ${agentResult?.durationMs ?? 0}ms ` +
+          `(in=${agentResult?.usage.inputTokens ?? 0} out=${agentResult?.usage.outputTokens ?? 0})`,
       );
 
-      return {
-        ...result,
-        bridgeMessageCount: context.getMessageCount(
-          params.numericChatId,
-          params.chatId,
-        ),
-      };
+      return this.toExecuteResult(agentResult, params);
     } finally {
-      clearInterval(typingTimer);
+      stopTyping();
       context.release(params.numericChatId, params.chatId);
     }
   }
+
+  private toExecuteResult(
+    result: AgentResult | undefined,
+    params: ExecuteParams,
+  ): ExecuteResult {
+    return {
+      text: result?.text ?? "",
+      durationMs: result?.durationMs ?? 0,
+      inputTokens: result?.usage.inputTokens ?? 0,
+      outputTokens: result?.usage.outputTokens ?? 0,
+      cacheRead: result?.usage.cacheRead ?? 0,
+      cacheWrite: result?.usage.cacheWrite ?? 0,
+      bridgeMessageCount: this.deps.context.getMessageCount(
+        params.numericChatId,
+        params.chatId,
+      ),
+    };
+  }
+
+  private emptyResult(text: string, params: ExecuteParams): ExecuteResult {
+    return {
+      text,
+      durationMs: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      bridgeMessageCount: this.deps.context.getMessageCount(
+        params.numericChatId,
+        params.chatId,
+      ),
+    };
+  }
 }
 
 let weaver: Weaver | null = null;
@@ -341,11 +255,6 @@ export function initWeaver(deps: WeaverDeps): Weaver {
   return weaver;
 }
 
-export function getWeaver(): Weaver {
-  if (!weaver) throw new Error("Weaver not initialized");
-  return weaver;
-}
-
 /**
  * The active Weaver's Loom, or `null` before the dispatcher is wired. The
  * gateway delegates its per-chat context bookkeeping here so the Loom is the

package/src/frontend/native/index.ts

@@ -22,7 +22,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { log, logError } from "../../util/log.js";
-import { dirs } from "../../util/paths.js";
+import { dirs, files } from "../../util/paths.js";
 import { PKG_ROOT } from "../../cli/context.js";
 import { getSessionInfo } from "../../storage/sessions.js";
 import { buildContextDisplay } from "../shared/status-context.js";
@@ -30,6 +30,7 @@ import { resolveActiveModelForChat } from "../../core/models/active-model.js";
 import { forceDream } from "../../core/background/dream.js";
 import { execute } from "../../core/engine/dispatcher.js";
 import { toolInputToRecord } from "../../core/agent-runtime/events.js";
+import { isDeliveryTool } from "../../core/tools/index.js";
 import {
   pushMessage,
   getRecentHistory,
@@ -66,6 +67,7 @@ import { extractSessionName } from "../../backend/shared/session-name.js";
 import { BridgeServer, type BridgeServerHandlers } from "./server.js";
 import { createNativeActionHandler } from "./actions.js";
 import { removeBridgeDiscovery, writeBridgeDiscovery } from "./discovery.js";
+import { readLogEntries } from "./logs.js";
 import {
   BRIDGE_PROTOCOL_VERSION,
   BOT_SENDER_ID,
@@ -575,6 +577,12 @@ export function createNativeFrontend(
               broadcast({ kind: "delta", chatId: entry.id, text: event.text });
               break;
             case "tool_call": {
+              // Delivery plumbing (end_turn / send_message / react) never
+              // enters the tool timeline — its effect arrives as the
+              // `message`/reaction itself. Skipping here keeps the live
+              // stream, the mid-turn replay to late joiners, and the
+              // persisted turn meta consistent from one choke point.
+              if (isDeliveryTool(event.name)) break;
               const input = toolInputToRecord(event.name, event.input);
               turnTools.set(event.id, {
                 call: { id: event.id, name: event.name, input },
@@ -591,6 +599,7 @@ export function createNativeFrontend(
               break;
             }
             case "tool_result": {
+              if (isDeliveryTool(event.name)) break;
               const output = summarizeToolResult(event.result);
               const live = turnTools.get(event.id);
               if (live) {
@@ -1026,7 +1035,11 @@ export function createNativeFrontend(
           if (msg.role === "assistant") {
             const meta = getTurnMeta(id, msg.id);
             if (meta) {
-              if (meta.tools?.length) msg.tools = meta.tools;
+              // Delivery tools are excluded at record time, but metas
+              // persisted by older daemons still carry them — filter on
+              // the way out so upgraded installs get clean history too.
+              const tools = meta.tools?.filter((t) => !isDeliveryTool(t.name));
+              if (tools?.length) msg.tools = tools;
               if (meta.durationMs) msg.durationMs = meta.durationMs;
               if (meta.tokensIn) msg.tokensIn = meta.tokensIn;
               if (meta.tokensOut) msg.tokensOut = meta.tokensOut;
@@ -1144,6 +1157,8 @@ export function createNativeFrontend(
       return snap;
     },
     control,
+    logs: ({ lines, minLevel, component }) =>
+      readLogEntries(files.log, { limit: lines, minLevel, component }),
     liveTurnEvents,
     mediaPath: (id) => media.get(id) ?? null,
   };