opencode-context-indicator 1.3.1 → 1.4.1

package/lib/v2.js

@@ -7,11 +7,14 @@
 // from index.js.
 
 import {
+  breakdownCategories,
   estJson,
   estimateTokens,
   fmt,
+  isSafeSessionKey,
   oneLine,
   tokenCountOf,
+  TOOL_OUT_MAX_KEYS,
   withTimeout,
 } from "./estimate.js";
 import {
@@ -60,12 +63,14 @@ const V2_FALLBACK_TIMEOUT_MS = 3000;
 // Estimate the per-category breakdown directly from a V2 SessionContext.
 // `context.messages` are @opencode/ai Message objects:
 //   { role, content: [ {type:"text",text} | {type:"media"} |
-//                      {type:"tool-call",input} | {type:"tool-result"} |
+//                      {type:"tool-call",input} | {type:"tool-result",result} |
 //                      {type:"reasoning",text} | ... ] }
 // `context.system` are SystemPart[] { type:"text", text }.
 // `context.tools` is Record<name, { description, input: JsonSchema }>.
-// As in V1, tool RESULTS are deliberately not counted (only call args), and
-// every returned *Chars value is a TOKEN estimate (unicode heuristic).
+// Tool RESULTS are counted into the toolOut category (the payload the model
+// sees back: webfetch pages, file reads, subagent reports); tool call ARGS are
+// counted separately. Every returned *Chars value is a TOKEN estimate (unicode
+// heuristic).
 //
 // `sessionID` is optional; when given, the tool-schema estimate is cached
 // per-session (see toolSchemasBySession) and reused while the cheap fingerprint
@@ -73,10 +78,11 @@ const V2_FALLBACK_TIMEOUT_MS = 3000;
 // every schema does not run on every single model request.
 // Cheap structural fingerprint of the tool schema map: count + total description
 // length + number of schema property keys + two O(n) charCode checksums (mod
-// 0xFFFFFF) over every description and over the top-level input keys. The
-// checksums widen the fingerprint so two different schemas that happen to share
-// the same length/key counts do not collide into a wrong cache hit — without
-// paying for full JSON.stringify (the whole point of the cache).
+// 0xFFFFFF) over every description and over the PARAMETER names
+// (input.properties keys). The checksums widen the fingerprint so two different
+// schemas that happen to share the same length/key counts do not collide into a
+// wrong cache hit — without paying for full JSON.stringify (the whole point of
+// the cache).
 function toolsFingerprint(tools) {
   if (!tools || typeof tools !== "object") return "none";
   let n = 0;
@@ -96,14 +102,16 @@ function toolsFingerprint(tools) {
     const input = t?.input;
     if (input && typeof input === "object") {
       const props = input.properties;
-      propKeys +=
+      // Hash the PARAMETER names (input.properties keys) when present — a
+      // property rename that keeps the same count/description must change the
+      // fingerprint, or the TTL cache would serve a stale schema estimate.
+      // Fall back to the top-level schema keys for schemas without `properties`.
+      const nameSource =
         props && typeof props === "object"
-          ? Object.keys(props).length
-          : Object.keys(input).length;
-      // Sum the top-level key names so property RENAMES that keep the same count
-      // still change the fingerprint.
-      const topKeys = Object.keys(input);
-      for (const k of topKeys) {
+          ? Object.keys(props)
+          : Object.keys(input);
+      propKeys += nameSource.length;
+      for (const k of nameSource) {
         for (let i = 0; i < k.length; i++) {
           keyHash = (keyHash + k.charCodeAt(i)) & 0xffffff;
         }
@@ -113,21 +121,74 @@ function toolsFingerprint(tools) {
   return `${n}:${descLen}:${propKeys}:${descHash}:${keyHash}`;
 }
 
+// Token estimate for one ToolResultPart (@opencode/ai schema/messages.d.ts):
+//   result: {type:"text",value} | {type:"json",value} | {type:"error",value}
+//         | {type:"content",value:[{type:"text",text}|{type:"file",uri,mime}]}
+// json / error payloads and non-string text values go through estJson; string
+// values through the char estimator. `content` file items are URI references,
+// not inline bytes — deliberately skipped (a data-URL base64 blob is consumed
+// by the model as media tokens, not as text the char heuristic can price).
+function toolResultChars(p) {
+  const r = p?.result;
+  if (!r || typeof r !== "object") return 0;
+  if (r.type === "content" && Array.isArray(r.value)) {
+    let n = 0;
+    for (const item of r.value) {
+      if (item?.type === "text") n += estimateTokens(item.text);
+    }
+    return n;
+  }
+  if (r.type === "text" && typeof r.value === "string") {
+    return estimateTokens(r.value);
+  }
+  return estJson(r.value); // json | error | unexpected shapes
+}
+
+// Accumulate the per-tool tool-result estimate. Tool names are untrusted
+// (host tool ids, plugin-defined tools): unsafe names and any name beyond the
+// cap fold into "other tools" so the bucket never becomes a prototype vector
+// and the map stays bounded. The sum of the map mirrors the toolOut category.
+// The cap is the SHARED TOOL_OUT_MAX_KEYS (lib/estimate.js) so the accumulation
+// bound and the persisted/displayed bound can never drift apart.
+function addToolOut(map, name, chars) {
+  if (!(chars > 0)) return;
+  const safe =
+    isSafeSessionKey(name) && name.length <= 64 ? name : "other tools";
+  if (
+    safe !== "other tools" &&
+    !Object.prototype.hasOwnProperty.call(map, safe) &&
+    Object.keys(map).length >= TOOL_OUT_MAX_KEYS
+  ) {
+    map["other tools"] = (map["other tools"] || 0) + chars;
+    return;
+  }
+  map[safe] = (map[safe] || 0) + chars;
+}
+
 function estimateBreakdownFromContext(context, sessionID) {
   let userChars = 0;
   let assistantChars = 0;
   let reasoningChars = 0;
   let toolArgsChars = 0;
+  let toolOutChars = 0;
+  const toolOutByTool = {};
 
   const messages = Array.isArray(context?.messages) ? context.messages : [];
   for (const msg of messages) {
     const parts = Array.isArray(msg?.content) ? msg.content : [];
-    if (msg?.role === "user") {
-      for (const p of parts) {
-        if (p?.type === "text") userChars += estimateTokens(p.text);
+    for (const p of parts) {
+      // Tool results arrive in dedicated tool-result parts; the message ROLE
+      // carrying them varies by host version (user, assistant, or the dedicated
+      // "tool" role) — count them role-independently.
+      if (p?.type === "tool-result") {
+        const chars = toolResultChars(p);
+        toolOutChars += chars;
+        addToolOut(toolOutByTool, p?.name, chars);
+        continue;
       }
-    } else if (msg?.role === "assistant") {
-      for (const p of parts) {
+      if (msg?.role === "user") {
+        if (p?.type === "text") userChars += estimateTokens(p.text);
+      } else if (msg?.role === "assistant") {
         if (p?.type === "text") {
           assistantChars += estimateTokens(p.text);
         } else if (p?.type === "reasoning") {
@@ -174,6 +235,8 @@ function estimateBreakdownFromContext(context, sessionID) {
     assistantChars,
     reasoningChars,
     toolArgsChars,
+    toolOutChars,
+    toolOutByTool,
     systemChars,
     toolSchemasChars,
   };
@@ -216,16 +279,18 @@ function onV2Context(context) {
 // instance (the public event stream is mirrored to every instance, but the
 // breakdown cache is process-local) or when the hook did not fire at all.
 //
-// Only user / assistant / reasoning / tool-args can be derived from the
-// persisted SessionMessageInfo[]: the ASSEMBLED system prompt and the tool
+// Only user / assistant / reasoning / tool-args / tool-OUT can be derived from
+// the persisted SessionMessageInfo[]: the ASSEMBLED system prompt and the tool
 // schemas are exclusive to the context hook, so they stay null ("n/a" in the
-// sidebar) unless the hook ran. Tool RESULTS are deliberately not counted
-// (only call args), exactly like the hook / V1 estimator.
+// sidebar) unless the hook ran. Tool RESULTS are counted from the resolved
+// `state.content` (ToolContent[]) of completed / errored tool parts.
 function estimateBreakdownFromClientMessages(messages) {
   let userChars = 0;
   let assistantChars = 0;
   let reasoningChars = 0;
   let toolArgsChars = 0;
+  let toolOutChars = 0;
+  const toolOutByTool = {};
   for (const m of messages || []) {
     if (!m || typeof m !== "object") continue;
     if (m.type === "user") {
@@ -242,6 +307,24 @@ function estimateBreakdownFromClientMessages(messages) {
           // object (running/completed/error) to avoid partial counts.
           const input = p?.state?.input;
           if (input && typeof input === "object") toolArgsChars += estJson(input);
+          // Tool results: completed / errored states carry the payload in
+          // state.content (ToolContent[]: {type:"text",text}|{type:"file"}) —
+          // NOT state.output (that field does not exist on SessionMessageInfo).
+          // Count text items; file items are URI references, skipped (same
+          // policy as the hook path).
+          const content = p?.state?.content;
+          if (Array.isArray(content)) {
+            let outChars = 0;
+            for (const item of content) {
+              if (item?.type === "text" && typeof item.text === "string") {
+                outChars += estimateTokens(item.text);
+              }
+            }
+            toolOutChars += outChars;
+            // The persisted tool part carries its name on `p.name`
+            // (SessionMessageAssistantTool.name) — same field as the hook path.
+            addToolOut(toolOutByTool, p?.name, outChars);
+          }
         }
       }
     }
@@ -251,6 +334,8 @@ function estimateBreakdownFromClientMessages(messages) {
     assistantChars,
     reasoningChars,
     toolArgsChars,
+    toolOutChars,
+    toolOutByTool,
     systemChars: null,
     toolSchemasChars: null,
   };
@@ -376,13 +461,9 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
   const source = bd?.source || "none";
   const rt = typeof reasoningTokens === "number" ? reasoningTokens : 0;
 
-  const sumEstimates = (bd?.userChars || 0) +
-    (bd?.assistantChars || 0) +
-    (bd?.reasoningChars || 0) +
-    (bd?.toolArgsChars || 0) +
-    (bd?.systemChars || 0) +
-    (bd?.toolSchemasChars || 0);
-  const other = Math.max(0, inputTokens - sumEstimates);
+  // Residual = input minus every measured category (shared normaliser; `bd`
+  // may be absent -> everything 0 and the residual is the whole input).
+  const other = breakdownCategories(bd, inputTokens).other;
 
   if (bd) {
     lines.push(`  user        ${fmt(bd.userChars || 0)} (est tokens)`);
@@ -390,6 +471,9 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
     const reasoningNote = rt > 0 ? ` (exact ${fmt(rt)})` : "";
     lines.push(`  reasoning   ${fmt(bd.reasoningChars || 0)} (est tokens)${reasoningNote}`);
     lines.push(`  tool args   ${fmt(bd.toolArgsChars || 0)} (est tokens, input only)`);
+    lines.push(
+      `  tool results ${fmt(bd.toolOutChars || 0)} (est tokens, outputs fed back)`,
+    );
     lines.push(
       bd.systemChars != null
         ? `  system      ${fmt(bd.systemChars)} (est tokens)`
@@ -405,6 +489,7 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
     lines.push(`  assistant   n/a`);
     lines.push(`  reasoning   n/a`);
     lines.push(`  tool args   n/a`);
+    lines.push(`  tool results n/a`);
     lines.push(`  system      n/a (hook did not run)`);
     lines.push(`  tool schemas n/a`);
   }
@@ -517,6 +602,11 @@ async function handleV2Event(ctx, event) {
         lastKnownInput(sid),
         lastKnownCtx(sid),
         lastKnownReasoning(sid),
+        // This write re-persists the PRE-compaction snapshot (the compaction
+        // flow fires no context hook — see README): mark the entry stale so the
+        // UI shows the numbers as pre-compaction until the next model request
+        // refreshes them.
+        { compacted: true },
       );
       pushFinalSummary(
         `compacted:${event.id ?? sid}`,
@@ -687,6 +777,7 @@ async function handleV2Event(ctx, event) {
 export {
   onV2Context,
   handleV2Event,
+  estimateBreakdownFromContext,
   estimateBreakdownFromClientMessages,
   V2_FALLBACK_TIMEOUT_MS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-context-indicator",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Real-time context-window usage for OpenCode: per-category token breakdown, a zero-LLM /cx panel with per-session cost and a searchable family-session picker, and a TUI sidebar. Dual V1 + V2 plugin entry.",
   "type": "module",
   "license": "MIT",
@@ -64,7 +64,7 @@
     "@opentui/solid": "0.5.17"
   },
   "devDependencies": {
-    "@opencode/plugin": "2.0.26",
+    "@opencode/plugin": "2.0.28",
     "@opentui/core": "0.5.17",
     "@types/node": "26.6.3",
     "esbuild": "^0.28.2",