Référence du SDK Agent - TypeScript

npm install @anthropic-ai/claude-agent-sdk

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

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

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

interface Query extends AsyncGenerator<SDKMessage, void> {
  interrupt(): Promise<void>;
  rewindFiles(userMessageUuid: string): Promise<void>;
  setPermissionMode(mode: PermissionMode): Promise<void>;
  setModel(model?: string): Promise<void>;
  setMaxThinkingTokens(maxThinkingTokens: number | null): Promise<void>;
  supportedCommands(): Promise<SlashCommand[]>;
  supportedModels(): Promise<ModelInfo[]>;
  mcpServerStatus(): Promise<McpServerStatus[]>;
  accountInfo(): Promise<AccountInfo>;
}

type AgentDefinition = {
  description: string;
  tools?: string[];
  prompt: string;
  model?: 'sonnet' | 'opus' | 'haiku' | 'inherit';
}

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

// Charger tous les paramètres comme le SDK v0.0.x l'a fait
const result = query({
  prompt: "Analyze this code",
  options: {
    settingSources: ['user', 'project', 'local']  // Charger tous les paramètres
  }
});

// Charger uniquement les paramètres de projet, ignorer les paramètres utilisateur et locaux
const result = query({
  prompt: "Run CI checks",
  options: {
    settingSources: ['project']  // Uniquement .claude/settings.json
  }
});

// Assurer un comportement cohérent en CI en excluant les paramètres locaux
const result = query({
  prompt: "Run tests",
  options: {
    settingSources: ['project'],  // Uniquement les paramètres partagés par l'équipe
    permissionMode: 'bypassPermissions'
  }
});

// Définir tout par programmation (comportement par défaut)
// Pas de dépendances du système de fichiers - settingSources par défaut à []
const result = query({
  prompt: "Review this PR",
  options: {
    // settingSources: [] est la valeur par défaut, pas besoin de spécifier
    agents: { /* ... */ },
    mcpServers: { /* ... */ },
    allowedTools: ['Read', 'Grep', 'Glob']
  }
});

// Charger les paramètres de projet pour inclure les fichiers CLAUDE.md
const result = query({
  prompt: "Add a new feature following project conventions",
  options: {
    systemPrompt: {
      type: 'preset',
      preset: 'claude_code'  // Requis pour utiliser CLAUDE.md
    },
    settingSources: ['project'],  // Charge CLAUDE.md à partir du répertoire du projet
    allowedTools: ['Read', 'Write', 'Edit']
  }
});

type PermissionMode =
  | 'default'           // Comportement de permission standard
  | 'acceptEdits'       // Accepter automatiquement les modifications de fichiers
  | 'bypassPermissions' // Contourner tous les contrôles de permission
  | 'plan'              // Mode de planification - pas d'exécution

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

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

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

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

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

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

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

type SdkPluginConfig = {
  type: 'local';
  path: string;
}

plugins: [
  { type: 'local', path: './my-plugin' },
  { type: 'local', path: '/absolute/path/to/plugin' }
]

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

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

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

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

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;
      modelUsage: { [modelName: string]: ModelUsage };
      permission_denials: SDKPermissionDenial[];
      structured_output?: unknown;
    }
  | {
      type: 'result';
      subtype:
        | 'error_max_turns'
        | 'error_during_execution'
        | 'error_max_budget_usd'
        | 'error_max_structured_output_retries';
      uuid: UUID;
      session_id: string;
      duration_ms: number;
      duration_api_ms: number;
      is_error: boolean;
      num_turns: number;
      total_cost_usd: number;
      usage: NonNullableUsage;
      modelUsage: { [modelName: string]: ModelUsage };
      permission_denials: SDKPermissionDenial[];
      errors: string[];
    }

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;
}

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

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

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

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

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

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

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

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

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

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

type PostToolUseFailureHookInput = BaseHookInput & {
  hook_event_name: 'PostToolUseFailure';
  tool_name: string;
  tool_input: unknown;
  error: string;
  is_interrupt?: boolean;
}

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

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

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

type SessionEndHookInput = BaseHookInput & {
  hook_event_name: 'SessionEnd';
  reason: ExitReason;  // Chaîne du tableau EXIT_REASONS
}

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

type SubagentStartHookInput = BaseHookInput & {
  hook_event_name: 'SubagentStart';
  agent_id: string;
  agent_type: string;
}

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

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

type PermissionRequestHookInput = BaseHookInput & {
  hook_event_name: 'PermissionRequest';
  tool_name: string;
  tool_input: unknown;
  permission_suggestions?: PermissionUpdate[];
}

type HookJSONOutput = AsyncHookJSONOutput | SyncHookJSONOutput;

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

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

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

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;
}

interface AskUserQuestionInput {
  /**
   * Questions à poser à l'utilisateur (1-4 questions)
   */
  questions: Array<{
    /**
     * La question complète à poser à l'utilisateur. Doit être claire, spécifique,
     * et se terminer par un point d'interrogation.
     */
    question: string;
    /**
     * Étiquette très courte affichée sous forme de puce/étiquette (max 12 caractères).
     * Exemples : "Auth method", "Library", "Approach"
     */
    header: string;
    /**
     * Les choix disponibles (2-4 options). Une option "Other" est
     * automatiquement fournie.
     */
    options: Array<{
      /**
       * Texte d'affichage pour cette option (1-5 mots)
       */
      label: string;
      /**
       * Explication de ce que signifie cette option
       */
      description: string;
    }>;
    /**
     * Définir sur true pour permettre les sélections multiples
     */
    multiSelect: boolean;
  }>;
  /**
   * Réponses utilisateur remplies par le système de permission.
   * Mappe le texte de la question aux étiquettes d'option sélectionnées.
   * Les réponses multi-sélection sont séparées par des virgules.
   */
  answers?: Record<string, string>;
}

interface BashInput {
  /**
   * La commande à exécuter
   */
  command: string;
  /**
   * Délai d'expiration 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 sur true pour exécuter cette commande en arrière-plan
   */
  run_in_background?: boolean;
}

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

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

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

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

interface GlobInput {
  /**
   * Le modèle glob pour correspondre aux fichiers
   */
  pattern: string;
  /**
   * Le répertoire à rechercher (par défaut cwd)
   */
  path?: string;
}

interface GrepInput {
  /**
   * Le modèle d'expression régulière à rechercher
   */
  pattern: string;
  /**
   * Fichier ou répertoire à rechercher (par défaut cwd)
   */
  path?: string;
  /**
   * Modèle glob pour filtrer les fichiers (par exemple "*.js")
   */
  glob?: string;
  /**
   * Type de fichier à rechercher (par exemple "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 contenu)
   */
  '-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;
}

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

interface NotebookEditInput {
  /**
   * Le chemin absolu du fichier de carnet Jupyter
   */
  notebook_path: string;
  /**
   * L'ID de la cellule à modifier
   */
  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 de modification (remplacer, insérer, supprimer)
   */
  edit_mode?: 'replace' | 'insert' | 'delete';
}

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

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[];
}

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

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

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

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

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

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;
}

interface AskUserQuestionOutput {
  /**
   * Les questions qui ont été posées
   */
  questions: Array<{
    question: string;
    header: string;
    options: Array<{
      label: string;
      description: string;
    }>;
    multiSelect: boolean;
  }>;
  /**
   * Les réponses fournies par l'utilisateur.
   * Mappe le texte de la question à la chaîne de réponse.
   * Les réponses multi-sélection sont séparées par des virgules.
   */
  answers: Record<string, string>;
}

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 en raison d'un délai d'expiration
   */
  killed?: boolean;
  /**
   * ID du shell pour les processus en arrière-plan
   */
  shellId?: string;
}

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

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

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 page
   */
  pages: Array<{
    page_number: number;
    text?: string;
    images?: Array<{
      image: string;
      mime_type: string;
    }>;
  }>;
  /**
   * Nombre total de pages
   */
  total_pages: number;
}

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

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;
}

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;
}

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 des correspondances
   */
  count: number;
}

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

interface KillBashOutput {
  /**
   * Message de succès
   */
  message: string;
  /**
   * ID du shell qui a été arrêté
   */
  shell_id: string;
}

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;
  /**
   * Nombre total de cellules dans le notebook après la modification
   */
  total_cells: number;
}

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

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;
}

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

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

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

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

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;
    }

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

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

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

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

type SdkBeta = 'context-1m-2025-08-07';

type SlashCommand = {
  name: string;
  description: string;
  argumentHint: string;
}

type ModelInfo = {
  value: string;
  displayName: string;
  description: string;
}

type McpServerStatus = {
  name: string;
  status: 'connected' | 'failed' | 'needs-auth' | 'pending';
  serverInfo?: {
    name: string;
    version: string;
  };
}

type AccountInfo = {
  email?: string;
  organization?: string;
  subscriptionType?: string;
  tokenSource?: string;
  apiKeySource?: string;
}

type ModelUsage = {
  inputTokens: number;
  outputTokens: number;
  cacheReadInputTokens: number;
  cacheCreationInputTokens: number;
  webSearchRequests: number;
  costUSD: number;
  contextWindow: number;
}

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

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

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

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

class AbortError extends Error {}

type SandboxSettings = {
  enabled?: boolean;
  autoAllowBashIfSandboxed?: boolean;
  excludedCommands?: string[];
  allowUnsandboxedCommands?: boolean;
  network?: NetworkSandboxSettings;
  ignoreViolations?: SandboxIgnoreViolations;
  enableWeakerNestedSandbox?: boolean;
}

import { query } from "@anthropic-ai/claude-agent-sdk";

const result = await query({
  prompt: "Build and test my project",
  options: {
    sandbox: {
      enabled: true,
      autoAllowBashIfSandboxed: true,
      excludedCommands: ["docker"],
      network: {
        allowLocalBinding: true,
        allowUnixSockets: ["/var/run/docker.sock"]
      }
    }
  }
});

type NetworkSandboxSettings = {
  allowLocalBinding?: boolean;
  allowUnixSockets?: string[];
  allowAllUnixSockets?: boolean;
  httpProxyPort?: number;
  socksProxyPort?: number;
}

type SandboxIgnoreViolations = {
  file?: string[];
  network?: string[];
}

import { query } from "@anthropic-ai/claude-agent-sdk";

const result = await query({
  prompt: "Deploy my application",
  options: {
    sandbox: {
      enabled: true,
      allowUnsandboxedCommands: true  // Le modèle peut demander l'exécution sans isolation
    },
    permissionMode: "default",
    canUseTool: async (tool, input) => {
      // Vérifier si le modèle demande de contourner le bac à sable
      if (tool === "Bash" && input.dangerouslyDisableSandbox) {
        // Le modèle veut exécuter cette commande en dehors du bac à sable
        console.log(`Unsandboxed command requested: ${input.command}`);

        // Retourner true pour autoriser, false pour refuser
        return isCommandAuthorized(input.command);
      }
      return true;
    }
  }
});