@4djs/assistant 0.1.3 → 0.1.4

package/dist/core/index.js

@@ -1460,8 +1460,34 @@ var DEFAULT_ASSISTANT_LABELS = {
   "composer.stop": "Stop",
   "composer.hint": "Enter to send · Shift+Enter for new line",
   "composer.llmSettings": "LLM settings",
+  "composer.contextUsage": "Context usage",
   "composer.generateSuggestions": "Generate suggestions",
   "composer.clearConversation": "Clear conversation",
+  "usage.ariaLabel": "Show context usage",
+  "usage.panelTitle": "Context usage",
+  "usage.panelClose": "Close context usage",
+  "usage.fullPercent": "{percent}% full",
+  "usage.tokenBudget": "{used} / {total} tokens",
+  "usage.tooltipTitle": "LLM usage",
+  "usage.context": "Context: {used} / {total} ({percent}%)",
+  "usage.tokensTotal": "Tokens: {count}",
+  "usage.promptCompletion": "Prompt: {prompt} · Completion: {completion}",
+  "usage.cached": "Cached: {count}",
+  "usage.reasoning": "Reasoning: {count}",
+  "usage.speed": "Speed: {rate} tok/s",
+  "usage.duration": "Duration: {duration}",
+  "usage.requests": "Requests this turn: {count}",
+  "usage.model": "Model: {model}",
+  "usage.session": "Session: {total} tokens · {requests} requests",
+  "usage.idle": "No usage yet — send a message to start tracking",
+  "usage.contextLimit": "Context window: {total}",
+  "usage.category.systemPrompt": "System prompt",
+  "usage.category.toolDefinitions": "Tool definitions",
+  "usage.category.conversation": "Conversation",
+  "usage.category.completion": "Completion",
+  "usage.category.cached": "Cached prompt",
+  "usage.category.reasoning": "Reasoning",
+  "usage.estimatedHint": "Category splits are estimated from payload size",
   "commandMenu.ariaLabel": "Composer commands",
   "commandMenu.header": "Commands",
   "commands.clear.description": "Clear the current conversation",
@@ -1487,7 +1513,7 @@ var DEFAULT_ASSISTANT_LABELS = {
   "llmSettings.modelList": "Model list",
   "llmSettings.baseUrlPlaceholder": "https://api.openai.com/v1",
   "llmSettings.apiKeyPlaceholder": "sk-…",
-  "llmSettings.apiKeyConfiguredPlaceholder": "Configured — leave blank to keep",
+  "llmSettings.apiKeyConfiguredPlaceholder": "Leave blank to keep current key",
   "llmSettings.modelPlaceholder": "gpt-4o-mini",
   "llmSettings.modelListPlaceholder": "Optional — comma-separated",
   "llmSettings.connected": "Connected · {model}",
@@ -2081,6 +2107,365 @@ function autoResolvedInteractiveResult(toolName, args) {
     message: "A choice was already submitted. Call the action tool immediately."
   });
 }
+// src/core/llm-usage.ts
+var EMPTY_USAGE = {
+  promptTokens: 0,
+  completionTokens: 0,
+  totalTokens: 0
+};
+var DEFAULT_MODEL_CONTEXT_WINDOWS = [
+  ["gpt-5.5-pro", 1050000],
+  ["gpt-5.5", 1050000],
+  ["gpt-5.4-pro", 1100000],
+  ["gpt-5.4", 1100000],
+  ["gpt-5.3", 400000],
+  ["gpt-5.2-pro", 400000],
+  ["gpt-5.2", 400000],
+  ["gpt-5.1", 400000],
+  ["gpt-5-pro", 400000],
+  ["gpt-5-mini", 400000],
+  ["gpt-5-nano", 400000],
+  ["gpt-5", 400000],
+  ["gpt-4.1-nano", 1047576],
+  ["gpt-4.1-mini", 1047576],
+  ["gpt-4.1", 1047576],
+  ["gpt-4o-mini", 128000],
+  ["gpt-4o-realtime", 128000],
+  ["gpt-4o-audio", 128000],
+  ["gpt-4o", 128000],
+  ["gpt-4.5-preview", 128000],
+  ["gpt-4.5", 128000],
+  ["gpt-4-turbo-preview", 128000],
+  ["gpt-4-turbo", 128000],
+  ["gpt-4-32k", 32768],
+  ["gpt-4-1106", 128000],
+  ["gpt-4-0125", 128000],
+  ["gpt-4", 8192],
+  ["gpt-3.5-turbo-16k", 16385],
+  ["gpt-3.5-turbo-1106", 16385],
+  ["gpt-3.5-turbo", 16385],
+  ["gpt-3.5", 16385],
+  ["o4-mini", 200000],
+  ["o3-deep-research", 200000],
+  ["o3-pro", 200000],
+  ["o3-mini", 200000],
+  ["o3", 200000],
+  ["o1-pro", 200000],
+  ["o1-preview", 200000],
+  ["o1-mini", 128000],
+  ["o1", 200000],
+  ["codex-mini", 200000],
+  ["chatgpt-4o", 128000],
+  ["claude-opus-4-8", 1e6],
+  ["claude-opus-4-7", 1e6],
+  ["claude-opus-4-6", 1e6],
+  ["claude-sonnet-4-6", 1e6],
+  ["claude-mythos", 1e6],
+  ["claude-fable", 1e6],
+  ["claude-opus-4-1", 200000],
+  ["claude-opus-4", 200000],
+  ["claude-sonnet-4-5", 200000],
+  ["claude-sonnet-4-1", 200000],
+  ["claude-sonnet-4", 200000],
+  ["claude-haiku-4-5", 200000],
+  ["claude-haiku-4", 200000],
+  ["claude-3-7-sonnet", 200000],
+  ["claude-3-7", 200000],
+  ["claude-3-5-sonnet", 200000],
+  ["claude-3-5-haiku", 200000],
+  ["claude-3-5", 200000],
+  ["claude-3-opus", 200000],
+  ["claude-3-sonnet", 200000],
+  ["claude-3-haiku", 200000],
+  ["claude-3", 200000],
+  ["claude-2.1", 200000],
+  ["claude-2", 1e5],
+  ["claude-instant", 1e5],
+  ["gemini-3.1-pro", 1048576],
+  ["gemini-3.1-flash", 1048576],
+  ["gemini-3.1", 1048576],
+  ["gemini-3-pro", 1048576],
+  ["gemini-3-flash", 1048576],
+  ["gemini-3-deep", 1048576],
+  ["gemini-3", 1048576],
+  ["gemini-2.5-pro", 1048576],
+  ["gemini-2.5-flash-lite", 1048576],
+  ["gemini-2.5-flash", 1048576],
+  ["gemini-2.5", 1048576],
+  ["gemini-2.0-flash-lite", 1048576],
+  ["gemini-2.0-flash", 1048576],
+  ["gemini-2.0", 1048576],
+  ["gemini-1.5-pro", 2097152],
+  ["gemini-1.5-flash-8b", 1048576],
+  ["gemini-1.5-flash", 1048576],
+  ["gemini-1.5", 1048576],
+  ["gemini-pro-1.5", 2097152],
+  ["gemini-ultra", 32768],
+  ["gemini-pro", 32768],
+  ["deepseek-r1", 128000],
+  ["deepseek-reasoner", 128000],
+  ["deepseek-v3.2", 128000],
+  ["deepseek-v3.1", 128000],
+  ["deepseek-v3", 128000],
+  ["deepseek-chat", 64000],
+  ["deepseek-coder", 64000],
+  ["deepseek", 64000],
+  ["llama-4-maverick", 1e6],
+  ["llama-4-scout", 1e6],
+  ["llama-4", 1e6],
+  ["llama-3.3", 128000],
+  ["llama-3.2", 128000],
+  ["llama-3.1", 128000],
+  ["llama-3-70b", 128000],
+  ["llama-3-8b", 128000],
+  ["llama-3", 128000],
+  ["llama-2-70b", 4096],
+  ["llama-2-13b", 4096],
+  ["llama-2-7b", 4096],
+  ["llama-2", 4096],
+  ["llama3.3", 128000],
+  ["llama3.2", 128000],
+  ["llama3.1", 128000],
+  ["llama3", 8192],
+  ["codellama", 16384],
+  ["mistral-large-3", 256000],
+  ["mistral-large-2", 128000],
+  ["mistral-large", 128000],
+  ["mistral-medium", 32768],
+  ["mistral-small", 32768],
+  ["mistral-nemo", 128000],
+  ["mistral-saba", 32768],
+  ["pixtral-large", 128000],
+  ["pixtral", 128000],
+  ["codestral", 32768],
+  ["mistral", 32768],
+  ["mixtral-8x22b", 65536],
+  ["mixtral-8x7b", 32768],
+  ["mixtral", 32768],
+  ["ministral", 128000],
+  ["qwen3-235b", 128000],
+  ["qwen3-32b", 128000],
+  ["qwen3", 128000],
+  ["qwen2.5-72b", 128000],
+  ["qwen2.5-32b", 128000],
+  ["qwen2.5-14b", 128000],
+  ["qwen2.5-7b", 128000],
+  ["qwen2.5-1m", 1e6],
+  ["qwen2.5", 128000],
+  ["qwen2-72b", 128000],
+  ["qwen2", 128000],
+  ["qwen-max", 32768],
+  ["qwen-plus", 131072],
+  ["qwen-turbo", 131072],
+  ["qwen", 32768],
+  ["command-r-plus", 128000],
+  ["command-r7b", 128000],
+  ["command-r", 128000],
+  ["command-light", 4096],
+  ["command", 4096],
+  ["aya", 8192],
+  ["grok-4.1", 1e6],
+  ["grok-4", 256000],
+  ["grok-3-mini", 131072],
+  ["grok-3", 131072],
+  ["grok-2-vision", 32768],
+  ["grok-2", 131072],
+  ["grok-beta", 131072],
+  ["grok", 131072],
+  ["glm-4.5", 128000],
+  ["glm-4-plus", 128000],
+  ["glm-4", 128000],
+  ["chatglm3", 128000],
+  ["chatglm", 32768],
+  ["phi-4-mini", 128000],
+  ["phi-4", 128000],
+  ["phi-3.5", 128000],
+  ["phi-3-medium", 128000],
+  ["phi-3-mini", 128000],
+  ["phi-3", 128000],
+  ["gemma-3-27b", 128000],
+  ["gemma-3", 128000],
+  ["gemma-2-27b", 8192],
+  ["gemma-2-9b", 8192],
+  ["gemma-2", 8192],
+  ["gemma", 8192],
+  ["kimi-k2", 128000],
+  ["moonshot-v1-128k", 128000],
+  ["moonshot-v1-32k", 32768],
+  ["moonshot", 128000],
+  ["nova-premier", 1e6],
+  ["nova-pro", 300000],
+  ["nova-lite", 300000],
+  ["nova-micro", 128000],
+  ["jamba-1.5-large", 256000],
+  ["jamba-1.5-mini", 256000],
+  ["jamba", 256000],
+  ["sonar-pro", 200000],
+  ["sonar-reasoning", 127072],
+  ["sonar", 127072],
+  ["sonar-deep-research", 127072],
+  ["yi-large", 32768],
+  ["yi-34b", 200000],
+  ["yi", 32768],
+  ["dbrx-instruct", 32768],
+  ["dbrx", 32768],
+  ["solar-pro", 32768],
+  ["solar", 32768],
+  ["internvl", 32768],
+  ["nvidia-nemotron", 128000],
+  ["nemotron", 128000],
+  ["reka-core", 128000],
+  ["reka-flash", 128000],
+  ["reka", 128000],
+  ["falcon-180b", 2048],
+  ["falcon", 2048],
+  ["stablelm", 4096],
+  ["wizardlm", 32768],
+  ["vicuna", 4096],
+  ["openchat", 8192],
+  ["nous-hermes", 32768],
+  ["hermes-3", 128000],
+  ["hermes", 32768]
+];
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function readNestedNumber(parent, key, nestedKey) {
+  if (!parent || typeof parent !== "object")
+    return;
+  const nested = parent[key];
+  if (!nested || typeof nested !== "object")
+    return;
+  const value = nested[nestedKey];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function parseUsage(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const usage = raw;
+  const promptTokens = readNumber(usage.prompt_tokens);
+  const completionTokens = readNumber(usage.completion_tokens);
+  const totalTokens = readNumber(usage.total_tokens) || promptTokens + completionTokens;
+  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0) {
+    return null;
+  }
+  const cachedTokens = readNestedNumber(usage, "prompt_tokens_details", "cached_tokens") || readNumber(usage.cached_tokens) || undefined;
+  const reasoningTokens = readNestedNumber(usage, "completion_tokens_details", "reasoning_tokens") || readNumber(usage.reasoning_tokens) || undefined;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    ...cachedTokens ? { cachedTokens } : {},
+    ...reasoningTokens ? { reasoningTokens } : {}
+  };
+}
+function aggregateUsage(usages) {
+  if (usages.length === 0)
+    return { ...EMPTY_USAGE };
+  return usages.reduce((acc, usage) => {
+    const cachedTokens = (acc.cachedTokens ?? 0) + (usage.cachedTokens ?? 0);
+    const reasoningTokens = (acc.reasoningTokens ?? 0) + (usage.reasoningTokens ?? 0);
+    return {
+      promptTokens: acc.promptTokens + usage.promptTokens,
+      completionTokens: acc.completionTokens + usage.completionTokens,
+      totalTokens: acc.totalTokens + usage.totalTokens,
+      ...cachedTokens > 0 ? { cachedTokens } : {},
+      ...reasoningTokens > 0 ? { reasoningTokens } : {}
+    };
+  }, { ...EMPTY_USAGE });
+}
+function resolveContextWindow(model, overrides) {
+  const normalized = model.trim().toLowerCase();
+  if (!normalized)
+    return null;
+  if (overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      if (normalized === key.toLowerCase() || normalized.includes(key.toLowerCase())) {
+        return value;
+      }
+    }
+  }
+  for (const [prefix, size] of DEFAULT_MODEL_CONTEXT_WINDOWS) {
+    if (normalized.includes(prefix))
+      return size;
+  }
+  return null;
+}
+function computeTokensPerSecond(completionTokens, durationMs) {
+  if (completionTokens <= 0 || durationMs <= 0)
+    return null;
+  return Math.round(completionTokens / durationMs * 1000 * 10) / 10;
+}
+function buildTurnUsage(input) {
+  const aggregated = aggregateUsage(input.usages);
+  const contextWindow = resolveContextWindow(input.model, input.modelContextWindows);
+  const contextUsedPercent = contextWindow && aggregated.totalTokens > 0 ? Math.min(100, aggregated.totalTokens / contextWindow * 100) : null;
+  return {
+    ...aggregated,
+    model: input.model,
+    durationMs: Math.max(0, Math.round(input.durationMs)),
+    tokensPerSecond: computeTokensPerSecond(aggregated.completionTokens, input.durationMs),
+    contextWindow,
+    contextUsedPercent,
+    requestCount: input.usages.length,
+    ...input.streaming ? { streaming: true } : {}
+  };
+}
+function appendSessionUsage(previous, turn) {
+  const session = previous?.session ?? {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+    requestCount: 0
+  };
+  return {
+    session: {
+      promptTokens: session.promptTokens + turn.promptTokens,
+      completionTokens: session.completionTokens + turn.completionTokens,
+      totalTokens: session.totalTokens + turn.totalTokens,
+      requestCount: session.requestCount + turn.requestCount
+    },
+    currentTurn: turn,
+    baselineBreakdown: previous?.baselineBreakdown ?? null
+  };
+}
+function createEmptySessionUsage() {
+  return {
+    session: {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+      requestCount: 0
+    },
+    currentTurn: null,
+    baselineBreakdown: null
+  };
+}
+function isStoredLlmTurnUsage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const usage = value;
+  return typeof usage.promptTokens === "number" && Number.isFinite(usage.promptTokens) && typeof usage.completionTokens === "number" && Number.isFinite(usage.completionTokens) && typeof usage.totalTokens === "number" && Number.isFinite(usage.totalTokens) && typeof usage.model === "string" && typeof usage.durationMs === "number" && Number.isFinite(usage.durationMs) && typeof usage.requestCount === "number" && Number.isFinite(usage.requestCount);
+}
+function rebuildSessionUsageFromMessages(messages) {
+  let sessionUsage = null;
+  for (const message of messages) {
+    if (message.role === "assistant" && message.llmUsage) {
+      sessionUsage = appendSessionUsage(sessionUsage, message.llmUsage);
+    }
+  }
+  return sessionUsage;
+}
+function formatTokenCount(value) {
+  if (value >= 1e6)
+    return `${(value / 1e6).toFixed(1)}M`;
+  if (value >= 1e4)
+    return `${Math.round(value / 1000)}k`;
+  if (value >= 1000)
+    return `${(value / 1000).toFixed(1)}k`;
+  return String(value);
+}
+
 // src/core/chat-history.ts
 var DEFAULT_HISTORY_KEY = "assistant-chat-history";
 var DEFAULT_MAX_STORED = 100;
@@ -2094,6 +2479,7 @@ function toStored(message) {
     replySuggestions: message.replySuggestions,
     isError: message.isError,
     llmSetupRequired: message.llmSetupRequired,
+    llmUsage: message.llmUsage,
     timestamp: message.timestamp
   };
 }
@@ -2107,6 +2493,7 @@ function fromStored(message) {
     replySuggestions: isValidReplySuggestions(message.replySuggestions) ? message.replySuggestions : undefined,
     isError: message.isError,
     llmSetupRequired: message.llmSetupRequired,
+    llmUsage: isStoredLlmTurnUsage(message.llmUsage) ? message.llmUsage : undefined,
     timestamp: message.timestamp
   };
 }
@@ -2684,10 +3071,144 @@ async function testLlmConnection(settings) {
   }
 }
 
+// src/core/llm-context-breakdown.ts
+function estimateTokenCount(text) {
+  if (!text.trim())
+    return 0;
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function estimateToolsTokens(tools) {
+  if (tools.length === 0)
+    return 0;
+  return estimateTokenCount(JSON.stringify(tools));
+}
+function estimateMessagesTokens(messages) {
+  return messages.reduce((sum, message) => {
+    let tokens = 4;
+    if (typeof message.content === "string" && message.content.length > 0) {
+      tokens += estimateTokenCount(message.content);
+    }
+    if (message.tool_calls?.length) {
+      tokens += estimateTokenCount(JSON.stringify(message.tool_calls));
+    }
+    if (message.tool_call_id) {
+      tokens += estimateTokenCount(message.tool_call_id);
+    }
+    return sum + tokens;
+  }, 0);
+}
+function scaleParts(parts, targetTotal) {
+  const rawTotal = parts.systemPrompt + parts.toolDefinitions + parts.conversation;
+  if (targetTotal <= 0 || rawTotal <= 0) {
+    return { systemPrompt: 0, toolDefinitions: 0, conversation: 0 };
+  }
+  const scale = targetTotal / rawTotal;
+  return {
+    systemPrompt: Math.round(parts.systemPrompt * scale),
+    toolDefinitions: Math.round(parts.toolDefinitions * scale),
+    conversation: Math.round(parts.conversation * scale)
+  };
+}
+function estimatePromptParts(input) {
+  return {
+    systemPrompt: estimateTokenCount(input.systemPrompt),
+    toolDefinitions: estimateToolsTokens(input.tools),
+    conversation: estimateMessagesTokens(input.messages)
+  };
+}
+function buildContextBreakdown(input) {
+  const parts = estimatePromptParts({
+    systemPrompt: input.systemPrompt,
+    tools: input.tools,
+    messages: input.messages
+  });
+  const promptTokens = input.usage?.promptTokens ?? 0;
+  const completionTokens = input.usage?.completionTokens ?? 0;
+  const cachedTokens = input.usage?.cachedTokens ?? 0;
+  const reasoningTokens = input.usage?.reasoningTokens ?? 0;
+  const scaled = promptTokens > 0 ? scaleParts(parts, Math.max(0, promptTokens - cachedTokens)) : parts;
+  const segments = [];
+  if (scaled.systemPrompt > 0 || promptTokens === 0) {
+    segments.push({
+      id: "systemPrompt",
+      tokens: scaled.systemPrompt,
+      estimated: promptTokens > 0
+    });
+  }
+  if (scaled.toolDefinitions > 0 || promptTokens === 0 && input.tools.length > 0) {
+    segments.push({
+      id: "toolDefinitions",
+      tokens: scaled.toolDefinitions || parts.toolDefinitions,
+      estimated: true
+    });
+  }
+  if (scaled.conversation > 0 || promptTokens === 0 && input.messages.length > 0) {
+    segments.push({
+      id: "conversation",
+      tokens: scaled.conversation || parts.conversation,
+      estimated: promptTokens === 0 || promptTokens > 0
+    });
+  }
+  if (completionTokens > 0) {
+    segments.push({ id: "completion", tokens: completionTokens });
+  }
+  if (cachedTokens > 0) {
+    segments.push({ id: "cached", tokens: cachedTokens });
+  }
+  if (reasoningTokens > 0) {
+    segments.push({ id: "reasoning", tokens: reasoningTokens });
+  }
+  const totalTokens = input.usage?.totalTokens ?? segments.reduce((sum, segment) => sum + segment.tokens, 0);
+  const contextWindow = resolveContextWindow(input.model, input.modelContextWindows);
+  const contextUsedPercent = contextWindow && totalTokens > 0 ? Math.min(100, totalTokens / contextWindow * 100) : null;
+  return {
+    segments: segments.filter((segment) => segment.tokens > 0),
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    contextWindow,
+    contextUsedPercent
+  };
+}
+function mergeBreakdownSegments(target, source) {
+  const map = new Map;
+  for (const segment of target.segments) {
+    map.set(segment.id, { ...segment });
+  }
+  for (const segment of source.segments) {
+    const existing = map.get(segment.id);
+    if (existing) {
+      existing.tokens += segment.tokens;
+    } else {
+      map.set(segment.id, { ...segment });
+    }
+  }
+  const segments = [...map.values()].filter((segment) => segment.tokens > 0);
+  const totalTokens = segments.reduce((sum, segment) => sum + segment.tokens, 0);
+  const promptTokens = target.promptTokens + source.promptTokens;
+  const completionTokens = target.completionTokens + source.completionTokens;
+  const contextWindow = target.contextWindow ?? source.contextWindow;
+  const contextUsedPercent = contextWindow && totalTokens > 0 ? Math.min(100, totalTokens / contextWindow * 100) : null;
+  return {
+    segments,
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    contextWindow,
+    contextUsedPercent
+  };
+}
+function formatApproxTokens(value) {
+  if (value <= 0)
+    return "0";
+  return `~${formatTokenCount(value)}`;
+}
+
 // src/core/llm-sse.ts
 function createStreamParser() {
   let content = "";
   let model = null;
+  let usage = null;
   const toolAcc = new Map;
   function toolCallAt(index) {
     const existing = toolAcc.get(index);
@@ -2712,6 +3233,7 @@ function createStreamParser() {
         content,
         toolCalls: finalizeToolCalls(),
         model,
+        usage,
         done: true
       };
     }
@@ -2723,6 +3245,9 @@ function createStreamParser() {
     }
     if (typeof json2.model === "string")
       model = json2.model;
+    const parsedUsage = parseUsage(json2.usage);
+    if (parsedUsage)
+      usage = parsedUsage;
     const choice = json2.choices?.[0];
     const delta = choice?.delta;
     if (!delta)
@@ -2752,6 +3277,7 @@ function createStreamParser() {
       content,
       toolCalls: finalizeToolCalls(),
       model,
+      usage,
       done: false
     };
   }
@@ -2770,6 +3296,7 @@ async function readSseStream(body, onChunk, signal) {
     content: "",
     toolCalls: [],
     model: null,
+    usage: null,
     done: false
   };
   const abort = () => {
@@ -2932,7 +3459,8 @@ async function requestLlmCompletion(input) {
   return {
     content: message.content ?? null,
     toolCalls: message.tool_calls ?? [],
-    model: typeof data.model === "string" ? data.model : settings.model
+    model: typeof data.model === "string" ? data.model : settings.model,
+    usage: parseUsage(data.usage)
   };
 }
 async function requestLlmCompletionStream(input, handlers) {
@@ -2942,7 +3470,11 @@ async function requestLlmCompletionStream(input, handlers) {
     const res = await fetch(buildCompletionsUrl(settings.baseUrl), {
       method: "POST",
       headers: buildLlmRequestHeaders(settings.apiKey),
-      body: JSON.stringify({ ...payload, stream: true }),
+      body: JSON.stringify({
+        ...payload,
+        stream: true,
+        stream_options: { include_usage: true }
+      }),
       signal: input.signal
     });
     if (!res.ok) {
@@ -2960,11 +3492,15 @@ async function requestLlmCompletionStream(input, handlers) {
       if (chunk.contentDelta) {
         handlers.onUpdate(chunk.content);
       }
+      if (chunk.usage) {
+        handlers.onUsage?.(chunk.usage);
+      }
     }, input.signal);
     return {
       content: final.content || null,
       toolCalls: final.toolCalls,
-      model: final.model ?? settings.model
+      model: final.model ?? settings.model,
+      usage: final.usage
     };
   } catch (error) {
     if (input.signal?.aborted || error instanceof DOMException && error.name === "AbortError") {
@@ -2973,6 +3509,22 @@ async function requestLlmCompletionStream(input, handlers) {
     throw error;
   }
 }
+async function computeBaselineContextBreakdown(input) {
+  const settings = await resolveAssistantLlmSettings();
+  const systemPrompt = buildSystemPromptWithTools(settings.systemPrompt ?? DEFAULT_SYSTEM_PROMPT, input.tools);
+  const clientTools = [
+    ...input.tools.map(toClientTool),
+    ...getChatInteractiveTools()
+  ];
+  return buildContextBreakdown({
+    systemPrompt,
+    tools: clientTools,
+    messages: [],
+    usage: null,
+    model: input.model,
+    modelContextWindows: input.modelContextWindows
+  });
+}
 async function runLlmAgent(input) {
   const apiMessages = [
     ...input.history,
@@ -2987,8 +3539,40 @@ async function runLlmAgent(input) {
   ];
   let finalContent = "";
   let endedWithPostResponseTool = false;
+  const collectedUsages = [];
+  let lastModel = input.model ?? null;
+  let lastBreakdown = null;
   const settings = await resolveAssistantLlmSettings();
   const systemPrompt = buildSystemPromptWithTools(settings.systemPrompt ?? DEFAULT_SYSTEM_PROMPT, input.tools);
+  function buildStreamHandlers() {
+    if (!input.stream)
+      return;
+    return {
+      turnId: input.stream.turnId,
+      onUpdate: (content) => {
+        finalContent = content;
+        input.stream?.onUpdate(content);
+      },
+      onUsage: (usage) => {
+        input.stream?.onUsage?.(usage);
+      }
+    };
+  }
+  function recordCompletionUsage(completion, messages) {
+    lastModel = completion.model;
+    if (completion.usage) {
+      collectedUsages.push(completion.usage);
+      input.stream?.onUsage?.(completion.usage);
+    }
+    lastBreakdown = buildContextBreakdown({
+      systemPrompt,
+      tools: clientTools,
+      messages,
+      usage: completion.usage,
+      model: completion.model,
+      modelContextWindows: input.modelContextWindows
+    });
+  }
   for (let step = 0;step < MAX_AGENT_STEPS; step++) {
     if (input.signal?.aborted) {
       throw new ChatAbortedError;
@@ -2999,14 +3583,9 @@ async function runLlmAgent(input) {
       model: input.model,
       systemPrompt,
       signal: input.signal,
-      stream: input.stream ? {
-        turnId: input.stream.turnId,
-        onUpdate: (content) => {
-          finalContent = content;
-          input.stream?.onUpdate(content);
-        }
-      } : undefined
+      stream: buildStreamHandlers()
     });
+    recordCompletionUsage(completion, apiMessages);
     if (completion.toolCalls.length === 0) {
       finalContent = completion.content?.trim() || "I couldn't produce a response. Try rephrasing your request.";
       input.stream?.onUpdate(finalContent);
@@ -3104,14 +3683,9 @@ async function runLlmAgent(input) {
       model: input.model,
       systemPrompt,
       signal: input.signal,
-      stream: input.stream ? {
-        turnId: input.stream.turnId,
-        onUpdate: (content) => {
-          finalContent = content;
-          input.stream?.onUpdate(content);
-        }
-      } : undefined
+      stream: buildStreamHandlers()
     });
+    recordCompletionUsage(completion, apiMessages);
     finalContent = completion.content?.trim() || "Done — see the trace below for details.";
     input.stream?.onUpdate(finalContent);
     apiMessages.push({
@@ -3122,7 +3696,10 @@ async function runLlmAgent(input) {
   return {
     assistantMessages: finalContent ? [{ id: input.stream?.turnId, content: finalContent }] : [],
     apiMessages,
-    lastToolResult
+    lastToolResult,
+    usages: collectedUsages,
+    model: lastModel,
+    contextBreakdown: lastBreakdown
   };
 }
 function resolveAssistantContentForApi(message) {
@@ -3484,11 +4061,34 @@ function createLlmSettingsStorage(storageKey) {
     }
   };
 }
+function maskApiKey(apiKey, visibleHead = 4, visibleTail = 4) {
+  const trimmed = apiKey.trim();
+  if (!trimmed)
+    return "";
+  if (trimmed.length <= visibleHead + visibleTail) {
+    if (trimmed.length <= 2)
+      return "***";
+    return `${trimmed.slice(0, 1)}***${trimmed.slice(-1)}`;
+  }
+  return `${trimmed.slice(0, visibleHead)}***${trimmed.slice(-visibleTail)}`;
+}
+function isUnchangedApiKeyInput(input, existingApiKey) {
+  const trimmed = input.trim();
+  if (!trimmed)
+    return true;
+  if (!existingApiKey)
+    return false;
+  return trimmed === maskApiKey(existingApiKey);
+}
+function apiKeyFormDisplayValue(apiKey) {
+  return apiKey ? maskApiKey(apiKey) : "";
+}
 function toStoredSettings(values, existingApiKey) {
   const apiKeyInput = values.apiKey.trim();
+  const apiKey = isUnchangedApiKeyInput(apiKeyInput, existingApiKey) ? existingApiKey : apiKeyInput.length > 0 ? apiKeyInput : existingApiKey;
   return {
     baseUrl: values.baseUrl.trim() || DEFAULT_LLM_BASE_URL,
-    apiKey: apiKeyInput.length > 0 ? apiKeyInput : existingApiKey,
+    apiKey,
     model: values.model.trim() || DEFAULT_LLM_MODEL,
     models: parseModelsText(values.modelsText),
     systemPrompt: values.systemPrompt
@@ -3497,7 +4097,7 @@ function toStoredSettings(values, existingApiKey) {
 function createLlmSettingsFormState(settings, hasStoredApiKey, defaultSystemPrompt = DEFAULT_ASSISTANT_SYSTEM_PROMPT) {
   return {
     baseUrl: settings.baseUrl,
-    apiKey: "",
+    apiKey: apiKeyFormDisplayValue(settings.apiKey),
     model: settings.model,
     modelsText: formatModelsText(settings.models),
     systemPrompt: settings.systemPrompt ?? "",
@@ -3508,7 +4108,7 @@ function createLlmSettingsFormState(settings, hasStoredApiKey, defaultSystemProm
 function createLlmSettingsFormStateFromStored(stored, defaultSystemPrompt = DEFAULT_ASSISTANT_SYSTEM_PROMPT) {
   return {
     baseUrl: stored.baseUrl,
-    apiKey: "",
+    apiKey: apiKeyFormDisplayValue(stored.apiKey),
     model: stored.model,
     modelsText: formatModelsText(stored.models),
     systemPrompt: stored.systemPrompt,
@@ -3637,17 +4237,47 @@ function createAssistantStore(deps) {
     llmEnabled: false,
     model: initialSelectedModel
   });
+  const initialLlmUsage = rebuildSessionUsageFromMessages(messages);
   const store = create((set, get) => {
+    async function refreshBaselineUsage(model) {
+      try {
+        const tools = await resolvedDeps.listTools();
+        const baselineBreakdown = await computeBaselineContextBreakdown({
+          tools,
+          model,
+          modelContextWindows: deps.modelContextWindows
+        });
+        set((state) => ({
+          llmUsage: {
+            ...state.llmUsage ?? createEmptySessionUsage(),
+            baselineBreakdown
+          }
+        }));
+      } catch {}
+    }
     async function runLlmChatTurn(message) {
       const tools = await resolvedDeps.listTools();
       const storedMessages = get().messages.filter((m) => m.id !== "welcome");
       const priorMessages = storedMessages.at(-1)?.role === "user" ? storedMessages.slice(0, -1) : storedMessages;
       const llmHistory = buildLlmHistory(priorMessages);
       const turnId = crypto.randomUUID();
+      const turnStart = performance.now();
+      const model = get().selectedModel ?? get().llmModel ?? DEFAULT_LLM_MODEL;
+      const liveUsages = [];
       set((state) => ({
-        messages: [...state.messages, createTurnMessage(turnId)]
+        messages: [...state.messages, createTurnMessage(turnId)],
+        llmUsage: {
+          ...state.llmUsage ?? createEmptySessionUsage(),
+          currentTurn: buildTurnUsage({
+            usages: [],
+            model,
+            durationMs: 0,
+            modelContextWindows: deps.modelContextWindows,
+            streaming: true
+          })
+        }
       }));
-      await runLlmAgent({
+      const agentResult = await runLlmAgent({
         userMessage: message,
         history: llmHistory,
         tools,
@@ -3660,7 +4290,31 @@ function createAssistantStore(deps) {
               messages: patchTurnMessage(state.messages, turnId, (msg) => ({
                 ...msg,
                 content
-              }))
+              })),
+              llmUsage: state.llmUsage?.currentTurn ? {
+                ...state.llmUsage,
+                currentTurn: {
+                  ...state.llmUsage.currentTurn,
+                  durationMs: Math.round(performance.now() - turnStart),
+                  streaming: true
+                }
+              } : state.llmUsage
+            }));
+          },
+          onUsage: (usage) => {
+            liveUsages.push(usage);
+            const partialTurn = buildTurnUsage({
+              usages: liveUsages,
+              model,
+              durationMs: Math.round(performance.now() - turnStart),
+              modelContextWindows: deps.modelContextWindows,
+              streaming: true
+            });
+            set((state) => ({
+              llmUsage: {
+                ...state.llmUsage ?? createEmptySessionUsage(),
+                currentTurn: partialTurn
+              }
             }));
           }
         },
@@ -3699,15 +4353,27 @@ function createAssistantStore(deps) {
           const result = await resolvedDeps.invokeTool(name, args);
           deps.onToolInvoked?.(result);
           return result;
-        }
+        },
+        modelContextWindows: deps.modelContextWindows
       });
+      const turnUsage = {
+        ...buildTurnUsage({
+          usages: agentResult.usages,
+          model: agentResult.model ?? model,
+          durationMs: performance.now() - turnStart,
+          modelContextWindows: deps.modelContextWindows
+        }),
+        contextBreakdown: agentResult.contextBreakdown ?? undefined
+      };
       set((state) => ({
         messages: state.messages.map((msg) => msg.id === turnId ? {
           ...msg,
           streaming: false,
+          llmUsage: turnUsage,
           content: msg.content.trim() || (msg.activity?.length ? "" : "I couldn't produce a response.")
         } : msg),
-        chatLoading: false
+        chatLoading: false,
+        llmUsage: appendSessionUsage(state.llmUsage, turnUsage)
       }));
     }
     return {
@@ -3718,6 +4384,7 @@ function createAssistantStore(deps) {
       llmModels: [],
       llmModelsLoading: false,
       selectedModel: initialSelectedModel,
+      llmUsage: initialLlmUsage,
       loadLlmStatus: async () => {
         set({ llmModelsLoading: true });
         try {
@@ -3736,6 +4403,9 @@ function createAssistantStore(deps) {
             selectedModel,
             messages: patchWelcomeMessage(state.messages, deps.welcomeMessage, selectedModel, status.enabled)
           }));
+          if (status.enabled) {
+            refreshBaselineUsage(selectedModel);
+          }
         } finally {
           set({ llmModelsLoading: false });
         }
@@ -3812,7 +4482,8 @@ function createAssistantStore(deps) {
         const { llmEnabled, selectedModel } = get();
         history.clear();
         set({
-          messages: [deps.welcomeMessage({ llmEnabled, model: selectedModel })]
+          messages: [deps.welcomeMessage({ llmEnabled, model: selectedModel })],
+          llmUsage: null
         });
       },
       stopChat: () => {
@@ -4118,6 +4789,7 @@ export {
   runAssistantChatCommand,
   resolveSelectedModel,
   resolveInteractiveToolResult,
+  resolveContextWindow,
   resolveAssistantToolHooks,
   resolveAssistantStoreDependencies,
   resolveAssistantLlmSettings,
@@ -4125,9 +4797,11 @@ export {
   resetAssistantLlm,
   requestLlmCompletion,
   rejectAllInteractiveToolWaiters,
+  rebuildSessionUsageFromMessages,
   prepareMarkdown,
   persistStoredModelSelection,
   peekStoredModel,
+  parseUsage,
   parseSuggestedPromptsResponse,
   parseModelsText,
   parseChatCommand,
@@ -4136,7 +4810,9 @@ export {
   normalizeCodeLineEndings,
   migrateLegacyModelStorage,
   mergeLlmSettings,
+  mergeBreakdownSegments,
   listChatCommands,
+  isStoredLlmTurnUsage,
   isLocalLlmBaseUrl,
   isLlmUnavailableMessage,
   isLlmSettingsFormDirty,
@@ -4146,32 +4822,43 @@ export {
   getFallbackModels,
   getChatCommandSuggestions,
   fromLlmToolName,
+  formatTokenCount,
   formatModelsText,
   formatLabel,
   formatJsonIfLarge,
+  formatApproxTokens,
   filterChatCommands,
   fetchProviderModels,
   fetchLlmStatus,
+  estimateTokenCount,
+  estimatePromptParts,
   createLlmSettingsStorage,
   createLlmSettingsFormStateFromStored,
   createLlmSettingsFormState,
+  createEmptySessionUsage,
   createDefaultStoredSettings,
   createChatHistoryHelpers,
   createAssistantToolRegistry,
   createAssistantStore,
   connectExternalTools,
   configureAssistantLlm,
+  computeTokensPerSecond,
+  computeBaselineContextBreakdown,
   completionForChatCommand,
   clearProviderModelCache,
   childrenToText,
   chatActivityStepLabel,
+  buildTurnUsage,
   buildSystemPromptWithTools,
   buildModelsUrl,
   buildLlmRequestHeaders,
   buildLlmHistory,
   buildDefaultLlmSettings,
+  buildContextBreakdown,
   buildCompletionsUrl,
   assistantToStored,
+  appendSessionUsage,
+  aggregateUsage,
   SUGGEST_REPLIES_TOOL,
   LlmUpstreamError,
   LlmNotConfiguredError,