@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.1

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/agentHostChatDebugProvider.d.ts

@@ -0,0 +1,123 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
+import { IChatDebugEvent, IChatDebugResolvedEventContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService";
+import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
+/**
+ * One record in an Agent Host Copilot CLI `events.jsonl` stream. The CLI
+ * writes a line-delimited JSON log of the session under
+ * `~/.copilot/session-state/<id>/events.jsonl`. Every record shares the same
+ * envelope. Note that `parentId` is **not** a logical parent: the SDK defines
+ * it as the chronologically preceding event in the session (a flat linked chain
+ * over every event), not the user → model-turn → tool-call hierarchy. The
+ * panel's trajectory tree is instead reconstructed from each record's logical
+ * context (turn / tool-call / agent ids); see
+ * {@link convertAgentHostEventsToDebugEvents}.
+ */
+interface IAgentHostEventRecord {
+    readonly type: string;
+    readonly id: string;
+    readonly parentId: string | null;
+    /** Sub-agent instance id; absent for the main agent and session-level events. */
+    readonly agentId?: string;
+    readonly timestamp: string;
+    readonly data: Record<string, unknown>;
+}
+/**
+ * Feeds Agent Host (Copilot CLI) sessions into the Agent Debug Logs panel by
+ * reading each session's on-disk `events.jsonl` and converting the records
+ * into {@link IChatDebugEvent}s. Registers a core-side
+ * {@link IChatDebugLogProvider} (the service supports multiple providers
+ * alongside the extension's), and adds discovered local sessions to the
+ * available-sessions list so they appear in the home view.
+ */
+export declare class AgentHostChatDebugContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _chatDebugService;
+    private readonly _fileService;
+    private readonly _pathService;
+    private readonly _remoteAgentHostService;
+    private readonly _agentHostService;
+    private readonly _configurationService;
+    private readonly _logService;
+    static readonly ID = "workbench.contrib.agentHostChatDebug";
+    /** Resolved (expanded) detail for each emitted event id. */
+    private readonly _resolved;
+    /** Guards against concurrent/overlapping session discovery scans. */
+    private _discovering;
+    /** Watches the currently-viewed session's events.jsonl for live refresh. */
+    private readonly _liveRefresh;
+    private _watchedSessionKey;
+    constructor(_chatDebugService: IChatDebugService, _fileService: IFileService, _pathService: IPathService, _remoteAgentHostService: IRemoteAgentHostService, _agentHostService: IAgentHostService, _configurationService: IConfigurationService, _logService: ILogService);
+    /**
+     * Runs {@link _discoverLocalSessions} when file logging is enabled,
+     * guarding against overlapping scans. Safe to call repeatedly:
+     * {@link IChatDebugService.addAvailableSessionResources} dedupes by URI.
+     */
+    private _maybeDiscoverLocalSessions;
+    private _resolveEventsUri;
+    /**
+     * Watches the given session's events.jsonl and re-invokes providers when it
+     * changes, so the panel updates as new turns/requests stream in. Only one
+     * session (the one currently shown) is watched at a time. Remote
+     * (non-`file`) sessions are not watched; they still load on open.
+     */
+    private _ensureLiveRefresh;
+    /**
+     * Returns the live AHP chat-state subscription for a local Agent Host
+     * session, if one is currently active (i.e. the session is open/subscribed).
+     * Turns (and their usage) live on the session's default chat channel, so we
+     * subscribe to that channel rather than the session. Read-only: never
+     * creates a subscription.
+     */
+    private _sessionChatSubscription;
+    /**
+     * Reads live Copilot AIU from the AHP session state as a fallback usage
+     * source for in-progress sessions (no `session.shutdown` summary yet).
+     * Only AIU is reliable live; input/cache need the shutdown summary (F1).
+     */
+    private _getLiveUsageTotals;
+    private _provideChatDebugLog;
+    private _discoverLocalSessions;
+}
+/**
+ * Converts a parsed `events.jsonl` record stream into debug-panel events plus
+ * their expanded detail. Pure (no services) so it can be unit-tested directly.
+ *
+ * The record `parentId` is **not** a logical parent: the Copilot SDK documents
+ * it as "the chronologically preceding event in the session, forming a linked
+ * chain" — a flat back-pointer over every event, not the user → model-turn →
+ * tool-call hierarchy the panel's flow chart needs. So we reconstruct that
+ * hierarchy from each record's logical context as we iterate chronologically:
+ *   - `session.start` is the tree root.
+ *   - a `user.message` hangs off the session root.
+ *   - an `assistant.message` hangs off the current user message (tracked per
+ *     agent), unless it carries a `parentToolCallId` (a sub-agent turn), in
+ *     which case it hangs off that spawning tool call.
+ *   - a `tool.execution_start` hangs off the current assistant message (tracked
+ *     per agent), unless it carries a `parentToolCallId` (a nested / sub-agent
+ *     tool), in which case it hangs off that parent tool call.
+ * `tool.execution_start` and `tool.execution_complete` records share a
+ * `toolCallId` and are merged into a single tool-call event.
+ */
+export declare function convertAgentHostEventsToDebugEvents(records: readonly IAgentHostEventRecord[], sessionResource: URI, fallbackUsageTotals?: ISessionUsageTotals): {
+    readonly events: IChatDebugEvent[];
+    readonly resolved: Map<string, IChatDebugResolvedEventContent>;
+};
+/** Session usage totals distributed across model turns. */
+interface ISessionUsageTotals {
+    /** Cumulative input tokens — only set when known from an exact source (`session.shutdown`). */
+    readonly inputTokens?: number;
+    /** Cumulative cache-read tokens — only set when known from an exact source. */
+    readonly cacheReadTokens?: number;
+    /** Cumulative Copilot AIU (nano). */
+    readonly totalNanoAiu: number;
+}
+/** Parses a line-delimited JSON stream, skipping blank or malformed lines. */
+export declare function parseJsonl(text: string): IAgentHostEventRecord[];
+export {};

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/agentHostChatDebugProvider.js

@@ -0,0 +1,567 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { agentHostAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { buildDefaultChatUri, StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { ChatDebugLogLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { resolveEventsUri, COPILOT_CLI_LOCAL_AH_SCHEME, getCopilotCliSessionRawId, COPILOT_CLI_EH_SCHEME } from '@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/chat/browser/copilotCliEventsUri';
+
+const MAX_DISCOVERED_SESSIONS = 30;
+const TITLE_READ_BYTES = 64 * 1024;
+const MAX_RESOLVED_DETAILS = 50_000;
+const MAX_EVENT_PAYLOAD = 4_000;
+const MAX_DETAIL_PAYLOAD = 100_000;
+let AgentHostChatDebugContribution = class AgentHostChatDebugContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostChatDebug";
+    }
+    constructor(
+        _chatDebugService,
+        _fileService,
+        _pathService,
+        _remoteAgentHostService,
+        _agentHostService,
+        _configurationService,
+        _logService
+    ) {
+        super();
+        this._chatDebugService = _chatDebugService;
+        this._fileService = _fileService;
+        this._pathService = _pathService;
+        this._remoteAgentHostService = _remoteAgentHostService;
+        this._agentHostService = _agentHostService;
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this._resolved = ( new Map());
+        this._discovering = false;
+        this._liveRefresh = this._register(( new MutableDisposable()));
+        const provider = {
+            provideChatDebugLog: (sessionResource, token) => this._provideChatDebugLog(sessionResource, token),
+            resolveChatDebugLogEvent: async eventId => this._resolved.get(eventId)
+        };
+        this._register(this._chatDebugService.registerProvider(provider));
+        this._register(this._chatDebugService.onDidEndSession(sessionResource => {
+            if (( sessionResource.toString()) === this._watchedSessionKey) {
+                this._liveRefresh.clear();
+                this._watchedSessionKey = undefined;
+            }
+        }));
+        this._maybeDiscoverLocalSessions();
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING)) {
+                this._maybeDiscoverLocalSessions();
+            }
+        }));
+    }
+    async _maybeDiscoverLocalSessions() {
+        if (this._discovering || !this._configurationService.getValue(AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING)) {
+            return;
+        }
+        this._discovering = true;
+        try {
+            await this._discoverLocalSessions();
+        } catch (err) {
+            this._logService.warn(`[AgentHostChatDebug] session discovery failed: ${toErrorMessage(err)}`);
+        } finally {
+            this._discovering = false;
+        }
+    }
+    _resolveEventsUri(sessionResource) {
+        const userHome = this._pathService.userHome({
+            preferLocal: true
+        });
+        const result = resolveEventsUri(
+            sessionResource,
+            userHome,
+            authority => this._remoteAgentHostService.connections.find(c => agentHostAuthority(c.address) === authority)
+        );
+        return result.kind === "ok" ? result.resource : undefined;
+    }
+    _ensureLiveRefresh(sessionResource, eventsUri) {
+        const key = ( sessionResource.toString());
+        if (this._watchedSessionKey === key) {
+            return;
+        }
+        if (eventsUri.scheme !== Schemas.file) {
+            this._liveRefresh.clear();
+            this._watchedSessionKey = undefined;
+            return;
+        }
+        this._watchedSessionKey = key;
+        const store = ( new DisposableStore());
+        const scheduler = store.add(( new RunOnceScheduler(() => this._chatDebugService.invokeProviders(sessionResource), 400)));
+        const watcher = store.add(this._fileService.createWatcher(eventsUri, {
+            recursive: false,
+            excludes: []
+        }));
+        store.add(watcher.onDidChange(e => {
+            if (e.affects(eventsUri)) {
+                scheduler.schedule();
+            }
+        }));
+        const liveSub = this._sessionChatSubscription(sessionResource);
+        if (liveSub) {
+            store.add(liveSub.onDidChange(() => scheduler.schedule()));
+        }
+        this._liveRefresh.value = store;
+    }
+    _sessionChatSubscription(sessionResource) {
+        if (sessionResource.scheme !== COPILOT_CLI_LOCAL_AH_SCHEME) {
+            return undefined;
+        }
+        const rawId = getCopilotCliSessionRawId(sessionResource);
+        if (!rawId) {
+            return undefined;
+        }
+        const backendSession = ( URI.from({
+            scheme: COPILOT_CLI_EH_SCHEME,
+            path: `/${rawId}`
+        }));
+        const chatUri = ( URI.parse(buildDefaultChatUri(( backendSession.toString()))));
+        return this._agentHostService.getSubscriptionUnmanaged(StateComponents.Chat, chatUri);
+    }
+    _getLiveUsageTotals(sessionResource) {
+        const chat = this._sessionChatSubscription(sessionResource)?.value;
+        if (!chat || chat instanceof Error) {
+            return undefined;
+        }
+        return sumChatStateUsage(chat);
+    }
+    async _provideChatDebugLog(sessionResource, token) {
+        const eventsUri = this._resolveEventsUri(sessionResource);
+        if (!eventsUri) {
+            return undefined;
+        }
+        let text;
+        try {
+            const content = await this._fileService.readFile(eventsUri);
+            text = ( content.value.toString());
+        } catch {
+            return undefined;
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        this._ensureLiveRefresh(sessionResource, eventsUri);
+        const liveUsageTotals = this._getLiveUsageTotals(sessionResource);
+        const {
+            events,
+            resolved
+        } = convertAgentHostEventsToDebugEvents(parseJsonl(text), sessionResource, liveUsageTotals);
+        for (const [id, detail] of resolved) {
+            this._resolved.set(id, detail);
+            if (this._resolved.size > MAX_RESOLVED_DETAILS) {
+                const first = ( this._resolved.keys()).next().value;
+                if (first !== undefined) {
+                    this._resolved.delete(first);
+                }
+            }
+        }
+        return events;
+    }
+    async _discoverLocalSessions() {
+        const userHome = this._pathService.userHome({
+            preferLocal: true
+        });
+        const sessionStateDir = joinPath(userHome, ".copilot", "session-state");
+        let stat;
+        try {
+            stat = await this._fileService.resolve(sessionStateDir, {
+                resolveMetadata: true
+            });
+        } catch {
+            return;
+        }
+        const folders = (stat.children ?? []).filter(child => child.isDirectory).sort((a, b) => b.mtime - a.mtime).slice(0, MAX_DISCOVERED_SESSIONS);
+        const found = await Promise.all(( folders.map(async folder => {
+            const eventsUri = joinPath(folder.resource, "events.jsonl");
+            let title;
+            try {
+                const head = await this._fileService.readFile(eventsUri, {
+                    length: TITLE_READ_BYTES
+                });
+                title = extractSessionTitle(( head.value.toString())) ?? fallbackSessionTitle(folder.name);
+            } catch {
+                return undefined;
+            }
+            return {
+                uri: ( URI.from({
+                    scheme: COPILOT_CLI_LOCAL_AH_SCHEME,
+                    path: `/${folder.name}`
+                })),
+                title
+            };
+        })));
+        const sessions = found.filter(s => s !== undefined);
+        if (sessions.length > 0) {
+            this._chatDebugService.addAvailableSessionResources(sessions);
+        }
+    }
+};
+AgentHostChatDebugContribution = ( __decorate([( __param(0, IChatDebugService)), ( __param(1, IFileService)), ( __param(2, IPathService)), ( __param(3, IRemoteAgentHostService)), ( __param(4, IAgentHostService)), ( __param(5, IConfigurationService)), ( __param(6, ILogService))], AgentHostChatDebugContribution));
+function convertAgentHostEventsToDebugEvents(records, sessionResource, fallbackUsageTotals) {
+    const completeByToolCallId = ( new Map());
+    const turnStartByTurnId = ( new Map());
+    for (const record of records) {
+        if (record.type === "tool.execution_complete") {
+            const toolCallId = asString(record.data.toolCallId);
+            if (toolCallId) {
+                completeByToolCallId.set(toolCallId, record);
+            }
+        } else if (record.type === "assistant.turn_start") {
+            const turnId = asString(record.data.turnId);
+            if (turnId) {
+                turnStartByTurnId.set(turnId, record);
+            }
+        }
+    }
+    const events = [];
+    const resolved = ( new Map());
+    const modelTurnRefs = [];
+    let rootEventId;
+    const currentUserMessageByAgent = ( new Map());
+    const currentAssistantMessageByAgent = ( new Map());
+    const toolEventByToolCallId = ( new Map());
+    for (const record of records) {
+        const created = ( new Date(record.timestamp));
+        const agentKey = record.agentId ?? "";
+        switch (record.type) {
+        case "session.start":
+            {
+                rootEventId = record.id;
+                const model = asString(record.data.selectedModel);
+                const effort = asString(record.data.reasoningEffort);
+                const details = model ? (effort ? ( localize(6516, "model={0}, reasoningEffort={1}", model, effort)) : ( localize(6517, "model={0}", model))) : undefined;
+                events.push({
+                    kind: "generic",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: undefined,
+                    name: ( localize(6518, "Session Started")),
+                    details,
+                    level: ChatDebugLogLevel.Info,
+                    category: "session"
+                });
+                break;
+            }
+        case "user.message":
+            {
+                const content = asString(record.data.content) ?? "";
+                const transformed = asString(record.data.transformedContent);
+                const sections = [{
+                    name: ( localize(6519, "User Request")),
+                    content
+                }];
+                if (transformed && transformed !== content) {
+                    sections.push({
+                        name: ( localize(6520, "Full Prompt")),
+                        content: transformed
+                    });
+                }
+                const message = summarize(content);
+                currentUserMessageByAgent.set(agentKey, record.id);
+                currentAssistantMessageByAgent.delete(agentKey);
+                events.push({
+                    kind: "userMessage",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId: rootEventId,
+                    message,
+                    sections
+                });
+                resolved.set(record.id, {
+                    kind: "message",
+                    type: "user",
+                    message,
+                    sections
+                });
+                break;
+            }
+        case "assistant.message":
+            {
+                const model = asString(record.data.model);
+                const outputTokens = asNumber(record.data.outputTokens);
+                const content = asString(record.data.content) ?? "";
+                const reasoning = asString(record.data.reasoningText);
+                const parentToolCallId = asString(record.data.parentToolCallId);
+                const spawningTool = parentToolCallId ? toolEventByToolCallId.get(parentToolCallId) : undefined;
+                const parentEventId = spawningTool ?? currentUserMessageByAgent.get(agentKey) ?? rootEventId;
+                const turnId = asString(record.data.turnId);
+                const turnStart = turnId ? turnStartByTurnId.get(turnId) : undefined;
+                const durationInMillis = turnStart ? diffMillis(turnStart.timestamp, record.timestamp) : undefined;
+                currentAssistantMessageByAgent.set(agentKey, record.id);
+                modelTurnRefs.push({
+                    index: events.length,
+                    id: record.id,
+                    outputTokens
+                });
+                events.push({
+                    kind: "modelTurn",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId,
+                    model,
+                    requestName: "copilotcli",
+                    outputTokens,
+                    durationInMillis
+                });
+                const sections = [];
+                if (content) {
+                    sections.push({
+                        name: ( localize(6521, "Response")),
+                        content
+                    });
+                }
+                if (reasoning) {
+                    sections.push({
+                        name: ( localize(6522, "Reasoning")),
+                        content: reasoning
+                    });
+                }
+                resolved.set(record.id, {
+                    kind: "modelTurn",
+                    requestName: "copilotcli",
+                    model,
+                    outputTokens,
+                    durationInMillis,
+                    sections
+                });
+                break;
+            }
+        case "tool.execution_start":
+            {
+                const toolName = asString(record.data.toolName) ?? "tool";
+                const toolCallId = asString(record.data.toolCallId);
+                const complete = toolCallId ? completeByToolCallId.get(toolCallId) : undefined;
+                const success = complete ? asBoolean(complete.data.success) : undefined;
+                const result = success === undefined ? undefined : (success ? "success" : "error");
+                const durationInMillis = complete ? diffMillis(record.timestamp, complete.timestamp) : undefined;
+                const fullInput = stringifyPayload(record.data.arguments);
+                const fullOutput = complete ? stringifyPayload(complete.data.result) : undefined;
+                const parentToolCallId = asString(record.data.parentToolCallId);
+                const parentTool = parentToolCallId ? toolEventByToolCallId.get(parentToolCallId) : undefined;
+                const parentEventId = parentTool ?? currentAssistantMessageByAgent.get(agentKey) ?? currentUserMessageByAgent.get(agentKey) ?? rootEventId;
+                if (toolCallId) {
+                    toolEventByToolCallId.set(toolCallId, record.id);
+                }
+                events.push({
+                    kind: "toolCall",
+                    id: record.id,
+                    sessionResource,
+                    created,
+                    parentEventId,
+                    toolName,
+                    toolCallId,
+                    result,
+                    durationInMillis,
+                    input: truncate(fullInput, MAX_EVENT_PAYLOAD),
+                    output: truncate(fullOutput, MAX_EVENT_PAYLOAD)
+                });
+                resolved.set(record.id, {
+                    kind: "toolCall",
+                    toolName,
+                    result,
+                    durationInMillis,
+                    input: truncate(fullInput, MAX_DETAIL_PAYLOAD),
+                    output: truncate(fullOutput, MAX_DETAIL_PAYLOAD)
+                });
+                break;
+            }
+        }
+    }
+    const totals = extractSessionUsageTotals(records) ?? fallbackUsageTotals;
+    if (totals && modelTurnRefs.length > 0) {
+        const n = modelTurnRefs.length;
+        const inputs = totals.inputTokens !== undefined ? distributeEvenly(totals.inputTokens, n) : undefined;
+        const cached = totals.cacheReadTokens !== undefined ? distributeEvenly(totals.cacheReadTokens, n) : undefined;
+        const aiu = distributeEvenly(totals.totalNanoAiu, n);
+        for (let i = 0; i < n; i++) {
+            const ref = modelTurnRefs[i];
+            const turn = events[ref.index];
+            const inputTokens = inputs?.[i];
+            const cachedTokens = cached?.[i];
+            const totalTokens = inputTokens !== undefined ? inputTokens + (ref.outputTokens ?? 0) : undefined;
+            const copilotUsageNanoAiu = aiu[i] > 0 ? aiu[i] : undefined;
+            events[ref.index] = {
+                ...turn,
+                inputTokens,
+                cachedTokens,
+                totalTokens,
+                copilotUsageNanoAiu
+            };
+            const detail = resolved.get(ref.id);
+            if (detail?.kind === "modelTurn") {
+                resolved.set(ref.id, {
+                    ...detail,
+                    inputTokens,
+                    cachedTokens,
+                    totalTokens
+                });
+            }
+        }
+    }
+    return {
+        events,
+        resolved
+    };
+}
+function extractSessionUsageTotals(records) {
+    let shutdown;
+    for (const record of records) {
+        if (record.type === "session.shutdown") {
+            shutdown = record;
+        }
+    }
+    if (!shutdown) {
+        return undefined;
+    }
+    let inputTokens = 0;
+    let cacheReadTokens = 0;
+    let perModelNanoAiu = 0;
+    const modelMetrics = shutdown.data.modelMetrics;
+    if (modelMetrics && typeof modelMetrics === "object") {
+        for (const metric of ( Object.values(modelMetrics))) {
+            const entry = metric;
+            const usage = entry?.usage;
+            inputTokens += asNumber(usage?.inputTokens) ?? 0;
+            cacheReadTokens += asNumber(usage?.cacheReadTokens) ?? 0;
+            perModelNanoAiu += asNumber(entry?.totalNanoAiu) ?? 0;
+        }
+    }
+    const totalNanoAiu = asNumber(shutdown.data.totalNanoAiu) ?? perModelNanoAiu;
+    return {
+        inputTokens,
+        cacheReadTokens,
+        totalNanoAiu
+    };
+}
+function distributeEvenly(total, n) {
+    if (n <= 0) {
+        return [];
+    }
+    const base = Math.floor(total / n);
+    const parts = ( new Array(n)).fill(base);
+    let remainder = total - base * n;
+    for (let i = n - 1; remainder > 0; i--, remainder--) {
+        parts[i] += 1;
+    }
+    return parts;
+}
+function sumChatStateUsage(chat) {
+    let totalNanoAiu = 0;
+    let hasUsage = false;
+    const add = usage => {
+        if (!usage) {
+            return;
+        }
+        hasUsage = true;
+        totalNanoAiu += readCopilotNanoAiu(usage);
+    };
+    for (const turn of chat.turns) {
+        add(turn.usage);
+    }
+    add(chat.activeTurn?.usage);
+    return hasUsage ? {
+        totalNanoAiu
+    } : undefined;
+}
+function readCopilotNanoAiu(usage) {
+    const meta = usage._meta;
+    if (!meta || typeof meta !== "object") {
+        return 0;
+    }
+    const copilotUsage = meta.copilotUsage;
+    if (!copilotUsage || typeof copilotUsage !== "object") {
+        return 0;
+    }
+    const nano = copilotUsage.totalNanoAiu;
+    return typeof nano === "number" ? nano : 0;
+}
+function parseJsonl(text) {
+    const records = [];
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed.type === "string" && typeof parsed.id === "string" && typeof parsed.timestamp === "string" && (parsed.parentId === null || typeof parsed.parentId === "string") && parsed.data && typeof parsed.data === "object" && !Array.isArray(parsed.data)) {
+                records.push(parsed);
+            }
+        } catch {}
+    }
+    return records;
+}
+function fallbackSessionTitle(sessionId) {
+    return localize(6523, "Copilot CLI Session {0}", sessionId.slice(0, 8));
+}
+function extractSessionTitle(text) {
+    for (const record of parseJsonl(text)) {
+        if (record.type === "user.message") {
+            const content = asString(record.data.content);
+            if (content) {
+                return summarize(content);
+            }
+        }
+    }
+    return undefined;
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && isFinite(value) ? value : undefined;
+}
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function diffMillis(start, end) {
+    const a = ( new Date(start)).getTime();
+    const b = ( new Date(end)).getTime();
+    return isFinite(a) && isFinite(b) && b >= a ? b - a : undefined;
+}
+function stringifyPayload(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value, undefined, 2);
+    } catch {
+        return undefined;
+    }
+}
+function truncate(value, max) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return value.length > max ? value.slice(0, max) + "…" : value;
+}
+function summarize(content) {
+    const firstLine = ( content.split("\n").map(l => l.trim())).find(l => l.length > 0) ?? "";
+    return firstLine.length > 100 ? firstLine.slice(0, 100) + "…" : firstLine;
+}
+function toErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+
+export { AgentHostChatDebugContribution, convertAgentHostEventsToDebugEvents, parseJsonl };