chainlesschain 0.162.182 → 0.162.184

package/src/lib/session-usage.js

@@ -12,6 +12,7 @@ import {
   readEvents,
   listJsonlSessions,
 } from "../harness/jsonl-session-store.js";
+import { extractPluginUsageAttribution } from "./plugin-usage-attribution.js";
 
 // Injectable disk seams (tests override). readEvents skips malformed JSON lines
 // but does NOT guard readFileSync, so an unreadable session file (EACCES /
@@ -31,6 +32,33 @@ function toNumber(v) {
   return Number.isFinite(n) ? n : 0;
 }
 
+const MAX_OBSERVED_DURATION_MS = 7 * 24 * 60 * 60 * 1000;
+
+function observedDuration(value) {
+  if (value === null || value === undefined || value === "") return null;
+  const number = Number(value);
+  if (!Number.isFinite(number) || number < 0) return null;
+  return Math.min(MAX_OBSERVED_DURATION_MS, Math.round(number));
+}
+
+function eventDuration(event) {
+  return observedDuration(
+    event?.data?.duration_ms ??
+      event?.data?.durationMs ??
+      event?.data?.result?.toolTelemetryRecord?.durationMs,
+  );
+}
+
+function addObservedDuration(row, durationMs) {
+  if (durationMs === null) return;
+  row.durationMs = (row.durationMs || 0) + durationMs;
+  row.timedCalls = (row.timedCalls || 0) + 1;
+}
+
+function addObservedRetry(row) {
+  row.retries = (row.retries || 0) + 1;
+}
+
 /**
  * Extract the optional usage-attribution frame (用量归因) persisted alongside
  * a token_usage event's data: `{ origin, skill?, subagentId?, role?,
@@ -208,6 +236,56 @@ function _isToolResultError(event) {
   );
 }
 
+/**
+ * Aggregate compact `llm_retry` events. Each event represents one failed
+ * streaming attempt that the runtime actually retried and includes only a
+ * controlled reason plus its elapsed time — never the raw provider error.
+ */
+export function aggregateLlmRetries(events) {
+  const byReason = new Map();
+  const byModel = new Map();
+  let totalRetries = 0;
+  let durationMs = 0;
+
+  const add = (map, key, seed, elapsed) => {
+    const row = map.get(key) || { ...seed, retries: 0, durationMs: 0 };
+    row.retries++;
+    row.durationMs += elapsed;
+    map.set(key, row);
+  };
+
+  for (const event of events || []) {
+    if (event?.type !== "llm_retry") continue;
+    const data = event.data || {};
+    const elapsed = eventDuration(event) ?? 0;
+    const reason =
+      typeof data.reason === "string" && data.reason ? data.reason : "unknown";
+    const provider =
+      typeof data.provider === "string" && data.provider ? data.provider : null;
+    const model =
+      typeof data.model === "string" && data.model ? data.model : null;
+    totalRetries++;
+    durationMs += elapsed;
+    add(byReason, reason, { reason }, elapsed);
+    add(
+      byModel,
+      `${provider || "?"}/${model || "?"}`,
+      { provider, model },
+      elapsed,
+    );
+  }
+
+  if (totalRetries === 0) return null;
+  const byRetriesDesc = (a, b) =>
+    b.retries - a.retries || b.durationMs - a.durationMs;
+  return {
+    totalRetries,
+    durationMs,
+    byReason: Array.from(byReason.values()).sort(byRetriesDesc),
+    byModel: Array.from(byModel.values()).sort(byRetriesDesc),
+  };
+}
+
 /**
  * Aggregate the transcript's tool events: per-tool call/error counts, an MCP
  * server bucket (`mcp__<server>__*`), and a turn-associated token figure.
@@ -228,8 +306,12 @@ function _isToolResultError(event) {
 export function aggregateToolCalls(events) {
   const byTool = new Map();
   const byServer = new Map();
+  const byPlugin = new Map();
   let totalCalls = 0;
   let totalErrors = 0;
+  let totalDurationMs = 0;
+  let timedCalls = 0;
+  let retryCalls = 0;
 
   const bumpTool = (name) => {
     let t = byTool.get(name);
@@ -253,19 +335,46 @@ export function aggregateToolCalls(events) {
     }
     return s;
   };
+  const bumpPlugin = (plugin, version = null) => {
+    const key = `${plugin}@${version || "?"}`;
+    let row = byPlugin.get(key);
+    if (!row) {
+      row = {
+        plugin,
+        version: version || null,
+        calls: 0,
+        errors: 0,
+        turnTokens: 0,
+      };
+      byPlugin.set(key, row);
+    }
+    return row;
+  };
 
   let turnTools = new Set();
   let turnServers = new Set();
+  let turnPlugins = new Set();
   let turnTokens = 0;
+  let pendingPlugin = null;
+  let pendingObservation = null;
+  let failedToolsInTurn = new Set();
   const flushTurn = () => {
     if (turnTokens > 0) {
       for (const name of turnTools) bumpTool(name).turnTokens += turnTokens;
       for (const server of turnServers)
         bumpServer(server).turnTokens += turnTokens;
+      for (const key of turnPlugins) {
+        const row = byPlugin.get(key);
+        if (row) row.turnTokens += turnTokens;
+      }
     }
     turnTools = new Set();
     turnServers = new Set();
+    turnPlugins = new Set();
     turnTokens = 0;
+    pendingPlugin = null;
+    pendingObservation = null;
+    failedToolsInTurn = new Set();
   };
 
   for (const evt of events || []) {
@@ -276,34 +385,107 @@ export function aggregateToolCalls(events) {
     }
     if (evt.type === "tool_call") {
       const name = evt.data?.tool || "?";
+      const durationMs = eventDuration(evt);
+      const isRetry = failedToolsInTurn.has(name);
       totalCalls++;
       const t = bumpTool(name);
       t.calls++;
       const isErr = evt.data?.is_error === true;
+      if (durationMs !== null) {
+        totalDurationMs += durationMs;
+        timedCalls++;
+        addObservedDuration(t, durationMs);
+      }
+      if (isRetry) {
+        retryCalls++;
+        addObservedRetry(t);
+      }
       if (isErr) {
         totalErrors++;
         t.errors++;
       }
+      if (isErr) failedToolsInTurn.add(name);
+      else failedToolsInTurn.delete(name);
       turnTools.add(name);
       const server = mcpServerOf(name);
       if (server) {
         const s = bumpServer(server);
         s.calls++;
         if (isErr) s.errors++;
+        addObservedDuration(s, durationMs);
+        if (isRetry) addObservedRetry(s);
         turnServers.add(server);
       }
+      const plugin =
+        typeof evt.data?.plugin === "string" && evt.data.plugin
+          ? evt.data.plugin
+          : null;
+      const pluginVersion =
+        typeof evt.data?.plugin_version === "string"
+          ? evt.data.plugin_version
+          : null;
+      pendingPlugin = { tool: name, plugin, version: pluginVersion };
+      pendingObservation = {
+        tool: name,
+        durationCounted: durationMs !== null,
+        errorCounted: isErr,
+      };
+      if (plugin) {
+        const p = bumpPlugin(plugin, pluginVersion);
+        p.calls++;
+        if (isErr) p.errors++;
+        addObservedDuration(p, durationMs);
+        if (isRetry) addObservedRetry(p);
+        turnPlugins.add(`${plugin}@${pluginVersion || "?"}`);
+      }
       continue;
     }
     if (evt.type === "tool_result") {
       const name = evt.data?.tool || "?";
+      const durationMs = eventDuration(evt);
       turnTools.add(name);
       const server = mcpServerOf(name);
       if (server) turnServers.add(server);
-      if (_isToolResultError(evt)) {
+      const isErr = _isToolResultError(evt);
+      const pairedObservation =
+        pendingObservation?.tool === name ? pendingObservation : null;
+      if (isErr && !pairedObservation?.errorCounted) {
         totalErrors++;
         bumpTool(name).errors++;
         if (server) bumpServer(server).errors++;
       }
+      if (isErr) failedToolsInTurn.add(name);
+      else failedToolsInTurn.delete(name);
+      if (durationMs !== null && !pairedObservation?.durationCounted) {
+        totalDurationMs += durationMs;
+        timedCalls++;
+        addObservedDuration(bumpTool(name), durationMs);
+        if (server) addObservedDuration(bumpServer(server), durationMs);
+      }
+      const extracted = extractPluginUsageAttribution(evt.data?.result);
+      const plugin =
+        typeof evt.data?.plugin === "string" && evt.data.plugin
+          ? evt.data.plugin
+          : extracted.plugin || null;
+      const pluginVersion =
+        typeof evt.data?.plugin_version === "string"
+          ? evt.data.plugin_version
+          : extracted.pluginVersion || null;
+      if (plugin) {
+        const p = bumpPlugin(plugin, pluginVersion);
+        const countedByCall =
+          pendingPlugin?.tool === name &&
+          pendingPlugin?.plugin === plugin &&
+          (pendingPlugin?.version || null) === (pluginVersion || null);
+        if (!countedByCall) p.calls++;
+        if (isErr && !countedByCall) p.errors++;
+        if (!countedByCall || !pairedObservation?.durationCounted) {
+          addObservedDuration(p, durationMs);
+        }
+        turnPlugins.add(`${plugin}@${pluginVersion || "?"}`);
+      }
+      pendingPlugin = null;
+      pendingObservation = null;
       continue;
     }
     const u = extractUsage(evt);
@@ -315,8 +497,11 @@ export function aggregateToolCalls(events) {
   return {
     totalCalls,
     totalErrors,
+    ...(timedCalls > 0 ? { totalDurationMs, timedCalls } : {}),
+    ...(retryCalls > 0 ? { retryCalls } : {}),
     byTool: Array.from(byTool.values()).sort(byCallsDesc),
     byMcpServer: Array.from(byServer.values()).sort(byCallsDesc),
+    byPlugin: Array.from(byPlugin.values()).sort(byCallsDesc),
   };
 }
 
@@ -325,9 +510,11 @@ export function aggregateToolCalls(events) {
  * roll-ups + the tool/MCP call aggregation. Pure.
  */
 export function sessionAttribution(events) {
+  const retries = aggregateLlmRetries(events);
   return {
     ...aggregateUsageAttribution(events),
     tools: aggregateToolCalls(events),
+    ...(retries ? { retries } : {}),
   };
 }
 
@@ -457,8 +644,16 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
   const gSubagent = new Map();
   const gTool = new Map();
   const gServer = new Map();
+  const gPlugin = new Map();
+  const gRetryReason = new Map();
+  const gRetryModel = new Map();
   let gToolCalls = 0;
   let gToolErrors = 0;
+  let gToolDurationMs = 0;
+  let gTimedToolCalls = 0;
+  let gToolRetryCalls = 0;
+  let gLlmRetries = 0;
+  let gLlmRetryDurationMs = 0;
   const mergeRow = (map, key, row, seed) => {
     const entry = map.get(key) || { ...seed, ..._newSums() };
     _addSums(entry, row);
@@ -483,6 +678,9 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
     const tools = a.tools || {};
     gToolCalls += tools.totalCalls || 0;
     gToolErrors += tools.totalErrors || 0;
+    gToolDurationMs += tools.totalDurationMs || 0;
+    gTimedToolCalls += tools.timedCalls || 0;
+    gToolRetryCalls += tools.retryCalls || 0;
     for (const row of tools.byTool || []) {
       const entry = gTool.get(row.tool) || {
         tool: row.tool,
@@ -494,6 +692,12 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
       entry.calls += row.calls || 0;
       entry.errors += row.errors || 0;
       entry.turnTokens += row.turnTokens || 0;
+      if (row.durationMs !== undefined) {
+        entry.durationMs = (entry.durationMs || 0) + (row.durationMs || 0);
+        entry.timedCalls = (entry.timedCalls || 0) + (row.timedCalls || 0);
+      }
+      if (row.retries !== undefined)
+        entry.retries = (entry.retries || 0) + (row.retries || 0);
       gTool.set(row.tool, entry);
     }
     for (const row of tools.byMcpServer || []) {
@@ -506,10 +710,65 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
       entry.calls += row.calls || 0;
       entry.errors += row.errors || 0;
       entry.turnTokens += row.turnTokens || 0;
+      if (row.durationMs !== undefined) {
+        entry.durationMs = (entry.durationMs || 0) + (row.durationMs || 0);
+        entry.timedCalls = (entry.timedCalls || 0) + (row.timedCalls || 0);
+      }
+      if (row.retries !== undefined)
+        entry.retries = (entry.retries || 0) + (row.retries || 0);
       gServer.set(row.server, entry);
     }
+    for (const row of tools.byPlugin || []) {
+      const key = `${row.plugin}@${row.version || "?"}`;
+      const entry = gPlugin.get(key) || {
+        plugin: row.plugin,
+        version: row.version || null,
+        calls: 0,
+        errors: 0,
+        turnTokens: 0,
+      };
+      entry.calls += row.calls || 0;
+      entry.errors += row.errors || 0;
+      entry.turnTokens += row.turnTokens || 0;
+      if (row.durationMs !== undefined) {
+        entry.durationMs = (entry.durationMs || 0) + (row.durationMs || 0);
+        entry.timedCalls = (entry.timedCalls || 0) + (row.timedCalls || 0);
+      }
+      if (row.retries !== undefined)
+        entry.retries = (entry.retries || 0) + (row.retries || 0);
+      gPlugin.set(key, entry);
+    }
+    const retries = a.retries || null;
+    if (retries) {
+      gLlmRetries += retries.totalRetries || 0;
+      gLlmRetryDurationMs += retries.durationMs || 0;
+      for (const row of retries.byReason || []) {
+        const entry = gRetryReason.get(row.reason) || {
+          reason: row.reason,
+          retries: 0,
+          durationMs: 0,
+        };
+        entry.retries += row.retries || 0;
+        entry.durationMs += row.durationMs || 0;
+        gRetryReason.set(row.reason, entry);
+      }
+      for (const row of retries.byModel || []) {
+        const key = `${row.provider || "?"}/${row.model || "?"}`;
+        const entry = gRetryModel.get(key) || {
+          provider: row.provider || null,
+          model: row.model || null,
+          retries: 0,
+          durationMs: 0,
+        };
+        entry.retries += row.retries || 0;
+        entry.durationMs += row.durationMs || 0;
+        gRetryModel.set(key, entry);
+      }
+    }
   }
   const byCallsDesc = (a, b) => b.calls - a.calls;
+  const byRetriesDesc = (a, b) =>
+    b.retries - a.retries || b.durationMs - a.durationMs;
 
   return {
     sessions: perSession,
@@ -525,9 +784,27 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
       tools: {
         totalCalls: gToolCalls,
         totalErrors: gToolErrors,
+        ...(gTimedToolCalls > 0
+          ? {
+              totalDurationMs: gToolDurationMs,
+              timedCalls: gTimedToolCalls,
+            }
+          : {}),
+        ...(gToolRetryCalls > 0 ? { retryCalls: gToolRetryCalls } : {}),
         byTool: Array.from(gTool.values()).sort(byCallsDesc),
         byMcpServer: Array.from(gServer.values()).sort(byCallsDesc),
+        byPlugin: Array.from(gPlugin.values()).sort(byCallsDesc),
       },
+      ...(gLlmRetries > 0
+        ? {
+            retries: {
+              totalRetries: gLlmRetries,
+              durationMs: gLlmRetryDurationMs,
+              byReason: Array.from(gRetryReason.values()).sort(byRetriesDesc),
+              byModel: Array.from(gRetryModel.values()).sort(byRetriesDesc),
+            },
+          }
+        : {}),
     },
   };
 }

package/src/lib/stream-retry.js

@@ -81,3 +81,32 @@ export function isRetryableStreamError(err, signal) {
     msg,
   );
 }
+
+/**
+ * Reduce a retryable stream failure to a small, secret-free reason vocabulary
+ * suitable for persisted usage telemetry. Never persist the provider's raw
+ * error message: it can contain a request URL, tenant id, or proxy details.
+ */
+export function classifyStreamRetryReason(err) {
+  const code = String(err?.code || err?.cause?.code || "").toUpperCase();
+  if (code === "ETIMEDOUT") return "timeout";
+  if (["EAI_AGAIN", "ENOTFOUND"].includes(code)) return "dns";
+  if (code === "ECONNREFUSED") return "connection_refused";
+  if (code === "ENETUNREACH") return "network_unreachable";
+  if (["ECONNRESET", "EPIPE", "UND_ERR_SOCKET"].includes(code)) {
+    return "connection_reset";
+  }
+  const msg = String(err?.message || err || "").toLowerCase();
+  if (/timed?\s*out|etimedout/.test(msg)) return "timeout";
+  if (/eai_again|enotfound|dns/.test(msg)) return "dns";
+  if (/econnrefused/.test(msg)) return "connection_refused";
+  if (/network unreachable|enetunreach/.test(msg)) return "network_unreachable";
+  if (
+    /econnreset|socket hang ?up|terminated|fetch failed|network error|premature close/.test(
+      msg,
+    )
+  ) {
+    return "connection_reset";
+  }
+  return "unknown";
+}

package/src/repl/agent-repl.js

@@ -48,10 +48,12 @@ import {
   appendCompactEvent,
   appendTokenUsage,
   appendToolCallCompact,
+  appendLlmRetryCompact,
   appendEvent,
   rebuildMessages,
   sessionExists,
 } from "../harness/jsonl-session-store.js";
+import { classifyStreamRetryReason } from "../lib/stream-retry.js";
 import { CLISkillLoader } from "../lib/skill-loader.js";
 import { storeMemory, consolidateMemory } from "../lib/hierarchical-memory.js";
 import { CLIContextEngineering } from "../lib/cli-context-engineering.js";
@@ -108,6 +110,7 @@ import {
 import { resolveSlashMacro } from "./slash-macro.js";
 import { expandMcpPrompt, renderMcpSurface } from "./mcp-prompt.js";
 import { newCostStore, addUsage } from "./session-cost.js";
+import { extractPluginUsageAttribution } from "../lib/plugin-usage-attribution.js";
 import { parseThinkCommand, parseEffortCommand } from "./think-command.js";
 import { parseBtwCommand, buildAsideBlock, applyAside } from "./btw-command.js";
 import { shouldStreamLive } from "./stream-decision.js";
@@ -352,17 +355,29 @@ export async function agentLoop(messages, options) {
         chalk.gray(`  ⎌ checkpoint ${event.id} (before ${event.tool})\n`),
       );
     } else if (event.type === "tool-executing") {
-      _lastExec = { tool: event.tool, args: event.args };
+      _lastExec = {
+        tool: event.tool,
+        args: event.args,
+        startedAt: options.now ? options.now() : Date.now(),
+      };
       process.stdout.write(
         chalk.gray(
           `  [${event.tool}] ${formatToolArgs(event.tool, event.args)}\n`,
         ),
       );
     } else if (event.type === "tool-result") {
+      const durationMs =
+        event.result?.toolTelemetryRecord?.durationMs ??
+        (_lastExec?.tool === event.tool
+          ? Math.max(
+              0,
+              (options.now ? options.now() : Date.now()) - _lastExec.startedAt,
+            )
+          : undefined);
       // 用量归因: persist a compact tool_call record (name + error flag +
-      // skill hint — never args, which can carry whole file bodies) so
-      // `cc session usage --by tool|mcp` and `cc insights` can aggregate
-      // tool use for REPL sessions. Best-effort; opt out with
+      // skill/plugin hints — never args, which can carry whole file bodies)
+      // so `cc session usage --by tool|mcp|plugin` and `cc insights` can
+      // aggregate tool use for REPL sessions. Best-effort; opt out with
       // options.persistToolCalls === false.
       if (options.sessionId && options.persistToolCalls !== false) {
         try {
@@ -373,6 +388,8 @@ export async function agentLoop(messages, options) {
               event.tool === "run_skill" && _lastExec?.tool === "run_skill"
                 ? _lastExec.args?.skill_name
                 : undefined,
+            ...extractPluginUsageAttribution(event.result),
+            durationMs,
           });
         } catch (_e) {
           // persistence is best-effort — never break the turn
@@ -1844,9 +1861,7 @@ export async function startAgentRepl(options = {}) {
                   "  Open this secure page? [y/N] ",
               ),
               async (answer) => {
-                const approved = /^(y|yes)$/i.test(
-                  String(answer || "").trim(),
-                );
+                const approved = /^(y|yes)$/i.test(String(answer || "").trim());
                 if (!approved) {
                   resolve({ action: "decline" });
                   rl.prompt();
@@ -5570,12 +5585,26 @@ export async function startAgentRepl(options = {}) {
         // streaming call hits a transient connection drop and retries, tell the
         // user instead of leaving them staring at a silent pause. To stderr so
         // it never corrupts the streamed answer on stdout.
-        onStreamRetry: (attempt) =>
+        onStreamRetry: (attempt, error, telemetry = {}) => {
           process.stderr.write(
             chalk.dim(
               `  ⟳ connection dropped — retrying (attempt ${attempt})…\n`,
             ),
-          ),
+          );
+          if (useJsonl && sessionId) {
+            try {
+              appendLlmRetryCompact(sessionId, {
+                attempt,
+                durationMs: telemetry.durationMs,
+                provider: telemetry.provider || provider,
+                model: telemetry.model || activeModel,
+                reason: classifyStreamRetryReason(error),
+              });
+            } catch {
+              /* usage telemetry is best-effort */
+            }
+          }
+        },
         // Stream-stall hint (Claude-Code 2.1.185): the connection is alive but
         // the API has gone silent mid-response — tell the user we're still
         // waiting instead of leaving a frozen spinner. stderr so it never

package/src/runtime/agent-core.js

@@ -6742,7 +6742,15 @@ export async function chatWithTools(rawMessages, options) {
             options.streamStallMs,
             options.streamStallTimeoutMs,
           ),
-        { signal, onRetry: options.onStreamRetry },
+        {
+          signal,
+          onRetry: (attempt, error, telemetry) =>
+            options.onStreamRetry?.(attempt, error, {
+              ...telemetry,
+              provider: "ollama",
+              model: model || null,
+            }),
+        },
       );
     }
     const response = await fetch(apiUrl, {
@@ -6868,7 +6876,15 @@ export async function chatWithTools(rawMessages, options) {
             options.streamStallMs,
             options.streamStallTimeoutMs,
           ),
-        { signal, onRetry: options.onStreamRetry },
+        {
+          signal,
+          onRetry: (attempt, error, telemetry) =>
+            options.onStreamRetry?.(attempt, error, {
+              ...telemetry,
+              provider: "anthropic",
+              model: effModel,
+            }),
+        },
       );
     }
 
@@ -6972,7 +6988,15 @@ export async function chatWithTools(rawMessages, options) {
           options.streamStallMs,
           options.streamStallTimeoutMs,
         ),
-      { signal, onRetry: options.onStreamRetry },
+      {
+        signal,
+        onRetry: (attempt, error, telemetry) =>
+          options.onStreamRetry?.(attempt, error, {
+            ...telemetry,
+            provider,
+            model: model || defaultModels[provider] || "gpt-4o-mini",
+          }),
+      },
     );
   }
 
@@ -7171,8 +7195,10 @@ export async function _retryStreamingChat(streamFn, opts = {}) {
   const base = opts.baseDelayMs ?? STREAM_RETRY_BASE_MS;
   const signal = opts.signal;
   const sleep = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const now = typeof opts.now === "function" ? opts.now : Date.now;
   let attempt = 0;
   for (;;) {
+    const attemptStartedAt = now();
     try {
       return await streamFn();
     } catch (err) {
@@ -7181,7 +7207,9 @@ export async function _retryStreamingChat(streamFn, opts = {}) {
       attempt++;
       if (typeof opts.onRetry === "function") {
         try {
-          opts.onRetry(attempt, err);
+          opts.onRetry(attempt, err, {
+            durationMs: Math.max(0, now() - attemptStartedAt),
+          });
         } catch {
           /* the retry notice is best-effort; never let it mask the retry */
         }