talon-agent 1.35.0 → 1.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.35.0",
+  "version": "1.37.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -101,7 +101,7 @@
     "@kilocode/sdk": "^7.2.22",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@openai/agents": "^0.13.0",
-    "@openai/codex-sdk": "^0.143.0",
+    "@openai/codex-sdk": "^0.144.0",
     "@opencode-ai/sdk": "^1.17.4",
     "@playwright/mcp": "^0.0.77",
     "@types/cross-spawn": "^6.0.6",
@@ -133,7 +133,7 @@
     "knip": "^6.3.1",
     "oxlint": "^1.59.0",
     "prettier": "^3.8.1",
-    "typescript": "^6.0.2",
+    "typescript": "^7.0.2",
     "vitest": "^4.1.3"
   },
   "overrides": {

package/src/backend/claude-sdk/handler.ts

@@ -336,7 +336,7 @@ export async function* runChatTurn(
         }
 
         for (const tool of result.tools) {
-          recordToolCall(tool.name, "claude");
+          recordToolCall(chatId, tool.name, "claude");
           captureIntoState(tool.name, tool.input);
           if (isTurnTerminator(tool.name, tool.input)) {
             state.turnTerminated = true;
@@ -487,6 +487,7 @@ export async function* runChatTurn(
 
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "claude",
     durationMs,
     toolCalls: state.toolCalls,
@@ -543,7 +544,10 @@ export async function* runChatTurn(
     : ({ violated: false } as const);
 
   if (violation.violated) {
-    recordFlowViolation(violation.shouldRetry ? "retried" : "cap_exhausted");
+    recordFlowViolation(
+      chatId,
+      violation.shouldRetry ? "retried" : "cap_exhausted",
+    );
     log(
       "agent",
       `[${chatId}] flow violation: ${violation.reason}. ${

package/src/backend/claude-sdk/options.ts

@@ -30,6 +30,23 @@ import { log, logError } from "../../util/log.js";
 import { getConfig, getBridgePort } from "./state.js";
 import { ALLOWED_TOOLS_CHAT, EFFORT_MAP } from "./constants.js";
 
+/**
+ * Built-in SDK tools that Talon's native tool set replaces when
+ * `config.nativeTools` is on. The shell/filesystem built-ins map 1:1 to
+ * bash/read/write/edit/glob/search; `Agent` (sub-agent dispatch) is dropped
+ * alongside them per the owner's preference for the native surface.
+ */
+const NATIVE_REPLACED_BUILTINS = new Set<string>([
+  "Read",
+  "Write",
+  "Edit",
+  "NotebookEdit",
+  "Bash",
+  "Glob",
+  "Grep",
+  "Agent",
+]);
+
 // ── Types ────────────────────────────────────────────────────────────────────
 
 export type BuildSdkOptionsResult = {
@@ -61,8 +78,19 @@ export type HubMcpEntry = {
   type: "http";
   url: string;
   alwaysLoad?: boolean;
+  /** Per-server tool-call timeout in ms (overrides MCP_TOOL_TIMEOUT). */
+  timeout?: number;
 };
 
+/**
+ * Tool-call timeout for the Talon frontend tool servers. Must sit ABOVE the
+ * bridge's largest per-action budget (1h for uncapped device file transfers)
+ * so the layer that times out is the bridge — whose error names the action,
+ * the budget, and warns the operation may still be running — rather than the
+ * SDK's generic MCP timeout, which tells the model nothing actionable.
+ */
+const FRONTEND_TOOL_CALL_TIMEOUT_MS = 3_900_000; // 65 min
+
 /**
  * Build the MCP servers map for a chat query.
  * Includes frontend-specific tool servers and Brave Search, if configured.
@@ -102,6 +130,8 @@ export function buildMcpServers(chatId: string): Record<string, HubMcpEntry> {
       // lever here. Cost: ~50 frontend tool schemas loaded every turn (~10k
       // tokens, cached, negligible on the 1M-context models Talon runs).
       alwaysLoad: true,
+      // Outlast the bridge's 1h transfer budget — see the constant's doc.
+      timeout: FRONTEND_TOOL_CALL_TIMEOUT_MS,
     };
   }
 
@@ -388,7 +418,17 @@ export function buildSdkOptions(
     // WebFetch, Monitor, PushNotification, RemoteTrigger, Plan/Worktree/Todo
     // helpers, AskUserQuestion, ScheduleWakeup) is unavailable to the model.
     // MCP tools are governed independently via `mcpServers` below.
-    tools: [...ALLOWED_TOOLS_CHAT],
+    //
+    // When `config.nativeTools` is on, the SDK's built-in shell/filesystem
+    // tools are dropped in favour of Talon's own native tools (which also
+    // teleport onto companion devices), and Agent (sub-agent dispatch) is
+    // removed too — the owner prefers the native surface without nested
+    // agents. Flip the flag back off to restore the built-ins instantly.
+    tools: config.nativeTools
+      ? ALLOWED_TOOLS_CHAT.filter(
+          (t) => !NATIVE_REPLACED_BUILTINS.has(t as string),
+        )
+      : [...ALLOWED_TOOLS_CHAT],
     ...thinkingConfig,
     mcpServers: {
       ...buildMcpServers(chatId),

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

@@ -182,7 +182,7 @@ function recordCodexToolMetric(
   // Shared vocabulary: `tool_calls.<bare>` (prefix-stripped, so codex
   // MCP calls land on the same keys as every other backend) plus the
   // `backend.codex.tool_calls` dimension.
-  recordToolCall(toolName, "codex");
+  recordToolCall(ctx.chatId, toolName, "codex");
   ctx.codexToolMetrics.count += 1;
 }
 

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

@@ -571,6 +571,7 @@ export async function handleMessage(
   const responseText = finalizeResponseText(streamState);
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "codex",
     durationMs,
     toolCalls: codexToolMetrics.count,

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

@@ -220,6 +220,7 @@ export async function handleMessage(
   const responseText = finalizeResponseText(state);
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "kilo",
     durationMs,
     toolCalls: state.toolCalls,

package/src/backend/kilo/handler/turn.ts

@@ -289,6 +289,7 @@ async function subscribeToTurnEvents(inputs: SubscribeInputs): Promise<void> {
       }
 
       const outcome = await processStreamEvent(event, {
+        chatId,
         sessionId,
         state,
         seenToolCallIds,

package/src/backend/openai-agents/handler/events.ts

@@ -103,7 +103,7 @@ function handleToolCalled(item: unknown, ctx: HandleRunItemContext): void {
     }
   }
 
-  recordToolCall(toolName, "openai-agents");
+  recordToolCall(ctx.chatId, toolName, "openai-agents");
   recordToolUse(ctx.state, toolName, input);
 
   if (ctx.onToolUse) {

package/src/backend/openai-agents/handler/message.ts

@@ -398,6 +398,7 @@ export async function handleMessage(
   const responseText = finalizeResponseText(streamState);
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "openai-agents",
     durationMs,
     toolCalls: streamState.toolCalls,
@@ -443,7 +444,10 @@ export async function handleMessage(
       : ({ violated: false } as const);
 
   if (violation.violated) {
-    recordFlowViolation(violation.shouldRetry ? "retried" : "cap_exhausted");
+    recordFlowViolation(
+      chatId,
+      violation.shouldRetry ? "retried" : "cap_exhausted",
+    );
     log(
       "agent",
       `[${chatId}] flow violation: trailing prose (${violation.trailing.length} chars) without end_turn/send. ${

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

@@ -232,6 +232,7 @@ export async function handleMessage(
   const responseText = finalizeResponseText(state);
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "opencode",
     durationMs,
     toolCalls: state.toolCalls,

package/src/backend/opencode/handler/turn.ts

@@ -277,6 +277,7 @@ async function subscribeToTurnEvents(inputs: SubscribeInputs): Promise<void> {
       }
 
       const outcome = await processStreamEvent(event, {
+        chatId,
         sessionId,
         state,
         seenToolCallIds,

package/src/backend/remote-server/events.ts

@@ -63,6 +63,8 @@ export type ProcessEventOutcome =
 
 /** Common context passed to the per-event helper. */
 export interface EventProcessingContext {
+  /** Chat id for session-scoped metrics. */
+  chatId: string;
   /** Session id we're scoped to — events for other sessions are dropped. */
   sessionId: string;
   /** Stream state accumulator (shared/). */
@@ -277,7 +279,7 @@ async function processPartUpdate(
   }
   // Count every tool the model calls — shared vocabulary across
   // backends (prefix-stripped name + backend dimension).
-  recordToolCall(toolName, ctx.backendLabel.toLowerCase());
+  recordToolCall(ctx.chatId, toolName, ctx.backendLabel.toLowerCase());
   recordToolUse(ctx.state, toolName, input);
   if (ctx.onToolUse) {
     try {

package/src/backend/shared/metrics.ts

@@ -38,10 +38,14 @@
  * registry. Never interpolate chat ids, model ids, or user input.
  */
 
-import { incrementCounter, recordHistogram } from "../../util/metrics.js";
 import { stripMcpPrefix } from "../../core/tools/index.js";
-import { cacheHitPercent, type TokenUsageSnapshot } from "./usage.js";
-import { clearLiveTurn, recordUsage } from "../../storage/sessions.js";
+import type { TokenUsageSnapshot } from "./usage.js";
+import {
+  clearLiveTurn,
+  recordSessionMetricEvent,
+  recordSessionMetrics,
+  recordUsage,
+} from "../../storage/sessions.js";
 
 /**
  * Count one tool call. `toolName` may be raw from any backend —
@@ -49,13 +53,21 @@ import { clearLiveTurn, recordUsage } from "../../storage/sessions.js";
  * (`talon-tools-123_send`), or bare — it is normalised so every
  * backend lands on the same `tool_calls.<bare>` key.
  */
-export function recordToolCall(toolName: string, backend?: string): void {
-  incrementCounter(`tool_calls.${stripMcpPrefix(toolName)}`);
-  if (backend) incrementCounter(`backend.${backend}.tool_calls`);
+export function recordToolCall(
+  chatId: string,
+  toolName: string,
+  backend?: string,
+): void {
+  recordSessionMetricEvent(chatId, {
+    toolCalls: 1,
+    toolName: stripMcpPrefix(toolName),
+    backend,
+  });
 }
 
 /** Per-turn rollup recorded once at the end of every chat turn. */
 export type TurnMetricInputs = {
+  chatId: string;
   /** Backend id, e.g. "claude", "codex", "kilo", "openai-agents", "opencode". */
   backend: string;
   durationMs: number;
@@ -78,45 +90,7 @@ export type TurnMetricInputs = {
  * ("queries_total")` pairs (and codex's private `codex.*` family).
  */
 export function recordTurnMetrics(inputs: TurnMetricInputs): void {
-  recordHistogram("response_latency_ms", inputs.durationMs);
-  recordHistogram(
-    `backend.${inputs.backend}.response_latency_ms`,
-    inputs.durationMs,
-  );
-  incrementCounter("queries_total");
-  incrementCounter(`backend.${inputs.backend}.queries`);
-
-  if (inputs.failed) incrementCounter(`backend.${inputs.backend}.turn_failed`);
-
-  if (inputs.toolCalls !== undefined) {
-    recordHistogram("tool_calls_per_turn", inputs.toolCalls);
-    if (inputs.toolCalls > 0) incrementCounter("turns_with_tools_total");
-  }
-  if (inputs.apiCalls !== undefined && inputs.apiCalls > 0) {
-    incrementCounter("api_calls_total", inputs.apiCalls);
-    recordHistogram("api_calls_per_turn", inputs.apiCalls);
-  }
-
-  if (inputs.usage) {
-    const u = inputs.usage;
-    const b = `backend.${inputs.backend}`;
-    incrementCounter("tokens.input_total", u.inputTokens);
-    incrementCounter("tokens.output_total", u.outputTokens);
-    incrementCounter("tokens.cache_read_total", u.cacheRead);
-    incrementCounter("tokens.cache_write_total", u.cacheWrite);
-    incrementCounter(`${b}.tokens.input`, u.inputTokens);
-    incrementCounter(`${b}.tokens.output`, u.outputTokens);
-    incrementCounter(`${b}.tokens.cache_read`, u.cacheRead);
-    incrementCounter(`${b}.tokens.cache_write`, u.cacheWrite);
-    // Only meaningful when the turn actually consumed input — an
-    // all-zero snapshot (failed turn, usage-less backend) would skew
-    // the distribution with hard zeros.
-    if (u.inputTokens + u.cacheRead > 0) {
-      const pct = cacheHitPercent(u);
-      recordHistogram("cache_hit_percent", pct);
-      recordHistogram(`${b}.cache_hit_percent`, pct);
-    }
-  }
+  recordSessionMetrics(inputs.chatId, inputs);
 }
 
 /**
@@ -152,6 +126,7 @@ export function recordFailedTurnAccounting(inputs: {
   contextWindow?: number;
 }): void {
   recordTurnMetrics({
+    chatId: inputs.chatId,
     backend: inputs.backend,
     durationMs: inputs.durationMs,
     toolCalls: inputs.toolCalls,
@@ -188,12 +163,12 @@ export function recordFailedTurnAccounting(inputs: {
  * reminder" unanswerable for that backend.
  */
 export function recordFlowViolation(
+  chatId: string,
   outcome: "retried" | "cap_exhausted",
 ): void {
-  incrementCounter("scratchpad.trailing_text_dropped");
-  incrementCounter(
-    outcome === "retried"
-      ? "scratchpad.flow_violation_retried"
-      : "scratchpad.flow_violation_cap_exhausted",
-  );
+  recordSessionMetricEvent(chatId, {
+    trailingTextDropped: 1,
+    flowViolationRetries: outcome === "retried" ? 1 : 0,
+    flowViolationCapExhausted: outcome === "cap_exhausted" ? 1 : 0,
+  });
 }

package/src/bootstrap.ts

@@ -167,6 +167,7 @@ export async function bootstrap(
     disabledTools: config.disabledTools,
     disabledToolTags: config.disabledToolTags,
     braveApiKey: config.braveApiKey,
+    nativeTools: config.nativeTools,
   });
 
   initWorkspace(config.workspace);

package/src/core/engine/gateway-actions/index.ts

@@ -32,6 +32,7 @@ import { skillHandlers } from "./skills.js";
 import { pluginHandlers } from "./plugins.js";
 import { modelHandlers } from "./models.js";
 import { meshHandlers } from "./mesh.js";
+import { nativeHandlers } from "./native.js";
 
 // Null-prototype so a request `action` of "toString" / "constructor" / etc.
 // can't resolve an inherited Object.prototype method — `handlers[action]` only
@@ -47,6 +48,7 @@ const handlers: SharedActionHandlers = Object.assign(Object.create(null), {
   ...pluginHandlers,
   ...modelHandlers,
   ...meshHandlers,
+  ...nativeHandlers,
 });
 
 export async function handleSharedAction(

package/src/core/engine/gateway-actions/mesh.ts

@@ -19,4 +19,31 @@ export const meshHandlers: SharedActionHandlers = {
     getMeshService().deviceHistory(body.device, body.hours),
   ring_device: (body) => getMeshService().ringDevice(body.device, body.message),
   get_device_status: (body) => getMeshService().getDeviceStatus(body.device),
+  // Exec + filesystem surface — the substrate teleport routes through.
+  device_exec: (body) =>
+    getMeshService().execOnDevice(
+      body.device,
+      body.cmd,
+      body.cwd,
+      body.timeout_sec,
+    ),
+  device_list_dir: (body) =>
+    getMeshService().listDirOnDevice(body.device, body.path),
+  device_stat: (body) => getMeshService().statOnDevice(body.device, body.path),
+  device_read_file: (body) =>
+    getMeshService().readFileFromDevice(body.device, body.path),
+  device_write_file: (body) =>
+    getMeshService().writeFileToDevice(body.device, body.path, body.content),
+  device_pull_file: (body) =>
+    getMeshService().pullFileFromDevice(
+      body.device,
+      body.remote_path,
+      body.local_path,
+    ),
+  device_push_file: (body) =>
+    getMeshService().pushFileToDevice(
+      body.device,
+      body.local_path,
+      body.remote_path,
+    ),
 };