talon-agent 1.46.0 → 1.46.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.46.0",
+  "version": "1.46.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/backend/codex/handler/events.ts

@@ -21,6 +21,13 @@ import {
 export interface HandleEventContext {
   state: StreamState;
   seenToolCallIds: Set<string>;
+  /**
+   * Tool item ids whose `item.started` was reported via [onToolStart] and
+   * still await their completion — the completion path must close them via
+   * [onToolEnd] (same id) instead of the collapsed [onToolUse] fallback.
+   * Owned by the caller so it spans the whole turn, like [seenToolCallIds].
+   */
+  startedToolIds: Set<string>;
   codexToolMetrics: { count: number };
   onTextBlock?: (text: string) => Promise<void>;
   onToolUse?: (
@@ -28,6 +35,16 @@ export interface HandleEventContext {
     input: Record<string, unknown>,
     meta?: { failed?: boolean },
   ) => void;
+  onToolStart?: (
+    callId: string,
+    toolName: string,
+    input: Record<string, unknown>,
+  ) => void;
+  onToolEnd?: (
+    callId: string,
+    toolName: string,
+    meta?: { failed?: boolean },
+  ) => void;
   chatId: string;
 }
 
@@ -36,12 +53,105 @@ export interface HandleEventContext {
  *
  * Synchronous — keeps the for-await loop simple. The shared
  * `routeDelivery` step at end-of-turn handles the final emit.
+ *
+ * `item.started` is observed ONLY to open the live tool window for
+ * consumers ([onToolStart] → UI spinner + real durations); every
+ * side effect that matters — metrics, terminator detection, delivered-
+ * text capture — stays strictly on `item.completed`, preserving the
+ * in_progress race fix documented on [handleMcpToolCall].
  */
 export function handleEvent(event: ThreadEvent, ctx: HandleEventContext): void {
+  if (event.type === "item.started") {
+    handleItemStarted(event.item, ctx);
+    return;
+  }
   if (event.type !== "item.completed") return;
   handleItem(event.item, ctx);
 }
 
+/**
+ * Map a tool-shaped [ThreadItem] to its fleet-vocabulary name + input,
+ * or null for non-tool items (agent_message / reasoning / todo_list /
+ * error). Single source of truth for the started + completed paths so
+ * the pair always reports the same name.
+ */
+function toolShape(
+  item: ThreadItem,
+): { name: string; input: Record<string, unknown> } | null {
+  switch (item.type) {
+    case "mcp_tool_call":
+      return {
+        name: item.tool,
+        input:
+          item.arguments && typeof item.arguments === "object"
+            ? (item.arguments as Record<string, unknown>)
+            : {},
+      };
+    case "command_execution":
+      return { name: "Bash", input: { command: item.command } };
+    case "file_change":
+      return {
+        name: fileChangeToolName(item.changes),
+        input: { changes: item.changes },
+      };
+    case "web_search":
+      return { name: "WebSearch", input: { query: item.query } };
+    case "agent_message":
+    case "reasoning":
+    case "todo_list":
+    case "error":
+      return null;
+    default: {
+      const type =
+        typeof (item as { type?: unknown }).type === "string"
+          ? (item as { type: string }).type
+          : "unknown";
+      return { name: type, input: nativeItemPayload(item) };
+    }
+  }
+}
+
+function handleItemStarted(item: ThreadItem, ctx: HandleEventContext): void {
+  if (!ctx.onToolStart) return;
+  const shape = toolShape(item);
+  if (!shape || ctx.startedToolIds.has(item.id)) return;
+  ctx.startedToolIds.add(item.id);
+  try {
+    ctx.onToolStart(item.id, shape.name, shape.input);
+  } catch {
+    /* non-fatal */
+  }
+}
+
+/**
+ * Close the live tool window for [item] if its start was reported,
+ * falling back to the collapsed one-shot [onToolUse] when it wasn't
+ * (older CLIs that never emit `item.started`, or no start listener).
+ */
+function reportToolTerminal(
+  ctx: HandleEventContext,
+  item: { id: string },
+  toolName: string,
+  input: Record<string, unknown>,
+  meta?: { failed?: boolean },
+): void {
+  if (ctx.startedToolIds.delete(item.id) && ctx.onToolEnd) {
+    try {
+      ctx.onToolEnd(item.id, toolName, meta);
+    } catch {
+      /* non-fatal */
+    }
+    return;
+  }
+  if (ctx.onToolUse) {
+    try {
+      ctx.onToolUse(toolName, input, meta);
+    } catch {
+      /* non-fatal */
+    }
+  }
+}
+
 function handleItem(item: ThreadItem, ctx: HandleEventContext): void {
   switch (item.type) {
     case "agent_message":
@@ -56,7 +166,7 @@ function handleItem(item: ThreadItem, ctx: HandleEventContext): void {
     // backend instead of splitting the same activity across
     // `tool_calls.command_execution` vs `tool_calls.Bash`.
     case "command_execution":
-      handleNativeCodexTool(ctx, "Bash", {
+      handleNativeCodexTool(ctx, item, "Bash", {
         command: item.command,
         status: item.status,
         ...(typeof item.exit_code === "number"
@@ -65,13 +175,13 @@ function handleItem(item: ThreadItem, ctx: HandleEventContext): void {
       });
       return;
     case "file_change":
-      handleNativeCodexTool(ctx, fileChangeToolName(item.changes), {
+      handleNativeCodexTool(ctx, item, fileChangeToolName(item.changes), {
         status: item.status,
         changes: item.changes,
       });
       return;
     case "web_search":
-      handleNativeCodexTool(ctx, "WebSearch", { query: item.query });
+      handleNativeCodexTool(ctx, item, "WebSearch", { query: item.query });
       return;
     case "reasoning":
     case "todo_list":
@@ -88,7 +198,7 @@ function handleItem(item: ThreadItem, ctx: HandleEventContext): void {
         typeof (item as { type?: unknown }).type === "string"
           ? (item as { type: string }).type
           : "unknown";
-      handleNativeCodexTool(ctx, type, nativeItemPayload(item));
+      handleNativeCodexTool(ctx, item, type, nativeItemPayload(item));
       return;
     }
   }
@@ -150,25 +260,12 @@ function handleMcpToolCall(
     // nothing was delivered and the turn is not terminated, so skip
     // the stream-state mutations (delivered-text capture / terminator
     // flip) that assume a successful call.
-    if (ctx.onToolUse) {
-      try {
-        ctx.onToolUse(toolName, input, { failed: true });
-      } catch {
-        /* non-fatal */
-      }
-    }
+    reportToolTerminal(ctx, item, toolName, input, { failed: true });
     return;
   }
 
   recordToolUse(ctx.state, toolName, input);
-
-  if (ctx.onToolUse) {
-    try {
-      ctx.onToolUse(toolName, input);
-    } catch {
-      /* non-fatal */
-    }
-  }
+  reportToolTerminal(ctx, item, toolName, input);
 
   if (!ctx.state.turnTerminated && isTurnTerminator(toolName, input)) {
     ctx.state.turnTerminated = true;
@@ -192,17 +289,12 @@ function recordCodexToolMetric(
 
 function handleNativeCodexTool(
   ctx: HandleEventContext,
+  item: { id: string },
   toolName: string,
   input: Record<string, unknown>,
 ): void {
   recordCodexToolMetric(ctx, toolName);
-  if (ctx.onToolUse) {
-    try {
-      ctx.onToolUse(toolName, input);
-    } catch {
-      /* non-fatal */
-    }
-  }
+  reportToolTerminal(ctx, item, toolName, input);
 }
 
 /**

package/src/backend/codex/handler/message.ts

@@ -203,6 +203,8 @@ export async function handleMessage(
     messageId,
     onTextBlock,
     onToolUse,
+    onToolStart,
+    onToolEnd,
   } = params;
   const t0 = Date.now();
   const session = getSession(chatId);
@@ -316,6 +318,7 @@ export async function handleMessage(
   // into the live-turn overlay — /status updates while the turn runs.
   const streamState = createStreamState(chatId);
   const seenToolCallIds = new Set<string>();
+  const startedToolIds = new Set<string>();
   const codexToolMetrics = { count: 0 };
   const abortController = new AbortController();
   activeAborts.set(chatId, abortController);
@@ -440,9 +443,12 @@ export async function handleMessage(
       handleEvent(event, {
         state: streamState,
         seenToolCallIds,
+        startedToolIds,
         codexToolMetrics,
         onTextBlock,
         onToolUse,
+        onToolStart,
+        onToolEnd,
         chatId,
       });
 

package/src/backend/shared/handler-to-events.ts

@@ -63,6 +63,12 @@ export async function* handlerToEvents(
     r?.();
   };
 
+  // Tool calls announced via `onToolStart` that have not yet reported an
+  // `onToolEnd` — flushed with an error result if the handler settles with
+  // any still open (abort/crash mid-tool), preserving the call→result
+  // pairing contract for every consumer.
+  const openToolCalls = new Map<string, string>();
+
   // Handler `onStreamDelta` delivers the FULL accumulated text so far,
   // not the new chunk. `AgentEvent.text_delta.text` carries the delta —
   // event-native consumers (the frontends, via the dispatcher's
@@ -109,7 +115,7 @@ export async function* handlerToEvents(
         .toString(36)
         .slice(2, 8)}`;
       emit({ type: "tool_call", id, name: toolName, input });
-      // Callback backends (Codex, OpenCode, Kilo, OpenAI Agents) surface a
+      // Callback backends (OpenCode, Kilo, OpenAI Agents) surface a
       // tool call only at terminal status — by the time onToolUse fires,
       // the tool has already finished. Emit the matching `tool_result`
       // immediately so consumers see the same call→result contract the
@@ -123,6 +129,23 @@ export async function* handlerToEvents(
         ...(meta?.failed ? { error: "tool call failed" } : {}),
       });
     },
+    // Live tool lifecycle (Codex `item.started` → `item.completed`):
+    // `tool_call` goes out the moment the SDK dispatches the tool and the
+    // matching `tool_result` when it settles, so consumers see a real
+    // running window instead of the collapsed 0ms call+result above.
+    onToolStart: (callId, toolName, input) => {
+      openToolCalls.set(callId, toolName);
+      emit({ type: "tool_call", id: callId, name: toolName, input });
+    },
+    onToolEnd: (callId, toolName, meta) => {
+      if (!openToolCalls.delete(callId)) return; // unknown/duplicate id
+      emit({
+        type: "tool_result",
+        id: callId,
+        name: toolName,
+        ...(meta?.failed ? { error: "tool call failed" } : {}),
+      });
+    },
   };
 
   let result: QueryResult | undefined;
@@ -158,6 +181,13 @@ export async function* handlerToEvents(
   }
   await handlerPromise;
 
+  // Resolve any tool that started but never settled (abort or crash killed
+  // the subprocess mid-call) so spinners close instead of hanging forever.
+  for (const [id, name] of openToolCalls) {
+    yield { type: "tool_result", id, name, error: "tool did not complete" };
+  }
+  openToolCalls.clear();
+
   if (error) {
     yield { type: "error", error: classifiedToAgentError(classify(error)) };
     return;

package/src/backend/shared/handler-types.ts

@@ -48,12 +48,34 @@ export type QueryParams = {
    * their SDKs surface it at (or after) terminal status, with no separate
    * start/finish pair. `meta.failed` marks a call whose terminal status was
    * an error, so consumers can render it as failed rather than successful.
+   *
+   * Backends whose SDK exposes a live start signal should prefer the
+   * `onToolStart` / `onToolEnd` pair below and only fall back to this
+   * for calls whose start was never observed.
    */
   onToolUse?: (
     toolName: string,
     input: Record<string, unknown>,
     meta?: { failed?: boolean },
   ) => void;
+  /**
+   * Live tool lifecycle (backends with start signals — Codex emits
+   * `item.started`). `callId` is the SDK's stable item id: the same id
+   * must be passed to `onToolEnd` so consumers can pair the two and
+   * measure a real duration. Without this pair, `onToolUse` collapses
+   * call+result into one instant and every tool renders as 0ms.
+   */
+  onToolStart?: (
+    callId: string,
+    toolName: string,
+    input: Record<string, unknown>,
+  ) => void;
+  /** Terminal counterpart to [onToolStart]; ignored for unknown ids. */
+  onToolEnd?: (
+    callId: string,
+    toolName: string,
+    meta?: { failed?: boolean },
+  ) => void;
 };
 
 /** Result of a backend AI query. */