@theia/ai-ide 1.63.0-next.24 → 1.63.0

package/src/browser/summarize-session-command-contribution.ts

@@ -16,12 +16,17 @@
 
 import { ChatAgentLocation, ChatService } from '@theia/ai-chat/lib/common';
 import { CommandContribution, CommandRegistry, CommandService } from '@theia/core';
+import { TaskContextStorageService, TaskContextService } from '@theia/ai-chat/lib/browser/task-context-service';
 import { injectable, inject } from '@theia/core/shared/inversify';
-import { AI_SUMMARIZE_SESSION_AS_TASK_FOR_CODER } from '../common/summarize-session-commands';
-import { TaskContextService } from '@theia/ai-chat/lib/browser/task-context-service';
+import { AI_SUMMARIZE_SESSION_AS_TASK_FOR_CODER, AI_UPDATE_TASK_CONTEXT_COMMAND } from '../common/summarize-session-commands';
 import { CoderAgent } from './coder-agent';
 import { TASK_CONTEXT_VARIABLE } from '@theia/ai-chat/lib/browser/task-context-variable';
-import { ARCHITECT_TASK_SUMMARY_PROMPT_TEMPLATE_ID } from '../common/architect-prompt-template';
+import { ARCHITECT_TASK_SUMMARY_PROMPT_TEMPLATE_ID, ARCHITECT_TASK_SUMMARY_UPDATE_PROMPT_TEMPLATE_ID } from '../common/architect-prompt-template';
+import { FILE_VARIABLE } from '@theia/ai-core/lib/browser/file-variable-contribution';
+import { AIVariableResolutionRequest } from '@theia/ai-core';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { AICommandHandlerFactory } from '@theia/ai-core/lib/browser';
 
 @injectable()
 export class SummarizeSessionCommandContribution implements CommandContribution {
@@ -37,8 +42,39 @@ export class SummarizeSessionCommandContribution implements CommandContribution
     @inject(CoderAgent)
     protected readonly coderAgent: CoderAgent;
 
+    @inject(TaskContextStorageService)
+    protected readonly taskContextStorageService: TaskContextStorageService;
+
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    @inject(WorkspaceService)
+    protected readonly wsService: WorkspaceService;
+
+    @inject(AICommandHandlerFactory)
+    protected readonly commandHandlerFactory: AICommandHandlerFactory;
+
     registerCommands(registry: CommandRegistry): void {
-        registry.registerCommand(AI_SUMMARIZE_SESSION_AS_TASK_FOR_CODER, {
+        registry.registerCommand(AI_UPDATE_TASK_CONTEXT_COMMAND, this.commandHandlerFactory({
+            execute: async () => {
+                const activeSession = this.chatService.getActiveSession();
+
+                if (!activeSession) {
+                    return;
+                }
+
+                // Check if there is an existing summary for this session
+                if (!this.taskContextService.hasSummary(activeSession)) {
+                    // If no summary exists, create one first
+                    await this.taskContextService.summarize(activeSession, ARCHITECT_TASK_SUMMARY_PROMPT_TEMPLATE_ID);
+                } else {
+                    // Update existing summary
+                    await this.taskContextService.update(activeSession, ARCHITECT_TASK_SUMMARY_UPDATE_PROMPT_TEMPLATE_ID);
+                }
+            }
+        }));
+
+        registry.registerCommand(AI_SUMMARIZE_SESSION_AS_TASK_FOR_CODER, this.commandHandlerFactory({
             execute: async () => {
                 const activeSession = this.chatService.getActiveSession();
 
@@ -48,10 +84,30 @@ export class SummarizeSessionCommandContribution implements CommandContribution
 
                 const summaryId = await this.taskContextService.summarize(activeSession, ARCHITECT_TASK_SUMMARY_PROMPT_TEMPLATE_ID);
 
-                const newSession = this.chatService.createSession(ChatAgentLocation.Panel, { focus: true }, this.coderAgent);
-                const summaryVariable = { variable: TASK_CONTEXT_VARIABLE, arg: summaryId };
-                newSession.model.context.addVariables(summaryVariable);
+                // Open the summary in a new editor
+                await this.taskContextStorageService.open(summaryId);
+
+                // Add the summary file to the context of the active Architect session
+                const summary = this.taskContextService.getAll().find(s => s.id === summaryId);
+                if (summary?.uri) {
+                    if (await this.fileService.exists(summary?.uri)) {
+                        const wsRelativePath = await this.wsService.getWorkspaceRelativePath(summary?.uri);
+                        // Create a file variable for the summary
+                        const fileVariable: AIVariableResolutionRequest = {
+                            variable: FILE_VARIABLE,
+                            arg: wsRelativePath
+                        };
+
+                        // Add the file to the active session's context
+                        activeSession.model.context.addVariables(fileVariable);
+                    }
+
+                    // Create a new session with the coder agent
+                    const newSession = this.chatService.createSession(ChatAgentLocation.Panel, { focus: true }, this.coderAgent);
+                    const summaryVariable = { variable: TASK_CONTEXT_VARIABLE, arg: summaryId };
+                    newSession.model.context.addVariables(summaryVariable);
+                }
             }
-        });
+        }));
     }
 }

package/src/browser/task-context-file-storage-service.ts

@@ -17,7 +17,7 @@
 import { Summary, SummaryMetadata, TaskContextStorageService } from '@theia/ai-chat/lib/browser/task-context-service';
 import { InMemoryTaskContextStorage } from '@theia/ai-chat/lib/browser/task-context-storage-service';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
-import { DisposableCollection, EOL, Emitter, Path, URI, unreachable } from '@theia/core';
+import { DisposableCollection, EOL, Emitter, ILogger, Path, URI, unreachable } from '@theia/core';
 import { PreferenceService, OpenerService, open } from '@theia/core/lib/browser';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
@@ -33,10 +33,16 @@ export class TaskContextFileStorageService implements TaskContextStorageService
     @inject(WorkspaceService) protected readonly workspaceService: WorkspaceService;
     @inject(FileService) protected readonly fileService: FileService;
     @inject(OpenerService) protected readonly openerService: OpenerService;
+    @inject(ILogger) protected readonly logger: ILogger;
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange = this.onDidChangeEmitter.event;
 
-    protected getStorageLocation(): URI | undefined {
+    protected sanitizeLabel(label: string): string {
+        return label.replace(/^[^\p{L}\p{N}]+/vg, '');
+    }
+
+    protected async getStorageLocation(): Promise<URI | undefined> {
+        await this.workspaceService.ready;
         if (!this.workspaceService.opened) { return; }
         const values = this.preferenceService.inspect(TASK_CONTEXT_STORAGE_DIRECTORY_PREF);
         const configuredPath = values?.globalValue === undefined ? values?.defaultValue : values?.globalValue;
@@ -47,9 +53,11 @@ export class TaskContextFileStorageService implements TaskContextStorageService
 
     @postConstruct()
     protected init(): void {
-        this.watchStorage();
+        this.watchStorage().catch(error => this.logger.error(error));
         this.preferenceService.onPreferenceChanged(e => {
-            if (e.affects(TASK_CONTEXT_STORAGE_DIRECTORY_PREF)) { this.watchStorage(); }
+            if (e.affects(TASK_CONTEXT_STORAGE_DIRECTORY_PREF)) {
+                this.watchStorage().catch(error => this.logger.error(error));
+            }
         });
     }
 
@@ -57,7 +65,7 @@ export class TaskContextFileStorageService implements TaskContextStorageService
     protected async watchStorage(): Promise<void> {
         this.toDisposeOnStorageChange?.dispose();
         this.toDisposeOnStorageChange = undefined;
-        const newStorage = this.getStorageLocation();
+        const newStorage = await this.getStorageLocation();
         if (!newStorage) { return; }
         this.toDisposeOnStorageChange = new DisposableCollection(
             this.fileService.watch(newStorage, { recursive: true, excludes: [] }),
@@ -109,10 +117,11 @@ export class TaskContextFileStorageService implements TaskContextStorageService
         const content = await this.fileService.read(uri).then(read => read.value).catch(() => undefined);
         if (content === undefined) { return; }
         const { frontmatter, body } = this.maybeReadFrontmatter(content);
+        const rawLabel = frontmatter?.label || uri.path.base.slice(0, (-1 * uri.path.ext.length) || uri.path.base.length);
         const summary = {
             ...frontmatter,
             summary: body,
-            label: frontmatter?.label || uri.path.base.slice(0, (-1 * uri.path.ext.length) || uri.path.base.length),
+            label: this.sanitizeLabel(rawLabel),
             uri,
             id: frontmatter?.sessionId || uri.path.base
         };
@@ -124,21 +133,22 @@ export class TaskContextFileStorageService implements TaskContextStorageService
     }
 
     async store(summary: Summary): Promise<void> {
-        const storageLocation = this.getStorageLocation();
+        const label = this.sanitizeLabel(summary.label);
+        const storageLocation = await this.getStorageLocation();
         if (storageLocation) {
             const frontmatter = {
                 sessionId: summary.sessionId,
                 date: new Date().toISOString(),
-                label: summary.label,
+                label,
             };
-            const derivedName = summary.label.trim().replace(/[^\p{L}\p{N}]/vg, '-').replace(/^-+|-+$/g, '');
+            const derivedName = label.trim().replace(/[^\p{L}\p{N}]/vg, '-').replace(/^-+|-+$/g, '');
             const filename = (derivedName.length > 32 ? derivedName.slice(0, derivedName.indexOf('-', 32)) : derivedName) + '.md';
             const content = yaml.dump(frontmatter).trim() + `${EOL}---${EOL}` + summary.summary;
             const uri = storageLocation.resolve(filename);
             summary.uri = uri;
             await this.fileService.writeFile(uri, BinaryBuffer.fromString(content));
         }
-        this.inMemoryStorage.store(summary);
+        this.inMemoryStorage.store({ ...summary, label });
         this.onDidChangeEmitter.fire();
     }
 

package/src/browser/workspace-preferences.ts

@@ -19,6 +19,7 @@ import { PreferenceSchema } from '@theia/core/lib/browser/preferences/preference
 
 export const CONSIDER_GITIGNORE_PREF = 'ai-features.workspaceFunctions.considerGitIgnore';
 export const USER_EXCLUDE_PATTERN_PREF = 'ai-features.workspaceFunctions.userExcludes';
+export const SEARCH_IN_WORKSPACE_MAX_RESULTS_PREF = 'ai-features.workspaceFunctions.searchMaxResults';
 export const PROMPT_TEMPLATE_WORKSPACE_DIRECTORIES_PREF = 'ai-features.promptTemplates.WorkspaceTemplateDirectories';
 export const PROMPT_TEMPLATE_ADDITIONAL_EXTENSIONS_PREF = 'ai-features.promptTemplates.TemplateExtensions';
 export const PROMPT_TEMPLATE_WORKSPACE_FILES_PREF = 'ai-features.promptTemplates.WorkspaceTemplateFiles';
@@ -46,6 +47,14 @@ export const WorkspacePreferencesSchema: PreferenceSchema = {
                 type: 'string'
             }
         },
+        [SEARCH_IN_WORKSPACE_MAX_RESULTS_PREF]: {
+            type: 'number',
+            title: nls.localize('theia/ai/workspace/searchMaxResults/title', 'Maximum Search Results'),
+            description: nls.localize('theia/ai/workspace/searchMaxResults/description',
+                'Maximum number of search results returned by the workspace search function.'),
+            default: 30,
+            minimum: 1
+        },
         [PROMPT_TEMPLATE_WORKSPACE_DIRECTORIES_PREF]: {
             type: 'array',
             title: nls.localize('theia/ai/promptTemplates/directories/title', 'Workspace-specific Prompt Template Directories'),

package/src/browser/workspace-search-provider.spec.ts

@@ -0,0 +1,255 @@
+// *****************************************************************************
+// 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 { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { URI } from '@theia/core';
+import { SearchInWorkspaceResult, LinePreview } from '@theia/search-in-workspace/lib/common/search-in-workspace-interface';
+import { optimizeSearchResults } from '../common/workspace-search-provider-util';
+
+disableJSDOM();
+
+describe('WorkspaceSearchProvider - Token Optimization', () => {
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    describe('optimizeSearchResults method', () => {
+        it('should preserve all information while optimizing format', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/src/test.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 5,
+                            length: 8,
+                            lineText: '  const test = "hello";  '
+                        },
+                        {
+                            line: 5,
+                            character: 10,
+                            length: 4,
+                            lineText: '\t\tfunction test() { }\n'
+                        }
+                    ]
+                },
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/lib/utils.js',
+                    matches: [
+                        {
+                            line: 10,
+                            character: 0,
+                            length: 6,
+                            lineText: 'export default function() {}'
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result).to.have.length(2);
+
+            // First file
+            expect(result[0]).to.deep.equal({
+                file: 'src/test.ts',
+                matches: [
+                    {
+                        line: 1,
+                        text: 'const test = "hello";'
+                    },
+                    {
+                        line: 5,
+                        text: 'function test() { }'
+                    }
+                ]
+            });
+
+            // Second file
+            expect(result[1]).to.deep.equal({
+                file: 'lib/utils.js',
+                matches: [
+                    {
+                        line: 10,
+                        text: 'export default function() {}'
+                    }
+                ]
+            });
+        });
+
+        it('should handle LinePreview objects correctly', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const linePreview: LinePreview = {
+                text: '  preview text with spaces  ',
+                character: 5
+            };
+
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/preview.ts',
+                    matches: [
+                        {
+                            line: 3,
+                            character: 5,
+                            length: 7,
+                            lineText: linePreview
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result[0].matches[0]).to.deep.equal({
+                line: 3,
+                text: 'preview text with spaces'
+            });
+        });
+
+        it('should handle empty LinePreview text gracefully', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const linePreview: LinePreview = {
+                text: '',
+                character: 0
+            };
+
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/empty.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 0,
+                            length: 0,
+                            lineText: linePreview
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result[0].matches[0]).to.deep.equal({
+                line: 1,
+                text: ''
+            });
+        });
+
+        it('should preserve semantic whitespace within lines', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/spaces.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 0,
+                            length: 20,
+                            lineText: '  if (a    &&    b) {  '
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result[0].matches[0].text).to.equal('if (a    &&    b) {');
+        });
+
+        it('should use absolute URI when relative path cannot be determined', () => {
+            const workspaceRoot = new URI('file:///different-workspace');
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/outside.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 0,
+                            length: 4,
+                            lineText: 'test'
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result[0].file).to.equal('file:///workspace/outside.ts');
+        });
+    });
+
+    describe('token efficiency validation', () => {
+        it('should produce more compact JSON than original format', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/src/test.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 5,
+                            length: 8,
+                            lineText: '  const test = "hello";  '
+                        }
+                    ]
+                }
+            ];
+
+            // Original format (simulated)
+            const originalFormat = JSON.stringify([{
+                root: 'file:///workspace',
+                fileUri: 'file:///workspace/src/test.ts',
+                matches: [{
+                    line: 1,
+                    character: 5,
+                    length: 8,
+                    lineText: '  const test = "hello";  '
+                }]
+            }]);
+
+            // Optimized format
+            const optimizedResults = optimizeSearchResults(mockResults, workspaceRoot);
+            const optimizedFormat = JSON.stringify(optimizedResults);
+
+            // The optimized format should be significantly shorter
+            expect(optimizedFormat.length).to.be.lessThan(originalFormat.length);
+
+            // But should preserve essential information
+            const parsed = JSON.parse(optimizedFormat);
+            expect(parsed[0].file).to.equal('src/test.ts');
+            expect(parsed[0].matches[0].line).to.equal(1);
+            expect(parsed[0].matches[0].text).to.equal('const test = "hello";');
+        });
+    });
+});

package/src/browser/workspace-search-provider.ts

@@ -16,12 +16,16 @@
 
 import { MutableChatRequestModel } from '@theia/ai-chat';
 import { ToolProvider, ToolRequest } from '@theia/ai-core';
-import { CancellationToken, URI } from '@theia/core';
+import { CancellationToken } from '@theia/core';
+import { PreferenceService } from '@theia/core/lib/browser/preferences/preference-service';
 import { inject, injectable } from '@theia/core/shared/inversify';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { SearchInWorkspaceService, SearchInWorkspaceCallbacks } from '@theia/search-in-workspace/lib/browser/search-in-workspace-service';
 import { SearchInWorkspaceResult, SearchInWorkspaceOptions } from '@theia/search-in-workspace/lib/common/search-in-workspace-interface';
 import { SEARCH_IN_WORKSPACE_FUNCTION_ID } from '../common/workspace-functions';
 import { WorkspaceFunctionScope } from './workspace-functions';
+import { SEARCH_IN_WORKSPACE_MAX_RESULTS_PREF } from './workspace-preferences';
+import { optimizeSearchResults } from '../common/workspace-search-provider-util';
 
 @injectable()
 export class WorkspaceSearchProvider implements ToolProvider {
@@ -32,7 +36,11 @@ export class WorkspaceSearchProvider implements ToolProvider {
     @inject(WorkspaceFunctionScope)
     protected readonly workspaceScope: WorkspaceFunctionScope;
 
-    private readonly MAX_RESULTS = 50;
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    @inject(FileService)
+    protected readonly fileService: FileService;
 
     getTool(): ToolRequest {
         return {
@@ -42,7 +50,7 @@ export class WorkspaceSearchProvider implements ToolProvider {
             The search uses case-insensitive string matching or regular expressions (controlled by the `useRegExp` parameter). \
             It returns a list of matching files, including the file path (URI), the line number, and the full text content of each matching line. \
             Multi-word patterns must match exactly (including spaces, case-insensitively). \
-            For best results, use specific search terms and consider filtering by file extensions to avoid overwhelming results. \
+            For best results, use specific search terms and consider filtering by file extensions or limiting to specific subdirectories to avoid overwhelming results. \
             For complex searches, prefer multiple simpler queries over one complex query or regular expression.',
             parameters: {
                 type: 'object',
@@ -61,6 +69,11 @@ export class WorkspaceSearchProvider implements ToolProvider {
                             type: 'string'
                         },
                         description: 'Optional array of file extensions to search in (e.g., ["ts", "js", "py"]). If not specified, searches all files.'
+                    },
+                    subDirectoryPath: {
+                        type: 'string',
+                        description: 'Optional subdirectory path to limit search scope. Use relative paths from workspace root ' +
+                            '(e.g., "packages/ai-ide/src", "packages/core/src/browser"). If not specified, searches entire workspace.'
                     }
                 },
                 required: ['query', 'useRegExp']
@@ -69,14 +82,36 @@ export class WorkspaceSearchProvider implements ToolProvider {
         };
     }
 
+    private async determineSearchRoots(subDirectoryPath?: string): Promise<string[]> {
+        const workspaceRoot = await this.workspaceScope.getWorkspaceRoot();
+
+        if (!subDirectoryPath) {
+            return [workspaceRoot.toString()];
+        }
+
+        const subDirUri = workspaceRoot.resolve(subDirectoryPath);
+        this.workspaceScope.ensureWithinWorkspace(subDirUri, workspaceRoot);
+
+        try {
+            const stat = await this.fileService.resolve(subDirUri);
+            if (!stat || !stat.isDirectory) {
+                throw new Error(`Subdirectory '${subDirectoryPath}' does not exist or is not a directory`);
+            }
+        } catch (error) {
+            throw new Error(`Invalid subdirectory path '${subDirectoryPath}': ${error.message}`);
+        }
+
+        return [subDirUri.toString()];
+    }
+
     private async handleSearch(argString: string, cancellationToken?: CancellationToken): Promise<string> {
         try {
-            const args: { query: string, useRegExp: boolean, fileExtensions?: string[] } = JSON.parse(argString);
+            const args: { query: string, useRegExp: boolean, fileExtensions?: string[], subDirectoryPath?: string } = JSON.parse(argString);
             const results: SearchInWorkspaceResult[] = [];
             let expectedSearchId: number | undefined;
             let searchCompleted = false;
 
-            const searchPromise = new Promise<SearchInWorkspaceResult[]>((resolve, reject) => {
+            const searchPromise = new Promise<SearchInWorkspaceResult[]>(async (resolve, reject) => {
                 const callbacks: SearchInWorkspaceCallbacks = {
                     onResult: (id, result) => {
                         if (expectedSearchId !== undefined && id !== expectedSearchId) {
@@ -100,25 +135,28 @@ export class WorkspaceSearchProvider implements ToolProvider {
 
                         searchCompleted = true;
                         if (error) {
-                            reject(new Error(`Search failed: ${error}`));
+                            reject(new Error('Search failed: ' + error));
                         } else {
                             resolve(results);
                         }
                     }
                 };
 
+                // Use one more than our actual maximum. this way we can determine if we have more results than our maximum and warn the user
+                const maxResultsForTheiaAPI = this.preferenceService.get<number>(SEARCH_IN_WORKSPACE_MAX_RESULTS_PREF, 30) + 1;
                 const options: SearchInWorkspaceOptions = {
                     useRegExp: args.useRegExp,
                     matchCase: false,
                     matchWholeWord: false,
-                    maxResults: this.MAX_RESULTS,
+                    maxResults: maxResultsForTheiaAPI,
                 };
 
                 if (args.fileExtensions && args.fileExtensions.length > 0) {
                     options.include = args.fileExtensions.map(ext => `**/*.${ext}`);
                 }
 
-                this.searchService.search(args.query, callbacks, options)
+                await this.determineSearchRoots(args.subDirectoryPath)
+                    .then(rootUris => this.searchService.searchWithCallback(args.query, rootUris, callbacks, options))
                     .then(id => {
                         expectedSearchId = id;
                         cancellationToken?.onCancellationRequested(() => {
@@ -143,16 +181,23 @@ export class WorkspaceSearchProvider implements ToolProvider {
             });
 
             const finalResults = await Promise.race([searchPromise, timeoutPromise]);
+            const maxResults = this.preferenceService.get<number>(SEARCH_IN_WORKSPACE_MAX_RESULTS_PREF, 30);
 
             const workspaceRoot = await this.workspaceScope.getWorkspaceRoot();
-            const formattedResults = finalResults.map(r => {
-                const fileUri = new URI(r.fileUri);
-                const relativePath = workspaceRoot.relative(fileUri);
-                return {
-                    file: relativePath ? relativePath.toString() : r.fileUri,
-                    matches: r.matches.map(m => ({ line: m.line, text: m.lineText }))
-                };
-            });
+            const formattedResults = optimizeSearchResults(finalResults, workspaceRoot);
+
+            let numberOfMatchesInFinalResults = 0;
+            for (const result of finalResults) {
+                numberOfMatchesInFinalResults += result.matches.length;
+            }
+            if (numberOfMatchesInFinalResults > maxResults) {
+                return JSON.stringify({
+                    info: 'Search limit exceeded: Found ' + maxResults + '+ results. ' +
+                        'Please refine your search with more specific terms or use file extension filters. ' +
+                        'You can increase the limit in preferences under \'ai-features.workspaceFunctions.searchMaxResults\'.',
+                    incompleteResults: formattedResults
+                });
+            }
 
             return JSON.stringify(formattedResults);
 
@@ -161,3 +206,4 @@ export class WorkspaceSearchProvider implements ToolProvider {
         }
     }
 }
+