vscode-copilot-chat/
├── src/
│   ├── extension/   # 拡張機能固有の機能
│   ├── platform/    # プラットフォーム共通のコア機能
│   └── util/        # ユーティリティ関数
├── test/           # テストコード
└── dist/           # ビルド成果物

// AgentPrompt の基本構造
<SystemMessage>
  You are an expert AI programming assistant, working with a user in the VS Code editor.<br />
  <CopilotIdentityRules />
  <SafetyRules />
</SystemMessage>

export const enum ToolName {
  ApplyPatch = 'apply_patch',
  Codebase = 'semantic_search',
  VSCodeAPI = 'get_vscode_api',
  RunTests = 'run_tests',
  FindFiles = 'file_search',
  ReadFile = 'read_file',
  RunInTerminal = 'run_in_terminal',
  EditFile = 'insert_edit_into_file',
  ReplaceString = 'replace_string_in_file',
  // ... 他多数
}

export const enum Intent {
  Agent = 'agent',
  EditCode = 'editCode',
  Fix = 'fix',
  Generate = 'generate',
  // ...
}

class ChatEndpoint implements IChatEndpoint {
  public readonly model: string;
  public readonly family: string;
  public readonly tokenizer: TokenizerType;
  // ...
}

constructor(
  @ILogService private readonly logService: ILogService,
  @IConfigurationService private readonly configService: IConfigurationService,
  // ...
) {}

const processor = await SSEProcessor.create(logService, telemetryService, ...);
const chatCompletions = AsyncIterableObject.map(finishedCompletions, ...);

<UserMessage>
  <CustomInstructions priority={725} chatVariables={chatVariables} />
  <LanguageServerContextPrompt priority={700} document={document} />
  <TemporalContext priority={600} context={[document]} />
</UserMessage>

export const enum ToolName {
  ReadFile = 'read_file',              // ファイル読み取り
  EditFile = 'insert_edit_into_file',  // ファイル編集
  CreateFile = 'create_file',          // ファイル作成
  ReplaceString = 'replace_string_in_file', // 文字列置換
  ListDirectory = 'list_dir',          // ディレクトリ一覧
  CreateDirectory = 'create_directory', // ディレクトリ作成
}

export const enum ToolName {
  Codebase = 'semantic_search',        // セマンティック検索
  FindFiles = 'file_search',           // ファイル名検索
  FindTextInFiles = 'grep_search',     // テキスト検索
  SearchWorkspaceSymbols = 'search_workspace_symbols', // シンボル検索
  Usages = 'list_code_usages',         // 使用箇所検索
}

export const enum ToolName {
  RunInTerminal = 'run_in_terminal',   // ターミナルでコマンド実行
  RunTests = 'run_tests',              // テスト実行
  RunTask = 'run_vs_code_task',        // VSCode タスク実行
  RunNotebookCell = 'run_notebook_cell', // Notebook セル実行
}

export const enum ToolName {
  GetErrors = 'get_errors',            // エラー情報取得
  GetTerminalOutput = 'get_terminal_output', // ターミナル出力取得
  GetScmChanges = 'get_changed_files', // Git 変更ファイル取得
  VSCodeAPI = 'get_vscode_api',        // VSCode API ドキュメント取得
}

// 内部名（モデルが使用）
ToolName.ReadFile = 'read_file'

// 公開名（VSCode に登録）
ContributedToolName.ReadFile = 'copilot_readFile'

export function getContributedToolName(name: string | ToolName): string | ContributedToolName {
  return toolNameToContributedToolNames.get(name as ToolName) ?? name;
}

export function getToolName(name: string | ContributedToolName): string | ToolName {
  return contributedToolNameToToolNames.get(name as ContributedToolName) ?? name;
}

{
  "languageModelTools": [
    {
      "name": "copilot_searchCodebase",
      "toolReferenceName": "codebase",
      "displayName": "%copilot.tools.searchCodebase.name%",
      "icon": "$(folder)",
      "canBeReferencedInPrompt": true,
      "userDescription": "%copilot.codebase.tool.description%",
      "modelDescription": "Run a natural language search for relevant code...",
      "tags": ["codesearch", "vscode_codesearch"],
      "inputSchema": {
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "description": "The query to search the codebase for..."
          }
        },
        "required": ["query"]
      }
    }
  ]
}

const getTools = (instaService: IInstantiationService, request: vscode.ChatRequest) =>
  instaService.invokeFunction(async accessor => {
    const allowTools: Record<string, boolean> = {};
    
    // モデルの能力に応じてツールを有効化
    const useApplyPatch = !!(modelSupportsApplyPatch(model) && applyPatchConfigEnabled);
    allowTools[ToolName.EditFile] = true;
    allowTools[ToolName.ReplaceString] = modelSupportsReplaceString(model);
    allowTools[ToolName.ApplyPatch] = useApplyPatch;
    
    // テストがある場合のみテスト実行ツールを有効化
    allowTools[ToolName.RunTests] = await testService.hasAnyTests();
    
    // タスクがある場合のみタスク実行ツールを有効化
    allowTools[ToolName.RunTask] = !!(configurationService.getConfig(ConfigKey.AgentCanRunTasks) 
      && tasksService.getTasks().length);
    
    return toolsService.getEnabledTools(request, tool => {
      if (typeof allowTools[tool.name] === 'boolean') {
        return allowTools[tool.name];
      }
      return undefined;
    });
  });

<Tag name='toolUseInstructions'>
  If the user is requesting a code sample, you can answer it directly without using any tools.<br />
  When using a tool, follow the JSON schema very carefully and make sure to include ALL required properties.<br />
  No need to ask permission before using a tool.<br />
  NEVER say the name of a tool to a user. For example, instead of saying that you'll use the {ToolName.RunInTerminal} tool, say "I'll run the command in a terminal".<br />
  {hasReadFileTool && <>
    When using the {ToolName.ReadFile} tool, prefer reading a large section over calling the {ToolName.ReadFile} tool many times in sequence.<br />
  </>}
  {hasTerminalTool && <>
    Don't call the {ToolName.RunInTerminal} tool multiple times in parallel. Instead, run one command and wait for the output before running the next command.<br />
  </>}
</Tag>

{
  "displayName": "%copilot.tools.think.name%",
  "name": "copilot_think",
  "modelDescription": `Use this tool to think deeply about the user's request and organize your thoughts. 
  This tool helps improve response quality by allowing the model to consider the request carefully, 
  brainstorm solutions, and plan complex tasks...`,
  "inputSchema": {
    "type": "object",
    "properties": {
      "thoughts": {
        "type": "string",
        "description": "Your thoughts about the current task or problem..."
      }
    }
  }
}

{hasUpdateUserPreferencesTool && <>
  After you have performed the user's task, if the user corrected something you did, 
  expressed a coding preference, or communicated a fact that you need to remember, 
  use the {ToolName.UpdateUserPreferences} tool to save their preferences.<br />
</>}

export const prerunTools: ReadonlySet<ToolName> = new Set([
  ToolName.EditFile
]);

protected override getIntentHandlerOptions(request: vscode.ChatRequest): IDefaultIntentRequestHandlerOptions | undefined {
  return {
    maxToolCallIterations: getRequestedToolCallIterationLimit(request) ??
      this.configurationService.getNonExtensionConfig('chat.agent.maxRequests') ??
      200, // 最大 200 回のツール呼び出し
    temperature: this.configurationService.getConfig(ConfigKey.Internal.AgentTemperature) ?? 0,
    overrideRequestLocation: ChatLocation.Agent,
    hideRateLimitTimeEstimate: true
  };
}

// Claude では replace_string を優先的に使用
if (modelMightUseReplaceStringExclusively(model) && 
    experimentationService.getTreatmentVariable<boolean>('vscode', 'copilotchat.claudeReplaceStringExclusively')) {
  allowTools[ToolName.ReplaceString] = true;
  allowTools[ToolName.EditFile] = false;
}

// Gemini では特別な設定
allowTools[ToolName.ReplaceString] = modelSupportsReplaceString(model) || 
  !!(model.family.includes('gemini') && 
     experimentationService.getTreatmentVariable<boolean>('vscode', 'copilotchat.geminiReplaceString'));

/** Proportion of the prompt token budget any singular textual tool result is allowed to use. */
const MAX_TOOL_RESPONSE_PCT = 0.5;

const maxToolResultLength = Math.floor(
  this.promptEndpoint.modelMaxPromptTokens * MAX_TOOL_RESPONSE_PCT
);

import { PromptElement, SystemMessage, UserMessage } from '@vscode/prompt-tsx';

class MyPrompt extends PromptElement {
  render() {
    return <>
      <SystemMessage>
        You are an AI assistant.
      </SystemMessage>
      <UserMessage>
        Help me with coding.
      </UserMessage>
    </>;
  }
}

export class DefaultAgentPrompt extends PromptElement<DefaultAgentPromptProps> {
  async render(state: void, sizing: PromptSizing) {
    return <InstructionMessage>
      <Tag name='instructions'>
        You are a highly sophisticated automated coding agent with expert-level knowledge across many different programming languages and frameworks.<br />
        The user will ask a question, or ask you to perform a task, and it may require lots of research to answer correctly. There is a selection of tools that let you perform actions or retrieve helpful context to answer the user's question.<br />
        {getKeepGoingReminder(this.props.modelFamily)}
        // ... 続く
      </Tag>
    </InstructionMessage>;
  }
}

{hasTerminalTool && <>
  NEVER print out a codeblock with a terminal command to run unless the user asked for it. 
  Use the {ToolName.RunInTerminal} tool instead.<br />
</>}
{!hasSomeEditTool && <>
  You don't currently have any tools available for editing files. 
  If the user asks you to edit a file, you can ask the user to enable editing tools or print a codeblock with the suggested changes.<br />
</>}

export class InlineChatEditCodePrompt extends PromptElement<InlineChatEditCodePromptProps> {
  async render(state: void, sizing: PromptSizing) {
    return (
      <>
        <SystemMessage priority={1000}>
          You are an AI programming assistant.<br />
          When asked for your name, you must respond with "GitHub Copilot".<br />
          You are a world class expert in programming, and especially good at {languageId}.<br />
          <LegacySafetyRules />
        </SystemMessage>
        <HistoryWithInstructions inline={true} historyPriority={700} passPriority history={history}>
          <InstructionMessage priority={1000}>
            Source code is always contained in ``` blocks.<br />
            The user needs help to modify some code.<br />
            {data.hasCodeWithoutSelection && <>
              The user includes existing code and marks with {data.placeholderText} where the selected code should go.<br />
            </>}
          </InstructionMessage>
        </HistoryWithInstructions>
        // ... 続く
      </>
    );
  }
}

export const systemPromptTemplate = `Your role as an AI assistant is to help developers complete their code tasks by assisting in editing specific sections of code marked by the ${CODE_TO_EDIT_START_TAG} and ${CODE_TO_EDIT_END_TAG} tags, while adhering to Microsoft's content policies and avoiding the creation of content that violates copyrights.

You have access to the following information to help you make informed suggestions:

- recently_viewed_code_snippets: These are code snippets that the developer has recently looked at...
- current_file_content: The content of the file the developer is currently working on...
- edit_diff_history: A record of changes made to the code...
- area_around_code_to_edit: The context showing the code surrounding the section to be edited.
- cursor position marked as ${CURSOR_TAG}: Indicates where the developer's cursor is currently located...
`;

class SummaryPrompt {
  render() {
    return {
      messages: [{
        role: 'system' as const,
        content: `You are an expert at summarizing chat conversations.
        
Structure your summary using the following format:

TITLE: A brief title for the summary
USER INTENT: The user's goal or intent for the conversation
TASK DESCRIPTION: Main technical goals and user requirements
EXISTING: What has already been accomplished. Include file paths and other direct references.
PENDING: What still needs to be done. Include file paths and other direct references.
CODE STATE: A list of all files discussed or modified. Provide code snippets or diffs that illustrate important context.
RELEVANT CODE/DOCUMENTATION SNIPPETS: Key code or documentation snippets from referenced files or discussions.
OTHER NOTES: Any additional context or information that may be relevant.`
      }]
    };
  }
}

<UserMessage priority={900} flexGrow={2} flexReserve={sizing.endpoint.modelMaxPromptTokens / 3}>
  <SummarizedDocumentWithSelection
    flexGrow={1}
    tokenBudget={'usePromptSizingBudget'}
    documentData={data}
  />
  <Tag name='userPrompt'>
    <UserQuery chatVariables={chatVariables} query={query} /><br />
  </Tag>
</UserMessage>

<CustomInstructions priority={725} chatVariables={chatVariables} languageId={languageId} />
<LanguageServerContextPrompt priority={700} document={document} position={context.selection.start} />
<TemporalContext priority={600} context={[document]} location={ChatLocation.Editor} />

export class SafetyRules extends PromptElement {
  render() {
    return <>
      Follow Microsoft content policies.<br />
      Avoid content that violates copyrights.<br />
      Keep your answers short and relevant to the user's query.<br />
      {/* ... その他のルール */}
    </>;
  }
}

{this.props.enableCacheBreakpoints && <cacheBreakpoint type={CacheType} />}

// 良い例：特定の目的に特化したコンポーネント
class NotebookInstructions extends PromptElement { /* ... */ }
class TerminalInstructions extends PromptElement { /* ... */ }

// 悪い例：全てを1つのコンポーネントに詰め込む
class AllInstructions extends PromptElement { /* ... */ }

interface AgentPromptProps {
  readonly endpoint: IChatEndpoint;
  readonly location: ChatLocation;
  readonly triggerSummarize?: boolean;
  readonly enableCacheBreakpoints?: boolean;
  readonly codesearchMode?: boolean;
}

const hasTerminalTool = !!this.props.availableTools?.find(
  tool => tool.name === ToolName.RunInTerminal
);