ツール呼び出し精度スコアの例

npm install @mastra/evals

import { createToolCallAccuracyScorerCode } from "@mastra/evals/scorers/code";
import { createAgentTestRun, createUIMessage, createToolInvocation } from "@mastra/evals/scorers/utils";

const scorer = createToolCallAccuracyScorerCode({ 
  expectedTool: 'weather-tool' 
});
 
// ツール呼び出しを伴う LLM の入出力をシミュレート
const inputMessages = [
  createUIMessage({ 
    content: 'What is the weather like in New York today?', 
    role: 'user', 
    id: 'input-1' 
  })
];
 
const output = [
  createUIMessage({
    content: 'Let me check the weather for you.',
    role: 'assistant',
    id: 'output-1',
    toolInvocations: [
      createToolInvocation({
        toolCallId: 'call-123',
        toolName: 'weather-tool',
        args: { location: 'New York' },
        result: { temperature: '72°F', condition: 'sunny' },
        state: 'result'
      })
    ]
  })
];
 
const run = createAgentTestRun({ inputMessages, output });
const result = await scorer.run(run);
 
console.log(result.score); // 1
console.log(result.preprocessStepResult?.correctToolCalled); // true

const strictScorer = createToolCallAccuracyScorerCode({ 
  expectedTool: 'weather-tool',
  strictMode: true
});
 
// 複数のツールが呼び出されているため、厳格モードでは不合格
const output = [
  createUIMessage({
    content: 'お任せください。',
    role: 'assistant',
    id: 'output-1',
    toolInvocations: [
      createToolInvocation({
        toolCallId: 'call-1',
        toolName: 'search-tool',
        args: {},
        result: {},
        state: 'result',
      }),
      createToolInvocation({
        toolCallId: 'call-2',
        toolName: 'weather-tool',
        args: { location: 'New York' },
        result: { temperature: '20°C' },
        state: 'result',
      })
    ]
  })
];
 
const result = await strictScorer.run(run);
console.log(result.score); // 0 - 複数のツールが呼び出されたため不合格

const orderScorer = createToolCallAccuracyScorerCode({
  expectedTool: 'auth-tool', // 順序が指定されている場合は無視される
  expectedToolOrder: ['auth-tool', 'fetch-tool'],
  strictMode: true // 追加のツールは許可しない
});
 
const output = [
  createUIMessage({
    content: '認証してデータを取得します。',
    role: 'assistant',
    id: 'output-1',
    toolInvocations: [
      createToolInvocation({
        toolCallId: 'call-1',
        toolName: 'auth-tool',
        args: { token: 'abc123' },
        result: { authenticated: true },
        state: 'result'
      }),
      createToolInvocation({
        toolCallId: 'call-2',
        toolName: 'fetch-tool',
        args: { endpoint: '/data' },
        result: { data: ['item1'] },
        state: 'result'
      })
    ]
  })
];
 
const result = await orderScorer.run(run);
console.log(result.score); // 1 - 正しい順序

const flexibleOrderScorer = createToolCallAccuracyScorerCode({
  expectedTool: 'auth-tool',
  expectedToolOrder: ['auth-tool', 'fetch-tool'],
  strictMode: false // 追加のツールを許可
});
 
const output = [
  createUIMessage({
    content: '包括的な処理を実行します。',
    role: 'assistant',
    id: 'output-1',
    toolInvocations: [
      createToolInvocation({
        toolCallId: 'call-1',
        toolName: 'auth-tool',
        args: { token: 'abc123' },
        result: { authenticated: true },
        state: 'result'
      }),
      createToolInvocation({
        toolCallId: 'call-2',
        toolName: 'log-tool', // 追加ツール — 柔軟モードではOK
        args: { message: 'フェッチを開始' },
        result: { logged: true },
        state: 'result'
      }),
      createToolInvocation({
        toolCallId: 'call-3',
        toolName: 'fetch-tool',
        args: { endpoint: '/data' },
        result: { data: ['item1'] },
        state: 'result'
      })
    ]
  })
];
 
const result = await flexibleOrderScorer.run(run);
console.log(result.score); // 1 - auth-tool が fetch-tool より前にある

import { createToolCallAccuracyScorerLLM } from "@mastra/evals/scorers/llm";
import { openai } from "@ai-sdk/openai";

const llmScorer = createToolCallAccuracyScorerLLM({
  model: openai('gpt-4o-mini'),
  availableTools: [
    { 
      name: 'weather-tool', 
      description: '任意の場所の現在の天気情報を取得' 
    },
    { 
      name: 'calendar-tool', 
      description: 'カレンダーの予定や日程を確認' 
    },
    { 
      name: 'search-tool', 
      description: '一般的な情報をウェブで検索' 
    }
  ]
});
 
const inputMessages = [
  createUIMessage({ 
    content: '今日のサンフランシスコの天気は？', 
    role: 'user', 
    id: 'input-1' 
  })
];
 
const output = [
  createUIMessage({
    content: '現在の天気を確認します。',
    role: 'assistant',
    id: 'output-1',
    toolInvocations: [
      createToolInvocation({
        toolCallId: 'call-123',
        toolName: 'weather-tool',
        args: { location: 'San Francisco', date: 'today' },
        result: { temperature: '68°F', condition: 'foggy' },
        state: 'result'
      })
    ]
  })
];
 
const run = createAgentTestRun({ inputMessages, output });
const result = await llmScorer.run(run);
 
console.log(result.score); // 1.0 - ツールの適切な使用
console.log(result.reason); // "エージェントはユーザーの天気に関する依頼に対応するため、weather-tool を正しく使用しました。"

const inputMessages = [
  createUIMessage({ 
    content: 'What is the weather in Tokyo?', 
    role: 'user', 
    id: 'input-1' 
  })
];
 
const inappropriateOutput = [
  createUIMessage({
    content: 'Let me search for that information.',
    role: 'assistant', 
    id: 'output-1',
    toolInvocations: [
      createToolInvocation({
        toolCallId: 'call-456',
        toolName: 'search-tool', // 直接の天気照会には weather-tool の方が適切
        args: { query: 'Tokyo weather' },
        result: { results: ['Tokyo weather data...'] },
        state: 'result'
      })
    ]
  })
];
 
const run = createAgentTestRun({ inputMessages, output: inappropriateOutput });
const result = await llmScorer.run(run);
 
console.log(result.score); // 0.5 - 部分的に適切
console.log(result.reason); // "エージェントは直接の天気問い合わせには weather-tool がより適切なところを、search-tool を使用しました。"

const vagueInput = [
  createUIMessage({ 
    content: 'I need help with something', 
    role: 'user', 
    id: 'input-1' 
  })
];
 
const clarificationOutput = [
  createUIMessage({
    content: 'お手伝いできます。どのような点でお困りなのか、もう少し詳しく教えていただけますか？',
    role: 'assistant',
    id: 'output-1',
    // ツールは呼び出さず、代わりに確認質問を行う
  })
];
 
const run = createAgentTestRun({ 
  inputMessages: vagueInput, 
  output: clarificationOutput 
});
const result = await llmScorer.run(run);
 
console.log(result.score); // 1.0 - 確認質問を行うのが適切
console.log(result.reason); // "エージェントは情報が不十分なままツールを呼び出すのではなく、適切に確認質問を行いました。"

import { createToolCallAccuracyScorerCode as createCodeScorer } from '@mastra/evals/scorers/code';
import { createToolCallAccuracyScorerLLM as createLLMScorer } from '@mastra/evals/scorers/llm';
import { openai } from '@ai-sdk/openai';
 
// 両方のスコアラーをセットアップ
const codeScorer = createCodeScorer({
  expectedTool: 'weather-tool',
  strictMode: false
});
 
const llmScorer = createLLMScorer({
  model: openai('gpt-4o-mini'),
  availableTools: [
    { name: 'weather-tool', description: 'Get weather information' },
    { name: 'search-tool', description: 'Search the web' }
  ]
});
 
// テストデータ
const run = createAgentTestRun({
  inputMessages: [
    createUIMessage({ 
      content: 'What is the weather?', 
      role: 'user', 
      id: 'input-1' 
    })
  ],
  output: [
    createUIMessage({
      content: 'その情報を探します。',
      role: 'assistant',
      id: 'output-1',
      toolInvocations: [
        createToolInvocation({
          toolCallId: 'call-1',
          toolName: 'search-tool',
          args: { query: 'weather' },
          result: { results: ['weather data'] },
          state: 'result'
        })
      ]
    })
  ]
});
 
// 両方のスコアラーを実行
const codeResult = await codeScorer.run(run);
const llmResult = await llmScorer.run(run);
 
console.log('Code Scorer:', codeResult.score); // 0 - ツールが不適切
console.log('LLM Scorer:', llmResult.score);   // 0.3 - 一部適切
console.log('LLM Reason:', llmResult.reason);  // search-tool が望ましくない理由の説明

// 標準モード - 想定されたツールが呼び出されれば合格
const lenientScorer = createCodeScorer({ 
  expectedTool: 'search-tool',
  strictMode: false
});
 
// 厳格モード - ツールがちょうど1つだけ呼び出された場合に合格
const strictScorer = createCodeScorer({ 
  expectedTool: 'search-tool',
  strictMode: true
});
 
// 厳格モードでの順序チェック
const strictOrderScorer = createCodeScorer({
  expectedTool: 'step1-tool',
  expectedToolOrder: ['step1-tool', 'step2-tool', 'step3-tool'],
  strictMode: true // 余分なツールは許可しない
});

// 基本設定
const basicLLMScorer = createLLMScorer({
  model: openai('gpt-4o-mini'),
  availableTools: [
    { name: 'tool1', description: '説明 1' },
    { name: 'tool2', description: '説明 2' }
  ]
});
 
// 別のモデルを使用
const customModelScorer = createLLMScorer({
  model: openai('gpt-4'), // より高度な評価向けの高性能モデル
  availableTools: [...]
});

{
  runId: string,
  preprocessStepResult: {
    expectedTool: string,
    actualTools: string[],
    strictMode: boolean,
    expectedToolOrder?: string[],
    hasToolCalls: boolean,
    correctToolCalled: boolean,
    correctOrderCalled: boolean | null,
    toolCallInfos: ToolCallInfo[]
  },
  score: number // 常に0または1
}

{
  runId: string,
  score: number,  // 0.0 〜 1.0
  reason: string, // 人間が読める説明
  analyzeStepResult: {
    evaluations: Array<{
      toolCalled: string,
      wasAppropriate: boolean,
      reasoning: string
    }>,
    missingTools?: string[]
  }
}