@theia/ai-chat 1.63.0-next.0 → 1.63.0-next.52

package/src/browser/chat-tool-preferences.ts

@@ -0,0 +1,178 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+import { AI_CORE_PREFERENCES_TITLE } from '@theia/ai-core/lib/browser/ai-core-preferences';
+import { nls } from '@theia/core';
+import { interfaces, injectable, inject } from '@theia/core/shared/inversify';
+import {
+    createPreferenceProxy,
+    PreferenceProxy,
+    PreferenceService,
+    PreferenceSchema,
+    PreferenceContribution
+} from '@theia/core/lib/browser/preferences';
+
+/**
+ * Enum for tool confirmation modes
+ */
+export enum ToolConfirmationMode {
+    ALWAYS_ALLOW = 'always_allow',
+    CONFIRM = 'confirm',
+    DISABLED = 'disabled'
+}
+
+export const TOOL_CONFIRMATION_PREFERENCE = 'ai-features.chat.toolConfirmation';
+
+export const chatToolPreferences: PreferenceSchema = {
+    type: 'object',
+    properties: {
+        [TOOL_CONFIRMATION_PREFERENCE]: {
+            type: 'object',
+            additionalProperties: {
+                type: 'string',
+                enum: [ToolConfirmationMode.ALWAYS_ALLOW, ToolConfirmationMode.CONFIRM, ToolConfirmationMode.DISABLED],
+                enumDescriptions: [
+                    nls.localize('theia/ai/chat/toolConfirmation/yolo/description', 'Execute tools automatically without confirmation'),
+                    nls.localize('theia/ai/chat/toolConfirmation/confirm/description', 'Ask for confirmation before executing tools'),
+                    nls.localize('theia/ai/chat/toolConfirmation/disabled/description', 'Disable tool execution')
+                ]
+            },
+            default: {},
+            description: nls.localize('theia/ai/chat/toolConfirmation/description',
+                'Configure confirmation behavior for different tools. Key is the tool ID, value is the confirmation mode.' +
+                'Use "*" as the key to set a global default for all tools.'),
+            title: AI_CORE_PREFERENCES_TITLE,
+        }
+    }
+};
+
+export interface ChatToolConfiguration {
+    [TOOL_CONFIRMATION_PREFERENCE]: { [toolId: string]: ToolConfirmationMode };
+}
+
+export const ChatToolPreferenceContribution = Symbol('ChatToolPreferenceContribution');
+export const ChatToolPreferences = Symbol('ChatToolPreferences');
+export type ChatToolPreferences = PreferenceProxy<ChatToolConfiguration>;
+
+export function createChatToolPreferences(preferences: PreferenceService, schema: PreferenceSchema = chatToolPreferences): ChatToolPreferences {
+    return createPreferenceProxy(preferences, schema);
+}
+
+export function bindChatToolPreferences(bind: interfaces.Bind): void {
+    bind(ChatToolPreferences).toDynamicValue((ctx: interfaces.Context) => {
+        const preferences = ctx.container.get<PreferenceService>(PreferenceService);
+        const contribution = ctx.container.get<PreferenceContribution>(ChatToolPreferenceContribution);
+        return createChatToolPreferences(preferences, contribution.schema);
+    }).inSingletonScope();
+    bind(ChatToolPreferenceContribution).toConstantValue({ schema: chatToolPreferences });
+    bind(PreferenceContribution).toService(ChatToolPreferenceContribution);
+}
+
+/**
+ * Utility class to manage tool confirmation settings
+ */
+@injectable()
+export class ToolConfirmationManager {
+    @inject(ChatToolPreferences)
+    protected readonly preferences: ChatToolPreferences;
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    // In-memory session overrides (not persisted), per chat
+    protected sessionOverrides: Map<string, Map<string, ToolConfirmationMode>> = new Map();
+
+    /**
+     * Get the confirmation mode for a specific tool, considering session overrides first (per chat)
+     */
+    getConfirmationMode(toolId: string, chatId: string): ToolConfirmationMode {
+        const chatMap = this.sessionOverrides.get(chatId);
+        if (chatMap && chatMap.has(toolId)) {
+            return chatMap.get(toolId)!;
+        }
+        const toolConfirmation = this.preferences[TOOL_CONFIRMATION_PREFERENCE];
+        if (toolConfirmation[toolId]) {
+            return toolConfirmation[toolId];
+        }
+        if (toolConfirmation['*']) {
+            return toolConfirmation['*'];
+        }
+        return ToolConfirmationMode.ALWAYS_ALLOW; // Default to Always Allow
+    }
+
+    /**
+     * Set the confirmation mode for a specific tool (persisted)
+     */
+    setConfirmationMode(toolId: string, mode: ToolConfirmationMode): void {
+        const current = this.preferences[TOOL_CONFIRMATION_PREFERENCE] || {};
+        // Determine the global default (star entry), or fallback to schema default
+        let starMode = current['*'];
+        if (starMode === undefined) {
+            starMode = ToolConfirmationMode.ALWAYS_ALLOW;
+        }
+        if (mode === starMode) {
+            // Remove the toolId entry if it exists
+            if (toolId in current) {
+                const { [toolId]: _, ...rest } = current;
+                this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, rest);
+            }
+            // else, nothing to update
+        } else {
+            // Set or update the toolId entry
+            const updated = { ...current, [toolId]: mode };
+            this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, updated);
+        }
+    }
+
+    /**
+     * Set the confirmation mode for a specific tool for this session only (not persisted, per chat)
+     */
+    setSessionConfirmationMode(toolId: string, mode: ToolConfirmationMode, chatId: string): void {
+        let chatMap = this.sessionOverrides.get(chatId);
+        if (!chatMap) {
+            chatMap = new Map();
+            this.sessionOverrides.set(chatId, chatMap);
+        }
+        chatMap.set(toolId, mode);
+    }
+
+    /**
+     * Clear all session overrides for a specific chat, or all if no chatId is given
+     */
+    clearSessionOverrides(chatId?: string): void {
+        if (chatId) {
+            this.sessionOverrides.delete(chatId);
+        } else {
+            this.sessionOverrides.clear();
+        }
+    }
+
+    /**
+     * Get all tool confirmation settings
+     */
+    getAllConfirmationSettings(): { [toolId: string]: ToolConfirmationMode } {
+        return this.preferences[TOOL_CONFIRMATION_PREFERENCE] || {};
+    }
+
+    resetAllConfirmationModeSettings(): void {
+        const current = this.preferences[TOOL_CONFIRMATION_PREFERENCE] || {};
+        if ('*' in current) {
+            this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, { '*': current['*'] });
+        } else {
+            this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, {});
+        }
+    }
+}

package/src/browser/chat-tool-request-service.ts

@@ -0,0 +1,93 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+import { ToolRequest } from '@theia/ai-core';
+import { injectable, inject } from '@theia/core/shared/inversify';
+import { ChatToolRequestService, ChatToolRequest } from '../common/chat-tool-request-service';
+import { MutableChatRequestModel, ToolCallChatResponseContent } from '../common/chat-model';
+import { ToolConfirmationManager, ToolConfirmationMode, ChatToolPreferences } from './chat-tool-preferences';
+
+/**
+ * Frontend-specific implementation of ChatToolRequestService that handles tool confirmation
+ */
+@injectable()
+export class FrontendChatToolRequestService extends ChatToolRequestService {
+
+    @inject(ToolConfirmationManager)
+    protected readonly confirmationManager: ToolConfirmationManager;
+
+    @inject(ChatToolPreferences)
+    protected readonly preferences: ChatToolPreferences;
+
+    protected override toChatToolRequest(toolRequest: ToolRequest, request: MutableChatRequestModel): ChatToolRequest {
+        const confirmationMode = this.confirmationManager.getConfirmationMode(toolRequest.id, request.session.id);
+
+        return {
+            ...toolRequest,
+            handler: async (arg_string: string) => {
+                switch (confirmationMode) {
+                    case ToolConfirmationMode.DISABLED:
+                        return { denied: true, message: `Tool ${toolRequest.id} is disabled` };
+
+                    case ToolConfirmationMode.ALWAYS_ALLOW:
+                        // Execute immediately without confirmation
+                        return toolRequest.handler(arg_string, request);
+
+                    case ToolConfirmationMode.CONFIRM:
+                    default:
+                        // Create confirmation requirement
+                        const toolCallContent = this.findToolCallContent(toolRequest, arg_string, request);
+                        const confirmed = await toolCallContent.confirmed;
+
+                        if (confirmed) {
+                            return toolRequest.handler(arg_string, request);
+                        } else {
+                            // Return an object indicating the user denied the tool execution
+                            // instead of throwing an error
+                            return { denied: true, message: `Tool execution denied by user: ${toolRequest.id}` };
+                        }
+                }
+            }
+        };
+    }
+
+    /**
+     * Find existing tool call content or create a new one for confirmation tracking
+     *
+     * Looks for ToolCallChatResponseContent nodes where the name field matches the toolRequest id.
+     * Starts from the back of the content array to find the most recent match.
+     */
+    protected findToolCallContent(
+        toolRequest: ToolRequest,
+        arguments_: string,
+        request: MutableChatRequestModel
+    ): ToolCallChatResponseContent {
+        // Look for existing tool call content with matching ID
+        const response = request.response.response;
+        const contentArray = response.content;
+
+        // Start from the end of the array and find the first match
+        for (let i = contentArray.length - 1; i >= 0; i--) {
+            const content = contentArray[i];
+            if (ToolCallChatResponseContent.is(content) &&
+                content.name === toolRequest.id) {
+                return content;
+            }
+        }
+
+        throw new Error(`Tool call content for tool ${toolRequest.id} not found in the response`);
+    }
+}

package/src/browser/delegation-response-content.ts

@@ -0,0 +1,55 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+import { isObject } from '@theia/core';
+import { ChatRequestInvocation, ChatResponseContent } from '../common';
+
+/**
+ * Response Content created when an Agent delegates a prompt to another agent.
+ * Contains agent id, delegated prompt, and the response.
+ */
+export class DelegationResponseContent implements ChatResponseContent {
+    kind = 'AgentDelegation';
+
+    /**
+     * @param agentId The id of the agent to whom the task was delegated
+     * @param prompt The prompt that was delegated
+     * @param response The response from the delegated agent
+     */
+    constructor(
+        public agentId: string,
+        public prompt: string,
+        public response: ChatRequestInvocation
+    ) {
+        // Empty
+    }
+
+    asString(): string {
+        const json = {
+            agentId: this.agentId,
+            prompt: this.prompt
+        };
+        return JSON.stringify(json);
+    }
+}
+
+export function isDelegationResponseContent(
+    value: unknown
+): value is DelegationResponseContent {
+    return (
+        isObject<DelegationResponseContent>(value) &&
+        value.kind === 'AgentDelegation'
+    );
+}

package/src/browser/file-chat-variable-contribution.ts

@@ -17,13 +17,14 @@
 import { AIVariableContext, AIVariableResolutionRequest, PromptText } from '@theia/ai-core';
 import { AIVariableCompletionContext, AIVariableDropResult, FrontendVariableContribution, FrontendVariableService } from '@theia/ai-core/lib/browser';
 import { FILE_VARIABLE } from '@theia/ai-core/lib/browser/file-variable-contribution';
-import { CancellationToken, QuickInputService, URI } from '@theia/core';
+import { CancellationToken, ILogger, QuickInputService, URI } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import * as monaco from '@theia/monaco-editor-core';
 import { FileQuickPickItem, QuickFileSelectService } from '@theia/file-search/lib/browser/quick-file-select-service';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { VARIABLE_ADD_CONTEXT_COMMAND } from './ai-chat-frontend-contribution';
+import { IMAGE_CONTEXT_VARIABLE, ImageContextVariable } from '../common/image-context-variable';
 
 @injectable()
 export class FileChatVariableContribution implements FrontendVariableContribution {
@@ -39,8 +40,12 @@ export class FileChatVariableContribution implements FrontendVariableContributio
     @inject(QuickFileSelectService)
     protected readonly quickFileSelectService: QuickFileSelectService;
 
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
     registerVariables(service: FrontendVariableService): void {
         service.registerArgumentPicker(FILE_VARIABLE, this.triggerArgumentPicker.bind(this));
+        service.registerArgumentPicker(IMAGE_CONTEXT_VARIABLE, this.imageArgumentPicker.bind(this));
         service.registerArgumentCompletionProvider(FILE_VARIABLE, this.provideArgumentCompletionItems.bind(this));
         service.registerDropHandler(this.handleDrop.bind(this));
     }
@@ -68,6 +73,57 @@ export class FileChatVariableContribution implements FrontendVariableContributio
         });
     }
 
+    protected async imageArgumentPicker(): Promise<string | undefined> {
+        const quickPick = this.quickInputService.createQuickPick();
+        quickPick.title = 'Select an image file';
+
+        // Get all files and filter only image files
+        const allPicks = await this.quickFileSelectService.getPicks();
+        quickPick.items = allPicks.filter(item => {
+            if (FileQuickPickItem.is(item)) {
+                return this.isImageFile(item.uri.path.toString());
+            }
+            return false;
+        });
+
+        const updateItems = async (value: string) => {
+            const filteredPicks = await this.quickFileSelectService.getPicks(value, CancellationToken.None);
+            quickPick.items = filteredPicks.filter(item => {
+                if (FileQuickPickItem.is(item)) {
+                    return this.isImageFile(item.uri.path.toString());
+                }
+                return false;
+            });
+        };
+
+        const onChangeListener = quickPick.onDidChangeValue(updateItems);
+        quickPick.show();
+
+        return new Promise(resolve => {
+            quickPick.onDispose(onChangeListener.dispose);
+            quickPick.onDidAccept(async () => {
+                const selectedItem = quickPick.selectedItems[0];
+                if (selectedItem && FileQuickPickItem.is(selectedItem)) {
+                    quickPick.dispose();
+                    const filePath = await this.wsService.getWorkspaceRelativePath(selectedItem.uri);
+                    const fileName = selectedItem.uri.displayName;
+                    const base64Data = await this.fileToBase64(selectedItem.uri);
+                    const mimeType = this.getMimeTypeFromExtension(selectedItem.uri.path.toString());
+
+                    // Create the argument string in the required format
+                    const imageVarArgs: ImageContextVariable = {
+                        name: fileName,
+                        wsRelativePath: filePath,
+                        data: base64Data,
+                        mimeType: mimeType
+                    };
+
+                    resolve(ImageContextVariable.createArgString(imageVarArgs));
+                }
+            });
+        });
+    }
+
     protected async provideArgumentCompletionItems(
         model: monaco.editor.ITextModel,
         position: monaco.Position,
@@ -106,6 +162,50 @@ export class FileChatVariableContribution implements FrontendVariableContributio
         );
     }
 
+    /**
+     * Checks if a file is an image based on its extension.
+     */
+    protected isImageFile(filePath: string): boolean {
+        const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg', '.webp'];
+        const extension = filePath.toLowerCase().substring(filePath.lastIndexOf('.'));
+        return imageExtensions.includes(extension);
+    }
+
+    /**
+     * Determines the MIME type based on file extension.
+     */
+    protected getMimeTypeFromExtension(filePath: string): string {
+        const extension = filePath.toLowerCase().substring(filePath.lastIndexOf('.'));
+        const mimeTypes: { [key: string]: string } = {
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.png': 'image/png',
+            '.gif': 'image/gif',
+            '.bmp': 'image/bmp',
+            '.svg': 'image/svg+xml',
+            '.webp': 'image/webp'
+        };
+        return mimeTypes[extension] || 'application/octet-stream';
+    }
+
+    /**
+     * Converts a file to base64 data URL.
+     */
+    protected async fileToBase64(uri: URI): Promise<string> {
+        try {
+            const fileContent = await this.fileService.readFile(uri);
+            const uint8Array = new Uint8Array(fileContent.value.buffer);
+            let binary = '';
+            for (let i = 0; i < uint8Array.length; i++) {
+                binary += String.fromCharCode(uint8Array[i]);
+            }
+            return btoa(binary);
+        } catch (error) {
+            this.logger.error('Error reading file content:', error);
+            return '';
+        }
+    }
+
     protected async handleDrop(event: DragEvent, _: AIVariableContext): Promise<AIVariableDropResult | undefined> {
         const data = event.dataTransfer?.getData('selected-tree-nodes');
         if (!data) {
@@ -126,11 +226,25 @@ export class FileChatVariableContribution implements FrontendVariableContributio
                 const uri = URI.fromFilePath(filePath);
                 if (await this.fileService.exists(uri)) {
                     const wsRelativePath = await this.wsService.getWorkspaceRelativePath(uri);
-                    variables.push({
-                        variable: FILE_VARIABLE,
-                        arg: wsRelativePath
-                    });
-                    texts.push(`${PromptText.VARIABLE_CHAR}${FILE_VARIABLE.name}${PromptText.VARIABLE_SEPARATOR_CHAR}${wsRelativePath}`);
+                    const fileName = uri.displayName;
+
+                    if (this.isImageFile(filePath)) {
+                        const base64Data = await this.fileToBase64(uri);
+                        const mimeType = this.getMimeTypeFromExtension(filePath);
+                        variables.push(ImageContextVariable.createRequest({
+                            [ImageContextVariable.name]: fileName,
+                            [ImageContextVariable.wsRelativePath]: wsRelativePath,
+                            [ImageContextVariable.data]: base64Data,
+                            [ImageContextVariable.mimeType]: mimeType
+                        }));
+                        // we do not want to push a text for image variables
+                    } else {
+                        variables.push({
+                            variable: FILE_VARIABLE,
+                            arg: wsRelativePath
+                        });
+                        texts.push(`${PromptText.VARIABLE_CHAR}${FILE_VARIABLE.name}${PromptText.VARIABLE_SEPARATOR_CHAR}${wsRelativePath}`);
+                    }
                 }
             }
 

package/src/browser/frontend-chat-service.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { ChangeSet, ChatAgent, ChatAgentLocation, ChatServiceImpl, ChatSession, ParsedChatRequest, SessionOptions } from '../common';
+import { ChatAgent, ChatAgentLocation, ChatChangeEvent, ChatServiceImpl, ChatSession, ParsedChatRequest, SessionOptions } from '../common';
 import { PreferenceService } from '@theia/core/lib/browser';
 import { DEFAULT_CHAT_AGENT_PREF, PIN_CHAT_AGENT_PREF } from './ai-chat-preferences';
 import { ChangeSetFileService } from './change-set-file-service';
@@ -68,11 +68,8 @@ export class FrontendChatServiceImpl extends ChatServiceImpl {
     override createSession(location?: ChatAgentLocation, options?: SessionOptions, pinnedAgent?: ChatAgent): ChatSession {
         const session = super.createSession(location, options, pinnedAgent);
         session.model.onDidChange(event => {
-            const changeSet = (event as { changeSet?: ChangeSet }).changeSet;
-            if (event.kind === 'removeChangeSet') {
-                this.changeSetFileService.closeDiffsForSession(session.id);
-            } else if (changeSet) {
-                this.changeSetFileService.closeDiffsForSession(session.id, changeSet.getElements().map(({ uri }) => uri));
+            if (ChatChangeEvent.isChangeSetEvent(event)) {
+                this.changeSetFileService.closeDiffsForSession(session.id, session.model.changeSet.getElements().map(({ uri }) => uri));
             }
         });
         return session;

package/src/browser/image-context-variable-contribution.ts

@@ -0,0 +1,153 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// 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
+// *****************************************************************************
+
+import {
+    AIVariableContext, AIVariableContribution,
+    AIVariableOpener, AIVariableResolutionRequest, AIVariableResolver, ResolvedAIContextVariable
+} from '@theia/ai-core';
+import { FrontendVariableService, AIVariablePasteResult } from '@theia/ai-core/lib/browser';
+import { Path, URI } from '@theia/core';
+import { LabelProvider, LabelProviderContribution, open, OpenerService } from '@theia/core/lib/browser';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { IMAGE_CONTEXT_VARIABLE, ImageContextVariable, ImageContextVariableRequest } from '../common/image-context-variable';
+
+@injectable()
+export class ImageContextVariableContribution implements AIVariableContribution, AIVariableResolver, AIVariableOpener, LabelProviderContribution {
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    @inject(WorkspaceService)
+    protected readonly wsService: WorkspaceService;
+
+    @inject(OpenerService)
+    protected readonly openerService: OpenerService;
+
+    @inject(LabelProvider)
+    protected readonly labelProvider: LabelProvider;
+
+    registerVariables(service: FrontendVariableService): void {
+        service.registerResolver(IMAGE_CONTEXT_VARIABLE, this);
+        service.registerOpener(IMAGE_CONTEXT_VARIABLE, this);
+        service.registerPasteHandler(this.handlePaste.bind(this));
+    }
+
+    async canResolve(request: AIVariableResolutionRequest, _: AIVariableContext): Promise<number> {
+        return ImageContextVariable.isImageContextRequest(request) ? 1 : 0;
+    }
+
+    async resolve(request: AIVariableResolutionRequest, _: AIVariableContext): Promise<ResolvedAIContextVariable | undefined> {
+        return ImageContextVariable.resolve(request as ImageContextVariableRequest);
+    }
+
+    async canOpen(request: AIVariableResolutionRequest, context: AIVariableContext): Promise<number> {
+        return ImageContextVariable.isImageContextRequest(request) && !!ImageContextVariable.parseRequest(request)?.wsRelativePath ? 1 : 0;
+    }
+
+    async open(request: ImageContextVariableRequest, context: AIVariableContext): Promise<void> {
+        const uri = await this.toUri(request);
+        if (!uri) {
+            throw new Error('Unable to resolve URI for request.');
+        }
+        await open(this.openerService, uri);
+    }
+
+    protected async toUri(request: ImageContextVariableRequest): Promise<URI | undefined> {
+        const variable = ImageContextVariable.parseRequest(request);
+        return variable?.wsRelativePath ? this.makeAbsolute(variable.wsRelativePath) : undefined;
+    }
+
+    async handlePaste(event: ClipboardEvent, context: AIVariableContext): Promise<AIVariablePasteResult | undefined> {
+        if (!event.clipboardData?.items) { return undefined; }
+
+        const variables: AIVariableResolutionRequest[] = [];
+
+        for (const item of event.clipboardData.items) {
+            if (item.type.startsWith('image/')) {
+                const blob = item.getAsFile();
+                if (blob) {
+                    try {
+                        const dataUrl = await this.readFileAsDataURL(blob);
+                        // Extract the base64 data by removing the data URL prefix
+                        // Format is like: data:image/png;base64,BASE64DATA
+                        const imageData = dataUrl.substring(dataUrl.indexOf(',') + 1);
+                        variables.push(ImageContextVariable.createRequest({
+                            data: imageData,
+                            name: blob.name || `pasted-image-${Date.now()}.png`,
+                            mimeType: blob.type
+                        }));
+                    } catch (error) {
+                        console.error('Failed to process pasted image:', error);
+                    }
+                }
+            }
+        }
+
+        return variables.length > 0 ? { variables } : undefined;
+    }
+
+    private readFileAsDataURL(blob: Blob): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = e => {
+                if (!e.target?.result) {
+                    reject(new Error('Failed to read file as data URL'));
+                    return;
+                }
+                resolve(e.target.result as string);
+            };
+            reader.onerror = () => reject(reader.error);
+            reader.readAsDataURL(blob);
+        });
+    }
+
+    protected async makeAbsolute(pathStr: string): Promise<URI | undefined> {
+        const path = new Path(Path.normalizePathSeparator(pathStr));
+        if (!path.isAbsolute) {
+            const workspaceRoots = this.wsService.tryGetRoots();
+            const wsUris = workspaceRoots.map(root => root.resource.resolve(path));
+            for (const uri of wsUris) {
+                if (await this.fileService.exists(uri)) {
+                    return uri;
+                }
+            }
+        }
+        const argUri = new URI(pathStr);
+        if (await this.fileService.exists(argUri)) {
+            return argUri;
+        }
+        return undefined;
+    }
+
+    canHandle(element: object): number {
+        return ImageContextVariable.isImageContextRequest(element) ? 10 : -1;
+    }
+
+    getIcon(element: ImageContextVariableRequest): string | undefined {
+        const path = ImageContextVariable.parseArg(element.arg).wsRelativePath;
+        return path ? this.labelProvider.getIcon(new URI(path)) : undefined;
+    }
+
+    getName(element: ImageContextVariableRequest): string | undefined {
+        return ImageContextVariable.parseArg(element.arg).name;
+    }
+
+    getDetails(element: ImageContextVariableRequest): string | undefined {
+        const path = ImageContextVariable.parseArg(element.arg).wsRelativePath;
+        return path ? this.labelProvider.getDetails(new URI(path)) : '[pasted]';
+    }
+}