AI API

AI API 是 Trae IDE 的核心功能之一，提供了强大的人工智能代码生成、分析、聊天助手和智能补全功能。

概述

Trae IDE 的 AI API 让您能够：

生成高质量的代码
分析和重构现有代码
与 AI 助手进行自然语言对话
提供智能代码补全
解释复杂的代码逻辑
自动生成文档和注释

核心接口

AIProvider

AI 提供程序是所有 AI 功能的基础接口。

typescript

interface AIProvider {
  readonly id: string;
  readonly name: string;
  readonly description?: string;
  readonly models: readonly AIModel[];
  
  // 生成代码
  generateCode(request: CodeGenerationRequest): Promise<CodeGenerationResponse>;
  
  // 分析代码
  analyzeCode(request: CodeAnalysisRequest): Promise<CodeAnalysisResponse>;
  
  // 聊天对话
  chat(request: ChatRequest): Promise<ChatResponse>;
  
  // 代码补全
  complete(request: CompletionRequest): Promise<CompletionResponse>;
  
  // 解释代码
  explainCode(request: ExplainRequest): Promise<ExplainResponse>;
}

AIModel

AI 模型定义了可用的人工智能模型。

typescript

interface AIModel {
  readonly id: string;
  readonly name: string;
  readonly provider: string;
  readonly capabilities: AICapability[];
  readonly maxTokens?: number;
  readonly contextWindow?: number;
}

enum AICapability {
  CodeGeneration = 'codeGeneration',
  CodeAnalysis = 'codeAnalysis',
  Chat = 'chat',
  Completion = 'completion',
  Explanation = 'explanation',
  Translation = 'translation',
  Refactoring = 'refactoring'
}

基本使用

typescript

// 获取可用的 AI 提供程序
const providers = TraeAPI.ai.getProviders();
console.log('可用的 AI 提供程序:', providers.map(p => p.name));

// 获取默认提供程序
const defaultProvider = TraeAPI.ai.getDefaultProvider();
if (defaultProvider) {
  console.log('默认提供程序:', defaultProvider.name);
}

// 设置默认提供程序
TraeAPI.ai.setDefaultProvider('openai-gpt4');

// 获取特定提供程序
const openaiProvider = TraeAPI.ai.getProvider('openai');
if (openaiProvider) {
  console.log('OpenAI 模型:', openaiProvider.models.map(m => m.name));
}

代码生成

基础代码生成

typescript

// 简单代码生成
const response = await TraeAPI.ai.generateCode({
  prompt: '创建一个计算阶乘的函数',
  language: 'typescript',
  style: 'functional'
});

console.log('生成的代码:', response.code);
console.log('解释:', response.explanation);

// 带上下文的代码生成
const contextualResponse = await TraeAPI.ai.generateCode({
  prompt: '添加一个验证用户输入的方法',
  language: 'typescript',
  context: {
    existingCode: `
      class UserService {
        private users: User[] = [];
        
        addUser(user: User): void {
          this.users.push(user);
        }
      }
    `,
    fileName: 'user-service.ts',
    cursorPosition: { line: 5, character: 0 }
  }
});

高级代码生成

typescript

// 生成完整的类
const classResponse = await TraeAPI.ai.generateCode({
  prompt: '创建一个用户管理类，包含增删改查功能',
  language: 'typescript',
  options: {
    includeTests: true,
    includeDocumentation: true,
    style: 'object-oriented',
    patterns: ['repository', 'singleton']
  }
});

// 生成 React 组件
const componentResponse = await TraeAPI.ai.generateCode({
  prompt: '创建一个可重用的按钮组件',
  language: 'typescript',
  framework: 'react',
  options: {
    includeProps: true,
    includeStyles: true,
    styleFramework: 'styled-components',
    accessibility: true
  }
});

// 生成 API 端点
const apiResponse = await TraeAPI.ai.generateCode({
  prompt: '创建用户注册的 REST API 端点',
  language: 'typescript',
  framework: 'express',
  options: {
    includeValidation: true,
    includeErrorHandling: true,
    includeTests: true,
    database: 'mongodb'
  }
});

代码生成配置

typescript

interface CodeGenerationRequest {
  prompt: string;
  language: string;
  framework?: string;
  style?: 'functional' | 'object-oriented' | 'procedural';
  context?: {
    existingCode?: string;
    fileName?: string;
    cursorPosition?: Position;
    selectedText?: string;
    projectStructure?: string[];
  };
  options?: {
    includeTests?: boolean;
    includeDocumentation?: boolean;
    includeComments?: boolean;
    includeErrorHandling?: boolean;
    maxLines?: number;
    patterns?: string[];
    styleFramework?: string;
    accessibility?: boolean;
  };
  model?: string;
  temperature?: number;
}

interface CodeGenerationResponse {
  code: string;
  explanation?: string;
  suggestions?: string[];
  tests?: string;
  documentation?: string;
  metadata?: {
    model: string;
    tokensUsed: number;
    confidence: number;
    executionTime: number;
  };
}

代码分析

基础代码分析

typescript

// 分析代码质量
const analysisResponse = await TraeAPI.ai.analyzeCode({
  code: `
    function calculateTotal(items) {
      let total = 0;
      for (let i = 0; i < items.length; i++) {
        total += items[i].price * items[i].quantity;
      }
      return total;
    }
  `,
  language: 'javascript',
  analysisType: ['quality', 'performance', 'security']
});

console.log('分析结果:', analysisResponse.issues);
console.log('建议:', analysisResponse.suggestions);
console.log('评分:', analysisResponse.score);

高级代码分析

typescript

// 复杂性分析
const complexityAnalysis = await TraeAPI.ai.analyzeCode({
  code: sourceCode,
  language: 'typescript',
  analysisType: ['complexity', 'maintainability'],
  options: {
    includeMetrics: true,
    includeRefactoringSuggestions: true,
    checkPatterns: ['solid', 'dry', 'kiss']
  }
});

// 安全性分析
const securityAnalysis = await TraeAPI.ai.analyzeCode({
  code: sourceCode,
  language: 'typescript',
  analysisType: ['security', 'vulnerabilities'],
  options: {
    checkOWASP: true,
    includeFixSuggestions: true,
    severityLevel: 'high'
  }
});

// 性能分析
const performanceAnalysis = await TraeAPI.ai.analyzeCode({
  code: sourceCode,
  language: 'typescript',
  analysisType: ['performance', 'optimization'],
  options: {
    includeBottlenecks: true,
    suggestOptimizations: true,
    targetEnvironment: 'browser'
  }
});

代码分析接口

typescript

interface CodeAnalysisRequest {
  code: string;
  language: string;
  analysisType: AnalysisType[];
  fileName?: string;
  options?: {
    includeMetrics?: boolean;
    includeRefactoringSuggestions?: boolean;
    includeFixSuggestions?: boolean;
    checkPatterns?: string[];
    checkOWASP?: boolean;
    severityLevel?: 'low' | 'medium' | 'high';
    targetEnvironment?: 'node' | 'browser' | 'mobile';
  };
}

enum AnalysisType {
  Quality = 'quality',
  Performance = 'performance',
  Security = 'security',
  Complexity = 'complexity',
  Maintainability = 'maintainability',
  Vulnerabilities = 'vulnerabilities',
  Optimization = 'optimization'
}

interface CodeAnalysisResponse {
  issues: Issue[];
  suggestions: Suggestion[];
  score: QualityScore;
  metrics?: CodeMetrics;
  refactoringSuggestions?: RefactoringSuggestion[];
}

interface Issue {
  type: string;
  severity: 'low' | 'medium' | 'high' | 'critical';
  message: string;
  line?: number;
  column?: number;
  range?: Range;
  fix?: string;
}

聊天集成

基础聊天功能

typescript

// 简单聊天
const chatResponse = await TraeAPI.ai.chat({
  message: '如何在 TypeScript 中实现单例模式？',
  context: 'development'
});

console.log('AI 回复:', chatResponse.message);
console.log('代码示例:', chatResponse.codeExamples);

// 带历史记录的聊天
const conversationResponse = await TraeAPI.ai.chat({
  message: '能否优化这个实现？',
  context: 'development',
  history: [
    { role: 'user', content: '如何实现单例模式？' },
    { role: 'assistant', content: '这里是单例模式的实现...' }
  ],
  attachments: [
    {
      type: 'code',
      content: singletonCode,
      language: 'typescript'
    }
  ]
});

上下文感知聊天

typescript

// 项目上下文聊天
const projectChatResponse = await TraeAPI.ai.chat({
  message: '这个项目的架构有什么问题？',
  context: 'architecture-review',
  projectContext: {
    files: await getProjectFiles(),
    structure: await getProjectStructure(),
    dependencies: await getProjectDependencies(),
    currentFile: editor?.document.fileName
  }
});

// 代码审查聊天
const reviewChatResponse = await TraeAPI.ai.chat({
  message: '请审查这段代码',
  context: 'code-review',
  attachments: [
    {
      type: 'code',
      content: selectedCode,
      language: document.languageId,
      fileName: document.fileName
    }
  ],
  options: {
    includeRefactoringSuggestions: true,
    checkBestPractices: true,
    focusAreas: ['performance', 'security', 'maintainability']
  }
});

聊天接口定义

typescript

interface ChatRequest {
  message: string;
  context?: string;
  history?: ChatMessage[];
  attachments?: Attachment[];
  projectContext?: ProjectContext;
  options?: ChatOptions;
}

interface ChatMessage {
  role: 'user' | 'assistant' | 'system';
  content: string;
  timestamp?: Date;
  metadata?: any;
}

interface Attachment {
  type: 'code' | 'file' | 'image' | 'document';
  content: string;
  language?: string;
  fileName?: string;
  mimeType?: string;
}

interface ChatResponse {
  message: string;
  codeExamples?: CodeExample[];
  suggestions?: string[];
  followUpQuestions?: string[];
  metadata?: {
    model: string;
    confidence: number;
    sources?: string[];
  };
}

代码补全

智能补全

typescript

// 基础代码补全
const completionResponse = await TraeAPI.ai.complete({
  document: editor.document,
  position: editor.selection.active,
  context: {
    prefix: getTextBefore(editor, 100),
    suffix: getTextAfter(editor, 100)
  }
});

// 应用补全
if (completionResponse.completions.length > 0) {
  const completion = completionResponse.completions[0];
  await editor.edit(editBuilder => {
    editBuilder.insert(editor.selection.active, completion.text);
  });
}

高级补全功能

typescript

// 多行补全
const multilineCompletion = await TraeAPI.ai.complete({
  document: editor.document,
  position: editor.selection.active,
  options: {
    maxLines: 10,
    includeImports: true,
    respectIndentation: true,
    completeFunction: true
  }
});

// 类型感知补全
const typeAwareCompletion = await TraeAPI.ai.complete({
  document: editor.document,
  position: editor.selection.active,
  context: {
    typeInformation: await getTypeInformation(editor),
    availableSymbols: await getAvailableSymbols(editor),
    imports: await getImports(editor.document)
  },
  options: {
    useTypeInformation: true,
    suggestImports: true,
    prioritizeLocalSymbols: true
  }
});

补全提供程序

typescript

// 注册自定义补全提供程序
const completionProvider: TraeAPI.CompletionItemProvider = {
  async provideCompletionItems(document, position, token, context) {
    // 获取 AI 补全
    const aiCompletions = await TraeAPI.ai.complete({
      document,
      position,
      context: {
        triggerCharacter: context.triggerCharacter,
        triggerKind: context.triggerKind
      }
    });
    
    // 转换为 VS Code 补全项
    return aiCompletions.completions.map(completion => {
      const item = new TraeAPI.CompletionItem(
        completion.label,
        TraeAPI.CompletionItemKind.Text
      );
      
      item.insertText = completion.text;
      item.detail = completion.description;
      item.documentation = completion.documentation;
      item.sortText = completion.priority.toString();
      
      return item;
    });
  }
};

TraeAPI.languages.registerCompletionItemProvider(
  'typescript',
  completionProvider,
  '.', '(', '['
);

代码解释

基础代码解释

typescript

// 解释选中的代码
const selectedText = editor.document.getText(editor.selection);
const explanation = await TraeAPI.ai.explainCode({
  code: selectedText,
  language: editor.document.languageId,
  level: 'beginner'
});

console.log('代码解释:', explanation.explanation);
console.log('关键概念:', explanation.concepts);
console.log('示例:', explanation.examples);

详细代码解释

typescript

// 深度代码解释
const detailedExplanation = await TraeAPI.ai.explainCode({
  code: complexFunction,
  language: 'typescript',
  level: 'advanced',
  options: {
    includeAlgorithmAnalysis: true,
    includeComplexityAnalysis: true,
    includeOptimizationSuggestions: true,
    explainPatterns: true,
    includeRelatedConcepts: true
  }
});

// 逐行解释
const lineByLineExplanation = await TraeAPI.ai.explainCode({
  code: sourceCode,
  language: 'typescript',
  explanationType: 'line-by-line',
  options: {
    includeVariableTracking: true,
    explainControlFlow: true,
    highlightImportantLines: true
  }
});

解释接口定义

typescript

interface ExplainRequest {
  code: string;
  language: string;
  level?: 'beginner' | 'intermediate' | 'advanced';
  explanationType?: 'overview' | 'detailed' | 'line-by-line';
  options?: {
    includeAlgorithmAnalysis?: boolean;
    includeComplexityAnalysis?: boolean;
    includeOptimizationSuggestions?: boolean;
    explainPatterns?: boolean;
    includeRelatedConcepts?: boolean;
    includeVariableTracking?: boolean;
    explainControlFlow?: boolean;
    highlightImportantLines?: boolean;
  };
}

interface ExplainResponse {
  explanation: string;
  concepts?: Concept[];
  examples?: CodeExample[];
  lineExplanations?: LineExplanation[];
  algorithmAnalysis?: AlgorithmAnalysis;
  optimizationSuggestions?: OptimizationSuggestion[];
}

interface Concept {
  name: string;
  description: string;
  examples?: string[];
  relatedConcepts?: string[];
}

interface LineExplanation {
  line: number;
  explanation: string;
  importance: 'low' | 'medium' | 'high';
  concepts?: string[];
}

高级功能

自定义 AI 模型

typescript

// 注册自定义 AI 提供程序
class CustomAIProvider implements AIProvider {
  readonly id = 'custom-ai';
  readonly name = 'Custom AI Provider';
  readonly models = [
    {
      id: 'custom-model-1',
      name: 'Custom Model 1',
      provider: 'custom-ai',
      capabilities: [AICapability.CodeGeneration, AICapability.Chat],
      maxTokens: 4096
    }
  ];
  
  async generateCode(request: CodeGenerationRequest): Promise<CodeGenerationResponse> {
    // 自定义代码生成逻辑
    const response = await this.callCustomAPI(request);
    return {
      code: response.generatedCode,
      explanation: response.explanation,
      metadata: {
        model: 'custom-model-1',
        tokensUsed: response.tokensUsed,
        confidence: response.confidence,
        executionTime: response.executionTime
      }
    };
  }
  
  async analyzeCode(request: CodeAnalysisRequest): Promise<CodeAnalysisResponse> {
    // 自定义代码分析逻辑
    return await this.performCustomAnalysis(request);
  }
  
  async chat(request: ChatRequest): Promise<ChatResponse> {
    // 自定义聊天逻辑
    return await this.handleCustomChat(request);
  }
  
  async complete(request: CompletionRequest): Promise<CompletionResponse> {
    // 自定义补全逻辑
    return await this.generateCustomCompletions(request);
  }
  
  async explainCode(request: ExplainRequest): Promise<ExplainResponse> {
    // 自定义解释逻辑
    return await this.generateCustomExplanation(request);
  }
  
  private async callCustomAPI(request: any): Promise<any> {
    // 调用自定义 API
    return {};
  }
  
  private async performCustomAnalysis(request: CodeAnalysisRequest): Promise<CodeAnalysisResponse> {
    // 执行自定义分析
    return {
      issues: [],
      suggestions: [],
      score: { overall: 85, quality: 90, performance: 80, security: 85 }
    };
  }
  
  private async handleCustomChat(request: ChatRequest): Promise<ChatResponse> {
    // 处理自定义聊天
    return {
      message: '这是自定义 AI 的回复',
      codeExamples: [],
      suggestions: []
    };
  }
  
  private async generateCustomCompletions(request: CompletionRequest): Promise<CompletionResponse> {
    // 生成自定义补全
    return {
      completions: []
    };
  }
  
  private async generateCustomExplanation(request: ExplainRequest): Promise<ExplainResponse> {
    // 生成自定义解释
    return {
      explanation: '这是自定义的代码解释',
      concepts: [],
      examples: []
    };
  }
}

// 注册提供程序
TraeAPI.ai.registerProvider(new CustomAIProvider());

AI 代码重构

typescript

// 智能重构
const refactorResponse = await TraeAPI.ai.refactor({
  code: legacyCode,
  language: 'javascript',
  targetLanguage: 'typescript',
  refactorType: 'modernize',
  options: {
    addTypeAnnotations: true,
    useModernSyntax: true,
    improvePerformance: true,
    addErrorHandling: true,
    followBestPractices: true
  }
});

// 应用重构
if (refactorResponse.success) {
  await editor.edit(editBuilder => {
    editBuilder.replace(
      new TraeAPI.Range(0, 0, editor.document.lineCount, 0),
      refactorResponse.refactoredCode
    );
  });
  
  // 显示重构说明
  TraeAPI.window.showInformationMessage(
    `重构完成: ${refactorResponse.changes.length} 项更改`
  );
}

AI 代码审查

typescript

// 自动代码审查
const reviewResponse = await TraeAPI.ai.reviewCode({
  code: pullRequestCode,
  language: 'typescript',
  reviewType: 'comprehensive',
  options: {
    checkBestPractices: true,
    checkSecurity: true,
    checkPerformance: true,
    checkMaintainability: true,
    suggestImprovements: true,
    includePositiveFeedback: true
  }
});

// 显示审查结果
const reviewPanel = TraeAPI.window.createWebviewPanel(
  'aiCodeReview',
  'AI 代码审查',
  TraeAPI.ViewColumn.Beside,
  {
    enableScripts: true,
    retainContextWhenHidden: true
  }
);

reviewPanel.webview.html = generateReviewHTML(reviewResponse);

// 代码审查接口
interface CodeReviewRequest {
  code: string;
  language: string;
  reviewType: 'quick' | 'standard' | 'comprehensive';
  options?: {
    checkBestPractices?: boolean;
    checkSecurity?: boolean;
    checkPerformance?: boolean;
    checkMaintainability?: boolean;
    suggestImprovements?: boolean;
    includePositiveFeedback?: boolean;
    focusAreas?: string[];
  };
}

interface CodeReviewResponse {
  overallScore: number;
  issues: ReviewIssue[];
  improvements: ReviewImprovement[];
  positiveFeedback: string[];
  summary: string;
  recommendations: string[];
}

interface ReviewIssue {
  type: 'bug' | 'security' | 'performance' | 'style' | 'maintainability';
  severity: 'low' | 'medium' | 'high' | 'critical';
  title: string;
  description: string;
  line?: number;
  suggestion?: string;
  example?: string;
}

配置

AI 设置

typescript

// 获取 AI 配置
const aiConfig = TraeAPI.workspace.getConfiguration('trae.ai');
const defaultModel = aiConfig.get<string>('defaultModel');
const temperature = aiConfig.get<number>('temperature', 0.7);
const maxTokens = aiConfig.get<number>('maxTokens', 2048);

// 更新 AI 配置
await aiConfig.update('defaultModel', 'gpt-4', TraeAPI.ConfigurationTarget.Global);
await aiConfig.update('temperature', 0.5, TraeAPI.ConfigurationTarget.Workspace);

// 配置 AI 提供程序
const providerConfig = {
  openai: {
    apiKey: await context.secrets.get('openai-api-key'),
    organization: 'your-org-id',
    models: ['gpt-4', 'gpt-3.5-turbo'],
    defaultModel: 'gpt-4'
  },
  anthropic: {
    apiKey: await context.secrets.get('anthropic-api-key'),
    models: ['claude-3', 'claude-2'],
    defaultModel: 'claude-3'
  }
};

TraeAPI.ai.configureProviders(providerConfig);

扩展配置示例

json

{
  "contributes": {
    "configuration": {
      "title": "Trae AI",
      "properties": {
        "trae.ai.defaultProvider": {
          "type": "string",
          "default": "openai",
          "description": "默认的 AI 提供程序",
          "enum": ["openai", "anthropic", "custom"]
        },
        "trae.ai.defaultModel": {
          "type": "string",
          "default": "gpt-4",
          "description": "默认的 AI 模型"
        },
        "trae.ai.temperature": {
          "type": "number",
          "default": 0.7,
          "minimum": 0,
          "maximum": 2,
          "description": "AI 生成的创造性程度"
        },
        "trae.ai.maxTokens": {
          "type": "number",
          "default": 2048,
          "minimum": 1,
          "maximum": 8192,
          "description": "最大令牌数"
        },
        "trae.ai.enableAutoCompletion": {
          "type": "boolean",
          "default": true,
          "description": "启用 AI 自动补全"
        },
        "trae.ai.enableCodeAnalysis": {
          "type": "boolean",
          "default": true,
          "description": "启用 AI 代码分析"
        }
      }
    }
  }
}

错误处理

常见错误处理

typescript

try {
  const response = await TraeAPI.ai.generateCode({
    prompt: 'Create a function',
    language: 'typescript'
  });
  
  console.log('生成的代码:', response.code);
} catch (error) {
  if (error instanceof TraeAPI.AIProviderError) {
    switch (error.code) {
      case 'RATE_LIMIT_EXCEEDED':
        TraeAPI.window.showWarningMessage('AI 服务请求过于频繁，请稍后再试');
        break;
      case 'INVALID_API_KEY':
        TraeAPI.window.showErrorMessage('AI 服务 API 密钥无效，请检查配置');
        break;
      case 'MODEL_NOT_AVAILABLE':
        TraeAPI.window.showErrorMessage('请求的 AI 模型不可用');
        break;
      case 'CONTEXT_TOO_LARGE':
        TraeAPI.window.showErrorMessage('输入内容过长，请减少内容后重试');
        break;
      default:
        TraeAPI.window.showErrorMessage(`AI 服务错误: ${error.message}`);
    }
  } else {
    console.error('未知错误:', error);
    TraeAPI.window.showErrorMessage('发生未知错误，请查看控制台');
  }
}

错误类型定义

typescript

class AIProviderError extends Error {
  constructor(
    public code: string,
    message: string,
    public provider?: string,
    public model?: string
  ) {
    super(message);
    this.name = 'AIProviderError';
  }
}

enum AIErrorCode {
  RATE_LIMIT_EXCEEDED = 'RATE_LIMIT_EXCEEDED',
  INVALID_API_KEY = 'INVALID_API_KEY',
  MODEL_NOT_AVAILABLE = 'MODEL_NOT_AVAILABLE',
  CONTEXT_TOO_LARGE = 'CONTEXT_TOO_LARGE',
  NETWORK_ERROR = 'NETWORK_ERROR',
  TIMEOUT = 'TIMEOUT',
  INVALID_REQUEST = 'INVALID_REQUEST',
  QUOTA_EXCEEDED = 'QUOTA_EXCEEDED'
}

最佳实践

性能优化

缓存 AI 响应

typescript

class AIResponseCache {
  private cache = new Map<string, any>();
  private maxSize = 100;
  
  get(key: string): any {
    return this.cache.get(key);
  }
  
  set(key: string, value: any): void {
    if (this.cache.size >= this.maxSize) {
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }
    this.cache.set(key, value);
  }
  
  generateKey(request: any): string {
    return JSON.stringify(request);
  }
}

const cache = new AIResponseCache();

async function cachedGenerateCode(request: CodeGenerationRequest): Promise<CodeGenerationResponse> {
  const key = cache.generateKey(request);
  const cached = cache.get(key);
  
  if (cached) {
    return cached;
  }
  
  const response = await TraeAPI.ai.generateCode(request);
  cache.set(key, response);
  return response;
}

批量处理

typescript

async function batchAnalyzeFiles(files: string[]): Promise<CodeAnalysisResponse[]> {
  const batchSize = 5;
  const results: CodeAnalysisResponse[] = [];
  
  for (let i = 0; i < files.length; i += batchSize) {
    const batch = files.slice(i, i + batchSize);
    const batchPromises = batch.map(file => 
      TraeAPI.ai.analyzeCode({
        code: fs.readFileSync(file, 'utf8'),
        language: getLanguageFromFile(file),
        analysisType: ['quality', 'security']
      })
    );
    
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // 避免过于频繁的请求
    await new Promise(resolve => setTimeout(resolve, 1000));
  }
  
  return results;
}

智能上下文管理

typescript

class ContextManager {
  private maxContextSize = 4000; // 令牌数
  
  optimizeContext(code: string, cursorPosition: Position): string {
    const lines = code.split('\n');
    const currentLine = cursorPosition.line;
    
    // 优先包含当前行周围的代码
    const contextRadius = 20;
    const start = Math.max(0, currentLine - contextRadius);
    const end = Math.min(lines.length, currentLine + contextRadius);
    
    let context = lines.slice(start, end).join('\n');
    
    // 如果上下文太大，进一步优化
    if (this.estimateTokens(context) > this.maxContextSize) {
      context = this.truncateContext(context);
    }
    
    return context;
  }
  
  private estimateTokens(text: string): number {
    // 简单的令牌估算
    return Math.ceil(text.length / 4);
  }
  
  private truncateContext(context: string): string {
    const lines = context.split('\n');
    const targetLines = Math.floor(this.maxContextSize / 20); // 估算
    
    if (lines.length <= targetLines) {
      return context;
    }
    
    // 保留开头和结尾的行
    const keepStart = Math.floor(targetLines / 2);
    const keepEnd = targetLines - keepStart;
    
    return [
      ...lines.slice(0, keepStart),
      '// ... (省略部分代码) ...',
      ...lines.slice(-keepEnd)
    ].join('\n');
  }
}

用户体验优化

进度指示

typescript

async function generateCodeWithProgress(request: CodeGenerationRequest): Promise<CodeGenerationResponse> {
  return TraeAPI.window.withProgress({
    location: TraeAPI.ProgressLocation.Notification,
    title: 'AI 正在生成代码...',
    cancellable: true
  }, async (progress, token) => {
    progress.report({ increment: 0, message: '准备请求...' });
    
    const response = await TraeAPI.ai.generateCode(request);
    
    if (token.isCancellationRequested) {
      throw new Error('用户取消了操作');
    }
    
    progress.report({ increment: 100, message: '代码生成完成！' });
    return response;
  });
}

智能建议

typescript

class SmartSuggestionProvider {
  async provideSuggestions(context: any): Promise<string[]> {
    const suggestions: string[] = [];
    
    // 基于当前代码提供建议
    if (context.currentCode.includes('TODO')) {
      suggestions.push('使用 AI 完成 TODO 项目');
    }
    
    if (context.hasErrors) {
      suggestions.push('使用 AI 修复代码错误');
    }
    
    if (context.isComplexFunction) {
      suggestions.push('使用 AI 重构复杂函数');
    }
    
    return suggestions;
  }
}

示例：完整的 AI 助手扩展

typescript

// AI 助手扩展
class AIAssistantExtension {
  private aiProvider: AIProvider;
  private cache: AIResponseCache;
  private contextManager: ContextManager;
  
  constructor(private context: TraeAPI.ExtensionContext) {
    this.aiProvider = TraeAPI.ai.getDefaultProvider()!;
    this.cache = new AIResponseCache();
    this.contextManager = new ContextManager();
    
    this.initialize();
  }
  
  private initialize() {
    // 注册命令
    const commands = [
      TraeAPI.commands.registerCommand('aiAssistant.generateCode', () => {
        this.generateCodeCommand();
      }),
      
      TraeAPI.commands.registerCommand('aiAssistant.explainCode', () => {
        this.explainCodeCommand();
      }),
      
      TraeAPI.commands.registerCommand('aiAssistant.refactorCode', () => {
        this.refactorCodeCommand();
      }),
      
      TraeAPI.commands.registerCommand('aiAssistant.reviewCode', () => {
        this.reviewCodeCommand();
      }),
      
      TraeAPI.commands.registerCommand('aiAssistant.chat', () => {
        this.openChatPanel();
      })
    ];
    
    // 注册补全提供程序
    const completionProvider = TraeAPI.languages.registerCompletionItemProvider(
      ['typescript', 'javascript', 'python'],
      new AICompletionProvider(this.aiProvider),
      '.', '(', '[', ' '
    );
    
    // 注册悬停提供程序
    const hoverProvider = TraeAPI.languages.registerHoverProvider(
      ['typescript', 'javascript', 'python'],
      new AIHoverProvider(this.aiProvider)
    );
    
    // 添加到订阅
    this.context.subscriptions.push(
      ...commands,
      completionProvider,
      hoverProvider
    );
  }
  
  private async generateCodeCommand() {
    const editor = TraeAPI.window.activeTextEditor;
    if (!editor) {
      TraeAPI.window.showWarningMessage('请先打开一个文件');
      return;
    }
    
    const prompt = await TraeAPI.window.showInputBox({
      prompt: '描述您想要生成的代码',
      placeHolder: '例如：创建一个用户认证函数'
    });
    
    if (!prompt) return;
    
    try {
      const response = await this.generateCodeWithProgress({
        prompt,
        language: editor.document.languageId,
        context: {
          existingCode: this.contextManager.optimizeContext(
            editor.document.getText(),
            editor.selection.active
          ),
          fileName: editor.document.fileName,
          cursorPosition: editor.selection.active
        }
      });
      
      // 插入生成的代码
      await editor.edit(editBuilder => {
        editBuilder.insert(editor.selection.active, response.code);
      });
      
      // 显示解释
      if (response.explanation) {
        TraeAPI.window.showInformationMessage(
          `代码已生成: ${response.explanation}`
        );
      }
      
    } catch (error) {
      this.handleError(error);
    }
  }
  
  private async explainCodeCommand() {
    const editor = TraeAPI.window.activeTextEditor;
    if (!editor) return;
    
    const selectedText = editor.document.getText(editor.selection);
    if (!selectedText.trim()) {
      TraeAPI.window.showWarningMessage('请先选择要解释的代码');
      return;
    }
    
    try {
      const explanation = await TraeAPI.ai.explainCode({
        code: selectedText,
        language: editor.document.languageId,
        level: 'intermediate'
      });
      
      // 显示解释面板
      this.showExplanationPanel(explanation);
      
    } catch (error) {
      this.handleError(error);
    }
  }
  
  private async refactorCodeCommand() {
    const editor = TraeAPI.window.activeTextEditor;
    if (!editor) return;
    
    const selectedText = editor.document.getText(editor.selection);
    if (!selectedText.trim()) {
      TraeAPI.window.showWarningMessage('请先选择要重构的代码');
      return;
    }
    
    const refactorType = await TraeAPI.window.showQuickPick([
      { label: '优化性能', value: 'performance' },
      { label: '提高可读性', value: 'readability' },
      { label: '现代化语法', value: 'modernize' },
      { label: '添加错误处理', value: 'error-handling' }
    ], {
      placeHolder: '选择重构类型'
    });
    
    if (!refactorType) return;
    
    try {
      const refactorResponse = await TraeAPI.ai.refactor({
        code: selectedText,
        language: editor.document.languageId,
        refactorType: refactorType.value,
        options: {
          preserveFunctionality: true,
          addComments: true,
          followBestPractices: true
        }
      });
      
      // 应用重构
      await editor.edit(editBuilder => {
        editBuilder.replace(editor.selection, refactorResponse.refactoredCode);
      });
      
      // 显示重构说明
      TraeAPI.window.showInformationMessage(
        `重构完成: ${refactorResponse.changes.length} 项更改`
      );
      
    } catch (error) {
      this.handleError(error);
    }
  }
  
  private async reviewCodeCommand() {
    const editor = TraeAPI.window.activeTextEditor;
    if (!editor) return;
    
    const code = editor.document.getText();
    
    try {
      const reviewResponse = await TraeAPI.ai.reviewCode({
        code,
        language: editor.document.languageId,
        reviewType: 'comprehensive',
        options: {
          checkBestPractices: true,
          checkSecurity: true,
          checkPerformance: true,
          suggestImprovements: true
        }
      });
      
      // 显示审查结果
      this.showReviewPanel(reviewResponse);
      
    } catch (error) {
      this.handleError(error);
    }
  }
  
  private openChatPanel() {
    // 创建聊天面板
    const panel = TraeAPI.window.createWebviewPanel(
      'aiChat',
      'AI 助手',
      TraeAPI.ViewColumn.Beside,
      {
        enableScripts: true,
        retainContextWhenHidden: true
      }
    );
    
    panel.webview.html = this.getChatHTML();
    
    // 处理来自 webview 的消息
    panel.webview.onDidReceiveMessage(async message => {
      if (message.command === 'sendMessage') {
        const response = await TraeAPI.ai.chat({
          message: message.text,
          context: 'development',
          projectContext: await this.getProjectContext()
        });
        
        panel.webview.postMessage({
          command: 'receiveMessage',
          message: response.message,
          codeExamples: response.codeExamples
        });
      }
    });
  }
  
  private async generateCodeWithProgress(request: CodeGenerationRequest): Promise<CodeGenerationResponse> {
    return TraeAPI.window.withProgress({
      location: TraeAPI.ProgressLocation.Notification,
      title: 'AI 正在生成代码...',
      cancellable: true
    }, async (progress, token) => {
      progress.report({ increment: 0, message: '准备请求...' });
      
      const cacheKey = this.cache.generateKey(request);
      const cached = this.cache.get(cacheKey);
      
      if (cached) {
        progress.report({ increment: 100, message: '从缓存获取结果' });
        return cached;
      }
      
      progress.report({ increment: 30, message: '发送请求到 AI 服务...' });
      
      const response = await TraeAPI.ai.generateCode(request);
      
      if (token.isCancellationRequested) {
        throw new Error('用户取消了操作');
      }
      
      progress.report({ increment: 100, message: '代码生成完成！' });
      
      this.cache.set(cacheKey, response);
      return response;
    });
  }
  
  private showExplanationPanel(explanation: ExplainResponse) {
    const panel = TraeAPI.window.createWebviewPanel(
      'codeExplanation',
      '代码解释',
      TraeAPI.ViewColumn.Beside,
      { enableScripts: true }
    );
    
    panel.webview.html = this.getExplanationHTML(explanation);
  }
  
  private showReviewPanel(review: CodeReviewResponse) {
    const panel = TraeAPI.window.createWebviewPanel(
      'codeReview',
      '代码审查',
      TraeAPI.ViewColumn.Beside,
      { enableScripts: true }
    );
    
    panel.webview.html = this.getReviewHTML(review);
  }
  
  private async getProjectContext(): Promise<ProjectContext> {
    const workspaceFolders = TraeAPI.workspace.workspaceFolders;
    if (!workspaceFolders) {
      return {};
    }
    
    // 获取项目结构和依赖
    return {
      files: await this.getProjectFiles(),
      structure: await this.getProjectStructure(),
      dependencies: await this.getProjectDependencies()
    };
  }
  
  private async getProjectFiles(): Promise<string[]> {
    // 实现获取项目文件列表
    return [];
  }
  
  private async getProjectStructure(): Promise<string[]> {
    // 实现获取项目结构
    return [];
  }
  
  private async getProjectDependencies(): Promise<any> {
    // 实现获取项目依赖
    return {};
  }
  
  private getChatHTML(): string {
    return `
      <!DOCTYPE html>
      <html>
      <head>
        <meta charset="UTF-8">
        <title>AI 助手</title>
        <style>
          body { font-family: Arial, sans-serif; padding: 20px; }
          .chat-container { max-width: 600px; margin: 0 auto; }
          .message { margin: 10px 0; padding: 10px; border-radius: 5px; }
          .user-message { background-color: #e3f2fd; text-align: right; }
          .ai-message { background-color: #f5f5f5; }
          .input-container { margin-top: 20px; }
          input { width: 80%; padding: 10px; }
          button { padding: 10px 20px; }
        </style>
      </head>
      <body>
        <div class="chat-container">
          <div id="messages"></div>
          <div class="input-container">
            <input type="text" id="messageInput" placeholder="输入您的问题...">
            <button onclick="sendMessage()">发送</button>
          </div>
        </div>
        
        <script>
          const vscode = acquireVsCodeApi();
          
          function sendMessage() {
            const input = document.getElementById('messageInput');
            const message = input.value.trim();
            if (!message) return;
            
            addMessage(message, 'user');
            input.value = '';
            
            vscode.postMessage({
              command: 'sendMessage',
              text: message
            });
          }
          
          function addMessage(text, sender) {
            const messages = document.getElementById('messages');
            const messageDiv = document.createElement('div');
            messageDiv.className = \`message \${sender}-message\`;
            messageDiv.textContent = text;
            messages.appendChild(messageDiv);
            messages.scrollTop = messages.scrollHeight;
          }
          
          window.addEventListener('message', event => {
            const message = event.data;
            if (message.command === 'receiveMessage') {
              addMessage(message.message, 'ai');
            }
          });
          
          document.getElementById('messageInput').addEventListener('keypress', function(e) {
            if (e.key === 'Enter') {
              sendMessage();
            }
          });
        </script>
      </body>
      </html>
    `;
  }
  
  private getExplanationHTML(explanation: ExplainResponse): string {
    return `
      <!DOCTYPE html>
      <html>
      <head>
        <meta charset="UTF-8">
        <title>代码解释</title>
        <style>
          body { font-family: Arial, sans-serif; padding: 20px; line-height: 1.6; }
          .explanation { background-color: #f9f9f9; padding: 15px; border-radius: 5px; }
          .concepts { margin-top: 20px; }
          .concept { margin: 10px 0; padding: 10px; background-color: #e8f4fd; border-radius: 3px; }
        </style>
      </head>
      <body>
        <h1>代码解释</h1>
        <div class="explanation">
          <p>${explanation.explanation}</p>
        </div>
        
        ${explanation.concepts ? `
          <div class="concepts">
            <h2>相关概念</h2>
            ${explanation.concepts.map(concept => `
              <div class="concept">
                <h3>${concept.name}</h3>
                <p>${concept.description}</p>
              </div>
            `).join('')}
          </div>
        ` : ''}
      </body>
      </html>
    `;
  }
  
  private getReviewHTML(review: CodeReviewResponse): string {
    return `
      <!DOCTYPE html>
      <html>
      <head>
        <meta charset="UTF-8">
        <title>代码审查</title>
        <style>
          body { font-family: Arial, sans-serif; padding: 20px; line-height: 1.6; }
          .score { font-size: 24px; font-weight: bold; color: #4caf50; }
          .issue { margin: 10px 0; padding: 10px; border-radius: 5px; }
          .high { background-color: #ffebee; border-left: 4px solid #f44336; }
          .medium { background-color: #fff3e0; border-left: 4px solid #ff9800; }
          .low { background-color: #f3e5f5; border-left: 4px solid #9c27b0; }
        </style>
      </head>
      <body>
        <h1>代码审查结果</h1>
        <div class="score">总体评分: ${review.overallScore}/100</div>
        
        <h2>发现的问题</h2>
        ${review.issues.map(issue => `
          <div class="issue ${issue.severity}">
            <h3>${issue.title}</h3>
            <p>${issue.description}</p>
            ${issue.suggestion ? `<p><strong>建议:</strong> ${issue.suggestion}</p>` : ''}
          </div>
        `).join('')}
        
        <h2>改进建议</h2>
        <ul>
          ${review.recommendations.map(rec => `<li>${rec}</li>`).join('')}
        </ul>
      </body>
      </html>
    `;
  }
  
  private handleError(error: any) {
    console.error('AI 助手错误:', error);
    
    if (error instanceof TraeAPI.AIProviderError) {
      switch (error.code) {
        case 'RATE_LIMIT_EXCEEDED':
          TraeAPI.window.showWarningMessage('AI 服务请求过于频繁，请稍后再试');
          break;
        case 'INVALID_API_KEY':
          TraeAPI.window.showErrorMessage('AI 服务配置错误，请检查 API 密钥');
          break;
        default:
          TraeAPI.window.showErrorMessage(`AI 服务错误: ${error.message}`);
      }
    } else {
      TraeAPI.window.showErrorMessage('发生未知错误，请查看控制台');
    }
  }
}

// 补全提供程序
class AICompletionProvider implements TraeAPI.CompletionItemProvider {
  constructor(private aiProvider: AIProvider) {}
  
  async provideCompletionItems(
    document: TraeAPI.TextDocument,
    position: TraeAPI.Position,
    token: TraeAPI.CancellationToken,
    context: TraeAPI.CompletionContext
  ): Promise<TraeAPI.CompletionItem[]> {
    try {
      const completions = await this.aiProvider.complete({
        document,
        position,
        context: {
          triggerCharacter: context.triggerCharacter,
          triggerKind: context.triggerKind
        }
      });
      
      return completions.completions.map(completion => {
        const item = new TraeAPI.CompletionItem(
          completion.label,
          TraeAPI.CompletionItemKind.Text
        );
        
        item.insertText = completion.text;
        item.detail = completion.description;
        item.sortText = completion.priority.toString();
        
        return item;
      });
    } catch (error) {
      console.error('AI 补全错误:', error);
      return [];
    }
  }
}

// 悬停提供程序
class AIHoverProvider implements TraeAPI.HoverProvider {
  constructor(private aiProvider: AIProvider) {}
  
  async provideHover(
    document: TraeAPI.TextDocument,
    position: TraeAPI.Position,
    token: TraeAPI.CancellationToken
  ): Promise<TraeAPI.Hover | undefined> {
    try {
      const wordRange = document.getWordRangeAtPosition(position);
      if (!wordRange) return;
      
      const word = document.getText(wordRange);
      const explanation = await this.aiProvider.explainCode({
        code: word,
        language: document.languageId,
        level: 'beginner'
      });
      
      return new TraeAPI.Hover(
        new TraeAPI.MarkdownString(explanation.explanation),
        wordRange
      );
    } catch (error) {
      console.error('AI 悬停错误:', error);
      return undefined;
    }
  }
}

// 激活扩展
export function activate(context: TraeAPI.ExtensionContext) {
  new AIAssistantExtension(context);
}

AI API 为 Trae IDE 提供了强大的人工智能功能，让开发者能够利用 AI 的力量提高编程效率和代码质量。通过合理使用这些 API，您可以创建出智能化的编程助手和工具。

AI API ​

概述 ​

核心接口 ​

AIProvider ​

AIModel ​

基本使用 ​

代码生成 ​

基础代码生成 ​

高级代码生成 ​

代码生成配置 ​

代码分析 ​

基础代码分析 ​

高级代码分析 ​

代码分析接口 ​

聊天集成 ​

基础聊天功能 ​

上下文感知聊天 ​

聊天接口定义 ​

代码补全 ​

智能补全 ​

高级补全功能 ​

补全提供程序 ​

代码解释 ​

基础代码解释 ​

详细代码解释 ​

解释接口定义 ​

高级功能 ​

自定义 AI 模型 ​

AI 代码重构 ​

AI 代码审查 ​

配置 ​

AI 设置 ​

扩展配置示例 ​

错误处理 ​

常见错误处理 ​

错误类型定义 ​

最佳实践 ​

性能优化 ​

用户体验优化 ​

示例：完整的 AI 助手扩展 ​

AI API

概述

核心接口

AIProvider

AIModel

基本使用

代码生成

基础代码生成

高级代码生成

代码生成配置

代码分析

基础代码分析

高级代码分析

代码分析接口

聊天集成

基础聊天功能

上下文感知聊天

聊天接口定义

代码补全

智能补全

高级补全功能

补全提供程序

代码解释

基础代码解释

详细代码解释

解释接口定义

高级功能

自定义 AI 模型

AI 代码重构

AI 代码审查

配置

AI 设置

扩展配置示例

错误处理

常见错误处理

错误类型定义

最佳实践

性能优化

用户体验优化

示例：完整的 AI 助手扩展