> ## Documentation Index
> Fetch the complete documentation index at: https://docs.responsibleailabs.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Fournisseurs et Références

> Enveloppes de fournisseurs LLM (OpenAI, Anthropic, Gemini), observabilité, gestion des erreurs, fonctions utilitaires et types TypeScript.

## Enveloppes de fournisseurs LLM

Enveloppes prêtes à l'emploi qui ajoutent un score RAIL automatique à vos appels LLM existants. Toutes les enveloppes retournent `{ response, content, railScore, evaluation }`.

### OpenAI

```typescript theme={null}
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: "Explain quantum computing simply." }],
});

console.log(result.content);            // Texte de réponse LLM
console.log(result.railScore.score);    // Score RAIL
console.log(result.evaluation);         // Résultat d'évaluation complet
```

### Anthropic

```typescript theme={null}
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: "Explain quantum computing simply." }],
});

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

### Google Gemini

```typescript theme={null}
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("Explain quantum computing simply.");
console.log(result.content);
console.log(result.railScore.score);
```

## Observabilité

### Langfuse

```typescript theme={null}
import { RAILLangfuse } from '@responsible-ai-labs/rail-score';
import { Langfuse } from 'langfuse';

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

// Évaluer le contenu et pousser les scores vers une trace Langfuse
const result = await railLangfuse.traceEvaluation("trace-id", "Contenu à évaluer");

// Pousser un résultat d'évaluation existant vers une trace
await railLangfuse.scoreTrace("trace-id", existingResult);
```

### Gestionnaire Guardrail

```typescript theme={null}
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("Message de l'utilisateur");
if (!preResult.allowed) {
  console.log("Entrée bloquée :", preResult.failedDimensions);
}

const postResult = await guardrail.postCall("Réponse LLM");
if (!postResult.allowed) {
  console.log("Sortie bloquée :", postResult.failedDimensions);
}
```

## Gestion des erreurs

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

try {
  const result = await client.eval({ content: "Contenu à évaluer" });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error("Clé API invalide");
  } else if (error instanceof InsufficientCreditsError) {
    console.error(`Besoin de ${error.required} crédits, en avoir ${error.balance}`);
  } else if (error instanceof RateLimitError) {
    console.error(`Limite de taux dépassée. Réessayez après ${error.retryAfter}s`);
  } else if (error instanceof ContentTooHarmfulError) {
    console.error("Contenu trop nuisible pour être régénéré (score moyen < 3.0)");
  } else if (error instanceof SessionExpiredError) {
    console.error("Session de régénération sécurisée expirée (TTL de 15 min)");
  } else if (error instanceof RAILBlockedError) {
    console.error(`Bloqué par la politique : ${error.policyMode}`);
  }
}
```

| Erreur                     | Statut | Quand                                         |
| -------------------------- | ------ | --------------------------------------------- |
| `AuthenticationError`      | 401    | Clé API invalide ou manquante                 |
| `InsufficientCreditsError` | 402    | Pas assez de crédits                          |
| `InsufficientTierError`    | 403    | La fonctionnalité nécessite un plan supérieur |
| `ValidationError`          | 400    | Paramètres invalides                          |
| `ContentTooLongError`      | 400    | Le contenu dépasse la longueur maximale       |
| `SessionExpiredError`      | 410    | Session de régénération sécurisée expirée     |
| `ContentTooHarmfulError`   | 422    | Score moyen du contenu en dessous de 3.0      |
| `RateLimitError`           | 429    | Limite de taux dépassée                       |
| `RAILBlockedError`         | —      | Contenu bloqué par le moteur de politique     |

## Fonctions utilitaires

```typescript theme={null}
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);                      // "Excellent"
getScoreColor(8.5);                      // "vert"
getScoreGrade(8.5);                      // "A-"
formatScore(8.567, 2);                   // "8.57"
formatDimensionName("user_impact");      // "Impact utilisateur"
normalizeDimensionName("legal_compliance"); // "inclusivité"
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);
```

## Types TypeScript

```typescript theme={null}
import type {
  // Client
  RailScoreConfig,

  // Évaluation
  EvalParams, EvalResult, EvalIssue, DimensionScore,
  Dimension, EvaluationMode, ContentDomain, ScoreLabel,

  // Régénération sécurisée
  SafeRegenerateParams, SafeRegenerateResult, SafeRegenerateContinueParams,

  // Conformité
  ComplianceCheckSingleParams, ComplianceCheckMultiParams,
  ComplianceResult, MultiComplianceResult, ComplianceFramework,

  // Session & Politique
  SessionConfig, SessionMetrics, PolicyMode, PolicyConfig, MiddlewareConfig,

  // Observabilité
  GuardResult, RAILGuardrailConfig,
} from '@responsible-ai-labs/rail-score';
```

## Quelles sont les prochaines étapes

<CardGroup cols={2}>
  <Card title="Référence de l'API d'évaluation" icon="code" href="/api-reference/evaluation">
    Paramètres HTTP complets et schéma de réponse.
  </Card>

  <Card title="API de conformité" icon="shield-check" href="/api-reference/compliance">
    RGPD, HIPAA, Loi sur l'IA de l'UE et plus encore.
  </Card>

  <Card title="Crédits et Tarification" icon="coins" href="/getting-started/credits">
    Coûts des crédits par point de terminaison et mode.
  </Card>

  <Card title="Aperçu des intégrations" icon="puzzle-piece" href="/integrations/overview">
    Tous les fournisseurs LLM et outils d'observabilité pris en charge.
  </Card>
</CardGroup>