SDK TypeScript

Cette bibliothèque fournit un accès pratique à la Claude API depuis TypeScript ou JavaScript.

Installation

npm install @anthropic-ai/sdk

Prérequis

TypeScript >= 4.9 est pris en charge.

Les environnements d'exécution suivants sont pris en charge :

• Node.js 20 LTS ou versions ultérieures (non-EOL).
• Deno v1.28.0 ou supérieur.
• Bun 1.0 ou ultérieur.
• Cloudflare Workers.
• Vercel Edge Runtime.
• Jest 28 ou supérieur avec l'environnement "node" ("jsdom" n'est pas pris en charge pour le moment).
• Nitro v2.6 ou supérieur.
• Navigateurs web : désactivés par défaut pour éviter d'exposer vos identifiants API secrets (consultez les bonnes pratiques relatives aux clés API). Activez la prise en charge des navigateurs en définissant explicitement dangerouslyAllowBrowser sur true.

Notez que React Native n'est pas pris en charge pour le moment.

Si vous êtes intéressé par d'autres environnements d'exécution, ouvrez un ticket ou votez pour un ticket existant sur le dépôt GitHub.

Utilisation

const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5"
});

for (const block of message.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

Pour les options d'authentification, y compris Workload Identity Federation, consultez Authentification. Si votre clé API est une clé personnelle ou de compte de service ayant accès à plusieurs espaces de travail, définissez l'identifiant de l'espace de travail dans l'en-tête de requête anthropic-workspace-id ; Sélectionner un espace de travail présente l'option par requête pour ce SDK.

Types de requêtes et de réponses

Cette bibliothèque inclut des définitions TypeScript pour tous les paramètres de requête et champs de réponse. Vous pouvez les importer et les utiliser comme suit :

const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const params: Anthropic.MessageCreateParams = {
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5"
};
const message: Anthropic.Message = await client.messages.create(params);

La documentation de chaque méthode, paramètre de requête et champ de réponse est disponible dans les docstrings et s'affiche au survol dans la plupart des éditeurs modernes.

Comptage des tokens

Vous pouvez consulter l'utilisation exacte pour une requête donnée via la propriété de réponse usage, par exemple :

const message = await client.messages.create(/* ... */);
console.log(message.usage);
// { input_tokens: 25, output_tokens: 13 }

Réponses en streaming

Le SDK prend en charge le « streaming » (diffusion en flux continu) des réponses à l'aide des « Server Sent Events » (événements envoyés par le serveur), ou SSE.

const client = new Anthropic();

const stream = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5",
  stream: true
});
for await (const messageStreamEvent of stream) {
  console.log(messageStreamEvent.type);
}

Si vous devez annuler un flux, vous pouvez utiliser break pour sortir de la boucle ou appeler stream.controller.abort().

Assistants de streaming

Cette bibliothèque fournit plusieurs commodités pour le streaming des messages, par exemple :

const anthropic = new Anthropic();

const stream = anthropic.messages
  .stream({
    model: "claude-opus-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: "Say hello there!"
      }
    ]
  })
  .on("text", (text) => {
    console.log(text);
  });

const message = await stream.finalMessage();
console.log(message);

Le streaming avec client.messages.stream(...) expose divers assistants pour votre commodité, notamment des gestionnaires d'événements et l'accumulation.

Vous pouvez également utiliser client.messages.create({ ..., stream: true }), qui renvoie uniquement un itérable asynchrone des événements du flux et utilise donc moins de mémoire (il ne construit pas d'objet message final pour vous).

Assistants d'outils

Ce SDK fournit des assistants pour faciliter la création et l'exécution d'outils dans l'API Messages. Vous pouvez utiliser des schémas Zod ou des JSON Schemas pour décrire l'entrée d'un outil. Vous pouvez ensuite exécuter ces outils à l'aide de la méthode client.beta.messages.toolRunner(). Cette méthode se charge de transmettre les entrées générées par le modèle choisi au bon outil et de renvoyer le résultat au modèle.

Pour plus de détails sur le « tool use » (utilisation d'outils), consultez Utilisation d'outils avec Claude.

import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
import { z } from "zod";

const anthropic = new Anthropic();

const weatherTool = betaZodTool({
  name: "get_weather",
  inputSchema: z.object({
    location: z.string()
  }),
  description: "Get the current weather in a given location",
  run: (input) => {
    return `The weather in ${input.location} is foggy and 60°F`;
  }
});

const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-5",
  max_tokens: 1000,
  messages: [{ role: "user", content: "What is the weather in San Francisco?" }],
  tools: [weatherTool]
});

console.log(finalMessage.content);

Erreurs d'outils

Pour signaler une erreur d'un outil au modèle, levez une ToolError depuis la fonction run. Contrairement à une simple Error, ToolError accepte des blocs de contenu, ce qui vous permet d'inclure des images ou d'autres contenus structurés dans la réponse d'erreur :

import { ToolError } from "@anthropic-ai/sdk/lib/tools/BetaRunnableTool";

const screenshotTool = betaZodTool({
  name: "take_screenshot",
  inputSchema: z.object({ url: z.string() }),
  run: async (input) => {
    if (!isValidUrl(input.url)) {
      throw new ToolError(`Invalid URL: ${input.url}`);
    }
    const result = await takeScreenshot(input.url);
    if (result.error) {
      // Inclure la capture d'écran de l'erreur pour que le modèle voie ce qui a mal tourné
      throw new ToolError([
        { type: "text", text: `Failed to load page: ${result.error}` },
        {
          type: "image",
          source: { type: "base64", data: result.screenshot, media_type: "image/png" }
        }
      ]);
    }
    return {
      type: "image",
      source: { type: "base64", data: result.screenshot, media_type: "image/png" }
    };
  }
});

Si une simple Error est levée, le message sera converti en bloc de contenu texte.

Utilisation d'outils

Ce SDK prend en charge l'utilisation d'outils, également appelée appel de fonctions. Pour plus de détails, consultez Utilisation d'outils avec Claude.

Assistants MCP

Ce SDK fournit des assistants pour l'intégration avec les serveurs Model Context Protocol (MCP). Ces assistants convertissent les types MCP en types de la Claude API, réduisant le code répétitif lors de l'utilisation des outils, prompts et ressources MCP.

import {
  mcpTools,
  mcpMessages,
  mcpResourceToContent,
  mcpResourceToFile
} from "@anthropic-ai/sdk/helpers/beta/mcp";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const anthropic = new Anthropic();

// Se connecter à un serveur MCP
const transport = new StdioClientTransport({ command: "mcp-server", args: [] });
const mcpClient = new Client({ name: "my-client", version: "1.0.0" });
await mcpClient.connect(transport);

// Utiliser les prompts MCP
const { messages } = await mcpClient.getPrompt({ name: "my-prompt" });
const response = await anthropic.beta.messages.create({
  model: "claude-opus-5",
  max_tokens: 1024,
  messages: mcpMessages(messages)
});
console.log(response.content);

// Utiliser les outils MCP avec toolRunner
const { tools } = await mcpClient.listTools();
const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Use the available tools" }],
  tools: mcpTools(tools, mcpClient)
});
console.log(finalMessage.content);

// Utiliser les ressources MCP comme contenu
const resource = await mcpClient.readResource({ uri: "file:///path/to/doc.txt" });
await anthropic.beta.messages.create({
  model: "claude-opus-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        mcpResourceToContent(resource),
        { type: "text", text: "Summarize this document" }
      ]
    }
  ]
});

// Téléverser les ressources MCP en tant que fichiers
const fileResource = await mcpClient.readResource({ uri: "file:///path/to/data.json" });
await anthropic.files.upload({ file: mcpResourceToFile(fileResource) });

Gestion des erreurs MCP

Les fonctions de conversion lèvent une UnsupportedMCPValueError si une valeur MCP n'est pas prise en charge par la Claude API (par exemple, type de contenu non pris en charge, type MIME non pris en charge, lien de ressource non http/https).

Lots de messages

Ce SDK prend en charge le traitement par lots sous l'espace de noms client.messages.batches.

Création d'un lot

Message Batches accepte un tableau de requêtes, où chaque objet possède un identifiant custom_id et exactement les mêmes params de requête que l'API Messages standard :

const batch = await client.messages.batches.create({
  requests: [
    {
      custom_id: "my-first-request",
      params: {
        model: "claude-opus-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hello, world" }]
      }
    },
    {
      custom_id: "my-second-request",
      params: {
        model: "claude-opus-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hi again, friend" }]
      }
    }
  ]
});

Obtention des résultats d'un lot

Une fois qu'un lot de messages a été traité, ce qui est indiqué par .processing_status === 'ended', vous pouvez accéder aux résultats avec .batches.results()

const results = await client.messages.batches.results(batch.id);
for await (const entry of results) {
  if (entry.result.type === "succeeded") {
    console.log(entry.result.message.content);
  }
}

Téléversement de fichiers

Les paramètres de requête correspondant à des téléversements de fichiers peuvent être transmis sous de nombreuses formes différentes :

• File (ou un objet ayant la même structure)
• une Response de fetch (ou un objet ayant la même structure)
• un fs.ReadStream
• la valeur de retour de l'assistant toFile

Définissez explicitement le content-type, car l'API Files ne le déduira pas pour vous :

import fs from "node:fs";
import Anthropic, { toFile } from "@anthropic-ai/sdk";

const client = new Anthropic();

// Si vous avez accès à `fs` de Node, utilisez `fs.createReadStream()` :
await client.files.upload({
  file: await toFile(fs.createReadStream("/path/to/file"), undefined, {
    type: "application/json"
  })
});

// Ou si vous disposez de l'API web `File`, vous pouvez passer une instance de `File` :
await client.files.upload({
  file: new File(["my bytes"], "file.txt", { type: "text/plain" })
});
// Vous pouvez également passer une `Response` de `fetch` :
await client.files.upload({
  file: await fetch("https://somesite/file")
});

// Ou un `Buffer` / `Uint8Array`
await client.files.upload({
  file: await toFile(Buffer.from("my bytes"), "file", { type: "text/plain" })
});
await client.files.upload({
  file: await toFile(new Uint8Array([0, 1, 2]), "file", { type: "text/plain" })
});

Gestion des erreurs

Lorsque la bibliothèque ne parvient pas à se connecter à l'API, ou si l'API renvoie un code de statut d'échec (c'est-à-dire une réponse 4xx ou 5xx), une sous-classe de APIError est levée :

const message = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5"
  })
  .catch(async (err) => {
    if (err instanceof Anthropic.APIError) {
      console.log(err.status); // 400
      console.log(err.name); // BadRequestError
      console.log(err.headers); // {server: 'nginx', ...}
    } else {
      throw err;
    }
  });

Les codes d'erreur sont les suivants :

Identifiants de requête

Pour plus d'informations sur le débogage des requêtes, consultez Identifiant de requête.

Toutes les réponses objet du SDK fournissent une propriété _request_id ajoutée à partir de l'en-tête de réponse request-id, afin que vous puissiez rapidement journaliser les requêtes en échec et les signaler à Anthropic.

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5"
});
console.log(message._request_id); // req_018EeWyXxfu5pfWkrYcMdjWG

Nouvelles tentatives

Certaines erreurs font automatiquement l'objet de 2 nouvelles tentatives par défaut, avec un court délai d'attente exponentiel. Les erreurs de connexion (par exemple, en raison d'un problème de connectivité réseau), 408 Request Timeout, 409 Conflict, 429 Rate Limit et les erreurs internes >=500 font toutes l'objet de nouvelles tentatives par défaut.

Vous pouvez utiliser l'option maxRetries pour configurer ou désactiver ce comportement :

// Configurez la valeur par défaut pour toutes les requêtes :
const client = new Anthropic({
  maxRetries: 0 // default is 2
});

// Ou configurez-la par requête :
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5"
  },
  { maxRetries: 5 }
);

Délais d'expiration

Par défaut, les requêtes expirent après 10 minutes. Cependant, si vous avez spécifié une valeur max_tokens élevée et que vous n'utilisez pas le streaming, le délai d'expiration par défaut sera calculé dynamiquement à l'aide de la formule :

const minimum = 10 * 60;
const calculated = (60 * 60 * maxTokens) / 128_000;
return calculated < minimum ? minimum * 1000 : calculated * 1000;

ce qui donnera un délai d'expiration allant jusqu'à 60 minutes, proportionnel au paramètre max_tokens, sauf s'il est remplacé au niveau de la requête ou du client.

Vous pouvez configurer cela avec une option timeout :

// Configurez la valeur par défaut pour toutes les requêtes :
const client = new Anthropic({
  timeout: 20 * 1000 // 20 seconds (default is 10 minutes)
});

// Remplacez-la pour une requête donnée :
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5"
  },
  { timeout: 5 * 1000 }
);

En cas d'expiration du délai, une APIConnectionTimeoutError est levée.

Notez que les requêtes qui expirent font l'objet de deux nouvelles tentatives par défaut.

Requêtes longues

Évitez de définir une valeur max_tokens élevée sans utiliser le streaming. Certains réseaux peuvent interrompre les connexions inactives après un certain temps, ce qui peut entraîner l'échec de la requête ou son expiration sans recevoir de réponse d'Anthropic.

Ce SDK lève également une erreur si une requête sans streaming est censée durer plus de 10 minutes environ. Passer stream: true ou remplacer l'option timeout au niveau du client ou de la requête désactive cette erreur.

Une « latency » (latence) de requête attendue supérieure au délai d'expiration pour une requête sans streaming entraînera la fermeture de la connexion par le client et une nouvelle tentative sans réception de réponse.

Lorsque l'implémentation de fetch le permet, le SDK définit une option TCP socket keep-alive afin de réduire l'impact des délais d'expiration des connexions inactives sur certains réseaux. Cela peut être remplacé en configurant un proxy personnalisé.

Pagination automatique

Les méthodes de liste de la Claude API sont paginées. Vous pouvez utiliser la syntaxe for await ... of pour parcourir les éléments de toutes les pages :

async function fetchAllMessageBatches() {
  const allMessageBatches = [];
  // Récupère automatiquement d'autres pages selon les besoins.
  for await (const messageBatch of client.messages.batches.list({ limit: 20 })) {
    allMessageBatches.push(messageBatch);
  }
  return allMessageBatches;
}

Vous pouvez également demander une seule page à la fois :

let page = await client.messages.batches.list({ limit: 20 });
for (const messageBatch of page.data) {
  console.log(messageBatch);
}

// Des méthodes pratiques sont fournies pour paginer manuellement :
while (page.hasNextPage()) {
  page = await page.getNextPage();
  // ...
}

En-têtes par défaut

Le SDK envoie automatiquement l'en-tête anthropic-version défini sur 2023-06-01.

Si nécessaire, vous pouvez le remplacer en définissant des en-têtes par défaut pour chaque requête.

Sachez que cela peut entraîner des types incorrects et d'autres comportements inattendus ou indéfinis dans le SDK.

const client = new Anthropic();

const message = await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5"
  },
  { headers: { "anthropic-version": "My-Custom-Value" } }
);

Utilisation avancée

Accès aux données brutes de Response (par exemple, les en-têtes)

La Response « brute » renvoyée par fetch() est accessible via la méthode .asResponse() du type APIPromise que toutes les méthodes renvoient. Cette méthode retourne dès que les en-têtes d'une réponse réussie sont reçus et ne consomme pas le corps de la réponse, vous êtes donc libre d'écrire une logique d'analyse ou de streaming personnalisée.

Vous pouvez également utiliser la méthode .withResponse() pour obtenir la Response brute ainsi que les données analysées. Contrairement à .asResponse(), cette méthode consomme le corps et retourne une fois celui-ci analysé.

const client = new Anthropic();

const response = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5"
  })
  .asResponse();
console.log(response.headers.get("X-My-Header"));
console.log(response.statusText); // access the underlying Response object

const { data: message, response: raw } = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5"
  })
  .withResponse();
console.log(raw.headers.get("X-My-Header"));
console.log(message.content);

Journalisation

Niveaux de journalisation

Vous pouvez configurer le niveau de journalisation de deux manières :

1. Via la variable d'environnement ANTHROPIC_LOG
2. À l'aide de l'option client logLevel (remplace la variable d'environnement si elle est définie)

const client = new Anthropic({
  logLevel: "debug" // Show all log messages
});

Niveaux de journalisation disponibles, du plus au moins verbeux :

• 'debug' - Affiche les messages de débogage, les informations, les avertissements et les erreurs
• 'info' - Affiche les messages d'information, les avertissements et les erreurs
• 'warn' - Affiche les avertissements et les erreurs (par défaut)
• 'error' - Affiche uniquement les erreurs
• 'off' - Désactive toute journalisation

Au niveau 'debug', toutes les requêtes et réponses HTTP sont journalisées, y compris les en-têtes et les corps. Certains en-têtes liés à l'authentification sont masqués, mais les données sensibles dans les corps de requête et de réponse peuvent rester visibles.

Journaliseur personnalisé

Par défaut, cette bibliothèque journalise vers globalThis.console. Vous pouvez également fournir un journaliseur personnalisé. La plupart des bibliothèques de journalisation sont prises en charge, notamment pino, winston, bunyan, consola, signale et @std/log. Si votre journaliseur ne fonctionne pas, ouvrez un ticket.

Lorsque vous fournissez un journaliseur personnalisé, l'option logLevel contrôle toujours quels messages sont émis ; les messages inférieurs au niveau configuré ne seront pas envoyés à votre journaliseur.

import pino from "pino";

const logger = pino();

const client = new Anthropic({
  logger: logger.child({ name: "Anthropic" }),
  logLevel: "debug" // Send all messages to pino, allowing it to filter
});

Effectuer des requêtes personnalisées/non documentées

Cette bibliothèque est typée pour un accès pratique à l'API documentée. Si vous devez accéder à des points de terminaison, paramètres ou propriétés de réponse non documentés, la bibliothèque peut tout de même être utilisée.

Points de terminaison non documentés

Pour effectuer des requêtes vers des points de terminaison non documentés, vous pouvez utiliser client.get, client.post et d'autres verbes HTTP. Les options du client, telles que les nouvelles tentatives, sont respectées lors de ces requêtes.

await client.post("/some/path", {
  body: { some_prop: "foo" },
  query: { some_query_arg: "bar" }
});

Paramètres de requête non documentés

Pour effectuer des requêtes avec des paramètres non documentés, vous pouvez utiliser // @ts-expect-error sur le paramètre non documenté. Cette bibliothèque ne valide pas à l'exécution que la requête correspond au type, donc toutes les valeurs supplémentaires que vous envoyez seront transmises telles quelles.

client.messages.create({
  // ...
  // @ts-expect-error baz is not yet public
  baz: "undocumented option"
});

Pour les requêtes avec le verbe GET, tous les paramètres supplémentaires seront placés dans la chaîne de requête ; toutes les autres requêtes enverront le paramètre supplémentaire dans le corps.

Si vous souhaitez envoyer explicitement un argument supplémentaire, vous pouvez le faire avec les options de requête query, body et headers.

Propriétés de réponse non documentées

Pour accéder aux propriétés de réponse non documentées, vous pouvez accéder à l'objet de réponse avec // @ts-expect-error sur l'objet de réponse, ou convertir l'objet de réponse vers le type requis. Comme pour les paramètres de requête, le SDK ne valide ni ne supprime les propriétés supplémentaires de la réponse de l'API.

Personnalisation du client fetch

Par défaut, cette bibliothèque s'attend à ce qu'une fonction globale fetch soit définie.

Si vous souhaitez utiliser une fonction fetch différente, vous pouvez soit appliquer un polyfill à la fonction globale :

import fetch from "my-fetch";

globalThis.fetch = fetch;

Soit la transmettre au client :

import fetch from "my-fetch";

const client = new Anthropic({ fetch });

Options fetch

Si vous souhaitez définir des options fetch personnalisées sans remplacer la fonction fetch, vous pouvez fournir un objet fetchOptions lors de la création du client ou de l'exécution d'une requête. (Les options spécifiques à la requête remplacent les options du client.)

const client = new Anthropic({
  fetchOptions: {
    // Options `RequestInit`
  }
});

Configuration des proxys

Pour modifier le comportement du proxy, vous pouvez fournir des fetchOptions personnalisées qui ajoutent aux requêtes des options de proxy spécifiques à l'environnement d'exécution :

import * as undici from "undici";

const proxyAgent = new undici.ProxyAgent("http://localhost:8888");
const client = new Anthropic({
  fetchOptions: {
    dispatcher: proxyAgent
  }
});

Fonctionnalités bêta

Les fonctionnalités bêta sont disponibles avant leur publication générale afin de recueillir des retours précoces et de tester de nouvelles fonctionnalités. Vous pouvez vérifier la disponibilité de toutes les capacités et outils de Claude dans la vue d'ensemble Construire avec Claude.

Vous pouvez accéder à la plupart des fonctionnalités bêta de l'API via la propriété beta du client. Pour activer une fonctionnalité bêta particulière, vous devez ajouter l'en-tête bêta approprié au champ betas lors de la création d'un message.

Par exemple, pour activer l'édition de contexte :

const client = new Anthropic();
const response = await client.beta.messages.create({
  model: "claude-opus-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  betas: ["context-management-2025-06-27"]
});

Prise en charge des environnements d'exécution

Intégrations de plateformes

Le SDK TypeScript prend en charge les plateformes suivantes :

• Agent Platform : npm install @anthropic-ai/vertex-sdk : fournit le client AnthropicVertex
• Bedrock : npm install @anthropic-ai/bedrock-sdk : fournit le client AnthropicBedrockMantle, ainsi que AnthropicBedrock pour le chemin bedrock-runtime
• Claude Platform sur AWS : npm install @anthropic-ai/aws-sdk : fournit le client AnthropicAws. Passez workspaceId au constructeur ou définissez la variable d'environnement ANTHROPIC_AWS_WORKSPACE_ID. Disponible en bêta.
• Foundry : npm install @anthropic-ai/foundry-sdk : fournit le client AnthropicFoundry

Utilisez AnthropicBedrockMantle pour les nouveaux projets ; AnthropicBedrock reste disponible pour les applications existantes utilisant l'API InvokeModel de Bedrock.

Gestion sémantique des versions

Ce paquet suit généralement les conventions SemVer, bien que certaines modifications non rétrocompatibles puissent être publiées en tant que versions mineures :

1. Les modifications qui n'affectent que les types statiques, sans rompre le comportement à l'exécution.
2. Les modifications des éléments internes de la bibliothèque qui sont techniquement publics mais ne sont ni destinés ni documentés pour un usage externe.
3. Les modifications qui ne devraient pas affecter la grande majorité des utilisateurs en pratique.

La rétrocompatibilité est prise au sérieux afin que vous puissiez compter sur une expérience de mise à niveau fluide.

Foire aux questions

Consultez le dépôt GitHub pour les FAQ, les tickets et l'assistance de la communauté.

Ressources supplémentaires

• Dépôt GitHub
• Référence de l'API
• Streaming des messages
• Utilisation d'outils avec Claude