Claude API Think Tool — エージェントのインターリーブド推論でツール呼び出し精度を劇的に向上させる

import Anthropic from "@anthropic-ai/sdk";
 
// Anthropic クライアント初期化
const client = new Anthropic();
 
// エージェントループの実装
async function runAgentLoop(
  userMessage: string,
  tools: Anthropic.Tool[]
): Promise<string> {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userMessage },
  ];
 
  while (true) {
    const response = await client.messages.create({
      model: "claude-opus-4-6",
      max_tokens: 8096,
      tools: tools,
      messages: messages,
    });
 
    // レスポンスをメッセージ履歴に追加
    messages.push({ role: "assistant", content: response.content });
 
    // stop_reason が "end_turn" ならループ終了
    if (response.stop_reason === "end_turn") {
      const textBlock = response.content.find(
        (block) => block.type === "text"
      );
      return textBlock?.text ?? "";
    }
 
    // ツール呼び出しの処理
    const toolResults: Anthropic.ToolResultBlockParam[] = [];
    for (const block of response.content) {
      if (block.type === "tool_use") {
        if (block.name === "think") {
          // Think Tool: 思考をそのまま結果として返す
          // サーバー側では何も処理しない
          toolResults.push({
            type: "tool_result",
            tool_use_id: block.id,
            content: `Thought recorded: ${(block.input as { thought: string }).thought}`,
          });
        } else {
          // 通常のツール: 実際の処理を実行
          const result = await executeExternalTool(block.name, block.input);
          toolResults.push({
            type: "tool_result",
            tool_use_id: block.id,
            content: result,
          });
        }
      }
    }
 
    // ツール結果をメッセージ履歴に追加
    messages.push({ role: "user", content: toolResults });
  }
}

const systemPrompt = `あなたはカスタマーサポートエージェントです。
 
## Think Tool の使用ガイドライン
 
以下の状況では、必ず think ツールを使用してから行動してください:
 
1. **ツール結果の分析時**: ツールから返されたデータを解釈する必要がある場合
2. **ポリシー判断の前**: 返金・キャンセル・例外処理などのポリシーを適用する前
3. **複数の選択肢がある場合**: 次のアクションに複数の候補がある場合
4. **矛盾する情報がある場合**: 顧客の申告とシステムデータが一致しない場合
5. **最終回答の直前**: 顧客への回答を生成する前に、全体を振り返る
 
## Think Tool の使い方
 
think ツールを呼び出す際は、以下の構造で思考を整理してください:
- 現在わかっていること
- まだ不明なこと
- 次に取るべきアクションとその理由
- リスクや注意点`;

interface AgentState {
  conversationHistory: Anthropic.MessageParam[];
  thinkingLog: Array<{
    timestamp: number;
    thought: string;
    context: string;
  }>;
  toolCallCount: number;
  maxToolCalls: number;
}
 
async function statefulAgentLoop(
  state: AgentState,
  tools: Anthropic.Tool[]
): Promise<{ response: string; state: AgentState }> {
  while (state.toolCallCount < state.maxToolCalls) {
    const response = await client.messages.create({
      model: "claude-opus-4-6",
      max_tokens: 8096,
      tools: tools,
      messages: state.conversationHistory,
    });
 
    state.conversationHistory.push({
      role: "assistant",
      content: response.content,
    });
 
    if (response.stop_reason === "end_turn") {
      const text = response.content.find((b) => b.type === "text");
      return { response: text?.text ?? "", state };
    }
 
    const toolResults: Anthropic.ToolResultBlockParam[] = [];
    for (const block of response.content) {
      if (block.type === "tool_use") {
        state.toolCallCount++;
        if (block.name === "think") {
          const thought = (block.input as { thought: string }).thought;
          // 思考ログを記録（デバッグ・監視用）
          state.thinkingLog.push({
            timestamp: Date.now(),
            thought,
            context: `tool_call_${state.toolCallCount}`,
          });
          toolResults.push({
            type: "tool_result",
            tool_use_id: block.id,
            content: thought,
          });
        } else {
          const result = await executeExternalTool(block.name, block.input);
          toolResults.push({
            type: "tool_result",
            tool_use_id: block.id,
            content: result,
          });
        }
      }
    }
 
    state.conversationHistory.push({ role: "user", content: toolResults });
  }
 
  return { response: "ツール呼び出し上限に達しました。", state };
}

interface ThinkAnalysis {
  confidence: "high" | "medium" | "low";
  risks: string[];
  shouldProceed: boolean;
}
 
function analyzeThought(thought: string): ThinkAnalysis {
  // 思考内容からリスクや不確実性を検出
  const lowConfidenceSignals = [
    "確信が持てない",
    "不明",
    "推測",
    "not sure",
    "uncertain",
    "might be",
  ];
  const riskSignals = [
    "返金",
    "削除",
    "キャンセル",
    "refund",
    "delete",
    "cancel",
  ];
 
  const hasLowConfidence = lowConfidenceSignals.some((s) =>
    thought.toLowerCase().includes(s)
  );
  const hasRisk = riskSignals.some((s) =>
    thought.toLowerCase().includes(s)
  );
 
  return {
    confidence: hasLowConfidence ? "low" : hasRisk ? "medium" : "high",
    risks: riskSignals.filter((s) =>
      thought.toLowerCase().includes(s)
    ),
    shouldProceed: !(hasLowConfidence && hasRisk),
  };
}

class SharedThinkingContext {
  private thoughts: Map<string, string[]> = new Map();
 
  addThought(agentId: string, thought: string): void {
    const existing = this.thoughts.get(agentId) ?? [];
    existing.push(thought);
    this.thoughts.set(agentId, existing);
  }
 
  getSummary(): string {
    let summary = "=== エージェント間の思考共有 ===\n";
    for (const [agentId, thoughts] of this.thoughts) {
      summary += `\n[${agentId}]:\n`;
      thoughts.forEach((t, i) => {
        summary += `  ${i + 1}. ${t.substring(0, 200)}\n`;
      });
    }
    return summary;
  }
}

// Extended Thinking + Think Tool の併用
const response = await client.messages.create({
  model: "claude-opus-4-6",
  max_tokens: 16000,
  thinking: {
    type: "enabled",
    budget_tokens: 5000, // 初期推論に予算を割り当て
  },
  tools: [thinkTool, ...businessTools],
  messages: messages,
});

// Think Tool のコスト制御
function createCostAwareThinkTool(maxThinkTokens: number = 500) {
  return {
    name: "think",
    description:
      "Use this tool to analyze the current situation and plan next steps. " +
      `Keep your thinking concise (under ${maxThinkTokens} tokens). ` +
      "Focus on: what you know, what you need, and your next action.",
    input_schema: {
      type: "object" as const,
      properties: {
        thought: {
          type: "string",
          description: `Concise reasoning (max ~${maxThinkTokens} tokens)`,
        },
      },
      required: ["thought"],
    },
  };
}
 
// トークン使用量の監視
interface TokenUsageTracker {
  thinkTokens: number;
  toolTokens: number;
  totalTokens: number;
}
 
function trackThinkToolUsage(
  response: Anthropic.Message,
  tracker: TokenUsageTracker
): void {
  for (const block of response.content) {
    if (block.type === "tool_use" && block.name === "think") {
      const thought = (block.input as { thought: string }).thought;
      // 概算: 日本語1文字≒1.5トークン、英語1単語≒1.3トークン
      const estimatedTokens = Math.ceil(thought.length * 1.5);
      tracker.thinkTokens += estimatedTokens;
    }
  }
  tracker.totalTokens =
    (response.usage?.input_tokens ?? 0) +
    (response.usage?.output_tokens ?? 0);
}

// Think Tool ログの構造化出力
interface ThinkLog {
  id: string;
  timestamp: string;
  agentStep: number;
  thought: string;
  precedingTool: string | null;
  followingTool: string | null;
  confidence: string;
}
 
function formatThinkLogs(logs: ThinkLog[]): string {
  return logs
    .map(
      (log) =>
        `[Step ${log.agentStep}] ${log.timestamp}\n` +
        `  After: ${log.precedingTool ?? "initial"}\n` +
        `  Thought: ${log.thought}\n` +
        `  Then: ${log.followingTool ?? "final_response"}\n` +
        `  Confidence: ${log.confidence}`
    )
    .join("\n---\n");
}