@chenlongapps/opencode-token-usage 0.3.4 → 0.4.0

package/README.md

@@ -40,6 +40,26 @@ Restart OpenCode after installation. The panel appears in the native sidebar whe
 
 For remote sessions, add the package name to `plugins` in your local `~/.config/opencode/cli.json` to load only the terminal entry point. The configuration path follows `XDG_CONFIG_HOME`.
 
+### Detailed usage
+
+Enter `/usage` in a session to open a native dialog with the session tree's token totals and estimated cost by recorded model. Scroll with ↑/↓, Page Up/Down, Home/End, press `d` to switch between compact and detailed numbers, and close with Escape. The command does not send a prompt to the model.
+
+The dialog is split into five sections with separate statistics:
+
+| Section | Contents |
+| --- | --- |
+| Context Window | Used / limit and a percentage of the active model's context limit, with a usage bar |
+| Last Request | The five token categories and cache rate of the viewed session's most recent reported call |
+| Context Breakdown | Estimated prompt composition, largest first, with bars |
+| Session | Tree totals: steps, calls, tokens, cache rate, cost (single line, or per-category rows in detailed mode) |
+| By Model | Tokens, calls and cost per recorded model, highest cost first |
+
+One line under the title names the session and its active model, and the body never repeats the model name. Compact mode uses `K`/`M` abbreviations (`812`, `139.4K`, `3.70M`), hides empty rows and merges the two tool families in Context Breakdown into a single `Tools` row. Detailed mode shows exact numbers, empty rows, and the `System Tools` / `MCP Tools` split. The sidebar keeps exact numbers and its own layout.
+
+Costs follow the sidebar's pricing and `partial`/unavailable/free conventions. Context sections are unavailable until the viewed session has reported usage and a known context limit.
+
+**Context Breakdown** separates Messages, System Tools, System Prompt, Skills, MCP Tools, and Other. It estimates the text and tool definitions in the viewed session's **latest assembled model request**; its percentages use the sum of those estimates. These are not provider-reported token counts and do not add up to the measured context window, which also includes output and reasoning. Media and provider-specific framing cannot be measured from the request. A server plugin records only aggregate estimates (not prompt text); sessions without a captured request or an available server RPC show “Source estimates unavailable”.
+
 ### Metrics
 
 | Metric | Definition |
@@ -76,7 +96,7 @@ npm run build
 npm run test:smoke
 ```
 
-`test:smoke` packages the real artifact and validates loading, refreshes, subagent aggregation, per-message pricing, official-price fallback, model switching, TPS, and TTFT against an isolated OpenCode instance and a local mock provider. It requires Python 3, an available local port, and npm network access. It never modifies your existing OpenCode configuration or calls paid models.
+`test:smoke` packages the real artifact and validates loading, refreshes, `/usage`, subagent aggregation, per-message pricing, official-price fallback, model switching, TPS, and TTFT against an isolated OpenCode instance and a local mock provider. It requires Python 3, an available local port, and npm network access. It never modifies your existing OpenCode configuration or calls paid models.
 
 To load the plugin from source, build the project and add the repository's absolute path to `plugins` in the target project.
 

package/README.zh-CN.md

@@ -40,6 +40,26 @@ opencode plugin add @chenlongapps/opencode-token-usage
 
 连接远程服务器时，可将包名加入本机 `~/.config/opencode/cli.json` 的 `plugins`，仅加载终端入口；配置路径遵循 `XDG_CONFIG_HOME`。
 
+### 详细用量
+
+在会话中输入 `/usage`，可打开原生弹窗查看当前会话树的 token 总量，以及按消息实际模型汇总的估算费用。使用 ↑/↓、Page Up/Down、Home/End 滚动，按 `d` 切换紧凑／详细数字，Escape 关闭。该命令不会向模型发送消息。
+
+弹窗分为五个区域，统计口径互相独立：
+
+| 区域 | 内容 |
+| --- | --- |
+| Context Window | 已用 / 上限、占活动模型上下文上限的百分比，并带占用条 |
+| Last Request | 被查看会话最近一次已上报调用的五类 token 与缓存命中率 |
+| Context Breakdown | 提示词构成估算，按占比降序排列并带条形图 |
+| Session | 全树汇总：steps、calls、tokens、缓存率与费用（紧凑模式为单行，详细模式逐类展开） |
+| By Model | 各模型的 tokens、calls 与费用，按费用降序 |
+
+标题下方一行注明会话与当前活动模型，正文不再重复模型名。紧凑模式使用 `K`/`M` 缩写（`812`、`139.4K`、`3.70M`），隐藏零值行，并把 Context Breakdown 中的两类工具合并为一行 `Tools`；详细模式显示精确数字、零值行及 `System Tools` / `MCP Tools` 拆分。侧边栏仍使用精确数字和原有布局。
+
+费用沿用侧边栏的价格及 `partial`、不可定价、免费口径。当前会话尚未上报用量或上下文上限未知时，上下文相关区域显示不可用。
+
+弹窗中的 **Context Breakdown** 将消息、系统工具、系统提示词、技能、MCP 工具及其他分开展示。它根据被查看会话**最近一次已组装的模型请求**中的文本和工具定义估算，占比的分母是六项估算值之和；这些不是提供商上报的精确 token，也不会与上方含输出、推理的实测上下文窗口相加一致。媒体内容与提供商额外包装无法准确计量。服务端插件仅保存分类数值，不保存提示词正文；未捕获到请求或服务端 RPC 不可用时显示“来源估算不可用”。
+
 ### 指标
 
 | 指标 | 定义 |
@@ -76,7 +96,7 @@ npm run build
 npm run test:smoke
 ```
 
-`test:smoke` 会打包真实产物，并在隔离的 OpenCode 与本地模拟提供商中验证加载、刷新、子代理累计、逐消息计价、官方价格补全、模型切换、TPS 和 TTFT。它需要 Python 3、可用的本地端口和 npm 网络访问，不会修改现有 OpenCode 配置或调用付费模型。
+`test:smoke` 会打包真实产物，并在隔离的 OpenCode 与本地模拟提供商中验证加载、刷新、`/usage`、子代理累计、逐消息计价、官方价格补全、模型切换、TPS 和 TTFT。它需要 Python 3、可用的本地端口和 npm 网络访问，不会修改现有 OpenCode 配置或调用付费模型。
 
 从源码加载时，先构建项目，再将仓库绝对路径加入目标项目的 `plugins`。
 

package/ROADMAP.md

@@ -90,14 +90,15 @@ Steps  1,234
 
 ## v0.4.0 — 用量命令
 
-目标：按需提供比侧边栏更详细的 token 信息。
-
-* [ ] 添加 `/usage`
-* [ ] 显示当前会话及会话树统计
-* [ ] 显示 context 各项占比
-* [ ] 显示 token 明细与上下文用量
-* [ ] 显示模型和价格信息
-* [ ] 显示估算费用明细
+目标：按需提供比侧边栏更详细的 token 信息。以弹窗的形式显示。
+
+* [x] 添加 `/usage`
+* [x] 显示当前会话树的 token 信息
+* [x] 显示 context 各项占比
+* [x] 显示 token 明细与上下文用量
+* [x] 显示各个模型费用
+* [x] 拆分为 Context Window / Last Request / Context Breakdown / Session / By Model，口径互不混用
+* [x] 紧凑数字（K/M）、来源条形图、Session 单行汇总、`d` 详细模式切换
 
 ## 后续评估
 

package/dist/context-rpc.d.ts

@@ -0,0 +1,52 @@
+export declare const ContextSourceRpc: {
+    readonly id: "opencode-token-usage.context";
+    readonly methods: {
+        readonly latest: {
+            readonly input: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly sessionID: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["sessionID"];
+                readonly additionalProperties: false;
+            };
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly estimate: {
+                        readonly anyOf: readonly [{
+                            readonly type: "null";
+                        }, {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly capturedAt: {
+                                    readonly type: "number";
+                                };
+                                readonly model: {
+                                    readonly type: "string";
+                                };
+                                readonly tokens: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        [k: string]: {
+                                            type: string;
+                                        };
+                                    };
+                                    readonly required: string[];
+                                    readonly additionalProperties: false;
+                                };
+                            };
+                            readonly required: readonly ["capturedAt", "model", "tokens"];
+                            readonly additionalProperties: false;
+                        }];
+                    };
+                };
+                readonly required: readonly ["estimate"];
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly events: {};
+};

package/dist/context-rpc.js

@@ -0,0 +1,35 @@
+import { Rpc } from "@opencode/plugin/rpc";
+const numbers = ["Messages", "System Tools", "System Prompt", "Skills", "MCP Tools", "Other"];
+export const ContextSourceRpc = Rpc.define({
+    id: "opencode-token-usage.context",
+    methods: {
+        latest: {
+            input: {
+                type: "object", properties: { sessionID: { type: "string" } }, required: ["sessionID"], additionalProperties: false,
+            },
+            output: {
+                type: "object",
+                properties: {
+                    estimate: {
+                        anyOf: [
+                            { type: "null" },
+                            {
+                                type: "object",
+                                properties: {
+                                    capturedAt: { type: "number" }, model: { type: "string" },
+                                    tokens: {
+                                        type: "object", properties: Object.fromEntries(numbers.map(label => [label, { type: "number" }])),
+                                        required: numbers, additionalProperties: false,
+                                    },
+                                },
+                                required: ["capturedAt", "model", "tokens"], additionalProperties: false,
+                            },
+                        ],
+                    },
+                },
+                required: ["estimate"], additionalProperties: false,
+            },
+        },
+    },
+    events: {},
+});

package/dist/context-sources.d.ts

@@ -0,0 +1,22 @@
+import type { SessionContext } from "@opencode/plugin/promise/session";
+export declare const sourceLabels: readonly ["Messages", "System Tools", "System Prompt", "Skills", "MCP Tools", "Other"];
+export type SourceLabel = typeof sourceLabels[number];
+/** A best-effort inventory of the last assembled request, never provider-reported usage. */
+export interface ContextSources {
+    capturedAt: number;
+    model: string;
+    tokens: Record<SourceLabel, number>;
+}
+export declare function estimateContextSources(request: Pick<SessionContext, "system" | "messages" | "tools" | "model">, mcpServers?: readonly string[], capturedAt?: number): ContextSources;
+export declare function parseContextSources(value: unknown): ContextSources | undefined;
+export interface BreakdownRow {
+    label: string;
+    tokens: number;
+    percent: number;
+}
+/**
+ * Presentation rows for the estimated sources, largest first. Compact mode merges the
+ * two tool families into one `Tools` row and hides empty rows; detailed mode keeps the
+ * six stored labels apart, including zeroes.
+ */
+export declare function breakdownRows(sources: ContextSources, detailed: boolean): readonly BreakdownRow[];

package/dist/context-sources.js

@@ -0,0 +1,108 @@
+export const sourceLabels = ["Messages", "System Tools", "System Prompt", "Skills", "MCP Tools", "Other"];
+const estimate = (text) => text ? Math.max(1, Math.ceil(Buffer.byteLength(text, "utf8") / 4)) : 0;
+/** Remove a recognisable instruction block while retaining the rest for another category. */
+function extract(text, pattern) {
+    let found = "";
+    const rest = text.replace(pattern, match => { found += match; return ""; });
+    return { rest, found };
+}
+function isMcpTool(name, servers) {
+    return servers.some(server => name.startsWith(`${server.replace(/[^a-zA-Z0-9_-]/g, "_")}_`));
+}
+function classifySystem(text, tokens, mcpServers) {
+    // Instruction sources are joined with blank lines by OpenCode; the Code Mode
+    // catalog precedes project instructions, skills and MCP guidance in that list.
+    let section = extract(text, /(?:# Code Mode|The Code Mode tool catalog(?: below)? is (?:partial|complete)\.|The Code Mode tool catalog has changed\.)[\s\S]*?(?=\n\n(?:Instructions from:|Skills provide specialized instructions|New skills are available|<mcp_instructions>|New MCP server instructions)|$)/g);
+    let namespace = "";
+    const codeMode = { "System Tools": [], "MCP Tools": [] };
+    for (const line of section.found.split("\n")) {
+        const heading = /^- ([a-zA-Z0-9_-]+) \(\d+ tools?/.exec(line);
+        if (heading)
+            namespace = heading[1];
+        const mcp = mcpServers.some(server => {
+            const name = server.replace(/[^a-zA-Z0-9_-]/g, "_");
+            return namespace === name || line.includes(`tools.${name}`);
+        });
+        codeMode[mcp ? "MCP Tools" : "System Tools"].push(line);
+    }
+    tokens["System Tools"] += estimate(codeMode["System Tools"].join("\n"));
+    tokens["MCP Tools"] += estimate(codeMode["MCP Tools"].join("\n"));
+    text = section.rest;
+    section = extract(text, /Skills provide specialized instructions[\s\S]*?(?:<\/available_skills>|No skills are currently available\.)/g);
+    tokens.Skills += estimate(section.found);
+    text = section.rest;
+    section = extract(text, /<mcp_instructions>[\s\S]*?<\/mcp_instructions>/g);
+    tokens["MCP Tools"] += estimate(section.found);
+    tokens["System Prompt"] += estimate(section.rest);
+}
+export function estimateContextSources(request, mcpServers = [], capturedAt = Date.now()) {
+    const tokens = Object.fromEntries(sourceLabels.map(label => [label, 0]));
+    for (const part of request.system)
+        classifySystem(part.text, tokens, mcpServers);
+    for (const [name, tool] of Object.entries(request.tools)) {
+        const size = estimate(`${name} ${tool.description} ${JSON.stringify(tool.input)}`);
+        tokens[isMcpTool(name, mcpServers) ? "MCP Tools" : "System Tools"] += size;
+    }
+    for (const message of request.messages) {
+        for (const part of message.content) {
+            if (part.type === "text") {
+                if (message.role === "system") {
+                    classifySystem(part.text, tokens, mcpServers);
+                    continue;
+                }
+                const section = extract(part.text, /<skill_content\b[\s\S]*?<\/skill_content>/g);
+                tokens.Skills += estimate(section.found);
+                tokens.Messages += estimate(section.rest);
+                continue;
+            }
+            if (part.type === "media") {
+                // Media payload sizes do not translate to provider token counts.
+                tokens.Other += estimate(part.filename ?? part.mediaType);
+                continue;
+            }
+            if (part.type === "tool-call") {
+                tokens.Messages += estimate(`${part.name} ${JSON.stringify(part.input)}`);
+                continue;
+            }
+            if (part.type === "tool-result") {
+                const result = part.result;
+                const content = result.type === "content"
+                    ? result.value.map(item => item.type === "file" ? `${item.name ?? ""} ${item.mime}` : item.text).join(" ")
+                    : JSON.stringify(result.value);
+                tokens.Messages += estimate(`${part.name} ${content}`);
+                continue;
+            }
+            tokens.Other += estimate(JSON.stringify(part));
+        }
+    }
+    return { capturedAt, model: `${request.model.providerID}/${request.model.id}`, tokens };
+}
+export function parseContextSources(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const input = value;
+    if (typeof input.capturedAt !== "number" || !Number.isFinite(input.capturedAt) || typeof input.model !== "string")
+        return undefined;
+    if (!input.tokens || typeof input.tokens !== "object")
+        return undefined;
+    if (!sourceLabels.every(label => typeof input.tokens?.[label] === "number" && Number.isFinite(input.tokens[label]) && input.tokens[label] >= 0))
+        return undefined;
+    return input;
+}
+/**
+ * Presentation rows for the estimated sources, largest first. Compact mode merges the
+ * two tool families into one `Tools` row and hides empty rows; detailed mode keeps the
+ * six stored labels apart, including zeroes.
+ */
+export function breakdownRows(sources, detailed) {
+    const t = sources.tokens;
+    const entries = detailed
+        ? sourceLabels.map(label => [label, t[label]])
+        : [["Messages", t.Messages], ["Tools", t["System Tools"] + t["MCP Tools"]],
+            ["System Prompt", t["System Prompt"]], ["Skills", t.Skills], ["Other", t.Other]];
+    const sum = sourceLabels.reduce((total, label) => total + t[label], 0);
+    return entries
+        .filter(([, tokens]) => detailed || tokens > 0)
+        .map(([label, tokens]) => ({ label, tokens, percent: sum ? tokens / sum * 100 : 0 }))
+        .sort((a, b) => b.tokens - a.tokens || a.label.localeCompare(b.label));
+}

package/dist/controller.d.ts

@@ -1,11 +1,18 @@
 import type { UsageSource } from "./source.js";
 import { PerformanceMonitor } from "./performance.js";
 import type { PerformanceSummary } from "./performance.js";
-import type { ContextUsage, Summary } from "./usage.js";
+import type { ContextSources } from "./context-sources.js";
+import type { ContextDetails, ContextUsage, ModelCost, Summary } from "./usage.js";
 export interface UsageState {
     status: "loading" | "ready" | "stale" | "unavailable";
     summary?: Summary;
     context?: ContextUsage | undefined;
+    details?: {
+        context?: ContextDetails | undefined;
+        models: readonly ModelCost[];
+        sources?: ContextSources | undefined;
+        sessionTitle?: string | undefined;
+    };
     performance?: PerformanceSummary;
     model?: string;
 }
@@ -16,13 +23,14 @@ export interface UsageEvent {
     created?: number;
 }
 export type Subscribe = (listener: (event: UsageEvent) => void) => () => void;
-/** Owns snapshot refreshes and throttled in-memory performance updates for one mounted panel. */
+/** Owns snapshot refreshes and throttled in-memory performance updates for one mounted view. */
 export declare class UsageController {
     private readonly source;
     private readonly publish;
     private readonly delay;
     private readonly retryDelay;
     private readonly performanceDelay;
+    private readonly detailed;
     private state;
     private snapshot;
     private sessionID;
@@ -38,7 +46,7 @@ export declare class UsageController {
     private readonly unsubscribePerformance;
     private readonly performance;
     private readonly ownsPerformance;
-    constructor(source: UsageSource, subscribe: Subscribe, publish: (state: UsageState) => void, delay?: number, retryDelay?: number, performanceDelay?: number, performance?: PerformanceMonitor);
+    constructor(source: UsageSource, subscribe: Subscribe, publish: (state: UsageState) => void, delay?: number, retryDelay?: number, performanceDelay?: number, performance?: PerformanceMonitor, detailed?: boolean);
     select(sessionID: string): void;
     refresh(): void;
     dispose(): void;

package/dist/controller.js

@@ -1,6 +1,6 @@
 import { loadSnapshot, uniqueMessages, viewedMessages } from "./source.js";
 import { PerformanceMonitor } from "./performance.js";
-import { contextUsage, summarize } from "./usage.js";
+import { contextDetails, summarize, summarizeModels } from "./usage.js";
 const sessionEvents = new Set([
     "session.created", "session.deleted", "session.forked", "session.moved",
     "session.model.selected", "session.agent.selected", "session.step.ended", "session.step.failed",
@@ -12,13 +12,14 @@ const globalEvents = new Set([
     "server.connected", "model.updated", "provider.updated", "models-dev.refreshed",
     "config.updated", "location.shutdown",
 ]);
-/** Owns snapshot refreshes and throttled in-memory performance updates for one mounted panel. */
+/** Owns snapshot refreshes and throttled in-memory performance updates for one mounted view. */
 export class UsageController {
     source;
     publish;
     delay;
     retryDelay;
     performanceDelay;
+    detailed;
     state = { status: "loading" };
     snapshot;
     sessionID;
@@ -34,12 +35,13 @@ export class UsageController {
     unsubscribePerformance;
     performance;
     ownsPerformance;
-    constructor(source, subscribe, publish, delay = 80, retryDelay = 3_000, performanceDelay = 100, performance) {
+    constructor(source, subscribe, publish, delay = 80, retryDelay = 3_000, performanceDelay = 100, performance, detailed = false) {
         this.source = source;
         this.publish = publish;
         this.delay = delay;
         this.retryDelay = retryDelay;
         this.performanceDelay = performanceDelay;
+        this.detailed = detailed;
         this.ownsPerformance = performance === undefined;
         this.performance = performance ?? new PerformanceMonitor(subscribe);
         this.unsubscribePerformance = this.performance.listen(sessionID => {
@@ -135,13 +137,25 @@ export class UsageController {
             this.performance.reconcile(messages, this.sessions);
             clearTimeout(this.performanceTimer);
             this.performanceTimer = undefined;
+            const context = contextDetails(viewedMessages(snapshot), snapshot.model.context);
             this.update({
                 status: "ready",
                 summary: summarize(messages, snapshot.model.catalog),
-                context: contextUsage(viewedMessages(snapshot), snapshot.model.context),
+                context: context?.usage,
+                ...(this.detailed ? { details: { context, models: summarizeModels(messages, snapshot.model.catalog), sessionTitle: snapshot.sessions.get(snapshot.viewedID)?.title } } : {}),
                 performance: this.performance.summary(messages, this.sessions),
                 model: snapshot.model.label,
             });
+            // The server plugin may be absent. An optional RPC must not delay measured usage.
+            if (this.detailed && this.source.composition) {
+                void this.source.composition(snapshot.sessions.get(snapshot.viewedID), AbortSignal.any([request.signal, AbortSignal.timeout(5_000)]))
+                    .then(sources => {
+                    if (this.disposed || generation !== this.generation || this.snapshot !== snapshot || this.state.status !== "ready" || !this.state.details)
+                        return;
+                    this.update({ ...this.state, details: { ...this.state.details, sources } });
+                })
+                    .catch(() => { });
+            }
         }
         catch {
             if (this.disposed || generation !== this.generation)

package/dist/index.js

@@ -1,5 +1,27 @@
 import { Plugin } from "@opencode/plugin";
+import { estimateContextSources, parseContextSources } from "./context-sources.js";
+import { ContextSourceRpc } from "./context-rpc.js";
 export default Plugin.define({
     id: "opencode-token-usage",
-    setup() { },
+    async setup(context) {
+        const rpc = await context.rpc.register(ContextSourceRpc, {
+            latest: async (input) => {
+                const sessionID = input.sessionID;
+                return { estimate: parseContextSources(await context.storage.get(`context/${sessionID}`)) ?? null };
+            },
+        });
+        const hook = await context.session.hook("context", async (request) => {
+            try {
+                const servers = (await context.mcp.list()).data.map(server => server.name);
+                const estimate = estimateContextSources(request, servers);
+                await context.storage.set(`context/${request.sessionID}`, {
+                    capturedAt: estimate.capturedAt, model: estimate.model, tokens: { ...estimate.tokens },
+                });
+            }
+            catch {
+                // Instrumentation must not interrupt the model call.
+            }
+        });
+        return async () => { await hook.dispose(); await rpc.dispose(); };
+    },
 });

package/dist/source.d.ts

@@ -1,6 +1,7 @@
 import type { OpenCodeClient, SessionInfo } from "@opencode/client";
+import type { ContextSources } from "./context-sources.js";
 import type { PriceCatalog, UsageMessage } from "./usage.js";
-export type Session = Pick<SessionInfo, "id" | "parentID" | "fork" | "model" | "location">;
+export type Session = Pick<SessionInfo, "id" | "parentID" | "fork" | "model" | "location" | "title">;
 export interface Page<T> {
     data: T[];
     cursor: {
@@ -19,6 +20,7 @@ export interface UsageSource {
     children(id: string, cursor: string | undefined, signal: AbortSignal): Promise<Page<Session>>;
     messages(id: string, cursor: string | undefined, signal: AbortSignal): Promise<Page<UsageMessage>>;
     model(session: Session, signal: AbortSignal): Promise<ActiveModel>;
+    composition?(session: Session, signal: AbortSignal): Promise<ContextSources | undefined>;
 }
 export declare function createSource(client: OpenCodeClient): UsageSource;
 export declare function pages<T>(read: (cursor?: string) => Promise<Page<T>>, signal: AbortSignal): Promise<T[]>;

package/dist/source.js

@@ -1,3 +1,5 @@
+import { ContextSourceRpc } from "./context-rpc.js";
+import { parseContextSources } from "./context-sources.js";
 import { modelKey } from "./usage.js";
 export function createSource(client) {
     return {
@@ -21,6 +23,12 @@ export function createSource(client) {
                 context: model?.limit?.context,
             };
         },
+        async composition(session, signal) {
+            const response = await client.rpc(ContextSourceRpc).latest({ sessionID: session.id }, { location: session.location, signal });
+            if (!response || typeof response !== "object" || !("estimate" in response))
+                return undefined;
+            return parseContextSources(response.estimate);
+        },
     };
 }
 export async function pages(read, signal) {