1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// vscode-copilot-chat的Tag组件实现
export class Tag extends PromptElement<TagProps> {
    render() {
        const { name, children, attrs = {} } = this.props;
        return (
            <>
                <KeepWith>{`<${name}${attrStr}>\n`}</KeepWith>
                <TagInner priority={1} flexGrow={1}>{children}<br /></TagInner>
                <KeepWith>{`</${name}>`}</KeepWith>
            </>
        );
    }
}

1
2
3
4
5
6
7

<instructions>
    You are a highly sophisticated automated coding agent with expert-level knowledge...
</instructions>

<toolUseInstructions>
    When using a tool, follow the JSON schema carefully and ensure all required parameters are provided...
</toolUseInstructions>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

<environment_info>
    <UserOSPrompt />
    <UserShellPrompt />
</environment_info>

<workspace_info>
    <WorkspaceFoldersHint />
    <MultirootWorkspaceStructure maxSize={2000} />
</workspace_info>

<context>
    <CurrentDatePrompt />
    <EditedFileEvents />
    <TerminalState />
</context>

1
2
3
4
5
6
7
8

<userRequest priority={900}>
    {query + attachmentHint}
</userRequest>

<reminderInstructions>
    {getKeepGoingReminder(modelFamily)}
    {getEditingReminder(hasEditTool, hasReplaceStringTool)}
</reminderInstructions>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 根据可用工具动态调整提示词内容
const hasReadFileTool = !!availableTools?.find(tool => tool.name === 'readFile');
const hasTerminalTool = !!availableTools?.find(tool => tool.name === 'runInTerminal');

return (
    <toolUseInstructions>
        {hasReadFileTool && <>When using the readFile tool, prefer reading large sections...</>}
        {hasTerminalTool && <>NEVER print terminal commands, use the runInTerminal tool instead...</>}
    </toolUseInstructions>
);

1
2
3
4
5
6
7
8

const prompt = `
请按以下JSON格式返回结果：
{
  "action": "create|edit|delete",
  "filePath": "文件路径",
  "content": "文件内容"
}
`;

1
2
3
4
5
6
7
8

❌ AI经常返回：
```json
{
  "action": "create",
  "filePath": "/test.js"
  // 突然停止或添加解释文字
}
我觉得这个文件还需要...

1
2
3

{
  action: "create"  // 缺少引号
  "filePath": "/test.js",  // 多余逗号

1
2
3
4
5
6
7
8

<outputFormat>
    Always respond in this format:
    <action>create|edit|delete</action>
    <filePath>/path/to/file</filePath>
    <content>
        // 文件内容
    </content>
</outputFormat>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 相对可靠的解析
function parseTagResponse(response) {
    const actionMatch = response.match(/<action>(.*?)<\/action>/);
    const pathMatch = response.match(/<filePath>(.*?)<\/filePath>/);
    const contentMatch = response.match(/<content>(.*?)<\/content>/s);

    return {
        action: actionMatch?.[1],
        filePath: pathMatch?.[1],
        content: contentMatch?.[1]
    };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

const toolSchema: vscode.LanguageModelToolInformation = {
    name: 'editFile',
    description: 'Edit a file with specific changes',
    inputSchema: {
        type: 'object',
        required: ['filePath', 'action'],
        properties: {
            filePath: {
                type: 'string',
                description: '文件绝对路径'
            },
            action: {
                type: 'string',
                enum: ['create', 'edit', 'delete'],
                description: '操作类型'
            },
            content: {
                type: 'string',
                description: '文件内容'
            }
        }
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class EditFileTool implements ICopilotTool<EditFileParams> {
    async invoke(options: vscode.LanguageModelToolInvocationOptions<EditFileParams>) {
        // 1. 自动验证输入参数（Schema强制约束）
        const { filePath, action, content } = options.input;

        // 2. 执行实际操作
        switch (action) {
            case 'create':
                await this.fileSystem.writeFile(filePath, content);
                break;
            case 'edit':
                await this.applyEdits(filePath, content);
                break;
            case 'delete':
                await this.fileSystem.deleteFile(filePath);
                break;
        }

        // 3. 返回结构化结果
        return new LanguageModelToolResult([
            new LanguageModelPromptTsxPart(
                <EditResult
                    operation={action}
                    filePath={filePath}
                    success={true}
                />
            )
        ]);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 统一的工具注册机制
export const ToolRegistry = new class {
    private _tools: ICopilotToolCtor[] = [];

    public registerTool(tool: ICopilotToolCtor) {
        this._tools.push(tool);
    }

    public getTools(): readonly ICopilotToolCtor[] {
        return this._tools;
    }
}();

// 注册工具
ToolRegistry.registerTool(ReadFileTool);
ToolRegistry.registerTool(CreateFileTool);
ToolRegistry.registerTool(EditFileTool);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

interface ICopilotTool<T> extends vscode.LanguageModelTool<T> {
    // 主执行方法
    invoke(options: vscode.LanguageModelToolInvocationOptions<T>): Promise<vscode.LanguageModelToolResult>;

    // 调用准备（显示进度等）
    prepareInvocation?(options: vscode.LanguageModelToolInvocationPrepareOptions<T>): vscode.ProviderResult<vscode.PreparedToolInvocation>;

    // 输入解析和验证
    resolveInput?(input: T, promptContext: IBuildPromptContext): Promise<T>;

    // 编辑确认过滤
    filterEdits?(resource: URI): Promise<IEditFilterData | undefined>;
}

1
2
3
4
5

import './readFileTool';          // 读取文件内容
import './createFileTool';        // 创建新文件
import './replaceStringTool';     // 字符串替换
import './applyPatchTool';        // 应用代码补丁
import './listDirTool';           // 列出目录内容

1
2
3
4

import './findFilesTool';         // 查找文件
import './findTextInFilesTool';   // 文本搜索
import './searchWorkspaceSymbolsTool'; // 符号搜索
import './codebaseTool';          // 代码库语义搜索

1
2
3
4

import './runTestsTool';          // 运行测试
import './runInTerminalTool';     // 终端命令执行
import './getErrorsTool';         // 获取错误信息
import './scmChangesTool';        // Git变更查看

1
2
3

import './insertEditTool';        // 插入编辑
import './editNotebookTool';      // Notebook编辑
import './newWorkspaceTool';      // 创建工作区

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

interface ComplexEditParams {
    files: Array<{
        path: string;
        operation: 'create' | 'edit' | 'delete';
        changes: Array<{
            startLine: number;
            endLine: number;
            newContent: string;
            reason: string;
        }>;
        metadata: {
            language: string;
            encoding: string;
            backup: boolean;
        };
    }>;
    batchOperation: {
        transactional: boolean;
        rollbackOnError: boolean;
        confirmEachFile: boolean;
    };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

async invoke(options: LanguageModelToolInvocationOptions<EditParams>) {
    // 1. 显示进度
    this.progressReporter.report({ message: 'Reading target file...' });

    // 2. 执行操作
    const result = await this.applyEdits(options.input);

    // 3. 实时反馈
    this.streamReporter.textEdit(uri, true);

    // 4. 返回丰富结果
    return new LanguageModelToolResult([
        new LanguageModelPromptTsxPart(
            <EditResult
                files={result.modifiedFiles}
                diagnostics={result.diagnostics}
                suggestions={result.suggestions}
            />
        )
    ]);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

try {
    const result = await this.performEdit(params);
    this.telemetryService.logSuccess('editFile', params);
    return result;
} catch (error) {
    // 详细错误分类
    if (error instanceof FileNotFoundError) {
        return new LanguageModelToolResult([
            new LanguageModelTextPart(`File not found: ${params.filePath}. Use createFile tool instead.`)
        ]);
    } else if (error instanceof PermissionError) {
        return new LanguageModelToolResult([
            new LanguageModelTextPart(`Permission denied. Please check file permissions.`)
        ]);
    }

    // 遥测和回退
    this.telemetryService.logError('editFile', error, params);
    throw error;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 使用Tag组织复杂提示词
<instructions>
    You are a sophisticated coding assistant that helps developers with file operations.
</instructions>

<toolUseInstructions>
    - Use readFile to understand existing code before making changes
    - Use createFile for new files, editFile for modifications
    - Always provide clear descriptions of your changes
    - Group related operations together
</toolUseInstructions>

<context>
    <currentWorkspace>{workspacePath}</currentWorkspace>
    <activeFile>{activeFileName}</activeFile>
    <recentChanges>{recentEditHistory}</recentChanges>
</context>

<availableTools>
    {toolNames.map(name => `- ${name}: ${toolDescriptions[name]}`).join('\n')}
</availableTools>

<userRequest>
    {userQuery}
</userRequest>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// 精确的Schema定义
const editFileSchema: vscode.LanguageModelToolInformation = {
    name: 'editFile',
    description: 'Apply specific edits to an existing file',
    inputSchema: {
        type: 'object',
        required: ['filePath', 'edits'],
        properties: {
            filePath: {
                type: 'string',
                description: 'Absolute path to the file to edit'
            },
            description: {
                type: 'string',
                description: 'Brief description of what changes are being made (max 100 chars)',
                maxLength: 100
            },
            edits: {
                type: 'array',
                description: 'Array of specific edits to apply',
                items: {
                    type: 'object',
                    required: ['startLine', 'endLine', 'newContent'],
                    properties: {
                        startLine: {
                            type: 'number',
                            minimum: 1,
                            description: '1-based line number where edit starts'
                        },
                        endLine: {
                            type: 'number',
                            minimum: 1,
                            description: '1-based line number where edit ends (inclusive)'
                        },
                        newContent: {
                            type: 'string',
                            description: 'New content to replace the specified lines'
                        }
                    }
                }
            }
        }
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

class EditFileTool implements ICopilotTool<EditFileParams> {
    async invoke(options: vscode.LanguageModelToolInvocationOptions<EditFileParams>) {
        const { filePath, description, edits } = options.input;

        // 1. 验证和准备
        const uri = this.resolveFilePath(filePath);
        const document = await this.loadDocument(uri);

        // 2. 应用编辑
        const results = [];
        for (const edit of edits) {
            const result = await this.applyEdit(document, edit);
            results.push(result);
        }

        // 3. 保存和反馈
        await this.saveDocument(document);
        this.notifyEditorOfChanges(uri);

        // 4. 返回结构化结果
        return new LanguageModelToolResult([
            new LanguageModelPromptTsxPart(
                <EditSummary
                    filePath={filePath}
                    description={description}
                    editsApplied={results.length}
                    success={true}
                    details={results}
                />
            )
        ]);
    }

    async prepareInvocation(options: vscode.LanguageModelToolInvocationPrepareOptions<EditFileParams>) {
        return {
            invocationMessage: new MarkdownString(`✏️ Editing ${this.getFileName(options.input.filePath)}...`),
            pastTenseMessage: new MarkdownString(`✅ Edited ${this.getFileName(options.input.filePath)}`)
        };
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// 完整的交互流程
async function handleUserRequest(query: string) {
    // 1. 构建结构化提示词
    const prompt = (
        <instructions>
            You are a coding assistant. Use the available tools to help the user.
        </instructions>

        <toolUseInstructions>
            - Read files before editing them
            - Provide clear descriptions of changes
            - Use appropriate tools for each task
        </toolUseInstructions>

        <context>
            <workspace>{getCurrentWorkspace()}</workspace>
            <activeFiles>{getActiveFiles()}</activeFiles>
        </context>

        <userRequest>
            {query}
        </userRequest>
    );

    // 2. AI调用工具
    const response = await languageModel.sendRequest(prompt, {
        tools: [readFileSchema, editFileSchema, createFileSchema]
    });

    // 3. 处理工具调用
    for (const toolCall of response.toolCalls) {
        const tool = getToolByName(toolCall.name);
        const result = await tool.invoke({
            input: toolCall.parameters,
            model: response.model,
            chatRequestId: generateId()
        });

        // 4. 展示结果
        displayToolResult(result);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<instructions>
    You are an expert React developer. Help refactor the code using modern React patterns.
</instructions>

<refactoringRules>
    - Convert class components to function components
    - Replace lifecycle methods with appropriate hooks
    - Maintain the same functionality and props interface
    - Use TypeScript if the original code uses it
    - Add proper error boundaries if needed
</refactoringRules>

<context>
    <currentFile>{currentComponentCode}</currentFile>
    <dependencies>{packageJsonDependencies}</dependencies>
    <tsConfig>{typeScriptConfig}</tsConfig>
</context>

<availableTools>
    - readFile: Read the current component file
    - editFile: Apply the refactored code
    - runTests: Verify the refactoring doesn't break tests
</availableTools>

<userRequest>
    {userQuery}
</userRequest>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// AI会调用这些工具
1. readFile({ filePath: '/src/components/UserProfile.tsx' })
2. editFile({
    filePath: '/src/components/UserProfile.tsx',
    description: 'Convert class component to function component with hooks',
    edits: [
        {
            startLine: 1,
            endLine: 50,
            newContent: `import React, { useState, useEffect } from 'react';
import { User } from '../types/User';

interface UserProfileProps {
    userId: string;
    onUserUpdate: (user: User) => void;
}

const UserProfile: React.FC<UserProfileProps> = ({ userId, onUserUpdate }) => {
    const [user, setUser] = useState<User | null>(null);
    const [loading, setLoading] = useState(true);

    useEffect(() => {
        fetchUser(userId).then(userData => {
            setUser(userData);
            setLoading(false);
        });
    }, [userId]);

    // ... rest of component
};

export default UserProfile;`,
            reason: 'Convert class component to functional component with hooks'
        }
    ]
})
3. runTests({ testPattern: '**/UserProfile.test.tsx' })

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

// 1. Tag构建的指导提示
<instructions>
    Create a robust user management API with proper error handling and validation.
</instructions>

<apiRequirements>
    - RESTful endpoints for CRUD operations
    - Input validation using Joi or similar
    - Proper HTTP status codes
    - Error handling middleware
    - Database integration with Prisma/Mongoose
    - Authentication middleware
</apiRequirements>

<context>
    <existingFiles>{currentApiStructure}</existingFiles>
    <databaseSchema>{userSchema}</databaseSchema>
    <framework>Express.js with TypeScript</framework>
</context>

// 2. Function Call执行多个工具
const toolCalls = [
    {
        name: 'createFile',
        parameters: {
            filePath: '/src/routes/users.ts',
            content: `// User routes with full CRUD operations
import express from 'express';
import { UserController } from '../controllers/UserController';
import { validateUser } from '../middleware/validation';
import { authenticate } from '../middleware/auth';

const router = express.Router();
const userController = new UserController();

router.get('/', authenticate, userController.getAllUsers);
router.get('/:id', authenticate, userController.getUserById);
router.post('/', authenticate, validateUser, userController.createUser);
router.put('/:id', authenticate, validateUser, userController.updateUser);
router.delete('/:id', authenticate, userController.deleteUser);

export default router;`
        }
    },
    {
        name: 'createFile',
        parameters: {
            filePath: '/src/controllers/UserController.ts',
            content: `// User controller with business logic and error handling
// ... implementation`
        }
    }
];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// ✅ 好的标签命名
<instructions>         // 清晰的功能指示
<toolUseInstructions>  // 具体的使用说明
<context>             // 上下文信息
<userRequest>         // 用户输入
<outputFormat>        // 输出格式要求

// ❌ 避免的命名
<info>               // 太模糊
<stuff>              // 无意义
<data>               // 不具体

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// ✅ 清晰的层次结构
<context>
    <environment>
        <operatingSystem>{os}</operatingSystem>
        <shell>{shell}</shell>
    </environment>

    <workspace>
        <rootPath>{workspaceRoot}</rootPath>
        <activeFiles>{activeFiles}</activeFiles>
    </workspace>

    <userPreferences>
        <codeStyle>{codeStyle}</codeStyle>
        <framework>{preferredFramework}</framework>
    </userPreferences>
</context>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// ✅ 逻辑分组
<instructions>
    You are a coding assistant specialized in web development.
</instructions>

<capabilities>
    - Create and edit files
    - Run terminal commands
    - Search codebase
    - Generate tests
</capabilities>

<limitations>
    - Cannot access external APIs without tools
    - Cannot modify system settings
    - Must follow security guidelines
</limitations>

<behaviorRules>
    - Always explain your reasoning
    - Ask for clarification when uncertain
    - Provide multiple solutions when appropriate
</behaviorRules>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// ✅ 详细的Schema设计
const toolSchema = {
    name: 'editFile',
    description: 'Edit an existing file with specific changes. Use this for modifications to existing code.',
    inputSchema: {
        type: 'object',
        required: ['filePath', 'edits'],
        properties: {
            filePath: {
                type: 'string',
                description: 'Absolute path to the file (use forward slashes)',
                pattern: '^/.*'  // 路径验证
            },
            description: {
                type: 'string',
                description: 'Brief summary of what changes are being made (max 100 chars)',
                maxLength: 100
            },
            edits: {
                type: 'array',
                minItems: 1,
                maxItems: 20,  // 防止过大的编辑
                items: {
                    type: 'object',
                    required: ['startLine', 'endLine', 'newContent'],
                    properties: {
                        startLine: {
                            type: 'integer',
                            minimum: 1,
                            description: '1-based line number where edit starts'
                        },
                        endLine: {
                            type: 'integer',
                            minimum: 1,
                            description: '1-based line number where edit ends (inclusive)'
                        },
                        newContent: {
                            type: 'string',
                            description: 'New content to replace the specified lines'
                        }
                    }
                }
            }
        }
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

class RobustTool implements ICopilotTool<ToolParams> {
    async invoke(options: LanguageModelToolInvocationOptions<ToolParams>) {
        try {
            // 预验证
            this.validateInput(options.input);

            // 执行操作
            const result = await this.performOperation(options.input);

            // 成功遥测
            this.logSuccess(options);

            return new LanguageModelToolResult([
                new LanguageModelPromptTsxPart(<SuccessResult {...result} />)
            ]);

        } catch (error) {
            // 分类错误处理
            if (error instanceof ValidationError) {
                return new LanguageModelToolResult([
                    new LanguageModelTextPart(`❌ Input validation failed: ${error.message}`)
                ]);
            } else if (error instanceof FileSystemError) {
                return new LanguageModelToolResult([
                    new LanguageModelTextPart(`📁 File system error: ${error.message}. Please check file permissions.`)
                ]);
            } else {
                // 记录未知错误
                this.logError(error, options);
                throw error; // 让系统处理
            }
        }
    }

    private validateInput(input: ToolParams) {
        if (!input.filePath || !input.filePath.startsWith('/')) {
            throw new ValidationError('filePath must be an absolute path starting with /');
        }
        // 更多验证...
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// 批量操作支持
interface BatchEditParams {
    operations: Array<{
        type: 'create' | 'edit' | 'delete';
        filePath: string;
        content?: string;
        edits?: EditOperation[];
    }>;
    transactional: boolean;  // 是否事务性执行
}

class BatchEditTool implements ICopilotTool<BatchEditParams> {
    async invoke(options: LanguageModelToolInvocationOptions<BatchEditParams>) {
        const { operations, transactional } = options.input;

        if (transactional) {
            // 事务性执行：全部成功或全部回滚
            return await this.executeTransactional(operations);
        } else {
            // 并行执行，提高性能
            return await this.executeParallel(operations);
        }
    }

    private async executeParallel(operations: BatchEditParams['operations']) {
        const results = await Promise.allSettled(
            operations.map(op => this.executeOperation(op))
        );

        return new LanguageModelToolResult([
            new LanguageModelPromptTsxPart(
                <BatchResult
                    totalOperations={operations.length}
                    successful={results.filter(r => r.status === 'fulfilled').length}
                    failed={results.filter(r => r.status === 'rejected').length}
                    details={results}
                />
            )
        ]);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// 根据上下文动态调整可用工具
const AdaptivePrompt = ({ userQuery, workspaceType, userSkillLevel }) => {
    const availableTools = selectToolsForContext(workspaceType, userSkillLevel);

    return (
        <instructions>
            You are a coding assistant adapted for {workspaceType} development.
            User skill level: {userSkillLevel}
        </instructions>

        <toolsContext>
            Available tools for this session:
            {availableTools.map(tool =>
                `- ${tool.name}: ${tool.description}`
            ).join('\n')}
        </toolsContext>

        <adaptiveRules>
            {userSkillLevel === 'beginner' &&
                'Provide detailed explanations and suggest best practices.'
            }
            {userSkillLevel === 'expert' &&
                'Focus on efficiency and advanced techniques.'
            }
        </adaptiveRules>

        <userRequest>
            {userQuery}
        </userRequest>
    );
};

function selectToolsForContext(workspaceType: string, skillLevel: string) {
    const baseTools = ['readFile', 'editFile', 'createFile'];

    if (workspaceType === 'react') {
        baseTools.push('generateComponent', 'runTests', 'bundleAnalyzer');
    } else if (workspaceType === 'python') {
        baseTools.push('runPython', 'installPackage', 'lintCode');
    }

    if (skillLevel === 'expert') {
        baseTools.push('refactorCode', 'performanceProfiling', 'securityAnalysis');
    }

    return baseTools.map(name => ToolRegistry.getTool(name));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// 复杂任务的工具链编排
class WorkflowOrchestrator {
    async executeWorkflow(userRequest: string, context: WorkspaceContext) {
        const workflow = this.planWorkflow(userRequest, context);

        for (const step of workflow.steps) {
            const stepResult = await this.executeStep(step);

            // 根据步骤结果调整后续步骤
            workflow.adjustRemainingSteps(stepResult);

            // 向用户报告进度
            this.reportProgress(step, stepResult);
        }

        return workflow.getFinalResult();
    }

    private planWorkflow(request: string, context: WorkspaceContext): Workflow {
        // 使用Tag标签构建规划提示
        const planningPrompt = (
            <planningInstructions>
                Analyze the user request and create a step-by-step plan.
                Consider the current workspace context and available tools.
            </planningInstructions>

            <availableTools>
                {this.getAvailableTools().map(tool => tool.description)}
            </availableTools>

            <workspaceContext>
                {JSON.stringify(context, null, 2)}
            </workspaceContext>

            <userRequest>
                {request}
            </userRequest>

            <outputFormat>
                Return a JSON plan with steps, dependencies, and tool assignments.
            </outputFormat>
        );

        // AI生成执行计划，然后使用Function Call执行
        return this.generateWorkflowPlan(planningPrompt);
    }
}