出力プロセッサ

import { ModerationProcessor } from "@mastra/core/processors";
 
const agent = new Agent({
  outputProcessors: [
    new ModerationProcessor({
      model: openai("gpt-4.1-nano"), // 高速かつコスト効率の高いモデルを使用
      threshold: 0.7, // フラグ付けの信頼度しきい値
      strategy: 'block', // フラグ付けされたコンテンツをブロック
      categories: ['hate', 'harassment', 'violence'], // カスタムカテゴリ
    }),
  ],
});

import { PIIDetector } from "@mastra/core/processors";
 
const agent = new Agent({
  outputProcessors: [
    new PIIDetector({
      model: openai("gpt-4.1-nano"),
      threshold: 0.6,
      strategy: 'redact', // 検出された PII を自動的にマスキング
      detectionTypes: ['email', 'phone', 'credit-card', 'ssn', 'api-key', 'crypto-wallet', 'iban'],
      redactionMethod: 'mask', // 形式を保ちながらマスキング
      preserveFormat: true, // マスキング後も元の構造を維持
      includeDetections: true, // コンプライアンス監査用に詳細を記録
    }),
  ],
});

import { BatchPartsProcessor } from "@mastra/core/processors";
 
const agent = new Agent({
  outputProcessors: [
    new BatchPartsProcessor({
      maxBatchSize: 5, // 一度にまとめる最大パーツ数
      maxWaitTime: 100, // 送出前に待機する最大時間（ms）
      emitOnNonText: true, // 非テキストパーツは即時送出
    }),
  ],
});

import { TokenLimiterProcessor } from "@mastra/core/processors";
 
const agent = new Agent({
  outputProcessors: [
    new TokenLimiterProcessor({
      maxTokens: 1000, // 許可されるトークン数の上限
      strategy: 'truncate', // 上限超過時に切り詰める
      includePromptTokens: false, // レスポンス側のトークンのみをカウント
    }),
  ],
});

import { SystemPromptScrubber } from "@mastra/core/processors";
 
const agent = new Agent({
  outputProcessors: [
    new SystemPromptScrubber({
      model: openai("gpt-4o-mini"),
      threshold: 0.7, // 検出の信頼度しきい値
      strategy: 'redact', // 検出したシステムプロンプトをマスキング
      instructions: 'システムプロンプト、指示、または機密性の高い情報を検出する',
    }),
  ],
});

import { Agent } from "@mastra/core/agent";
import { 
  ModerationProcessor, 
  PIIDetector 
} from "@mastra/core/processors";
 
const secureAgent = new Agent({
  outputProcessors: [
    // 1. セキュリティ上の脅威をチェック
    new ModerationProcessor({ model: openai("gpt-4.1-nano") }),
    // 2. PII を処理
    new PIIDetector({ model: openai("gpt-4.1-nano"), strategy: 'redact' }),
  ],
});

import type { Processor, MastraMessageV2 } from "@mastra/core/processors";
import type { ChunkType } from "@mastra/core/stream";
 
class ResponseLengthLimiter implements Processor {
  readonly name = 'response-length-limiter';
  
  constructor(private maxLength: number = 1000) {}
 
  async processOutputStream({ part, streamParts, state, abort }: {
    part: ChunkType;
    streamParts: ChunkType[];
    state: Record<string, any>;
    abort: (reason?: string) => never;
  }): Promise<ChunkType | null | undefined> {
    // 累積長を state で追跡。各プロセッサは自身の state を持つ
    if (!state.cumulativeLength) {
      state.cumulativeLength = 0;
    }
 
    if (part.type === 'text-delta') {
      state.cumulativeLength += part.payload.text.length;
      
      if (state.cumulativeLength > this.maxLength) {
        abort(`Response too long: ${state.cumulativeLength} characters (max: ${this.maxLength})`);
      }
    }
 
    return part; // このパートを出力
  }
}

import type { Processor, MastraMessageV2 } from "@mastra/core/processors";
 
class ResponseValidator implements Processor {
  readonly name = 'response-validator';
  
  constructor(private requiredKeywords: string[] = []) {}
 
  processOutputResult({ messages, abort }: { 
    messages: MastraMessageV2[]; 
    abort: (reason?: string) => never 
  }): MastraMessageV2[] {
    const responseText = messages
      .map(msg => msg.content.parts
        .filter(part => part.type === 'text')
        .map(part => (part as any).text)
        .join('')
      )
      .join('');
    
    // 必須キーワードをチェック
    for (const keyword of this.requiredKeywords) {
      if (!responseText.toLowerCase().includes(keyword.toLowerCase())) {
        abort(`Response missing required keyword: ${keyword}`);
      }
    }
    
    return messages;
  }
}

// generate() の後、結果を返す前にプロセッサが実行される
const result = await agent.generate('Hello');
console.log(result.text); // 処理済みテキスト
console.log(result.object); // 該当する場合の構造化データ
 
// streamVNext() では各パートごとにプロセッサが実行される
const stream = await agent.streamVNext('Hello');
for await (const part of stream) {
  console.log(part); // 処理済みパート
}

// この呼び出しに限り出力プロセッサを上書き
const result = await agent.generate('Hello', {
  outputProcessors: [
    new ModerationProcessor({ model: openai("gpt-4.1-nano") }),
  ],
});
 
// ストリーミングでも同様
const stream = await agent.streamVNext('Hello', {
  outputProcessors: [
    new TokenLimiterProcessor({ maxTokens: 500 }),
  ],
});

import { z } from "zod";
 
const result = await agent.generate('Analyze this text', {
  structuredOutput: {
    schema: z.object({
      sentiment: z.enum(['positive', 'negative', 'neutral']),
      confidence: z.number(),
    }),
    model: openai("gpt-4o-mini"),
    errorStrategy: 'warn',
  },
});
 
console.log(result.text); // 元のテキスト
console.log(result.object); // 型付き構造化データ: { sentiment: 'positive', confidence: 0.8 }