talon-agent 1.33.0 → 1.34.0

package/package.json

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

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

@@ -384,6 +384,19 @@ export async function* runChatTurn(
         armPostResultWatchdog();
       }
     }
+
+    // The SDK doesn't throw on API errors — it converts them into a
+    // synthetic assistant message and finishes the turn with an error-
+    // flagged result (usage limits, 429s, auth failures all land here).
+    // Rethrow the captured error text so this turn takes the SAME path
+    // as a thrown SDK error: retry decision, failed-turn accounting, and
+    // an `error` event carrying the real message — instead of being
+    // treated as a normal reply (which, with no delivery tool call,
+    // would trip the flow-violation re-prompt loop and burn more turns
+    // against an already-exhausted limit).
+    if (state.resultErrorText) {
+      throw new Error(state.resultErrorText);
+    }
   } catch (err) {
     if (!postResultForceClosed) {
       const buildRetryStream = (

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

@@ -75,6 +75,17 @@ export type StreamState = {
    * doesn't poison the visible-text delta buffer.
    */
   unflushedThinkingDelta: string;
+  /**
+   * Set when the SDK's final result message reported a failed turn —
+   * either an error subtype (`error_during_execution`, `error_max_turns`,
+   * …) or `is_error: true` on a `success` result. The latter is how API
+   * errors surface: the SDK converts them (usage limits, 429s, auth
+   * failures) into a synthetic assistant message and finishes the turn
+   * "successfully" with the error text in `result` — it never throws.
+   * Carries the best error text available so the handler can fail the
+   * turn with the REAL message instead of treating it as a normal reply.
+   */
+  resultErrorText: string | undefined;
 };
 
 export function createStreamState(): StreamState {
@@ -96,6 +107,7 @@ export function createStreamState(): StreamState {
     turnTerminated: false,
     unflushedTextDelta: "",
     unflushedThinkingDelta: "",
+    resultErrorText: undefined,
   };
 }
 
@@ -358,6 +370,27 @@ export function processResultMessage(
   ) {
     state.currentBlockText = msg.result;
   }
+
+  // Failed turn. Two shapes (see StreamState.resultErrorText):
+  //  - error subtype: no `result` field, but `errors[]` carries diagnostics.
+  //  - success subtype with is_error: `result` (and the trailing assistant
+  //    text) IS the API error message, e.g. "You've hit your weekly limit
+  //    · resets Jul 10, 9am". Prefer that text — it's the user-facing one.
+  if (msg.subtype !== "success") {
+    const diagnostics = (msg.errors ?? [])
+      .filter((e) => typeof e === "string" && !e.startsWith("[ede_diagnostic]"))
+      .join("; ")
+      .slice(0, 500);
+    state.resultErrorText =
+      state.lastTrailingText.trim() ||
+      diagnostics ||
+      `Claude SDK turn failed (${msg.subtype})`;
+  } else if (msg.is_error) {
+    state.resultErrorText =
+      (typeof msg.result === "string" && msg.result.trim()) ||
+      state.lastTrailingText.trim() ||
+      "Claude SDK turn failed (API error)";
+  }
 }
 
 // ── Trailing-text fallback dedup ────────────────────────────────────────────

package/src/core/agent-runtime/events.ts

@@ -259,6 +259,10 @@ export function addUsage(a: UsageSnapshot, b: UsageSnapshot): UsageSnapshot {
  */
 const REASON_TO_KIND: Partial<Record<TalonError["reason"], AgentErrorKind>> = {
   rate_limit: "rate_limit",
+  // Subscription usage limits share the rate_limit kind — same family for
+  // event consumers; `retryable: false` (carried through) is what
+  // distinguishes them from a transient 429.
+  usage_limit: "rate_limit",
   overloaded: "overload",
   context_length: "context_overflow",
   session_expired: "session_expired",

package/src/core/errors.ts

@@ -9,6 +9,7 @@
 
 type ErrorReason =
   | "rate_limit"
+  | "usage_limit"
   | "overloaded"
   | "network"
   | "auth"
@@ -19,6 +20,19 @@ type ErrorReason =
   | "telegram_api"
   | "unknown";
 
+/**
+ * Claude subscription usage-limit messages, as produced by Claude Code /
+ * the Agent SDK (see rateLimitMessages.ts upstream: "You've hit your
+ * weekly limit · resets Jul 10, 9am", "You're out of extra usage", …)
+ * plus the legacy "Claude AI usage limit reached|<ts>" format. These are
+ * already user-facing text — classification marks them `usage_limit` so
+ * `friendlyMessage` passes them through instead of collapsing them to a
+ * generic template. Unlike `rate_limit` (a transient 429), a usage limit
+ * doesn't clear on a short retry, so `retryable` stays false.
+ */
+const USAGE_LIMIT_RE =
+  /you['’]ve hit your .{0,40}limit|you['’]re out of extra usage|claude ai usage limit reached|usage limit reached/i;
+
 // ── TalonError class ────────────────────────────────────────────────────────
 
 export class TalonError extends Error {
@@ -74,6 +88,18 @@ export function classify(err: unknown): TalonError {
   const statusMatch = msg.match(/\b([45]\d{2})\b/);
   const status = statusMatch ? parseInt(statusMatch[1], 10) : undefined;
 
+  // Subscription usage limit — checked before the generic rate-limit
+  // branch ("usage limit reached" would otherwise never be reached, and
+  // "You've hit your…" carries no 429/rate-limit marker at all).
+  if (USAGE_LIMIT_RE.test(msg)) {
+    return new TalonError(msg, {
+      reason: "usage_limit",
+      retryable: false,
+      status: status ?? 429,
+      cause,
+    });
+  }
+
   // Rate limit
   if (/rate.?limit|429|too many requests/i.test(msg)) {
     const retryMatch = msg.match(/retry.?after[:\s]*(\d+)/i);
@@ -190,6 +216,7 @@ export function classify(err: unknown): TalonError {
 
 const FRIENDLY_MESSAGES: Record<ErrorReason, string> = {
   rate_limit: "Rate limited. Try again in a moment.",
+  usage_limit: "Usage limit reached. Try again after it resets.",
   overloaded:
     "Upstream model is busy right now. Retrying with a faster fallback...",
   network: "Connection issue. Retrying shortly.",
@@ -203,8 +230,30 @@ const FRIENDLY_MESSAGES: Record<ErrorReason, string> = {
   unknown: "Something went wrong. Try again or /reset.",
 };
 
+/**
+ * Reasons whose template alone tells the user nothing actionable — the
+ * underlying error detail is appended so "Something went wrong" always
+ * says WHAT went wrong. Templated reasons like `network`/`overloaded`
+ * stay terse: they're transient and the detail is just transport noise.
+ */
+const DETAIL_REASONS: ReadonlySet<ErrorReason> = new Set([
+  "auth",
+  "bad_request",
+  "forbidden",
+  "unknown",
+]);
+
+/** Collapse whitespace and clip the raw error for inline display. */
+function clipDetail(msg: string, max = 300): string {
+  const flat = msg.replace(/\s+/g, " ").trim();
+  if (!flat || flat === "[non-stringifiable error]") return "";
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+
 /**
  * Get a user-friendly error message. For rate limits, includes retry timing.
+ * Usage-limit and session-expired messages pass through verbatim (they're
+ * already user-facing); generic reasons carry the underlying detail.
  */
 export function friendlyMessage(err: unknown): string {
   const classified = err instanceof TalonError ? err : classify(err);
@@ -214,10 +263,19 @@ export function friendlyMessage(err: unknown): string {
     return `Rate limited. Try again in ${seconds} seconds.`;
   }
 
-  // Session expired messages are already user-friendly from the backend
-  if (classified.reason === "session_expired") {
-    return classified.message;
+  // Already user-friendly from the backend — pass through as-is.
+  if (
+    classified.reason === "session_expired" ||
+    classified.reason === "usage_limit"
+  ) {
+    return classified.message || FRIENDLY_MESSAGES[classified.reason];
   }
 
-  return FRIENDLY_MESSAGES[classified.reason];
+  const base = FRIENDLY_MESSAGES[classified.reason];
+  if (DETAIL_REASONS.has(classified.reason)) {
+    const detail = clipDetail(classified.message);
+    // Skip when the detail adds nothing over the template itself.
+    if (detail && detail !== base) return `${base}\n\nDetail: ${detail}`;
+  }
+  return base;
 }

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";
@@ -66,6 +66,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,
@@ -1144,6 +1145,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,
   };

package/src/frontend/native/logs.ts

@@ -0,0 +1,95 @@
+/**
+ * Daemon log access for the client bridge.
+ *
+ * Parses the pino JSON log file (`~/.talon/talon.log`, one object per
+ * line — see util/log.ts) into the wire `LogEntry` shape so clients can
+ * render the daemon's log without shipping a pino parser of their own.
+ * Pure functions over a raw tail string; file I/O stays with the caller.
+ */
+
+import { tailFile } from "../../util/tail-file.js";
+import type { LogEntry, LogLevel } from "./protocol.js";
+
+/** pino numeric levels → wire level names. */
+const PINO_LEVELS: Record<number, LogLevel> = {
+  10: "trace",
+  20: "debug",
+  30: "info",
+  40: "warn",
+  50: "error",
+  60: "fatal",
+};
+
+const LEVEL_RANK: Record<LogLevel, number> = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+};
+
+export type LogQuery = {
+  /** Max entries returned (most recent last). */
+  limit: number;
+  /** Minimum severity — entries below it are dropped. */
+  minLevel?: LogLevel;
+  /** Exact component match (e.g. "agent", "native"). */
+  component?: string;
+};
+
+/**
+ * Parse a raw tail of the pino log file into wire entries, newest last.
+ * Malformed lines (partial first line of the byte window, rotation
+ * artifacts) are skipped rather than failing the whole request.
+ */
+export function parseLogTail(raw: string, query: LogQuery): LogEntry[] {
+  const minRank = query.minLevel ? LEVEL_RANK[query.minLevel] : 0;
+  const entries: LogEntry[] = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    let obj: Record<string, unknown>;
+    try {
+      obj = JSON.parse(trimmed) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    const levelNum = typeof obj.level === "number" ? obj.level : 30;
+    if (levelNum < minRank) continue;
+    const component =
+      typeof obj.component === "string" ? obj.component : undefined;
+    if (query.component && component !== query.component) continue;
+    entries.push({
+      ts: typeof obj.time === "number" ? obj.time : 0,
+      level: PINO_LEVELS[levelNum] ?? "info",
+      ...(component ? { component } : {}),
+      msg: typeof obj.msg === "string" ? obj.msg : "",
+      ...(typeof obj.err === "string" ? { err: obj.err } : {}),
+      ...(typeof obj.stack === "string" ? { stack: obj.stack } : {}),
+    });
+  }
+  return entries.slice(-query.limit);
+}
+
+/**
+ * Read + parse the newest `query.limit` entries from `path`. The byte
+ * window scales with the request so filtered queries (level/component)
+ * still have material to fill from, capped so a hostile `lines` value
+ * can't make the daemon slurp the whole file.
+ */
+export function readLogEntries(path: string, query: LogQuery): LogEntry[] {
+  const maxBytes = Math.min(
+    2 * 1024 * 1024,
+    Math.max(64 * 1024, query.limit * 2048),
+  );
+  let raw: string;
+  try {
+    // Line budget is generous vs `limit` so level-filtered queries can
+    // still return `limit` matches from a mostly-info tail.
+    raw = tailFile(path, query.limit * 20, maxBytes);
+  } catch {
+    return [];
+  }
+  return parseLogTail(raw, query);
+}

package/src/frontend/native/protocol.ts

@@ -142,6 +142,40 @@ export type BridgeStatus = {
   startedAt: string;
 };
 
+/** Wire severity for a daemon log entry (mirrors pino's level names). */
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+
+const LOG_LEVELS: readonly LogLevel[] = [
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "fatal",
+];
+
+/** Narrow an untrusted query-param string to a wire log level. */
+export function isLogLevel(v: string): v is LogLevel {
+  return (LOG_LEVELS as readonly string[]).includes(v);
+}
+
+/**
+ * One daemon log line, served by `GET /logs` for the client's log viewer
+ * (additive in v1 — older clients simply never call the endpoint).
+ */
+export type LogEntry = {
+  /** Epoch milliseconds. */
+  ts: number;
+  level: LogLevel;
+  /** Subsystem tag (e.g. "agent", "native", "gateway"), when present. */
+  component?: string;
+  msg: string;
+  /** Concise error message, when the line logged one. */
+  err?: string;
+  /** Full stack trace, when the line logged one. */
+  stack?: string;
+};
+
 /** A selectable model for the picker. */
 export type ModelOption = {
   id: string;

package/src/frontend/native/server.ts

@@ -24,11 +24,14 @@ import { extname } from "node:path";
 import { log, logError, logDebug } from "../../util/log.js";
 import {
   BRIDGE_PROTOCOL_VERSION,
+  isLogLevel,
   type BackendOption,
   type BridgeEvent,
   type BridgeStatus,
   type ClientChat,
   type ClientMessage,
+  type LogEntry,
+  type LogLevel,
   type ModelOption,
   type SearchResult,
 } from "./protocol.js";
@@ -92,6 +95,12 @@ export type BridgeServerHandlers = {
   setConfig(update: Record<string, unknown>): ConfigSnapshot;
   /** Fire a daemon-level control action (e.g. "restart", "dream"). */
   control(action: string): Promise<{ ok: boolean; message: string }>;
+  /** Newest daemon log entries (for the client's log viewer). */
+  logs(opts: {
+    lines: number;
+    minLevel?: LogLevel;
+    component?: string;
+  }): LogEntry[];
   /** Events reconstructing any in-progress turns, for a just-connected client. */
   liveTurnEvents(): BridgeEvent[];
   /** Resolve a media id to an absolute file path (or null if unknown). */
@@ -407,6 +416,22 @@ export class BridgeServer {
         return await this.serveMedia(res, id);
       }
 
+      if (method === "GET" && path === "/logs") {
+        const lines = Math.min(
+          asPositiveInt(url.searchParams.get("lines")) ?? 200,
+          1000,
+        );
+        const level = url.searchParams.get("level") ?? "";
+        const component = url.searchParams.get("component") ?? undefined;
+        return this.json(res, 200, {
+          entries: this.handlers.logs({
+            lines,
+            minLevel: isLogLevel(level) ? level : undefined,
+            component,
+          }),
+        });
+      }
+
       if (method === "GET" && path === "/config")
         return this.json(res, 200, this.handlers.getConfig());