@theia/ai-codex 1.67.0-next.56 → 1.67.0-next.59

package/lib/browser/codex-chat-agent.d.ts

@@ -0,0 +1,79 @@
+import { ChatAgent, ChatAgentLocation, MutableChatRequestModel } from '@theia/ai-chat';
+import { TokenUsageService } from '@theia/ai-core';
+import { URI } from '@theia/core/lib/common/uri';
+import type { ItemStartedEvent, ItemUpdatedEvent, ItemCompletedEvent, TurnCompletedEvent, TurnFailedEvent, ThreadEvent, ThreadItem, CommandExecutionItem, FileChangeItem, McpToolCallItem, WebSearchItem, Usage, TodoListItem } from '@openai/codex-sdk';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { ChangeSetFileElementFactory } from '@theia/ai-chat/lib/browser/change-set-file-element';
+import { CodexToolCallChatResponseContent } from './codex-tool-call-content';
+import { CodexFrontendService } from './codex-frontend-service';
+export declare const CODEX_CHAT_AGENT_ID = "Codex";
+export declare const CODEX_INPUT_TOKENS_KEY = "codexInputTokens";
+export declare const CODEX_OUTPUT_TOKENS_KEY = "codexOutputTokens";
+export declare const CODEX_TOOL_CALLS_KEY = "codexToolCalls";
+type ToolInvocationItem = CommandExecutionItem | FileChangeItem | McpToolCallItem | WebSearchItem | TodoListItem;
+/**
+ * Chat agent for OpenAI Codex integration.
+ */
+export declare class CodexChatAgent implements ChatAgent {
+    id: string;
+    name: string;
+    description: string;
+    iconClass: string;
+    locations: ChatAgentLocation[];
+    tags: string[];
+    variables: string[];
+    prompts: [];
+    languageModelRequirements: [];
+    agentSpecificVariables: [];
+    functions: string[];
+    modes: {
+        id: string;
+        name: string;
+    }[];
+    protected codexService: CodexFrontendService;
+    protected tokenUsageService: TokenUsageService;
+    protected readonly fileService: FileService;
+    protected readonly workspaceService: WorkspaceService;
+    protected readonly fileChangeFactory: ChangeSetFileElementFactory;
+    invoke(request: MutableChatRequestModel): Promise<void>;
+    protected extractSandboxMode(modeId?: string): 'read-only' | 'workspace-write' | 'danger-full-access';
+    protected getToolCalls(request: MutableChatRequestModel): Map<string, CodexToolCallChatResponseContent>;
+    protected handleEvent(event: ThreadEvent, request: MutableChatRequestModel): Promise<void>;
+    /**
+     * Type guard using discriminated union narrowing from SDK types.
+     */
+    protected isToolInvocation(item: ThreadItem): item is ToolInvocationItem;
+    protected extractToolArguments(item: ToolInvocationItem): string;
+    /**
+     * Creates a pending tool call that will be updated when the item completes.
+     */
+    protected handleItemStarted(event: ItemStartedEvent, request: MutableChatRequestModel): Promise<void>;
+    /**
+     * Updates the pending tool call with new data, especially for todo_list items.
+     */
+    protected handleItemUpdated(event: ItemUpdatedEvent, request: MutableChatRequestModel): Promise<void>;
+    protected findMatchingToolCall(item: ToolInvocationItem, toolCalls: Map<string, CodexToolCallChatResponseContent>): [string, CodexToolCallChatResponseContent] | undefined;
+    protected getFileChangeOriginals(request: MutableChatRequestModel): Map<string, Map<string, string>>;
+    /**
+     * Snapshot the original contents for files that Codex is about to modify so we can populate the change set later.
+     */
+    protected captureFileChangeOriginals(item: FileChangeItem, request: MutableChatRequestModel): Promise<void>;
+    protected handleFileChangeCompleted(item: FileChangeItem, request: MutableChatRequestModel): Promise<boolean>;
+    protected normalizeRelativePath(path: string, rootUri?: URI): string | undefined;
+    protected ensureTrailingSlash(path: string): string;
+    protected resolveFileUri(rootUri: URI, relativePath: string): URI | undefined;
+    protected getWorkspaceRootUri(): Promise<URI | undefined>;
+    protected handleItemCompleted(event: ItemCompletedEvent, request: MutableChatRequestModel): Promise<void>;
+    protected handleTurnCompleted(event: TurnCompletedEvent, request: MutableChatRequestModel): void;
+    protected handleTurnFailed(event: TurnFailedEvent, request: MutableChatRequestModel): void;
+    protected updateTokens(request: MutableChatRequestModel, inputTokens: number, outputTokens: number): void;
+    protected updateSessionSuggestion(request: MutableChatRequestModel): void;
+    protected getSessionTotalTokens(request: MutableChatRequestModel): {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    protected reportTokenUsage(request: MutableChatRequestModel, usage: Usage): Promise<void>;
+}
+export {};
+//# sourceMappingURL=codex-chat-agent.d.ts.map

package/lib/browser/codex-chat-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-chat-agent.d.ts","sourceRoot":"","sources":["../../src/browser/codex-chat-agent.ts"],"names":[],"mappings":"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"}

package/lib/browser/codex-chat-agent.js

@@ -0,0 +1,556 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexChatAgent = exports.CODEX_TOOL_CALLS_KEY = exports.CODEX_OUTPUT_TOKENS_KEY = exports.CODEX_INPUT_TOKENS_KEY = exports.CODEX_CHAT_AGENT_ID = void 0;
+const tslib_1 = require("tslib");
+const ai_chat_1 = require("@theia/ai-chat");
+const ai_core_1 = require("@theia/ai-core");
+const prompt_text_1 = require("@theia/ai-core/lib/common/prompt-text");
+const core_1 = require("@theia/core");
+const uri_1 = require("@theia/core/lib/common/uri");
+const inversify_1 = require("@theia/core/shared/inversify");
+const file_service_1 = require("@theia/filesystem/lib/browser/file-service");
+const browser_1 = require("@theia/workspace/lib/browser");
+const change_set_file_element_1 = require("@theia/ai-chat/lib/browser/change-set-file-element");
+const codex_tool_call_content_1 = require("./codex-tool-call-content");
+const codex_frontend_service_1 = require("./codex-frontend-service");
+exports.CODEX_CHAT_AGENT_ID = 'Codex';
+exports.CODEX_INPUT_TOKENS_KEY = 'codexInputTokens';
+exports.CODEX_OUTPUT_TOKENS_KEY = 'codexOutputTokens';
+exports.CODEX_TOOL_CALLS_KEY = 'codexToolCalls';
+const CODEX_FILE_CHANGE_ORIGINALS_KEY = 'codexFileChangeOriginals';
+/**
+ * Chat agent for OpenAI Codex integration.
+ */
+let CodexChatAgent = class CodexChatAgent {
+    constructor() {
+        this.id = exports.CODEX_CHAT_AGENT_ID;
+        this.name = 'Codex';
+        this.description = core_1.nls.localize('theia/ai/codex/agentDescription', 'OpenAI\'s coding assistant powered by Codex');
+        this.iconClass = 'codicon codicon-robot';
+        this.locations = ai_chat_1.ChatAgentLocation.ALL;
+        this.tags = [core_1.nls.localizeByDefault('Chat')];
+        this.variables = [];
+        this.prompts = [];
+        this.languageModelRequirements = [];
+        this.agentSpecificVariables = [];
+        this.functions = [];
+        this.modes = [
+            { id: 'workspace-write', name: 'Workspace' },
+            { id: 'read-only', name: 'Read-Only' },
+            { id: 'danger-full-access', name: 'Full Access' }
+        ];
+    }
+    async invoke(request) {
+        try {
+            const agentAddress = `${prompt_text_1.PromptText.AGENT_CHAR}${exports.CODEX_CHAT_AGENT_ID}`;
+            let prompt = request.request.text.trim();
+            if (prompt.startsWith(agentAddress)) {
+                prompt = prompt.replace(agentAddress, '').trim();
+            }
+            const sessionId = request.session.id;
+            const sandboxMode = this.extractSandboxMode(request.request.modeId);
+            const streamResult = await this.codexService.send({ prompt, sessionId, sandboxMode }, request.response.cancellationToken);
+            for await (const event of streamResult) {
+                await this.handleEvent(event, request);
+            }
+            request.response.complete();
+        }
+        catch (error) {
+            console.error('Codex error:', error);
+            request.response.response.addContent(new ai_chat_1.ErrorChatResponseContentImpl(error));
+            request.response.error(error);
+        }
+    }
+    extractSandboxMode(modeId) {
+        if (modeId === 'read-only' || modeId === 'workspace-write' || modeId === 'danger-full-access') {
+            return modeId;
+        }
+        return 'workspace-write';
+    }
+    getToolCalls(request) {
+        let toolCalls = request.getDataByKey(exports.CODEX_TOOL_CALLS_KEY);
+        if (!toolCalls) {
+            toolCalls = new Map();
+            request.addData(exports.CODEX_TOOL_CALLS_KEY, toolCalls);
+        }
+        return toolCalls;
+    }
+    async handleEvent(event, request) {
+        if (event.type === 'item.started') {
+            await this.handleItemStarted(event, request);
+        }
+        else if (event.type === 'item.updated') {
+            await this.handleItemUpdated(event, request);
+        }
+        else if (event.type === 'item.completed') {
+            await this.handleItemCompleted(event, request);
+        }
+        else if (event.type === 'turn.completed') {
+            this.handleTurnCompleted(event, request);
+        }
+        else if (event.type === 'turn.failed') {
+            this.handleTurnFailed(event, request);
+        }
+    }
+    /**
+     * Type guard using discriminated union narrowing from SDK types.
+     */
+    isToolInvocation(item) {
+        return item.type === 'command_execution' ||
+            item.type === 'todo_list' ||
+            item.type === 'file_change' ||
+            item.type === 'mcp_tool_call' ||
+            item.type === 'web_search';
+    }
+    extractToolArguments(item) {
+        const args = {};
+        if (item.type === 'command_execution') {
+            args.command = item.command;
+            args.status = item.status;
+            if (item.exit_code !== undefined) {
+                args.exit_code = item.exit_code;
+            }
+        }
+        else if (item.type === 'file_change') {
+            args.changes = item.changes;
+            args.status = item.status;
+        }
+        else if (item.type === 'mcp_tool_call') {
+            args.server = item.server;
+            args.tool = item.tool;
+            args.status = item.status;
+        }
+        else if (item.type === 'web_search') {
+            args.query = item.query;
+        }
+        else if (item.type === 'todo_list') {
+            args.id = item.id;
+            args.items = item.items;
+        }
+        return JSON.stringify(args);
+    }
+    /**
+     * Creates a pending tool call that will be updated when the item completes.
+     */
+    async handleItemStarted(event, request) {
+        const item = event.item;
+        if (this.isToolInvocation(item)) {
+            if (item.type === 'file_change') {
+                await this.captureFileChangeOriginals(item, request);
+                return;
+            }
+            const toolCallId = (0, core_1.generateUuid)();
+            const args = this.extractToolArguments(item);
+            const toolCall = new codex_tool_call_content_1.CodexToolCallChatResponseContent(toolCallId, item.type, args, false, undefined);
+            this.getToolCalls(request).set(toolCallId, toolCall);
+            request.response.response.addContent(toolCall);
+        }
+    }
+    /**
+     * Updates the pending tool call with new data, especially for todo_list items.
+     */
+    async handleItemUpdated(event, request) {
+        const item = event.item;
+        if (this.isToolInvocation(item)) {
+            const toolCalls = this.getToolCalls(request);
+            const match = this.findMatchingToolCall(item, toolCalls);
+            if (match) {
+                const [_, existingCall] = match;
+                existingCall.update(this.extractToolArguments(item));
+                request.response.response.responseContentChanged();
+            }
+        }
+    }
+    findMatchingToolCall(item, toolCalls) {
+        let matchKey;
+        if (item.type === 'command_execution') {
+            matchKey = item.command;
+        }
+        else if (item.type === 'web_search') {
+            matchKey = item.query;
+        }
+        else if (item.type === 'mcp_tool_call') {
+            matchKey = `${item.server}:${item.tool}`;
+        }
+        else if (item.type === 'todo_list') {
+            matchKey = item.id;
+        }
+        if (!matchKey) {
+            return undefined;
+        }
+        for (const [id, call] of toolCalls.entries()) {
+            const toolCallContent = call;
+            if (toolCallContent.name !== item.type || toolCallContent.finished) {
+                continue;
+            }
+            try {
+                const args = toolCallContent.arguments ? JSON.parse(toolCallContent.arguments) : {};
+                let argKey;
+                if (item.type === 'command_execution') {
+                    argKey = args.command;
+                }
+                else if (item.type === 'web_search') {
+                    argKey = args.query;
+                }
+                else if (item.type === 'mcp_tool_call') {
+                    argKey = `${args.server}:${args.tool}`;
+                }
+                else if (item.type === 'todo_list') {
+                    argKey = args.id;
+                }
+                if (argKey === matchKey) {
+                    return [id, call];
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return undefined;
+    }
+    getFileChangeOriginals(request) {
+        let originals = request.getDataByKey(CODEX_FILE_CHANGE_ORIGINALS_KEY);
+        if (!originals) {
+            originals = new Map();
+            request.addData(CODEX_FILE_CHANGE_ORIGINALS_KEY, originals);
+        }
+        return originals;
+    }
+    /**
+     * Snapshot the original contents for files that Codex is about to modify so we can populate the change set later.
+     */
+    async captureFileChangeOriginals(item, request) {
+        const changes = item.changes;
+        if (!changes || changes.length === 0) {
+            return;
+        }
+        const rootUri = await this.getWorkspaceRootUri();
+        if (!rootUri) {
+            return;
+        }
+        const originals = this.getFileChangeOriginals(request);
+        let itemOriginals = originals.get(item.id);
+        if (!itemOriginals) {
+            itemOriginals = new Map();
+            originals.set(item.id, itemOriginals);
+        }
+        for (const change of changes) {
+            const rawPath = typeof change.path === 'string' ? change.path.trim() : '';
+            const path = this.normalizeRelativePath(rawPath, rootUri);
+            if (!path) {
+                continue;
+            }
+            const fileUri = this.resolveFileUri(rootUri, path);
+            if (!fileUri) {
+                continue;
+            }
+            // For additions we snapshot an empty original state; for deletions/updates we capture existing content if available.
+            if (change.kind === 'add') {
+                itemOriginals.set(path, '');
+                continue;
+            }
+            try {
+                if (await this.fileService.exists(fileUri)) {
+                    const currentContent = await this.fileService.read(fileUri);
+                    itemOriginals.set(path, currentContent.value.toString());
+                }
+                else {
+                    itemOriginals.set(path, '');
+                }
+            }
+            catch (error) {
+                console.error('CodexChatAgent: Failed to capture original content for', path, error);
+                itemOriginals.set(path, '');
+            }
+        }
+    }
+    async handleFileChangeCompleted(item, request) {
+        if (!item.changes || item.changes.length === 0) {
+            return false;
+        }
+        const originals = this.getFileChangeOriginals(request);
+        if (item.status === 'failed') {
+            const affectedPaths = item.changes
+                .map(change => change.path)
+                .filter(path => !!path)
+                .join(', ');
+            const message = affectedPaths.length > 0
+                ? core_1.nls.localize('theia/ai/codex/fileChangeFailed', 'Codex failed to apply changes for: {0}', affectedPaths)
+                : core_1.nls.localize('theia/ai/codex/fileChangeFailedGeneric', 'Codex failed to apply file changes.');
+            request.response.response.addContent(new ai_chat_1.ErrorChatResponseContentImpl(new Error(message)));
+            originals.delete(item.id);
+            return true;
+        }
+        // const rootUri = await this.getWorkspaceRootUri();
+        // if (!rootUri) {
+        //     console.warn('CodexChatAgent: Unable to resolve workspace root for file change event.');
+        //     return false;
+        // }
+        // const changeSet = request.session?.changeSet;
+        // if (!changeSet) {
+        //     originals.delete(item.id);
+        //     return false;
+        // }
+        // const itemOriginals = originals.get(item.id);
+        // let createdElement = false;
+        // for (const change of item.changes) {
+        //     const rawPath = typeof change.path === 'string' ? change.path.trim() : '';
+        //     const path = this.normalizeRelativePath(rawPath, rootUri);
+        //     if (!path) {
+        //         continue;
+        //     }
+        //     const fileUri = this.resolveFileUri(rootUri, path);
+        //     if (!fileUri) {
+        //         continue;
+        //     }
+        //     const originalState = itemOriginals?.get(path) ?? '';
+        //     let targetState = '';
+        //     if (change.kind !== 'delete') {
+        //         const content = await this.readFileContentSafe(fileUri);
+        //         if (content === undefined) {
+        //             continue;
+        //         }
+        //         targetState = content;
+        //     }
+        //     const elementType = this.mapChangeKind(change.kind);
+        //     const fileElement = this.fileChangeFactory({
+        //         uri: fileUri,
+        //         type: elementType,
+        //         state: 'applied',
+        //         targetState,
+        //         originalState,
+        //         requestId: request.id,
+        //         chatSessionId: request.session.id
+        //     });
+        //     changeSet.addElements(fileElement);
+        //     createdElement = true;
+        // }
+        originals.delete(item.id);
+        // if (createdElement) {
+        //     changeSet.setTitle(CODEX_CHANGESET_TITLE);
+        // }
+        return false;
+    }
+    normalizeRelativePath(path, rootUri) {
+        if (!path) {
+            return undefined;
+        }
+        let normalized = path.replace(/\\/g, '/').trim();
+        if (!normalized) {
+            return undefined;
+        }
+        if (normalized.includes('://')) {
+            try {
+                const uri = new uri_1.URI(normalized);
+                normalized = uri.path.fsPath();
+            }
+            catch {
+            }
+        }
+        if (/^[a-zA-Z]:\//.test(normalized)) {
+            normalized = `/${normalized}`;
+        }
+        if (rootUri) {
+            const candidates = [
+                this.ensureTrailingSlash(rootUri.path.normalize().toString()),
+                this.ensureTrailingSlash(rootUri.path.fsPath().replace(/\\/g, '/'))
+            ];
+            const lowerNormalized = normalized.toLowerCase();
+            for (const candidate of candidates) {
+                if (!candidate) {
+                    continue;
+                }
+                const lowerCandidate = candidate.toLowerCase();
+                if (lowerNormalized.startsWith(lowerCandidate)) {
+                    normalized = normalized.substring(candidate.length);
+                    break;
+                }
+            }
+        }
+        if (normalized.startsWith('./')) {
+            normalized = normalized.substring(2);
+        }
+        while (normalized.startsWith('/')) {
+            normalized = normalized.substring(1);
+        }
+        normalized = normalized.trim();
+        return normalized || undefined;
+    }
+    ensureTrailingSlash(path) {
+        if (!path) {
+            return '';
+        }
+        return path.endsWith('/') ? path : `${path}/`;
+    }
+    // protected async readFileContentSafe(fileUri: URI): Promise<string | undefined> {
+    //     try {
+    //         if (!await this.fileService.exists(fileUri)) {
+    //             console.warn('CodexChatAgent: Skipping file change entry because file is missing', fileUri.toString());
+    //             return undefined;
+    //         }
+    //         const fileContent = await this.fileService.read(fileUri);
+    //         return fileContent.value.toString();
+    //     } catch (error) {
+    //         console.error('CodexChatAgent: Failed to read updated file content for', fileUri.toString(), error);
+    //         return undefined;
+    //     }
+    // }
+    // protected mapChangeKind(kind: FileChangeItem['changes'][number]['kind']): 'add' | 'delete' | 'modify' {
+    //     switch (kind) {
+    //         case 'add':
+    //             return 'add';
+    //         case 'delete':
+    //             return 'delete';
+    //         default:
+    //             return 'modify';
+    //     }
+    // }
+    resolveFileUri(rootUri, relativePath) {
+        try {
+            const candidate = rootUri.resolve(relativePath);
+            const normalizedCandidate = candidate.withPath(candidate.path.normalize());
+            const normalizedRoot = rootUri.withPath(rootUri.path.normalize());
+            if (!normalizedRoot.isEqualOrParent(normalizedCandidate)) {
+                console.warn(`CodexChatAgent: Skipping file change outside workspace: ${relativePath}`);
+                return undefined;
+            }
+            return normalizedCandidate;
+        }
+        catch (error) {
+            console.error('CodexChatAgent: Failed to resolve file URI for', relativePath, error);
+            return undefined;
+        }
+    }
+    async getWorkspaceRootUri() {
+        const roots = await this.workspaceService.roots;
+        if (roots && roots.length > 0) {
+            return roots[0].resource;
+        }
+        return undefined;
+    }
+    async handleItemCompleted(event, request) {
+        const item = event.item;
+        if (this.isToolInvocation(item)) {
+            if (item.type === 'file_change') {
+                const handled = await this.handleFileChangeCompleted(item, request);
+                if (handled) {
+                    return;
+                }
+            }
+            const toolCalls = this.getToolCalls(request);
+            const match = this.findMatchingToolCall(item, toolCalls);
+            if (match) {
+                const [id, _] = match;
+                const updatedCall = new codex_tool_call_content_1.CodexToolCallChatResponseContent(id, item.type, this.extractToolArguments(item), true, JSON.stringify(item));
+                toolCalls.set(id, updatedCall);
+                request.response.response.addContent(updatedCall);
+            }
+            else {
+                const toolCallId = (0, core_1.generateUuid)();
+                const newToolCall = new codex_tool_call_content_1.CodexToolCallChatResponseContent(toolCallId, item.type, this.extractToolArguments(item), true, JSON.stringify(item));
+                toolCalls.set(toolCallId, newToolCall);
+                request.response.response.addContent(newToolCall);
+            }
+        }
+        else if (item.type === 'reasoning') {
+            request.response.response.addContent(new ai_chat_1.ThinkingChatResponseContentImpl(item.text, ''));
+        }
+        else if (item.type === 'agent_message') {
+            request.response.response.addContent(new ai_chat_1.MarkdownChatResponseContentImpl(item.text));
+        }
+        else if (item.type === 'error') {
+            request.response.response.addContent(new ai_chat_1.ErrorChatResponseContentImpl(new Error(item.message)));
+        }
+    }
+    handleTurnCompleted(event, request) {
+        const usage = event.usage;
+        this.updateTokens(request, usage.input_tokens, usage.output_tokens);
+        this.reportTokenUsage(request, usage);
+    }
+    handleTurnFailed(event, request) {
+        const errorMsg = event.error.message;
+        request.response.response.addContent(new ai_chat_1.ErrorChatResponseContentImpl(new Error(errorMsg)));
+    }
+    updateTokens(request, inputTokens, outputTokens) {
+        request.addData(exports.CODEX_INPUT_TOKENS_KEY, inputTokens);
+        request.addData(exports.CODEX_OUTPUT_TOKENS_KEY, outputTokens);
+        this.updateSessionSuggestion(request);
+    }
+    updateSessionSuggestion(request) {
+        const { inputTokens, outputTokens } = this.getSessionTotalTokens(request);
+        const formatTokens = (tokens) => {
+            if (tokens >= 1000) {
+                return `${(tokens / 1000).toFixed(1)}K`;
+            }
+            return tokens.toString();
+        };
+        const suggestion = `↑ ${formatTokens(inputTokens)} | ↓ ${formatTokens(outputTokens)}`;
+        request.session.setSuggestions([suggestion]);
+    }
+    getSessionTotalTokens(request) {
+        var _a, _b;
+        const requests = request.session.getRequests();
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        for (const req of requests) {
+            const inputTokens = (_a = req.getDataByKey(exports.CODEX_INPUT_TOKENS_KEY)) !== null && _a !== void 0 ? _a : 0;
+            const outputTokens = (_b = req.getDataByKey(exports.CODEX_OUTPUT_TOKENS_KEY)) !== null && _b !== void 0 ? _b : 0;
+            totalInputTokens += inputTokens;
+            totalOutputTokens += outputTokens;
+        }
+        return { inputTokens: totalInputTokens, outputTokens: totalOutputTokens };
+    }
+    async reportTokenUsage(request, usage) {
+        try {
+            await this.tokenUsageService.recordTokenUsage('openai/codex', {
+                inputTokens: usage.input_tokens,
+                outputTokens: usage.output_tokens,
+                cachedInputTokens: usage.cached_input_tokens,
+                requestId: request.id
+            });
+        }
+        catch (error) {
+            console.error('Failed to report token usage:', error);
+        }
+    }
+};
+exports.CodexChatAgent = CodexChatAgent;
+tslib_1.__decorate([
+    (0, inversify_1.inject)(codex_frontend_service_1.CodexFrontendService),
+    tslib_1.__metadata("design:type", codex_frontend_service_1.CodexFrontendService)
+], CodexChatAgent.prototype, "codexService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(ai_core_1.TokenUsageService),
+    tslib_1.__metadata("design:type", Object)
+], CodexChatAgent.prototype, "tokenUsageService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(file_service_1.FileService),
+    tslib_1.__metadata("design:type", file_service_1.FileService)
+], CodexChatAgent.prototype, "fileService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(browser_1.WorkspaceService),
+    tslib_1.__metadata("design:type", browser_1.WorkspaceService)
+], CodexChatAgent.prototype, "workspaceService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(change_set_file_element_1.ChangeSetFileElementFactory),
+    tslib_1.__metadata("design:type", Function)
+], CodexChatAgent.prototype, "fileChangeFactory", void 0);
+exports.CodexChatAgent = CodexChatAgent = tslib_1.__decorate([
+    (0, inversify_1.injectable)()
+], CodexChatAgent);
+//# sourceMappingURL=codex-chat-agent.js.map