プロバイダーとリファレンス

import { RAILOpenAI } from '@responsible-ai-labs/rail-score';
import OpenAI from 'openai';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const railOpenAI = new RAILOpenAI(client, openai, {
  thresholds: { safety: 7.0 },
});

const result = await railOpenAI.chat({
  model: "gpt-4o",
  messages: [{ role: "user", content: "量子コンピューティングを簡単に説明してください。" }],
});

console.log(result.content);            // LLMの応答テキスト
console.log(result.railScore.score);    // RAILスコア
console.log(result.evaluation);         // 完全なEvalResult

import { RAILAnthropic } from '@responsible-ai-labs/rail-score';
import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();
const railAnthropic = new RAILAnthropic(client, anthropic, {
  thresholds: { safety: 7.0 },
});

const result = await railAnthropic.message({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [{ role: "user", content: "量子コンピューティングを簡単に説明してください。" }],
});

console.log(result.content);
console.log(result.railScore.score);

import { RAILGemini } from '@responsible-ai-labs/rail-score';
import { GoogleGenerativeAI } from '@google/generative-ai';

const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
const railGemini = new RAILGemini(client, model, {
  thresholds: { safety: 7.0 },
});

const result = await railGemini.generate("量子コンピューティングを簡単に説明してください。");
console.log(result.content);
console.log(result.railScore.score);

import { RAILLangfuse } from '@responsible-ai-labs/rail-score';
import { Langfuse } from 'langfuse';

const langfuse = new Langfuse({ publicKey: "...", secretKey: "..." });
const railLangfuse = new RAILLangfuse(client, langfuse);

// コンテンツを評価し、スコアをLangfuseトレースにプッシュ
const result = await railLangfuse.traceEvaluation("trace-id", "評価するコンテンツ");

// 既存の評価結果をトレースにプッシュ
await railLangfuse.scoreTrace("trace-id", existingResult);

import { RAILGuardrail } from '@responsible-ai-labs/rail-score';

const guardrail = new RAILGuardrail(client, {
  inputThresholds:  { safety: 7.0 },
  outputThresholds: { safety: 7.0, fairness: 7.0 },
});

const preResult = await guardrail.preCall("ユーザーメッセージ");
if (!preResult.allowed) {
  console.log("入力がブロックされました:", preResult.failedDimensions);
}

const postResult = await guardrail.postCall("LLMの応答");
if (!postResult.allowed) {
  console.log("出力がブロックされました:", postResult.failedDimensions);
}

import {
  AuthenticationError,
  InsufficientCreditsError,
  InsufficientTierError,
  ValidationError,
  ContentTooLongError,
  SessionExpiredError,
  ContentTooHarmfulError,
  RateLimitError,
  RAILBlockedError
} from '@responsible-ai-labs/rail-score';

try {
  const result = await client.eval({ content: "評価するコンテンツ" });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error("無効なAPIキー");
  } else if (error instanceof InsufficientCreditsError) {
    console.error(`必要なクレジット: ${error.required}, 残高: ${error.balance}`);
  } else if (error instanceof RateLimitError) {
    console.error(`レート制限。${error.retryAfter}s後に再試行してください`);
  } else if (error instanceof ContentTooHarmfulError) {
    console.error("再生成するにはコンテンツが有害すぎます（平均スコア < 3.0）");
  } else if (error instanceof SessionExpiredError) {
    console.error("安全再生成セッションが期限切れです（15分TTL）");
  } else if (error instanceof RAILBlockedError) {
    console.error(`ポリシーによってブロックされました: ${error.policyMode}`);
  }
}

import {
  getScoreLabel, getScoreColor, getScoreGrade, formatScore,
  formatDimensionName, normalizeDimensionName, resolveFrameworkAlias,
  validateWeights, normalizeWeights, calculateWeightedScore,
  isPassing, getDimensionsBelowThreshold, getLowestScoringDimension,
  getHighestScoringDimension, aggregateScores
} from '@responsible-ai-labs/rail-score';

getScoreLabel(8.5);                      // "優秀"
getScoreColor(8.5);                      // "緑"
getScoreGrade(8.5);                      // "A-"
formatScore(8.567, 2);                   // "8.57"
formatDimensionName("user_impact");      // "ユーザーインパクト"
normalizeDimensionName("legal_compliance"); // "包括性"
resolveFrameworkAlias("ai_act");         // "eu_ai_act"

const weakAreas = getDimensionsBelowThreshold(result, 7.0);
const lowest = getLowestScoringDimension(result);
const stats = aggregateScores([result1, result2, result3]);
console.log(stats.averageScore, stats.minScore, stats.maxScore);

import type {
  // クライアント
  RailScoreConfig,

  // 評価
  EvalParams, EvalResult, EvalIssue, DimensionScore,
  Dimension, EvaluationMode, ContentDomain, ScoreLabel,

  // 安全再生成
  SafeRegenerateParams, SafeRegenerateResult, SafeRegenerateContinueParams,

  // コンプライアンス
  ComplianceCheckSingleParams, ComplianceCheckMultiParams,
  ComplianceResult, MultiComplianceResult, ComplianceFramework,

  // セッションとポリシー
  SessionConfig, SessionMetrics, PolicyMode, PolicyConfig, MiddlewareConfig,

  // 可観測性
  GuardResult, RAILGuardrailConfig,
} from '@responsible-ai-labs/rail-score';