Référence du SDK TypeScript

Fonctions

`query()`

La fonction principale pour interagir avec Claude Code. Crée un générateur asynchrone qui diffuse les messages au fur et à mesure qu’ils arrivent.

function query({
  prompt,
  options
}: {
  prompt: string | AsyncIterable<SDKUserMessage>;
  options?: Options;
}): Query

Paramètres

Paramètre	Type	Description
`prompt`	`string \| AsyncIterable<SDKUserMessage>`	L’invite d’entrée sous forme de chaîne ou d’itérable asynchrone pour le mode streaming
`options`	`Options`	Objet de configuration optionnel (voir le type Options ci-dessous)

Retourne

Retourne un objet Query qui étend AsyncGenerator<SDKMessage, void> avec des méthodes supplémentaires.

`tool()`

Crée une définition d’outil MCP type-safe pour une utilisation avec les serveurs MCP du SDK.

function tool<Schema extends ZodRawShape>(
  name: string,
  description: string,
  inputSchema: Schema,
  handler: (args: z.infer<ZodObject<Schema>>, extra: unknown) => Promise<CallToolResult>
): SdkMcpToolDefinition<Schema>

Paramètres

Paramètre	Type	Description
`name`	`string`	Le nom de l’outil
`description`	`string`	Une description de ce que fait l’outil
`inputSchema`	`Schema extends ZodRawShape`	Schéma Zod définissant les paramètres d’entrée de l’outil
`handler`	`(args, extra) => Promise<CallToolResult>`	Fonction asynchrone qui exécute la logique de l’outil

`createSdkMcpServer()`

Crée une instance de serveur MCP qui s’exécute dans le même processus que votre application.

function createSdkMcpServer(options: {
  name: string;
  version?: string;
  tools?: Array<SdkMcpToolDefinition<any>>;
}): McpSdkServerConfigWithInstance

Paramètres

Paramètre	Type	Description
`options.name`	`string`	Le nom du serveur MCP
`options.version`	`string`	Chaîne de version optionnelle
`options.tools`	`Array<SdkMcpToolDefinition>`	Tableau de définitions d’outils créées avec `tool()`

Types

`Options`

Objet de configuration pour la fonction query().

Propriété	Type	Défaut	Description
`abortController`	`AbortController`	`new AbortController()`	Contrôleur pour annuler les opérations
`additionalDirectories`	`string[]`	`[]`	Répertoires supplémentaires auxquels Claude peut accéder
`allowedTools`	`string[]`	Tous les outils	Liste des noms d’outils autorisés
`appendSystemPrompt`	`string`	`undefined`	Texte à ajouter à l’invite système par défaut
`canUseTool`	`CanUseTool`	`undefined`	Fonction de permission personnalisée pour l’utilisation d’outils
`continue`	`boolean`	`false`	Continuer la conversation la plus récente
`customSystemPrompt`	`string`	`undefined`	Remplacer entièrement l’invite système par défaut
`cwd`	`string`	`process.cwd()`	Répertoire de travail actuel
`disallowedTools`	`string[]`	`[]`	Liste des noms d’outils interdits
`env`	`Dict<string>`	`process.env`	Variables d’environnement
`executable`	`'bun' \| 'deno' \| 'node'`	Auto-détecté	Runtime JavaScript à utiliser
`executableArgs`	`string[]`	`[]`	Arguments à passer à l’exécutable
`extraArgs`	`Record<string, string \| null>`	`{}`	Arguments supplémentaires
`fallbackModel`	`string`	`undefined`	Modèle à utiliser si le principal échoue
`hooks`	`Partial<Record<HookEvent,` `HookCallbackMatcher[]>>`	`{}`	Callbacks de hook pour les événements
`includePartialMessages`	`boolean`	`false`	Inclure les événements de messages partiels
`maxThinkingTokens`	`number`	`undefined`	Tokens maximum pour le processus de réflexion
`maxTurns`	`number`	`undefined`	Tours de conversation maximum
`mcpServers`	`Record<string,` `McpServerConfig>`	`{}`	Configurations des serveurs MCP
`model`	`string`	Défaut du CLI	Modèle Claude à utiliser
`pathToClaudeCodeExecutable`	`string`	Auto-détecté	Chemin vers l’exécutable Claude Code
`permissionMode`	`PermissionMode`	`'default'`	Mode de permission pour la session
`permissionPromptToolName`	`string`	`undefined`	Nom de l’outil MCP pour les invites de permission
`resume`	`string`	`undefined`	ID de session à reprendre
`stderr`	`(data: string) => void`	`undefined`	Callback pour la sortie stderr
`strictMcpConfig`	`boolean`	`false`	Appliquer la validation MCP stricte

`Query`

Interface retournée par la fonction query().

interface Query extends AsyncGenerator<SDKMessage, void> {
  interrupt(): Promise<void>;
  setPermissionMode(mode: PermissionMode): Promise<void>;
}

Méthodes

Méthode	Description
`interrupt()`	Interrompt la requête (disponible uniquement en mode d’entrée streaming)
`setPermissionMode()`	Change le mode de permission (disponible uniquement en mode d’entrée streaming)

`PermissionMode`

type PermissionMode = 
  | 'default'           // Comportement de permission standard
  | 'acceptEdits'       // Auto-accepter les modifications de fichiers
  | 'bypassPermissions' // Contourner toutes les vérifications de permission
  | 'plan'              // Mode planification - pas d'exécution

`CanUseTool`

Type de fonction de permission personnalisée pour contrôler l’utilisation d’outils.

type CanUseTool = (
  toolName: string,
  input: ToolInput,
  options: {
    signal: AbortSignal;
    suggestions?: PermissionUpdate[];
  }
) => Promise<PermissionResult>;

`PermissionResult`

Résultat d’une vérification de permission.

type PermissionResult = 
  | {
      behavior: 'allow';
      updatedInput: ToolInput;
      updatedPermissions?: PermissionUpdate[];
    }
  | {
      behavior: 'deny';
      message: string;
      interrupt?: boolean;
    }

`McpServerConfig`

Configuration pour les serveurs MCP.

type McpServerConfig = 
  | McpStdioServerConfig
  | McpSSEServerConfig
  | McpHttpServerConfig
  | McpSdkServerConfigWithInstance;

`McpStdioServerConfig`

type McpStdioServerConfig = {
  type?: 'stdio';
  command: string;
  args?: string[];
  env?: Record<string, string>;
}

`McpSSEServerConfig`

type McpSSEServerConfig = {
  type: 'sse';
  url: string;
  headers?: Record<string, string>;
}

`McpHttpServerConfig`

type McpHttpServerConfig = {
  type: 'http';
  url: string;
  headers?: Record<string, string>;
}

`McpSdkServerConfigWithInstance`

type McpSdkServerConfigWithInstance = {
  type: 'sdk';
  name: string;
  instance: McpServer;
}

Types de Messages

`SDKMessage`

Type union de tous les messages possibles retournés par la requête.

type SDKMessage = 
  | SDKAssistantMessage
  | SDKUserMessage
  | SDKUserMessageReplay
  | SDKResultMessage
  | SDKSystemMessage
  | SDKPartialAssistantMessage
  | SDKCompactBoundaryMessage;

`SDKAssistantMessage`

Message de réponse de l’assistant.

type SDKAssistantMessage = {
  type: 'assistant';
  uuid: UUID;
  session_id: string;
  message: APIAssistantMessage; // Du SDK Anthropic
  parent_tool_use_id: string | null;
}

`SDKUserMessage`

Message d’entrée utilisateur.

type SDKUserMessage = {
  type: 'user';
  uuid?: UUID;
  session_id: string;
  message: APIUserMessage; // Du SDK Anthropic
  parent_tool_use_id: string | null;
}

`SDKUserMessageReplay`

Message utilisateur rejoué avec UUID requis.

type SDKUserMessageReplay = {
  type: 'user';
  uuid: UUID;
  session_id: string;
  message: APIUserMessage;
  parent_tool_use_id: string | null;
}

`SDKResultMessage`

Message de résultat final.

type SDKResultMessage = 
  | {
      type: 'result';
      subtype: 'success';
      uuid: UUID;
      session_id: string;
      duration_ms: number;
      duration_api_ms: number;
      is_error: boolean;
      num_turns: number;
      result: string;
      total_cost_usd: number;
      usage: NonNullableUsage;
      permission_denials: SDKPermissionDenial[];
    }
  | {
      type: 'result';
      subtype: 'error_max_turns' | 'error_during_execution';
      uuid: UUID;
      session_id: string;
      duration_ms: number;
      duration_api_ms: number;
      is_error: boolean;
      num_turns: number;
      total_cost_usd: number;
      usage: NonNullableUsage;
      permission_denials: SDKPermissionDenial[];
    }

`SDKSystemMessage`

Message d’initialisation du système.

type SDKSystemMessage = {
  type: 'system';
  subtype: 'init';
  uuid: UUID;
  session_id: string;
  apiKeySource: ApiKeySource;
  cwd: string;
  tools: string[];
  mcp_servers: {
    name: string;
    status: string;
  }[];
  model: string;
  permissionMode: PermissionMode;
  slash_commands: string[];
  output_style: string;
}

`SDKPartialAssistantMessage`

Message partiel en streaming (uniquement quand includePartialMessages est true).

type SDKPartialAssistantMessage = {
  type: 'stream_event';
  event: RawMessageStreamEvent; // Du SDK Anthropic
  parent_tool_use_id: string | null;
  uuid: UUID;
  session_id: string;
}

`SDKCompactBoundaryMessage`

Message indiquant une limite de compactage de conversation.

type SDKCompactBoundaryMessage = {
  type: 'system';
  subtype: 'compact_boundary';
  uuid: UUID;
  session_id: string;
  compact_metadata: {
    trigger: 'manual' | 'auto';
    pre_tokens: number;
  };
}

`SDKPermissionDenial`

Information sur une utilisation d’outil refusée.

type SDKPermissionDenial = {
  tool_name: string;
  tool_use_id: string;
  tool_input: ToolInput;
}

Types de Hook

`HookEvent`

Événements de hook disponibles.

type HookEvent = 
  | 'PreToolUse'
  | 'PostToolUse'
  | 'Notification'
  | 'UserPromptSubmit'
  | 'SessionStart'
  | 'SessionEnd'
  | 'Stop'
  | 'SubagentStop'
  | 'PreCompact';

`HookCallback`

Type de fonction callback de hook.

type HookCallback = (
  input: HookInput, // Union de tous les types d'entrée de hook
  toolUseID: string | undefined,
  options: { signal: AbortSignal }
) => Promise<HookJSONOutput>;

`HookCallbackMatcher`

Configuration de hook avec matcher optionnel.

interface HookCallbackMatcher {
  matcher?: string;
  hooks: HookCallback[];
}

`HookInput`

Type union de tous les types d’entrée de hook.

type HookInput = 
  | PreToolUseHookInput
  | PostToolUseHookInput
  | NotificationHookInput
  | UserPromptSubmitHookInput
  | SessionStartHookInput
  | SessionEndHookInput
  | StopHookInput
  | SubagentStopHookInput
  | PreCompactHookInput;

`BaseHookInput`

Interface de base que tous les types d’entrée de hook étendent.

type BaseHookInput = {
  session_id: string;
  transcript_path: string;
  cwd: string;
  permission_mode?: string;
}

`PreToolUseHookInput`

type PreToolUseHookInput = BaseHookInput & {
  hook_event_name: 'PreToolUse';
  tool_name: string;
  tool_input: ToolInput;
}

`PostToolUseHookInput`

type PostToolUseHookInput = BaseHookInput & {
  hook_event_name: 'PostToolUse';
  tool_name: string;
  tool_input: ToolInput;
  tool_response: ToolOutput;
}

`NotificationHookInput`

type NotificationHookInput = BaseHookInput & {
  hook_event_name: 'Notification';
  message: string;
  title?: string;
}

`UserPromptSubmitHookInput`

type UserPromptSubmitHookInput = BaseHookInput & {
  hook_event_name: 'UserPromptSubmit';
  prompt: string;
}

`SessionStartHookInput`

type SessionStartHookInput = BaseHookInput & {
  hook_event_name: 'SessionStart';
  source: 'startup' | 'resume' | 'clear' | 'compact';
}

`SessionEndHookInput`

type SessionEndHookInput = BaseHookInput & {
  hook_event_name: 'SessionEnd';
  reason: 'clear' | 'logout' | 'prompt_input_exit' | 'other';
}

`StopHookInput`

type StopHookInput = BaseHookInput & {
  hook_event_name: 'Stop';
  stop_hook_active: boolean;
}

`SubagentStopHookInput`

type SubagentStopHookInput = BaseHookInput & {
  hook_event_name: 'SubagentStop';
  stop_hook_active: boolean;
}

`PreCompactHookInput`

type PreCompactHookInput = BaseHookInput & {
  hook_event_name: 'PreCompact';
  trigger: 'manual' | 'auto';
  custom_instructions: string | null;
}

`HookJSONOutput`

Valeur de retour de hook.

type HookJSONOutput = AsyncHookJSONOutput | SyncHookJSONOutput;

`AsyncHookJSONOutput`

type AsyncHookJSONOutput = {
  async: true;
  asyncTimeout?: number;
}

`SyncHookJSONOutput`

type SyncHookJSONOutput = {
  continue?: boolean;
  suppressOutput?: boolean;
  stopReason?: string;
  decision?: 'approve' | 'block';
  systemMessage?: string;
  reason?: string;
  hookSpecificOutput?:
    | {
        hookEventName: 'PreToolUse';
        permissionDecision?: 'allow' | 'deny' | 'ask';
        permissionDecisionReason?: string;
      }
    | {
        hookEventName: 'UserPromptSubmit';
        additionalContext?: string;
      }
    | {
        hookEventName: 'SessionStart';
        additionalContext?: string;
      }
    | {
        hookEventName: 'PostToolUse';
        additionalContext?: string;
      };
}

Types d’Entrée d’Outils

Documentation des schémas d’entrée pour tous les outils intégrés de Claude Code. Ces types sont exportés depuis @anthropic/claude-code-sdk et peuvent être utilisés pour des interactions d’outils type-safe.

`ToolInput`

Note : Ceci est un type uniquement pour la documentation pour plus de clarté. Il représente l’union de tous les types d’entrée d’outils.

type ToolInput = 
  | AgentInput
  | BashInput
  | BashOutputInput
  | FileEditInput
  | FileMultiEditInput
  | FileReadInput
  | FileWriteInput
  | GlobInput
  | GrepInput
  | KillShellInput
  | NotebookEditInput
  | WebFetchInput
  | WebSearchInput
  | TodoWriteInput
  | ExitPlanModeInput
  | ListMcpResourcesInput
  | ReadMcpResourceInput;

Task

Nom de l’outil : Task

interface AgentInput {
  /**
   * Une description courte (3-5 mots) de la tâche
   */
  description: string;
  /**
   * La tâche que l'agent doit effectuer
   */
  prompt: string;
  /**
   * Le type d'agent spécialisé à utiliser pour cette tâche
   */
  subagent_type: string;
}

Lance un nouvel agent pour gérer des tâches complexes et multi-étapes de manière autonome.

Bash

Nom de l’outil : Bash

interface BashInput {
  /**
   * La commande à exécuter
   */
  command: string;
  /**
   * Timeout optionnel en millisecondes (max 600000)
   */
  timeout?: number;
  /**
   * Description claire et concise de ce que fait cette commande en 5-10 mots
   */
  description?: string;
  /**
   * Définir à true pour exécuter cette commande en arrière-plan
   */
  run_in_background?: boolean;
}

Exécute des commandes bash dans une session shell persistante avec timeout optionnel et exécution en arrière-plan.

BashOutput

Nom de l’outil : BashOutput

interface BashOutputInput {
  /**
   * L'ID du shell en arrière-plan pour récupérer la sortie
   */
  bash_id: string;
  /**
   * Regex optionnel pour filtrer les lignes de sortie
   */
  filter?: string;
}

Récupère la sortie d’un shell bash en arrière-plan en cours d’exécution ou terminé.

Edit

Nom de l’outil : Edit

interface FileEditInput {
  /**
   * Le chemin absolu vers le fichier à modifier
   */
  file_path: string;
  /**
   * Le texte à remplacer
   */
  old_string: string;
  /**
   * Le texte par lequel le remplacer (doit être différent de old_string)
   */
  new_string: string;
  /**
   * Remplacer toutes les occurrences de old_string (défaut false)
   */
  replace_all?: boolean;
}

Effectue des remplacements de chaînes exacts dans les fichiers.

MultiEdit

Nom de l’outil : MultiEdit

interface FileMultiEditInput {
  /**
   * Le chemin absolu vers le fichier à modifier
   */
  file_path: string;
  /**
   * Tableau d'opérations d'édition à effectuer séquentiellement
   */
  edits: Array<{
    /**
     * Le texte à remplacer
     */
    old_string: string;
    /**
     * Le texte par lequel le remplacer
     */
    new_string: string;
    /**
     * Remplacer toutes les occurrences (défaut false)
     */
    replace_all?: boolean;
  }>;
}

Effectue plusieurs modifications sur un seul fichier en une opération.

Read

Nom de l’outil : Read

interface FileReadInput {
  /**
   * Le chemin absolu vers le fichier à lire
   */
  file_path: string;
  /**
   * Le numéro de ligne à partir duquel commencer la lecture
   */
  offset?: number;
  /**
   * Le nombre de lignes à lire
   */
  limit?: number;
}

Lit les fichiers du système de fichiers local, incluant le texte, les images, les PDF et les notebooks Jupyter.

Write

Nom de l’outil : Write

interface FileWriteInput {
  /**
   * Le chemin absolu vers le fichier à écrire
   */
  file_path: string;
  /**
   * Le contenu à écrire dans le fichier
   */
  content: string;
}

Écrit un fichier dans le système de fichiers local, en écrasant s’il existe.

Glob

Nom de l’outil : Glob

interface GlobInput {
  /**
   * Le motif glob pour faire correspondre les fichiers
   */
  pattern: string;
  /**
   * Le répertoire dans lequel chercher (par défaut cwd)
   */
  path?: string;
}

Correspondance de motifs de fichiers rapide qui fonctionne avec n’importe quelle taille de base de code.

Grep

Nom de l’outil : Grep

interface GrepInput {
  /**
   * Le motif d'expression régulière à rechercher
   */
  pattern: string;
  /**
   * Fichier ou répertoire dans lequel chercher (par défaut cwd)
   */
  path?: string;
  /**
   * Motif glob pour filtrer les fichiers (ex. "*.js")
   */
  glob?: string;
  /**
   * Type de fichier à rechercher (ex. "js", "py", "rust")
   */
  type?: string;
  /**
   * Mode de sortie : "content", "files_with_matches", ou "count"
   */
  output_mode?: 'content' | 'files_with_matches' | 'count';
  /**
   * Recherche insensible à la casse
   */
  '-i'?: boolean;
  /**
   * Afficher les numéros de ligne (pour le mode content)
   */
  '-n'?: boolean;
  /**
   * Lignes à afficher avant chaque correspondance
   */
  '-B'?: number;
  /**
   * Lignes à afficher après chaque correspondance
   */
  '-A'?: number;
  /**
   * Lignes à afficher avant et après chaque correspondance
   */
  '-C'?: number;
  /**
   * Limiter la sortie aux N premières lignes/entrées
   */
  head_limit?: number;
  /**
   * Activer le mode multiligne
   */
  multiline?: boolean;
}

Outil de recherche puissant basé sur ripgrep avec support regex.

KillBash

Nom de l’outil : KillBash

interface KillShellInput {
  /**
   * L'ID du shell en arrière-plan à tuer
   */
  shell_id: string;
}

Tue un shell bash en arrière-plan en cours d’exécution par son ID.

NotebookEdit

Nom de l’outil : NotebookEdit

interface NotebookEditInput {
  /**
   * Le chemin absolu vers le fichier notebook Jupyter
   */
  notebook_path: string;
  /**
   * L'ID de la cellule à éditer
   */
  cell_id?: string;
  /**
   * La nouvelle source pour la cellule
   */
  new_source: string;
  /**
   * Le type de la cellule (code ou markdown)
   */
  cell_type?: 'code' | 'markdown';
  /**
   * Le type d'édition (replace, insert, delete)
   */
  edit_mode?: 'replace' | 'insert' | 'delete';
}

Édite les cellules dans les fichiers notebook Jupyter.

WebFetch

Nom de l’outil : WebFetch

interface WebFetchInput {
  /**
   * L'URL pour récupérer le contenu
   */
  url: string;
  /**
   * L'invite à exécuter sur le contenu récupéré
   */
  prompt: string;
}

Récupère le contenu d’une URL et le traite avec un modèle IA.

WebSearch

Nom de l’outil : WebSearch

interface WebSearchInput {
  /**
   * La requête de recherche à utiliser
   */
  query: string;
  /**
   * Inclure uniquement les résultats de ces domaines
   */
  allowed_domains?: string[];
  /**
   * Ne jamais inclure les résultats de ces domaines
   */
  blocked_domains?: string[];
}

Recherche sur le web et retourne des résultats formatés.

TodoWrite

Nom de l’outil : TodoWrite

interface TodoWriteInput {
  /**
   * La liste de tâches mise à jour
   */
  todos: Array<{
    /**
     * La description de la tâche
     */
    content: string;
    /**
     * Le statut de la tâche
     */
    status: 'pending' | 'in_progress' | 'completed';
    /**
     * Forme active de la description de la tâche
     */
    activeForm: string;
  }>;
}

Crée et gère une liste de tâches structurée pour suivre les progrès.

ExitPlanMode

Nom de l’outil : ExitPlanMode

interface ExitPlanModeInput {
  /**
   * Le plan à exécuter par l'utilisateur pour approbation
   */
  plan: string;
}

Sort du mode planification et invite l’utilisateur à approuver le plan.

ListMcpResources

Nom de l’outil : ListMcpResources

interface ListMcpResourcesInput {
  /**
   * Nom de serveur optionnel pour filtrer les ressources
   */
  server?: string;
}

Liste les ressources MCP disponibles des serveurs connectés.

ReadMcpResource

Nom de l’outil : ReadMcpResource

interface ReadMcpResourceInput {
  /**
   * Le nom du serveur MCP
   */
  server: string;
  /**
   * L'URI de la ressource à lire
   */
  uri: string;
}

Lit une ressource MCP spécifique d’un serveur.

Types de Sortie d’Outils

Documentation des schémas de sortie pour tous les outils intégrés de Claude Code. Ces types représentent les données de réponse réelles retournées par chaque outil.

`ToolOutput`

Note : Ceci est un type uniquement pour la documentation pour plus de clarté. Il représente l’union de tous les types de sortie d’outils.

type ToolOutput = 
  | TaskOutput
  | BashOutput
  | BashOutputToolOutput
  | EditOutput
  | MultiEditOutput
  | ReadOutput
  | WriteOutput
  | GlobOutput
  | GrepOutput
  | KillBashOutput
  | NotebookEditOutput
  | WebFetchOutput
  | WebSearchOutput
  | TodoWriteOutput
  | ExitPlanModeOutput
  | ListMcpResourcesOutput
  | ReadMcpResourceOutput;

Task

Nom de l’outil : Task

interface TaskOutput {
  /**
   * Message de résultat final du sous-agent
   */
  result: string;
  /**
   * Statistiques d'utilisation des tokens
   */
  usage?: {
    input_tokens: number;
    output_tokens: number;
    cache_creation_input_tokens?: number;
    cache_read_input_tokens?: number;
  };
  /**
   * Coût total en USD
   */
  total_cost_usd?: number;
  /**
   * Durée d'exécution en millisecondes
   */
  duration_ms?: number;
}

Retourne le résultat final du sous-agent après avoir terminé la tâche déléguée.

Bash

Nom de l’outil : Bash

interface BashOutput {
  /**
   * Sortie combinée stdout et stderr
   */
  output: string;
  /**
   * Code de sortie de la commande
   */
  exitCode: number;
  /**
   * Si la commande a été tuée à cause du timeout
   */
  killed?: boolean;
  /**
   * ID de shell pour les processus en arrière-plan
   */
  shellId?: string;
}

Retourne la sortie de commande avec le statut de sortie. Les commandes en arrière-plan retournent immédiatement avec un shellId.

BashOutput

Nom de l’outil : BashOutput

interface BashOutputToolOutput {
  /**
   * Nouvelle sortie depuis la dernière vérification
   */
  output: string;
  /**
   * Statut actuel du shell
   */
  status: 'running' | 'completed' | 'failed';
  /**
   * Code de sortie (quand terminé)
   */
  exitCode?: number;
}

Retourne la sortie incrémentale des shells en arrière-plan.

Edit

Nom de l’outil : Edit

interface EditOutput {
  /**
   * Message de confirmation
   */
  message: string;
  /**
   * Nombre de remplacements effectués
   */
  replacements: number;
  /**
   * Chemin du fichier qui a été édité
   */
  file_path: string;
}

Retourne la confirmation des modifications réussies avec le nombre de remplacements.

MultiEdit

Nom de l’outil : MultiEdit

interface MultiEditOutput {
  /**
   * Message de succès
   */
  message: string;
  /**
   * Nombre total de modifications appliquées
   */
  edits_applied: number;
  /**
   * Chemin du fichier qui a été édité
   */
  file_path: string;
}

Retourne la confirmation après avoir appliqué toutes les modifications séquentiellement.

Read

Nom de l’outil : Read

type ReadOutput = 
  | TextFileOutput
  | ImageFileOutput
  | PDFFileOutput
  | NotebookFileOutput;

interface TextFileOutput {
  /**
   * Contenu du fichier avec numéros de ligne
   */
  content: string;
  /**
   * Nombre total de lignes dans le fichier
   */
  total_lines: number;
  /**
   * Lignes réellement retournées
   */
  lines_returned: number;
}

interface ImageFileOutput {
  /**
   * Données d'image encodées en base64
   */
  image: string;
  /**
   * Type MIME de l'image
   */
  mime_type: string;
  /**
   * Taille du fichier en octets
   */
  file_size: number;
}

interface PDFFileOutput {
  /**
   * Tableau des contenus de pages
   */
  pages: Array<{
    page_number: number;
    text?: string;
    images?: Array<{
      image: string;
      mime_type: string;
    }>;
  }>;
  /**
   * Nombre total de pages
   */
  total_pages: number;
}

interface NotebookFileOutput {
  /**
   * Cellules du notebook Jupyter
   */
  cells: Array<{
    cell_type: 'code' | 'markdown';
    source: string;
    outputs?: any[];
    execution_count?: number;
  }>;
  /**
   * Métadonnées du notebook
   */
  metadata?: Record<string, any>;
}

Retourne le contenu du fichier dans un format approprié au type de fichier.

Write

Nom de l’outil : Write

interface WriteOutput {
  /**
   * Message de succès
   */
  message: string;
  /**
   * Nombre d'octets écrits
   */
  bytes_written: number;
  /**
   * Chemin du fichier qui a été écrit
   */
  file_path: string;
}

Retourne la confirmation après avoir écrit le fichier avec succès.

Glob

Nom de l’outil : Glob

interface GlobOutput {
  /**
   * Tableau des chemins de fichiers correspondants
   */
  matches: string[];
  /**
   * Nombre de correspondances trouvées
   */
  count: number;
  /**
   * Répertoire de recherche utilisé
   */
  search_path: string;
}

Retourne les chemins de fichiers correspondant au motif glob, triés par heure de modification.

Grep

Nom de l’outil : Grep

type GrepOutput = 
  | GrepContentOutput
  | GrepFilesOutput
  | GrepCountOutput;

interface GrepContentOutput {
  /**
   * Lignes correspondantes avec contexte
   */
  matches: Array<{
    file: string;
    line_number?: number;
    line: string;
    before_context?: string[];
    after_context?: string[];
  }>;
  /**
   * Nombre total de correspondances
   */
  total_matches: number;
}

interface GrepFilesOutput {
  /**
   * Fichiers contenant des correspondances
   */
  files: string[];
  /**
   * Nombre de fichiers avec correspondances
   */
  count: number;
}

interface GrepCountOutput {
  /**
   * Nombres de correspondances par fichier
   */
  counts: Array<{
    file: string;
    count: number;
  }>;
  /**
   * Total des correspondances dans tous les fichiers
   */
  total: number;
}

Retourne les résultats de recherche dans le format spécifié par output_mode.

KillBash

Nom de l’outil : KillBash

interface KillBashOutput {
  /**
   * Message de succès
   */
  message: string;
  /**
   * ID du shell tué
   */
  shell_id: string;
}

Retourne la confirmation après avoir terminé le shell en arrière-plan.

NotebookEdit

Nom de l’outil : NotebookEdit

interface NotebookEditOutput {
  /**
   * Message de succès
   */
  message: string;
  /**
   * Type de modification effectuée
   */
  edit_type: 'replaced' | 'inserted' | 'deleted';
  /**
   * ID de la cellule qui a été affectée
   */
  cell_id?: string;
  /**
   * Total des cellules dans le notebook après modification
   */
  total_cells: number;
}

Retourne la confirmation après avoir modifié le notebook Jupyter.

WebFetch

Nom de l’outil : WebFetch

interface WebFetchOutput {
  /**
   * Réponse du modèle IA à l'invite
   */
  response: string;
  /**
   * URL qui a été récupérée
   */
  url: string;
  /**
   * URL finale après redirections
   */
  final_url?: string;
  /**
   * Code de statut HTTP
   */
  status_code?: number;
}

Retourne l’analyse de l’IA du contenu web récupéré.

WebSearch

Nom de l’outil : WebSearch

interface WebSearchOutput {
  /**
   * Résultats de recherche
   */
  results: Array<{
    title: string;
    url: string;
    snippet: string;
    /**
     * Métadonnées supplémentaires si disponibles
     */
    metadata?: Record<string, any>;
  }>;
  /**
   * Nombre total de résultats
   */
  total_results: number;
  /**
   * La requête qui a été recherchée
   */
  query: string;
}

Retourne les résultats de recherche formatés du web.

TodoWrite

Nom de l’outil : TodoWrite

interface TodoWriteOutput {
  /**
   * Message de succès
   */
  message: string;
  /**
   * Statistiques actuelles des tâches
   */
  stats: {
    total: number;
    pending: number;
    in_progress: number;
    completed: number;
  };
}

Retourne la confirmation avec les statistiques actuelles des tâches.

ExitPlanMode

Nom de l’outil : ExitPlanMode

interface ExitPlanModeOutput {
  /**
   * Message de confirmation
   */
  message: string;
  /**
   * Si l'utilisateur a approuvé le plan
   */
  approved?: boolean;
}

Retourne la confirmation après avoir quitté le mode plan.

ListMcpResources

Nom de l’outil : ListMcpResources

interface ListMcpResourcesOutput {
  /**
   * Ressources disponibles
   */
  resources: Array<{
    uri: string;
    name: string;
    description?: string;
    mimeType?: string;
    server: string;
  }>;
  /**
   * Nombre total de ressources
   */
  total: number;
}

Retourne la liste des ressources MCP disponibles.

ReadMcpResource

Nom de l’outil : ReadMcpResource

interface ReadMcpResourceOutput {
  /**
   * Contenu de la ressource
   */
  contents: Array<{
    uri: string;
    mimeType?: string;
    text?: string;
    blob?: string;
  }>;
  /**
   * Serveur qui a fourni la ressource
   */
  server: string;
}

Retourne le contenu de la ressource MCP demandée.

Types de Permission

`PermissionUpdate`

Opérations pour mettre à jour les permissions.

type PermissionUpdate = 
  | {
      type: 'addRules';
      rules: PermissionRuleValue[];
      behavior: PermissionBehavior;
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'replaceRules';
      rules: PermissionRuleValue[];
      behavior: PermissionBehavior;
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'removeRules';
      rules: PermissionRuleValue[];
      behavior: PermissionBehavior;
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'setMode';
      mode: PermissionMode;
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'addDirectories';
      directories: string[];
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'removeDirectories';
      directories: string[];
      destination: PermissionUpdateDestination;
    }

`PermissionBehavior`

type PermissionBehavior = 'allow' | 'deny' | 'ask';

`PermissionUpdateDestination`

type PermissionUpdateDestination = 
  | 'userSettings'     // Paramètres utilisateur globaux
  | 'projectSettings'  // Paramètres de projet par répertoire
  | 'localSettings'    // Paramètres locaux ignorés par git
  | 'session'          // Session actuelle uniquement

`PermissionRuleValue`

type PermissionRuleValue = {
  toolName: string;
  ruleContent?: string;
}

Autres Types

`ApiKeySource`

type ApiKeySource = 'user' | 'project' | 'org' | 'temporary';

`ConfigScope`

type ConfigScope = 'local' | 'user' | 'project';

`NonNullableUsage`

Une version de Usage avec tous les champs nullable rendus non-nullable.

type NonNullableUsage = {
  [K in keyof Usage]: NonNullable<Usage[K]>;
}

`Usage`

Statistiques d’utilisation des tokens (de @anthropic-ai/sdk).

type Usage = {
  input_tokens: number | null;
  output_tokens: number | null;
  cache_creation_input_tokens?: number | null;
  cache_read_input_tokens?: number | null;
}

`CallToolResult`

Type de résultat d’outil MCP (de @modelcontextprotocol/sdk/types.js).

type CallToolResult = {
  content: Array<{
    type: 'text' | 'image' | 'resource';
    // Les champs supplémentaires varient selon le type
  }>;
  isError?: boolean;
}

`AbortError`

Classe d’erreur personnalisée pour les opérations d’abandon.

class AbortError extends Error {}

Voir aussi

Guide du SDK TypeScript - Tutoriel et exemples
Aperçu du SDK - Concepts généraux du SDK
Référence du SDK Python - Documentation du SDK Python
Référence CLI - Interface en ligne de commande
Workflows courants - Guides étape par étape

Commencer

Créer avec Claude Code

SDK de code Claude

Déploiement

Administration

Configuration

Référence

Ressources

​Fonctions

​query()

​Paramètres

​Retourne

​tool()

​Paramètres

​createSdkMcpServer()

​Paramètres

​Types

​Options

​Query

​Méthodes

​PermissionMode

​CanUseTool

​PermissionResult

​McpServerConfig

​McpStdioServerConfig

​McpSSEServerConfig

​McpHttpServerConfig

​McpSdkServerConfigWithInstance

​Types de Messages

​SDKMessage

​SDKAssistantMessage

​SDKUserMessage

​SDKUserMessageReplay

​SDKResultMessage

​SDKSystemMessage

​SDKPartialAssistantMessage

​SDKCompactBoundaryMessage

​SDKPermissionDenial

​Types de Hook

​HookEvent

​HookCallback

​HookCallbackMatcher

​HookInput

​BaseHookInput

​PreToolUseHookInput

​PostToolUseHookInput

​NotificationHookInput

​UserPromptSubmitHookInput

​SessionStartHookInput

​SessionEndHookInput

​StopHookInput

​SubagentStopHookInput

​PreCompactHookInput

​HookJSONOutput

​AsyncHookJSONOutput

​SyncHookJSONOutput

​Types d’Entrée d’Outils

​ToolInput

​Task

​Bash

​BashOutput

​Edit

​MultiEdit

​Read

​Write

​Glob

​Grep

​KillBash

​NotebookEdit

​WebFetch

​WebSearch

​TodoWrite

​ExitPlanMode

​ListMcpResources

​ReadMcpResource

​Types de Sortie d’Outils

​ToolOutput

​Task

​Bash

​BashOutput

Fonctions

`query()`

Paramètres

Retourne

`tool()`

Paramètres

`createSdkMcpServer()`

Paramètres

Types

`Options`

`Query`

Méthodes

`PermissionMode`

`CanUseTool`

`PermissionResult`

`McpServerConfig`

`McpStdioServerConfig`

`McpSSEServerConfig`

`McpHttpServerConfig`

`McpSdkServerConfigWithInstance`

Types de Messages

`SDKMessage`

`SDKAssistantMessage`

`SDKUserMessage`

`SDKUserMessageReplay`

`SDKResultMessage`

`SDKSystemMessage`

`SDKPartialAssistantMessage`

`SDKCompactBoundaryMessage`

`SDKPermissionDenial`

Types de Hook

`HookEvent`

`HookCallback`

`HookCallbackMatcher`

`HookInput`

`BaseHookInput`

`PreToolUseHookInput`

`PostToolUseHookInput`

`NotificationHookInput`

`UserPromptSubmitHookInput`

`SessionStartHookInput`

`SessionEndHookInput`

`StopHookInput`

`SubagentStopHookInput`

`PreCompactHookInput`

`HookJSONOutput`

`AsyncHookJSONOutput`

`SyncHookJSONOutput`

Types d’Entrée d’Outils

`ToolInput`

Task

Bash

BashOutput

Edit

MultiEdit

Read

Write

Glob

Grep

KillBash

NotebookEdit

WebFetch

WebSearch

TodoWrite

ExitPlanMode

ListMcpResources

ReadMcpResource

Types de Sortie d’Outils

`ToolOutput`

Task

Bash

BashOutput

Edit

MultiEdit

Read

Write

Glob

Grep

KillBash

NotebookEdit