--- title: SDK TypeScript url: https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript description: Installez et configurez le SDK TypeScript Anthropic pour Node.js, Deno, Bun et les environnements de navigateur --- Cette bibliothèque fournit un accès pratique à la Claude API depuis TypeScript ou JavaScript. Pour la documentation des fonctionnalités de l'API avec des exemples de code, consultez la [référence de l'API](https://platform.claude.com/docs/fr/api/overview). Cette page couvre les fonctionnalités et la configuration du SDK spécifiques à TypeScript. ## Installation ```bash npm install @anthropic-ai/sdk ``` ## Prérequis TypeScript >= 5.0 est pris en charge. Les environnements d'exécution suivants sont pris en charge : * Node.js 20 LTS ou versions ultérieures ([non-EOL](https://endoflife.date/nodejs)). * 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](https://support.claude.com/en/articles/9767949-api-key-best-practices-keeping-your-keys-safe-and-secure)). 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](https://github.com/anthropics/anthropic-sdk-typescript). ## Utilisation ```typescript 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-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](https://platform.claude.com/docs/fr/manage-claude/authentication). Si votre clé API est une [clé personnelle ou de compte de service](https://platform.claude.com/docs/fr/manage-claude/authentication#key-types) 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](https://platform.claude.com/docs/fr/manage-claude/authentication#select-a-workspace) 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 : ```typescript 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-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 : ```typescript const message = await client.messages.create({ max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }], model: "claude-opus-5-5" }); console.log(message.usage); // { input_tokens: 25, output_tokens: 13 } ``` ## Réponses en streaming Le SDK prend en charge les réponses en « streaming » (diffusion en flux continu) à l'aide des « Server-Sent Events » (événements envoyés par le serveur), ou SSE. ```typescript const client = new Anthropic(); const stream = await client.messages.create({ max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }], model: "claude-opus-5-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 : ```typescript const anthropic = new Anthropic(); const stream = anthropic.messages .stream({ model: "claude-opus-5-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](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview). Pour exécuter l'outil d'utilisation du navigateur ou l'outil d'utilisation de l'ordinateur avec ce SDK, consultez [Utilisation du navigateur et de l'ordinateur avec les ensembles d'outils du SDK](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-sdk). ```typescript 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-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 : ```typescript 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](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview). ## Assistants MCP Ce SDK fournit des assistants pour l'intégration avec les serveurs [Model Context Protocol (MCP)](https://modelcontextprotocol.io/). 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. La Claude API prend également en charge un [paramètre `mcp_servers`](https://platform.claude.com/docs/fr/agents-and-tools/mcp-connector) qui permet à Claude de se connecter directement à des serveurs MCP distants. Utilisez `mcp_servers` lorsque vous disposez de serveurs distants accessibles par URL et que vous n'avez besoin que de la prise en charge des outils. Utilisez les assistants MCP lorsque vous avez besoin de serveurs MCP locaux, de prompts, de ressources ou d'un contrôle accru sur la connexion MCP. ```typescript 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-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-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-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 `UnsupportedMCPValueError` si une valeur MCP n'est pas prise en charge par l'API Claude (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](https://platform.claude.com/docs/fr/build-with-claude/batch-processing) 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 : ```typescript const batch = await client.messages.batches.create({ requests: [ { custom_id: "my-first-request", params: { model: "claude-opus-5-5", max_tokens: 1024, messages: [{ role: "user", content: "Hello, world" }] } }, { custom_id: "my-second-request", params: { model: "claude-opus-5-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()` ```typescript 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 type de contenu, car l'API Files ne le déduira pas pour vous : ```typescript 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 : ```typescript const message = await client.messages .create({ max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }], model: "claude-opus-5-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 : | Code de statut | Type d'erreur | | -------------- | -------------------------- | | 400 | `BadRequestError` | | 401 | `AuthenticationError` | | 403 | `PermissionDeniedError` | | 404 | `NotFoundError` | | 409 | `ConflictError` | | 422 | `UnprocessableEntityError` | | 429 | `RateLimitError` | | >=500 | `InternalServerError` | | N/A | `APIConnectionError` | ## Identifiants de requête > Pour plus d'informations sur le débogage des requêtes, consultez [Identifiant de requête](https://platform.claude.com/docs/fr/api/errors#request-id). 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. ```typescript const message = await client.messages.create({ max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }], model: "claude-opus-5-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 : ```typescript // 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-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 : ```typescript 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` : ```typescript // 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 chaque requête : await client.messages.create( { max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }], model: "claude-opus-5-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](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#retries). ## Requêtes longues Envisagez d'utiliser l'[API Messages](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#streaming-responses) en streaming pour les requêtes de longue durée. É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](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#timeouts) 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](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#timeouts) 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](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#timeouts) 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](https://tldp.org/HOWTO/TCP-Keepalive-HOWTO/overview.html) afin de réduire l'impact des délais d'expiration des connexions inactives sur certains réseaux. Cela peut être [remplacé](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#configuring-proxies) 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 : ```typescript 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 : ```typescript 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. ```typescript const client = new Anthropic(); const message = await client.messages.create( { max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }], model: "claude-opus-5-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é. ```typescript const client = new Anthropic(); const response = await client.messages .create({ max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }], model: "claude-opus-5-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-5" }) .withResponse(); console.log(raw.headers.get("X-My-Header")); console.log(message.content); ``` ### Journalisation Tous les messages de journal sont destinés uniquement au débogage. Le format et le contenu des messages de journal peuvent changer d'une version à l'autre. #### 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) ```typescript 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](https://www.npmjs.com/package/pino), [winston](https://www.npmjs.com/package/winston), [bunyan](https://www.npmjs.com/package/bunyan), [consola](https://www.npmjs.com/package/consola), [signale](https://www.npmjs.com/package/signale) et [@std/log](https://jsr.io/@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. ```typescript 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. ```typescript 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. ```typescript 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 : ```typescript import fetch from "my-fetch"; globalThis.fetch = fetch; ``` Soit la transmettre au client : ```typescript 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.) ```typescript 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 : ```typescript import * as undici from "undici"; const proxyAgent = new undici.ProxyAgent("http://localhost:8888"); const client = new Anthropic({ fetchOptions: { dispatcher: proxyAgent } }); ``` ```typescript const client = new Anthropic({ fetchOptions: { proxy: "http://localhost:8888" } }); ``` ```typescript import Anthropic from "npm:@anthropic-ai/sdk"; const httpClient = Deno.createHttpClient({ proxy: { url: "http://localhost:8888" } }); const client = new Anthropic({ fetchOptions: { client: httpClient } }); ``` ## Fonctionnalités bêta Les fonctionnalités bêta sont disponibles avant la 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 de tous les outils de Claude dans l'[Aperçu des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/overview). 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](https://platform.claude.com/docs/fr/api/beta-headers) approprié au champ `betas` lors de la création d'un message. Par exemple, pour activer l'[édition de contexte](https://platform.claude.com/docs/fr/build-with-claude/context-editing) : ```typescript const client = new Anthropic(); const response = await client.beta.messages.create({ model: "claude-opus-5-5", max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }], betas: ["context-management-2025-06-27"] }); ``` ## Prise en charge des environnements d'exécution Activer l'option `dangerouslyAllowBrowser` peut être dangereux, car cela expose vos identifiants API secrets dans le code côté client. Les navigateurs web sont intrinsèquement moins sécurisés que les environnements serveur. Tout utilisateur ayant accès au navigateur peut potentiellement inspecter, extraire et utiliser abusivement ces identifiants. Cela pourrait entraîner un accès non autorisé à l'aide de vos identifiants et potentiellement compromettre des données ou des fonctionnalités sensibles. **Quand cela pourrait-il ne pas être dangereux ?** Dans certains scénarios, l'activation de la prise en charge des navigateurs peut ne pas présenter de risques significatifs : * **Outils internes :** si l'application est utilisée uniquement dans un environnement interne contrôlé où les utilisateurs sont de confiance, le risque d'exposition des identifiants peut être atténué. * **Développement ou débogage :** l'activation temporaire de cette fonctionnalité peut être acceptable, à condition que les identifiants soient de courte durée, ne soient pas également utilisés dans des environnements de production ou soient fréquemment renouvelés. ## Intégrations de plateformes Pour des guides détaillés de configuration des plateformes avec des exemples de code, consultez : * [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock) * [Amazon Bedrock (Opus 4.6 et versions antérieures)](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy) * [Claude Platform sur AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws) * [Google Cloud](https://platform.claude.com/docs/fr/build-with-claude/claude-on-vertex-ai) * [Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry) 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](https://semver.org/spec/v2.0.0.html), 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](https://github.com/anthropics/anthropic-sdk-typescript) pour les FAQ, les tickets et l'assistance de la communauté. ## Ressources supplémentaires * [Dépôt GitHub](https://github.com/anthropics/anthropic-sdk-typescript) * [Référence de l'API](https://platform.claude.com/docs/fr/api/overview) * [Streaming des messages](https://platform.claude.com/docs/fr/build-with-claude/streaming) * [Utilisation d'outils avec Claude](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview)