@vybestack/llxprt-code 0.1.23 → 0.2.2-nightly.250908.7b895396

package/dist/src/zed-integration/zedIntegration.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, MCPServerConfig, DiscoveredMCPTool, } from '@vybestack/llxprt-code-core';
+import { AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, DiscoveredMCPTool, DebugLogger, getFunctionCalls, EmojiFilter, } from '@vybestack/llxprt-code-core';
 import * as acp from './acp.js';
 import { AcpFileSystemService } from './fileSystemService.js';
 import { Readable, Writable } from 'node:stream';
@@ -11,32 +11,43 @@ import { SettingScope } from '../config/settings.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { z } from 'zod';
+import os from 'os';
 import { randomUUID } from 'crypto';
-import { loadCliConfig } from '../config/config.js';
-export async function runZedIntegration(config, settings, extensions, argv) {
+export async function runZedIntegration(config, settings) {
+    const logger = new DebugLogger('llxprt:zed-integration');
+    logger.debug(() => 'Starting Zed integration');
     const stdout = Writable.toWeb(process.stdout);
     const stdin = Readable.toWeb(process.stdin);
-    // Stdout is used to send messages to the client, so console.log/console.info
-    // messages to stderr so that they don't interfere with ACP.
-    console.log = console.error;
-    console.info = console.error;
-    console.debug = console.error;
-    new acp.AgentSideConnection((client) => new GeminiAgent(config, settings, extensions, argv, client), stdout, stdin);
+    logger.debug(() => 'Streams created');
+    try {
+        new acp.AgentSideConnection((client) => {
+            logger.debug(() => 'Creating GeminiAgent');
+            return new GeminiAgent(config, settings, client);
+        }, stdout, stdin);
+        logger.debug(() => 'AgentSideConnection created successfully');
+    }
+    catch (e) {
+        logger.debug(() => `ERROR: Failed to create AgentSideConnection: ${e}`);
+        throw e;
+    }
+    logger.debug(() => 'Zed integration ready, waiting for messages');
+    // Keep the process alive - the Connection's #receive method will handle messages
+    await new Promise(() => {
+        // This promise never resolves, keeping the process alive
+    });
 }
 class GeminiAgent {
     config;
     settings;
-    extensions;
-    argv;
     client;
     sessions = new Map();
     clientCapabilities;
-    constructor(config, settings, extensions, argv, client) {
+    logger;
+    constructor(config, settings, client) {
         this.config = config;
         this.settings = settings;
-        this.extensions = extensions;
-        this.argv = argv;
         this.client = client;
+        this.logger = new DebugLogger('llxprt:zed-integration');
     }
     async initialize(args) {
         this.clientCapabilities = args.clientCapabilities;
@@ -62,6 +73,11 @@ class GeminiAgent {
             authMethods,
             agentCapabilities: {
                 loadSession: false,
+                promptCapabilities: {
+                    image: true,
+                    audio: true,
+                    embeddedContext: true,
+                },
             },
         };
     }
@@ -71,47 +87,176 @@ class GeminiAgent {
         await this.config.refreshAuth(method);
         this.settings.setValue(SettingScope.User, 'selectedAuthType', method);
     }
-    async newSession({ cwd, mcpServers, }) {
-        const sessionId = randomUUID();
-        const config = await this.newSessionConfig(sessionId, cwd, mcpServers);
-        let isAuthenticated = false;
-        if (this.settings.merged.selectedAuthType) {
+    async newSession({ cwd: _cwd, mcpServers: _mcpServers, }) {
+        try {
+            const sessionId = randomUUID();
+            // Use the existing config that was passed to runZedIntegration
+            const sessionConfig = this.config;
+            this.logger.debug(() => `newSession - creating session ${sessionId}`);
+            if (this.clientCapabilities?.fs) {
+                const acpFileSystemService = new AcpFileSystemService(this.client, sessionId, this.clientCapabilities.fs, sessionConfig.getFileSystemService());
+                sessionConfig.setFileSystemService(acpFileSystemService);
+            }
+            // Try to get the client and check if it's properly initialized
+            let geminiClient = sessionConfig.getGeminiClient();
+            const hasContentGeneratorConfig = sessionConfig.getContentGeneratorConfig() !== undefined;
+            this.logger.debug(() => `GeminiClient exists: ${!!geminiClient}, ContentGeneratorConfig exists: ${hasContentGeneratorConfig}`);
+            if (!geminiClient || !hasContentGeneratorConfig) {
+                this.logger.debug(() => 'GeminiClient not available - attempting auto-authentication');
+                // Auto-authenticate based on available configuration
+                const providerManager = sessionConfig.getProviderManager();
+                // Debug provider state
+                if (providerManager) {
+                    this.logger.debug(() => `ProviderManager exists: ${providerManager.hasActiveProvider() ? 'has active provider' : 'no active provider'}`);
+                    this.logger.debug(() => `Active provider name: ${providerManager.getActiveProviderName() || 'none'}`);
+                }
+                else {
+                    this.logger.debug(() => 'No ProviderManager available');
+                }
+                // Check for provider from config (loaded from profile or CLI)
+                const configProvider = sessionConfig.getProvider();
+                if (configProvider && providerManager) {
+                    this.logger.debug(() => `Config has provider: ${configProvider}`);
+                    // Ensure provider is activated
+                    if (!providerManager.hasActiveProvider()) {
+                        this.logger.debug(() => `Activating provider: ${configProvider}`);
+                        await providerManager.setActiveProvider(configProvider);
+                        // Apply ephemeral settings from profile to the provider
+                        const activeProvider = providerManager.getActiveProvider();
+                        if (activeProvider) {
+                            const authKey = sessionConfig.getEphemeralSetting('auth-key');
+                            const authKeyfile = sessionConfig.getEphemeralSetting('auth-keyfile');
+                            const baseUrl = sessionConfig.getEphemeralSetting('base-url');
+                            // Apply auth settings from profile
+                            if (authKey && activeProvider.setApiKey) {
+                                this.logger.debug(() => 'Setting API key from profile');
+                                activeProvider.setApiKey(authKey);
+                            }
+                            else if (authKeyfile && activeProvider.setApiKey) {
+                                // Load API key from file
+                                try {
+                                    const apiKey = (await fs.readFile(authKeyfile.replace(/^~/, os.homedir()), 'utf-8')).trim();
+                                    if (apiKey) {
+                                        this.logger.debug(() => 'Setting API key from keyfile');
+                                        activeProvider.setApiKey(apiKey);
+                                    }
+                                }
+                                catch (error) {
+                                    this.logger.debug(() => `ERROR: Failed to load keyfile ${authKeyfile}: ${error}`);
+                                }
+                            }
+                            // Apply base URL if specified
+                            if (baseUrl && baseUrl !== 'none' && activeProvider.setBaseUrl) {
+                                this.logger.debug(() => `Setting base URL: ${baseUrl}`);
+                                activeProvider.setBaseUrl(baseUrl);
+                            }
+                            // Apply profile model params if loaded
+                            const configWithProfile = sessionConfig;
+                            if (configWithProfile._profileModelParams &&
+                                'setModelParams' in activeProvider &&
+                                activeProvider.setModelParams) {
+                                this.logger.debug(() => 'Setting model params from profile');
+                                activeProvider.setModelParams(configWithProfile._profileModelParams);
+                            }
+                        }
+                    }
+                }
+                if (providerManager && providerManager.hasActiveProvider()) {
+                    // Use provider-based auth if a provider is configured
+                    this.logger.debug(() => `Auto-authenticating with provider: ${providerManager.getActiveProviderName()}`);
+                    // Ensure provider manager is set on config before refreshAuth
+                    // This is crucial for createContentGeneratorConfig to include the provider manager
+                    if (!sessionConfig.getProviderManager()) {
+                        this.logger.debug(() => 'Setting provider manager on config');
+                        sessionConfig.providerManager = providerManager;
+                        // Ensure serverToolsProvider (Gemini) has config set BEFORE refreshAuth
+                        // This is critical for web search to work properly
+                        const serverToolsProvider = providerManager.getServerToolsProvider();
+                        if (serverToolsProvider &&
+                            serverToolsProvider.name === 'gemini' &&
+                            serverToolsProvider.setConfig) {
+                            this.logger.debug(() => 'Setting config on serverToolsProvider for web search (before auth)');
+                            serverToolsProvider.setConfig(sessionConfig);
+                        }
+                    }
+                    await sessionConfig.refreshAuth(AuthType.USE_PROVIDER);
+                    // After refreshAuth, verify ContentGeneratorConfig was created with provider manager
+                    const contentGenConfig = sessionConfig.getContentGeneratorConfig();
+                    if (contentGenConfig && !contentGenConfig.providerManager) {
+                        this.logger.debug(() => 'Adding provider manager to ContentGeneratorConfig');
+                        contentGenConfig.providerManager = providerManager;
+                    }
+                }
+                else if (process.env.GEMINI_API_KEY) {
+                    // Use API key if available
+                    this.logger.debug(() => 'Auto-authenticating with GEMINI_API_KEY');
+                    await sessionConfig.refreshAuth(AuthType.USE_GEMINI);
+                }
+                else {
+                    // Try OAuth as last resort (this might open a browser)
+                    this.logger.debug(() => 'Auto-authenticating with OAuth');
+                    await sessionConfig.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+                }
+                geminiClient = sessionConfig.getGeminiClient();
+                if (!geminiClient) {
+                    throw new Error('Failed to authenticate. Please ensure valid credentials are available.');
+                }
+            }
+            this.logger.debug(() => 'Successfully obtained GeminiClient');
+            // Verify ContentGeneratorConfig was created properly
+            let contentGenConfig;
             try {
-                await config.refreshAuth(this.settings.merged.selectedAuthType);
-                isAuthenticated = true;
+                contentGenConfig = sessionConfig.getContentGeneratorConfig();
+                this.logger.debug(() => `ContentGeneratorConfig exists: ${!!contentGenConfig}`);
+                if (contentGenConfig) {
+                    this.logger.debug(() => `ContentGeneratorConfig has providerManager: ${!!contentGenConfig.providerManager}`);
+                    this.logger.debug(() => `ContentGeneratorConfig authType: ${contentGenConfig.authType}`);
+                }
             }
-            catch (e) {
-                console.error(`Authentication failed: ${e}`);
+            catch (error) {
+                this.logger.debug(() => `Failed to get ContentGeneratorConfig: ${error}`);
+                throw new Error('Content generator config not created after authentication. Please check your credentials.');
             }
-        }
-        if (!isAuthenticated) {
-            throw acp.RequestError.authRequired();
-        }
-        if (this.clientCapabilities?.fs) {
-            const acpFileSystemService = new AcpFileSystemService(this.client, sessionId, this.clientCapabilities.fs, config.getFileSystemService());
-            config.setFileSystemService(acpFileSystemService);
-        }
-        const geminiClient = config.getGeminiClient();
-        const chat = await geminiClient.startChat();
-        const session = new Session(sessionId, chat, config, this.client);
-        this.sessions.set(sessionId, session);
-        return {
-            sessionId,
-        };
-    }
-    async newSessionConfig(sessionId, cwd, mcpServers) {
-        const mergedMcpServers = { ...this.settings.merged.mcpServers };
-        for (const { command, args, env: rawEnv, name } of mcpServers) {
-            const env = {};
-            for (const { name: envName, value } of rawEnv) {
-                env[envName] = value;
+            if (!contentGenConfig) {
+                throw new Error('Content generator config not created after authentication.');
             }
-            mergedMcpServers[name] = new MCPServerConfig(command, args, env, cwd);
+            let chat;
+            try {
+                chat = await geminiClient.startChat();
+            }
+            catch (error) {
+                this.logger.debug(() => `Error starting chat: ${error}`);
+                // If startChat fails due to missing config, try to authenticate now
+                if (error instanceof Error &&
+                    error.message.includes('Content generator config')) {
+                    this.logger.debug(() => 'Attempting late authentication due to missing config');
+                    const providerManager = sessionConfig.getProviderManager();
+                    if (providerManager && providerManager.hasActiveProvider()) {
+                        await sessionConfig.refreshAuth(AuthType.USE_PROVIDER);
+                    }
+                    else if (process.env.GEMINI_API_KEY) {
+                        await sessionConfig.refreshAuth(AuthType.USE_GEMINI);
+                    }
+                    else {
+                        await sessionConfig.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+                    }
+                    // Try again after auth
+                    chat = await geminiClient.startChat();
+                }
+                else {
+                    throw error;
+                }
+            }
+            const session = new Session(sessionId, chat, sessionConfig, this.client);
+            this.sessions.set(sessionId, session);
+            return {
+                sessionId,
+            };
+        }
+        catch (error) {
+            this.logger.debug(() => `ERROR in newSession: ${error}`);
+            throw error;
         }
-        const settings = { ...this.settings.merged, mcpServers: mergedMcpServers };
-        const config = await loadCliConfig(settings, this.extensions, sessionId, this.argv, cwd);
-        await config.initialize();
-        return config;
     }
     async cancel(params) {
         const session = this.sessions.get(params.sessionId);
@@ -134,11 +279,16 @@ class Session {
     config;
     client;
     pendingPrompt = null;
+    emojiFilter;
     constructor(id, chat, config, client) {
         this.id = id;
         this.chat = chat;
         this.config = config;
         this.client = client;
+        // Initialize emoji filter from settings
+        const emojiFilterMode = this.config.getEphemeralSetting('emojifilter') || 'auto';
+        const filterConfig = { mode: emojiFilterMode };
+        this.emojiFilter = new EmojiFilter(filterConfig);
     }
     async cancelPendingPrompt() {
         if (!this.pendingPrompt) {
@@ -156,10 +306,6 @@ class Session {
         const parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
         let nextMessage = { role: 'user', parts };
         while (nextMessage !== null) {
-            if (pendingSend.signal.aborted) {
-                chat.addHistory(nextMessage);
-                return { stopReason: 'cancelled' };
-            }
             const functionCalls = [];
             try {
                 const responseStream = await chat.sendMessageStream({
@@ -171,7 +317,9 @@ class Session {
                 nextMessage = null;
                 for await (const resp of responseStream) {
                     if (pendingSend.signal.aborted) {
-                        return { stopReason: 'cancelled' };
+                        // Let the stream processing complete naturally to handle cancellation properly
+                        // Don't return early here - let the tool pipeline handle cleanup
+                        break;
                     }
                     if (resp.candidates && resp.candidates.length > 0) {
                         const candidate = resp.candidates[0];
@@ -179,9 +327,27 @@ class Session {
                             if (!part.text) {
                                 continue;
                             }
+                            // Filter the content through emoji filter
+                            const filterResult = this.emojiFilter.filterStreamChunk(part.text);
+                            if (filterResult.blocked) {
+                                // In error mode: inject error feedback to model for retry
+                                this.sendUpdate({
+                                    sessionUpdate: 'agent_message_chunk',
+                                    content: {
+                                        type: 'text',
+                                        text: '[Error: Response blocked due to emoji detection]',
+                                    },
+                                });
+                                // Add system feedback to be sent with next tool response
+                                // This could be done by queueing feedback similar to TUI implementation
+                                continue;
+                            }
+                            const filteredText = typeof filterResult.filtered === 'string'
+                                ? filterResult.filtered
+                                : '';
                             const content = {
                                 type: 'text',
-                                text: part.text,
+                                text: filteredText,
                             };
                             this.sendUpdate({
                                 sessionUpdate: part.thought
@@ -191,8 +357,10 @@ class Session {
                             });
                         }
                     }
-                    if (resp.functionCalls) {
-                        functionCalls.push(...resp.functionCalls);
+                    // Extract function calls from the response using the proper utility
+                    const respFunctionCalls = getFunctionCalls(resp);
+                    if (respFunctionCalls && respFunctionCalls.length > 0) {
+                        functionCalls.push(...respFunctionCalls);
                     }
                 }
             }
@@ -200,11 +368,31 @@ class Session {
                 if (getErrorStatus(error) === 429) {
                     throw new acp.RequestError(429, 'Rate limit exceeded. Try again later.');
                 }
-                throw error;
+                // If this is an abort error due to cancellation, handle it gracefully
+                if (pendingSend.signal.aborted &&
+                    isNodeError(error) &&
+                    error.name === 'AbortError') {
+                    // Don't throw - let the cancellation be handled below
+                }
+                else {
+                    throw error;
+                }
+            }
+            // Check for cancellation after stream processing but before tool execution
+            if (pendingSend.signal.aborted) {
+                // Return cancellation without adding to conversation history
+                // The conversation state should remain clean for proper context handling
+                return { stopReason: 'cancelled' };
             }
             if (functionCalls.length > 0) {
                 const toolResponseParts = [];
                 for (const fc of functionCalls) {
+                    // Check for cancellation before each tool execution
+                    if (pendingSend.signal.aborted) {
+                        // Return cancellation without polluting conversation history
+                        // Tool execution cancellation should be handled by the tool execution system
+                        return { stopReason: 'cancelled' };
+                    }
                     const response = await this.runTool(pendingSend.signal, promptId, fc);
                     const parts = Array.isArray(response) ? response : [response];
                     for (const part of parts) {
@@ -216,7 +404,14 @@ class Session {
                         }
                     }
                 }
-                nextMessage = { role: 'user', parts: toolResponseParts };
+                // For multiple tool responses, send them all together as the TUI does
+                // This ensures proper conversation history structure for providers like Anthropic
+                if (toolResponseParts.length > 0) {
+                    nextMessage = { role: 'user', parts: toolResponseParts };
+                }
+                else {
+                    nextMessage = null;
+                }
             }
         }
         return { stopReason: 'end_turn' };
@@ -247,7 +442,15 @@ class Session {
                     ? 'mcp'
                     : 'native',
             });
+            // Return paired function call and function response for proper conversation history
             return [
+                {
+                    functionCall: {
+                        id: callId,
+                        name: fc.name ?? '',
+                        args,
+                    },
+                },
                 {
                     functionResponse: {
                         id: callId,
@@ -265,64 +468,64 @@ class Session {
         if (!tool) {
             return errorResponse(new Error(`Tool "${fc.name}" not found in registry.`));
         }
-        const invocation = tool.build(args);
-        const confirmationDetails = await invocation.shouldConfirmExecute(abortSignal);
-        if (confirmationDetails) {
-            const content = [];
-            if (confirmationDetails.type === 'edit') {
-                content.push({
-                    type: 'diff',
-                    path: confirmationDetails.fileName,
-                    oldText: confirmationDetails.originalContent,
-                    newText: confirmationDetails.newContent,
-                });
+        try {
+            const invocation = tool.build(args);
+            const confirmationDetails = await invocation.shouldConfirmExecute(abortSignal);
+            if (confirmationDetails) {
+                const content = [];
+                if (confirmationDetails.type === 'edit') {
+                    content.push({
+                        type: 'diff',
+                        path: confirmationDetails.fileName,
+                        oldText: confirmationDetails.originalContent,
+                        newText: confirmationDetails.newContent,
+                    });
+                }
+                const params = {
+                    sessionId: this.id,
+                    options: toPermissionOptions(confirmationDetails),
+                    toolCall: {
+                        toolCallId: callId,
+                        status: 'pending',
+                        title: invocation.getDescription(),
+                        content,
+                        locations: invocation.toolLocations(),
+                        kind: tool.kind,
+                    },
+                };
+                const output = await this.client.requestPermission(params);
+                const outcome = output.outcome.outcome === 'cancelled'
+                    ? ToolConfirmationOutcome.Cancel
+                    : z
+                        .nativeEnum(ToolConfirmationOutcome)
+                        .parse(output.outcome.optionId);
+                await confirmationDetails.onConfirm(outcome);
+                switch (outcome) {
+                    case ToolConfirmationOutcome.Cancel:
+                        return errorResponse(new Error(`Tool "${fc.name}" was canceled by the user.`));
+                    case ToolConfirmationOutcome.ProceedOnce:
+                    case ToolConfirmationOutcome.ProceedAlways:
+                    case ToolConfirmationOutcome.ProceedAlwaysServer:
+                    case ToolConfirmationOutcome.ProceedAlwaysTool:
+                    case ToolConfirmationOutcome.ModifyWithEditor:
+                        break;
+                    default: {
+                        const resultOutcome = outcome;
+                        throw new Error(`Unexpected: ${resultOutcome}`);
+                    }
+                }
             }
-            const params = {
-                sessionId: this.id,
-                options: toPermissionOptions(confirmationDetails),
-                toolCall: {
+            else {
+                await this.sendUpdate({
+                    sessionUpdate: 'tool_call',
                     toolCallId: callId,
-                    status: 'pending',
+                    status: 'in_progress',
                     title: invocation.getDescription(),
-                    content,
+                    content: [],
                     locations: invocation.toolLocations(),
                     kind: tool.kind,
-                },
-            };
-            const output = await this.client.requestPermission(params);
-            const outcome = output.outcome.outcome === 'cancelled'
-                ? ToolConfirmationOutcome.Cancel
-                : z
-                    .nativeEnum(ToolConfirmationOutcome)
-                    .parse(output.outcome.optionId);
-            await confirmationDetails.onConfirm(outcome);
-            switch (outcome) {
-                case ToolConfirmationOutcome.Cancel:
-                    return errorResponse(new Error(`Tool "${fc.name}" was canceled by the user.`));
-                case ToolConfirmationOutcome.ProceedOnce:
-                case ToolConfirmationOutcome.ProceedAlways:
-                case ToolConfirmationOutcome.ProceedAlwaysServer:
-                case ToolConfirmationOutcome.ProceedAlwaysTool:
-                case ToolConfirmationOutcome.ModifyWithEditor:
-                    break;
-                default: {
-                    const resultOutcome = outcome;
-                    throw new Error(`Unexpected: ${resultOutcome}`);
-                }
+                });
             }
-        }
-        else {
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call',
-                toolCallId: callId,
-                status: 'in_progress',
-                title: invocation.getDescription(),
-                content: [],
-                locations: invocation.toolLocations(),
-                kind: tool.kind,
-            });
-        }
-        try {
             const toolResult = await invocation.execute(abortSignal);
             const content = toToolCallContent(toolResult);
             await this.sendUpdate({
@@ -344,7 +547,21 @@ class Session {
                     ? 'mcp'
                     : 'native',
             });
-            return convertToFunctionResponse(fc.name, callId, toolResult.llmContent);
+            // Return paired function call and function response like the TUI does
+            // This ensures proper conversation history for providers that need it (like Anthropic)
+            const functionResponseParts = convertToFunctionResponse(fc.name, callId, toolResult.llmContent);
+            return [
+                {
+                    functionCall: {
+                        id: callId,
+                        name: fc.name,
+                        args,
+                    },
+                },
+                ...(Array.isArray(functionResponseParts)
+                    ? functionResponseParts
+                    : [functionResponseParts]),
+            ];
         }
         catch (e) {
             const error = e instanceof Error ? e : new Error(String(e));
@@ -360,41 +577,53 @@ class Session {
         }
     }
     async #resolvePrompt(message, abortSignal) {
+        const FILE_URI_SCHEME = 'file://';
+        const embeddedContext = [];
         const parts = message.map((part) => {
             switch (part.type) {
                 case 'text':
                     return { text: part.text };
-                case 'resource_link':
+                case 'image':
+                case 'audio':
                     return {
-                        fileData: {
-                            mimeData: part.mimeType,
-                            name: part.name,
-                            fileUri: part.uri,
+                        inlineData: {
+                            mimeType: part.mimeType,
+                            data: part.data,
                         },
                     };
+                case 'resource_link': {
+                    if (part.uri.startsWith(FILE_URI_SCHEME)) {
+                        return {
+                            fileData: {
+                                mimeData: part.mimeType,
+                                name: part.name,
+                                fileUri: part.uri.slice(FILE_URI_SCHEME.length),
+                            },
+                        };
+                    }
+                    else {
+                        return { text: `@${part.uri}` };
+                    }
+                }
                 case 'resource': {
-                    return {
-                        fileData: {
-                            mimeData: part.resource.mimeType,
-                            name: part.resource.uri,
-                            fileUri: part.resource.uri,
-                        },
-                    };
+                    embeddedContext.push(part.resource);
+                    return { text: `@${part.resource.uri}` };
                 }
                 default: {
-                    throw new Error(`Unexpected chunk type: '${part.type}'`);
+                    const unreachable = part;
+                    throw new Error(`Unexpected chunk type: '${unreachable}'`);
                 }
             }
         });
         const atPathCommandParts = parts.filter((part) => 'fileData' in part);
-        if (atPathCommandParts.length === 0) {
+        if (atPathCommandParts.length === 0 && embeddedContext.length === 0) {
             return parts;
         }
+        const atPathToResolvedSpecMap = new Map();
         // Get centralized file discovery service
         const fileDiscovery = this.config.getFileService();
         const respectGitIgnore = this.config.getFileFilteringRespectGitIgnore();
         const pathSpecsToRead = [];
-        const atPathToResolvedSpecMap = new Map();
         const contentLabelsForDisplay = [];
         const ignoredPaths = [];
         const toolRegistry = this.config.getToolRegistry();
@@ -527,91 +756,115 @@ class Session {
             const ignoreType = respectGitIgnore ? 'git-ignored' : 'custom-ignored';
             this.debug(`Ignored ${ignoredPaths.length} ${ignoreType} files: ${ignoredPaths.join(', ')}`);
         }
-        // Fallback for lone "@" or completely invalid @-commands resulting in empty initialQueryText
-        if (pathSpecsToRead.length === 0) {
+        const processedQueryParts = [{ text: initialQueryText }];
+        if (pathSpecsToRead.length === 0 && embeddedContext.length === 0) {
+            // Fallback for lone "@" or completely invalid @-commands resulting in empty initialQueryText
             console.warn('No valid file paths found in @ commands to read.');
             return [{ text: initialQueryText }];
         }
-        const processedQueryParts = [{ text: initialQueryText }];
-        const toolArgs = {
-            paths: pathSpecsToRead,
-            respectGitIgnore, // Use configuration setting
-        };
-        const callId = `${readManyFilesTool.name}-${Date.now()}`;
-        try {
-            const invocation = readManyFilesTool.build(toolArgs);
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call',
-                toolCallId: callId,
-                status: 'in_progress',
-                title: invocation.getDescription(),
-                content: [],
-                locations: invocation.toolLocations(),
-                kind: readManyFilesTool.kind,
-            });
-            const result = await invocation.execute(abortSignal);
-            const content = toToolCallContent(result) || {
-                type: 'content',
-                content: {
-                    type: 'text',
-                    text: `Successfully read: ${contentLabelsForDisplay.join(', ')}`,
-                },
+        if (pathSpecsToRead.length > 0) {
+            const toolArgs = {
+                paths: pathSpecsToRead,
+                respectGitIgnore, // Use configuration setting
             };
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call_update',
-                toolCallId: callId,
-                status: 'completed',
-                content: content ? [content] : [],
-            });
-            if (Array.isArray(result.llmContent)) {
-                const fileContentRegex = /^--- (.*?) ---\n\n([\s\S]*?)\n\n$/;
-                processedQueryParts.push({
-                    text: '\n--- Content from referenced files ---',
+            const callId = `${readManyFilesTool.name}-${Date.now()}`;
+            try {
+                const invocation = readManyFilesTool.build(toolArgs);
+                await this.sendUpdate({
+                    sessionUpdate: 'tool_call',
+                    toolCallId: callId,
+                    status: 'in_progress',
+                    title: invocation.getDescription(),
+                    content: [],
+                    locations: invocation.toolLocations(),
+                    kind: readManyFilesTool.kind,
                 });
-                for (const part of result.llmContent) {
-                    if (typeof part === 'string') {
-                        const match = fileContentRegex.exec(part);
-                        if (match) {
-                            const filePathSpecInContent = match[1]; // This is a resolved pathSpec
-                            const fileActualContent = match[2].trim();
-                            processedQueryParts.push({
-                                text: `\nContent from @${filePathSpecInContent}:\n`,
-                            });
-                            processedQueryParts.push({ text: fileActualContent });
+                const result = await invocation.execute(abortSignal);
+                const content = toToolCallContent(result) || {
+                    type: 'content',
+                    content: {
+                        type: 'text',
+                        text: `Successfully read: ${contentLabelsForDisplay.join(', ')}`,
+                    },
+                };
+                await this.sendUpdate({
+                    sessionUpdate: 'tool_call_update',
+                    toolCallId: callId,
+                    status: 'completed',
+                    content: content ? [content] : [],
+                });
+                if (Array.isArray(result.llmContent)) {
+                    const fileContentRegex = /^--- (.*?) ---\n\n([\s\S]*?)\n\n$/;
+                    processedQueryParts.push({
+                        text: '\n--- Content from referenced files ---',
+                    });
+                    for (const part of result.llmContent) {
+                        if (typeof part === 'string') {
+                            const match = fileContentRegex.exec(part);
+                            if (match) {
+                                const filePathSpecInContent = match[1]; // This is a resolved pathSpec
+                                const fileActualContent = match[2].trim();
+                                processedQueryParts.push({
+                                    text: `\nContent from @${filePathSpecInContent}:\n`,
+                                });
+                                processedQueryParts.push({ text: fileActualContent });
+                            }
+                            else {
+                                processedQueryParts.push({ text: part });
+                            }
                         }
                         else {
-                            processedQueryParts.push({ text: part });
+                            // part is a Part object.
+                            processedQueryParts.push(part);
                         }
                     }
-                    else {
-                        // part is a Part object.
-                        processedQueryParts.push(part);
-                    }
                 }
-                processedQueryParts.push({ text: '\n--- End of content ---' });
+                else {
+                    console.warn('read_many_files tool returned no content or empty content.');
+                }
             }
-            else {
-                console.warn('read_many_files tool returned no content or empty content.');
+            catch (error) {
+                await this.sendUpdate({
+                    sessionUpdate: 'tool_call_update',
+                    toolCallId: callId,
+                    status: 'failed',
+                    content: [
+                        {
+                            type: 'content',
+                            content: {
+                                type: 'text',
+                                text: `Error reading files (${contentLabelsForDisplay.join(', ')}): ${getErrorMessage(error)}`,
+                            },
+                        },
+                    ],
+                });
+                throw error;
             }
-            return processedQueryParts;
         }
-        catch (error) {
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call_update',
-                toolCallId: callId,
-                status: 'failed',
-                content: [
-                    {
-                        type: 'content',
-                        content: {
-                            type: 'text',
-                            text: `Error reading files (${contentLabelsForDisplay.join(', ')}): ${getErrorMessage(error)}`,
-                        },
-                    },
-                ],
+        if (embeddedContext.length > 0) {
+            processedQueryParts.push({
+                text: '\n--- Content from referenced context ---',
             });
-            throw error;
+            for (const contextPart of embeddedContext) {
+                processedQueryParts.push({
+                    text: `\nContent from @${contextPart.uri}:\n`,
+                });
+                if ('text' in contextPart) {
+                    processedQueryParts.push({
+                        text: contextPart.text,
+                    });
+                }
+                else {
+                    processedQueryParts.push({
+                        inlineData: {
+                            mimeType: contextPart.mimeType ?? 'application/octet-stream',
+                            data: contextPart.blob,
+                        },
+                    });
+                }
+            }
         }
+        return processedQueryParts;
     }
     debug(msg) {
         if (this.config.getDebugMode()) {
@@ -620,6 +873,9 @@ class Session {
     }
 }
 function toToolCallContent(toolResult) {
+    if (toolResult.error?.message) {
+        throw new Error(toolResult.error.message);
+    }
     if (toolResult.returnDisplay) {
         if (typeof toolResult.returnDisplay === 'string') {
             return {