Claude Code SDK

claude -p "Analyser les performances du système" \
  --append-system-prompt "Vous êtes un ingénieur de performance" \
  --allowedTools "Bash,Read,WebSearch" \
  --permission-mode acceptEdits \
  --cwd /chemin/vers/projet

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

for await (const message of query({
  prompt: "Analyser les performances du système",
  abortController: new AbortController(),
  options: {
    maxTurns: 5,
    systemPrompt: "Vous êtes un ingénieur de performance",
    allowedTools: ["Bash", "Read", "WebSearch"]
  }
})) {
  if (message.type === "result") {
    console.log(message.result);
  }
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def main():
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Vous êtes un ingénieur de performance",
            allowed_tools=["Bash", "Read", "WebSearch"],
            max_turns=5
        )
    ) as client:
        await client.query("Analyser les performances du système")
        
        # Diffuser les réponses
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text, end='', flush=True)

# Exécuter comme script
asyncio.run(main())

# Ou dans IPython/Jupyter : await main()

from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async with ClaudeSDKClient() as client:
    # Message texte
    await client.query("Analysez ce code pour les problèmes de sécurité")
    
    # Message avec référence d'image (l'image sera lue par l'outil Read de Claude)
    await client.query("Expliquez ce qui est montré dans screenshot.png")
    
    # Plusieurs messages en séquence
    messages = [
        "D'abord, analysez le diagramme d'architecture dans diagram.png",
        "Maintenant suggérez des améliorations basées sur le diagramme",
        "Enfin, générez le code d'implémentation"
    ]
    
    for msg in messages:
        await client.query(msg)
        async for response in client.receive_response():
            # Traiter chaque réponse
            pass

# Le SDK gère les fichiers d'images via l'outil Read intégré de Claude
# Formats supportés : PNG, JPG, PDF, et autres formats courants

from claude_code_sdk import query, ClaudeCodeOptions

async for message in query(
    prompt="Analyser les performances du système",
    options=ClaudeCodeOptions(system_prompt="Vous êtes un ingénieur de performance")
):
    if type(message).__name__ == "ResultMessage":
        print(message.result)

# Continuer la conversation la plus récente
claude --continue "Maintenant refactorisez ceci pour de meilleures performances"

# Reprendre une conversation spécifique par ID de session
claude --resume 550e8400-e29b-41d4-a716-446655440000 "Mettre à jour les tests"

# Reprendre en mode non-interactif
claude --resume 550e8400-e29b-41d4-a716-446655440000 "Corriger tous les problèmes de linting" --no-interactive

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

// Continuer la conversation la plus récente
for await (const message of query({
  prompt: "Maintenant refactorisez ceci pour de meilleures performances",
  options: { continueSession: true }
})) {
  if (message.type === "result") console.log(message.result);
}

// Reprendre une session spécifique
for await (const message of query({
  prompt: "Mettre à jour les tests",
  options: { 
    resumeSessionId: "550e8400-e29b-41d4-a716-446655440000",
    maxTurns: 3
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions, query

# Méthode 1 : Utiliser ClaudeSDKClient pour des conversations persistantes
async def multi_turn_conversation():
    async with ClaudeSDKClient() as client:
        # Première requête
        await client.query("Refactorisons le module de paiement")
        async for msg in client.receive_response():
            # Traiter la première réponse
            pass
        
        # Continuer dans la même session
        await client.query("Maintenant ajoutez une gestion d'erreurs complète")
        async for msg in client.receive_response():
            # Traiter la continuation
            pass
        
        # Le contexte de conversation est maintenu tout au long

# Méthode 2 : Utiliser la fonction query avec gestion de session
async def resume_session():
    # Continuer la conversation la plus récente
    async for message in query(
        prompt="Maintenant refactorisez ceci pour de meilleures performances",
        options=ClaudeCodeOptions(continue_conversation=True)
    ):
        if type(message).__name__ == "ResultMessage":
            print(message.result)

    # Reprendre une session spécifique
    async for message in query(
        prompt="Mettre à jour les tests", 
        options=ClaudeCodeOptions(
            resume="550e8400-e29b-41d4-a716-446655440000",
            max_turns=3
        )
    ):
        if type(message).__name__ == "ResultMessage":
            print(message.result)

# Exécuter les exemples
asyncio.run(multi_turn_conversation())

claude -p "Révisez ce code" --permission-mode plan

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

for await (const message of query({
  prompt: "Votre prompt ici",
  options: {
    permissionMode: 'plan'
  }
})) {
  if (message.type === "result") {
    console.log(message.result);
  }
}

from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async with ClaudeSDKClient(
    options=ClaudeCodeOptions(permission_mode='plan')
) as client:
    await client.query("Votre prompt ici")

# Agent de réponse aux incidents SRE
claude -p "L'API est en panne, enquêtez" \
  --append-system-prompt "Vous êtes un expert SRE. Diagnostiquez les problèmes systématiquement et fournissez des solutions exploitables."

# Agent de révision de documents juridiques  
claude -p "Révisez ce contrat" \
  --append-system-prompt "Vous êtes un avocat d'entreprise. Identifiez les risques, suggérez des améliorations, et assurez la conformité."

# Ajouter au prompt système par défaut
claude -p "Refactorisez cette fonction" \
  --append-system-prompt "Incluez toujours une gestion d'erreurs complète et des tests unit."

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

// Agent de réponse aux incidents SRE
for await (const message of query({
  prompt: "L'API est en panne, enquêtez",
  options: {
    systemPrompt: "Vous êtes un expert SRE. Diagnostiquez les problèmes systématiquement et fournissez des solutions exploitables.",
    maxTurns: 3
  }
})) {
  if (message.type === "result") console.log(message.result);
}

// Ajouter au prompt système par défaut
for await (const message of query({
  prompt: "Refactorisez cette fonction",
  options: {
    appendSystemPrompt: "Incluez toujours une gestion d'erreurs complète et des tests unit.",
    maxTurns: 2
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def specialized_agents():
    # Agent de réponse aux incidents SRE avec streaming
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Vous êtes un expert SRE. Diagnostiquez les problèmes systématiquement et fournissez des solutions exploitables.",
            max_turns=3
        )
    ) as sre_agent:
        await sre_agent.query("L'API est en panne, enquêtez")
        
        # Diffuser le processus de diagnostic
        async for message in sre_agent.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text, end='', flush=True)
    
    # Agent de révision juridique avec prompt personnalisé
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            append_system_prompt="Incluez toujours une gestion d'erreurs complète et des tests unit.",
            max_turns=2
        )
    ) as dev_agent:
        await dev_agent.query("Refactorisez cette fonction")
        
        # Collecter la réponse complète
        full_response = []
        async for message in dev_agent.receive_response():
            if type(message).__name__ == "ResultMessage":
                print(message.result)

asyncio.run(specialized_agents())

# Agent SRE avec outils de surveillance
claude -p "Enquêtez sur la panne du service de paiement" \
  --mcp-config sre-tools.json \
  --allowedTools "mcp__datadog,mcp__pagerduty,mcp__kubernetes" \
  --append-system-prompt "Vous êtes un SRE. Utilisez les données de surveillance pour diagnostiquer les problèmes."

# Agent de support client avec accès CRM
claude -p "Aidez à résoudre le ticket client #12345" \
  --mcp-config support-tools.json \
  --allowedTools "mcp__zendesk,mcp__stripe,mcp__user_db" \
  --append-system-prompt "Vous êtes un spécialiste du support technique."

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

// Agent SRE avec outils de surveillance
for await (const message of query({
  prompt: "Enquêtez sur la panne du service de paiement",
  options: {
    mcpConfig: "sre-tools.json",
    allowedTools: ["mcp__datadog", "mcp__pagerduty", "mcp__kubernetes"],
    systemPrompt: "Vous êtes un SRE. Utilisez les données de surveillance pour diagnostiquer les problèmes.",
    maxTurns: 4
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def mcp_enabled_agent():
    # Agent juridique avec accès aux documents et streaming
    # Note : Configurez vos serveurs MCP selon vos besoins
    mcp_servers = {
        # Exemple de configuration - décommentez et configurez selon vos besoins :
        # "docusign": {
        #     "command": "npx",
        #     "args": ["-y", "@modelcontextprotocol/server-docusign"],
        #     "env": {"API_KEY": "votre-clé"}
        # }
    }
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            mcp_servers=mcp_servers,
            allowed_tools=["mcp__docusign", "mcp__compliance_db"],
            system_prompt="Vous êtes un avocat d'entreprise spécialisé dans la révision de contrats.",
            max_turns=4
        )
    ) as client:
        await client.query("Révisez ce contrat pour les risques de conformité")
        
        # Surveiller l'utilisation des outils et les réponses
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'type'):
                        if block.type == 'tool_use':
                            print(f"\n[Utilisation de l'outil : {block.name}]\n")
                        elif hasattr(block, 'text'):
                            print(block.text, end='', flush=True)
                    elif hasattr(block, 'text'):
                        print(block.text, end='', flush=True)
            
            if type(message).__name__ == "ResultMessage":
                print(f"\n\nRévision terminée. Coût total : ${message.total_cost_usd:.4f}")

asyncio.run(mcp_enabled_agent())

# Utiliser avec votre configuration de serveur MCP
claude -p "Analysez et corrigez les problèmes de sécurité" \
  --permission-prompt-tool mcp__security__approval_prompt \
  --mcp-config security-tools.json \
  --allowedTools "Read,Grep" \
  --disallowedTools "Bash(rm*),Write"

# Avec des règles de permission personnalisées
claude -p "Refactorisez la base de code" \
  --permission-prompt-tool mcp__custom__permission_check \
  --mcp-config custom-config.json \
  --output-format json

const server = new McpServer({
  name: "Test permission prompt MCP Server",
  version: "0.0.1",
});

server.tool(
  "approval_prompt",
  'Simuler une vérification de permission - approuver si l\'entrée contient "allow", sinon refuser',
  {
    tool_name: z.string().describe("Le nom de l'outil demandant la permission"),
    input: z.object({}).passthrough().describe("L'entrée pour l'outil"),
    tool_use_id: z.string().optional().describe("L'ID unique de demande d'utilisation d'outil"),
  },
  async ({ tool_name, input }) => {
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(
            JSON.stringify(input).includes("allow")
              ? {
                  behavior: "allow",
                  updatedInput: input,
                }
              : {
                  behavior: "deny",
                  message: "Permission refusée par l'outil approval_prompt de test",
                }
          ),
        },
      ],
    };
  }
);

// Utiliser dans le SDK
import { query } from "@anthropic-ai/claude-code";

for await (const message of query({
  prompt: "Analysez la base de code",
  options: {
    permissionPromptTool: "mcp__test-server__approval_prompt",
    mcpConfig: "my-config.json",
    allowedTools: ["Read", "Grep"]
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def use_permission_prompt():
    """Exemple utilisant un outil de prompt de permission personnalisé"""
    
    # Configuration du serveur MCP
    mcp_servers = {
        # Exemple de configuration - décommentez et configurez selon vos besoins :
        # "security": {
        #     "command": "npx",
        #     "args": ["-y", "@modelcontextprotocol/server-security"],
        #     "env": {"API_KEY": "votre-clé"}
        # }
    }
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            permission_prompt_tool_name="mcp__security__approval_prompt",  # Changé de permission_prompt_tool
            mcp_servers=mcp_servers,
            allowed_tools=["Read", "Grep"],
            disallowed_tools=["Bash(rm*)", "Write"],
            system_prompt="Vous êtes un auditeur de sécurité"
        )
    ) as client:
        await client.query("Analysez et corrigez les problèmes de sécurité")
        
        # Surveiller l'utilisation des outils et les permissions
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'type'):  # Ajout de la vérification de l'attribut 'type'
                        if block.type == 'tool_use':
                            print(f"[Outil : {block.name}] ", end='')
                    if hasattr(block, 'text'):
                        print(block.text, end='', flush=True)
            
            # Vérifier les refus de permission dans les messages d'erreur
            if type(message).__name__ == "ErrorMessage":
                if hasattr(message, 'error') and "Permission denied" in str(message.error):
                    print(f"\n⚠️ Permission refusée : {message.error}")

# Exemple d'implémentation de serveur MCP (Python)
# Ceci serait dans votre code de serveur MCP
async def approval_prompt(tool_name: str, input: dict, tool_use_id: str = None):
    """Gestionnaire de prompt de permission personnalisé"""
    # Votre logique personnalisée ici
    if "allow" in str(input):
        return json.dumps({
            "behavior": "allow",
            "updatedInput": input
        })
    else:
        return json.dumps({
            "behavior": "deny",
            "message": f"Permission refusée pour {tool_name}"
        })

asyncio.run(use_permission_prompt())

claude -p "Expliquez le fichier src/components/Header.tsx"
# Sortie : Ceci est un composant React montrant...

// Sortie texte par défaut
for await (const message of query({
  prompt: "Expliquez le fichier src/components/Header.tsx"
})) {
  if (message.type === "result") {
    console.log(message.result);
    // Sortie : Ceci est un composant React montrant...
  }
}

# Sortie texte par défaut avec streaming
async with ClaudeSDKClient() as client:
    await client.query("Expliquez le fichier src/components/Header.tsx")
    
    # Diffuser le texte au fur et à mesure qu'il arrive
    async for message in client.receive_response():
        if hasattr(message, 'content'):
            for block in message.content:
                if hasattr(block, 'text'):
                    print(block.text, end='', flush=True)
                    # La sortie se diffuse en temps réel : Ceci est un composant React montrant...

claude -p "Comment fonctionne la couche de données ?" --output-format json

// Collecter tous les messages pour un accès de type JSON
const messages = [];
for await (const message of query({
  prompt: "Comment fonctionne la couche de données ?"
})) {
  messages.push(message);
}

// Accéder au message de résultat avec métadonnées
const result = messages.find(m => m.type === "result");
console.log({
  result: result.result,
  cost: result.total_cost_usd,
  duration: result.duration_ms
});

# Collecter tous les messages avec métadonnées
async with ClaudeSDKClient() as client:
    await client.query("Comment fonctionne la couche de données ?")
    
    messages = []
    result_data = None
    
    async for message in client.receive_messages():
        messages.append(message)
        
        # Capturer le message de résultat avec métadonnées
        if type(message).__name__ == "ResultMessage":
            result_data = {
                "result": message.result,
                "cost": message.total_cost_usd,
                "duration": message.duration_ms,
                "num_turns": message.num_turns,
                "session_id": message.session_id
            }
            break
    
    print(result_data)

# Argument direct
claude -p "Expliquez ce code"

# Depuis stdin
echo "Expliquez ce code" | claude -p

// Prompt direct
for await (const message of query({
  prompt: "Expliquez ce code"
})) {
  if (message.type === "result") console.log(message.result);
}

// Depuis une variable
const userInput = "Expliquez ce code";
for await (const message of query({ prompt: userInput })) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient

async def process_inputs():
    async with ClaudeSDKClient() as client:
        # Entrée texte
        await client.query("Expliquez ce code")
        async for message in client.receive_response():
            # Traiter la réponse en streaming
            pass
        
        
        
        # Entrée image (Claude utilisera automatiquement l'outil Read)
        await client.query("Qu'y a-t-il dans ce diagramme ? screenshot.png")
        async for message in client.receive_response():
            # Traiter l'analyse d'image
            pass
        
        # Plusieurs entrées avec contenu mixte
        inputs = [
            "Analysez l'architecture dans diagram.png",
            "Comparez-la avec les meilleures pratiques",
            "Générez une version améliorée"
        ]
        
        for prompt in inputs:
            await client.query(prompt)
            async for message in client.receive_response():
                # Traiter chaque réponse
                pass

asyncio.run(process_inputs())

#!/bin/bash

# Agent de réponse automatisée aux incidents
investigate_incident() {
    local incident_description="$1"
    local severity="${2:-medium}"
    
    claude -p "Incident : $incident_description (Gravité : $severity)" \
      --append-system-prompt "Vous êtes un expert SRE. Diagnostiquez le problème, évaluez l'impact, et fournissez des éléments d'action immédiats." \
      --output-format json \
      --allowedTools "Bash,Read,WebSearch,mcp__datadog" \
      --mcp-config monitoring-tools.json
}

# Utilisation
investigate_incident "API de paiement retournant des erreurs 500" "high"

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

// Agent de réponse automatisée aux incidents
async function investigateIncident(
  incidentDescription: string, 
  severity = "medium"
) {
  const messages = [];
  
  for await (const message of query({
    prompt: `Incident : ${incidentDescription} (Gravité : ${severity})`,
    options: {
      systemPrompt: "Vous êtes un expert SRE. Diagnostiquez le problème, évaluez l'impact, et fournissez des éléments d'action immédiats.",
      maxTurns: 6,
      allowedTools: ["Bash", "Read", "WebSearch", "mcp__datadog"],
      mcpConfig: "monitoring-tools.json"
    }
  })) {
    messages.push(message);
  }
  
  return messages.find(m => m.type === "result");
}

// Utilisation
const result = await investigateIncident("API de paiement retournant des erreurs 500", "high");
console.log(result.result);

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def investigate_incident(incident_description: str, severity: str = "medium"):
    """Agent de réponse automatisée aux incidents avec streaming en temps réel"""
    
    # Configuration du serveur MCP pour les outils de surveillance
    mcp_servers = {
        # Exemple de configuration - décommentez et configurez selon vos besoins :
        # "datadog": {
        #     "command": "npx",
        #     "args": ["-y", "@modelcontextprotocol/server-datadog"],
        #     "env": {"API_KEY": "votre-clé-datadog", "APP_KEY": "votre-clé-app"}
        # }
    }
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Vous êtes un expert SRE. Diagnostiquez le problème, évaluez l'impact, et fournissez des éléments d'action immédiats.",
            max_turns=6,
            allowed_tools=["Bash", "Read", "WebSearch", "mcp__datadog"],
            mcp_servers=mcp_servers
        )
    ) as client:
        # Envoyer les détails de l'incident
        prompt = f"Incident : {incident_description} (Gravité : {severity})"
        print(f"🚨 Enquête : {prompt}\n")
        await client.query(prompt)
        
        # Diffuser le processus d'enquête
        investigation_log = []
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'type'):
                        if block.type == 'tool_use':
                            print(f"[{block.name}] ", end='')
                    if hasattr(block, 'text'):
                        text = block.text
                        print(text, end='', flush=True)
                        investigation_log.append(text)
            
            # Capturer le résultat final
            if type(message).__name__ == "ResultMessage":
                return {
                    'analysis': ''.join(investigation_log),
                    'cost': message.total_cost_usd,
                    'duration_ms': message.duration_ms
                }

# Utilisation
result = await investigate_incident("API de paiement retournant des erreurs 500", "high")
print(f"\n\nEnquête terminée. Coût : ${result['cost']:.4f}")

# Agent d'audit de sécurité pour les pull requests
audit_pr() {
    local pr_number="$1"
    
    gh pr diff "$pr_number" | claude -p \
      --append-system-prompt "Vous êtes un ingénieur de sécurité. Révisez cette PR pour les vulnérabilités, les modèles non sécurisés, et les problèmes de conformité." \
      --output-format json \
      --allowedTools "Read,Grep,WebSearch"
}

# Utilisation et sauvegarde dans un fichier
audit_pr 123 > security-report.json

import { query } from "@anthropic-ai/claude-code";
import { execSync } from "child_process";

async function auditPR(prNumber: number) {
  // Obtenir le diff de la PR
  const prDiff = execSync(`gh pr diff ${prNumber}`, { encoding: 'utf8' });
  
  const messages = [];
  for await (const message of query({
    prompt: prDiff,
    options: {
      systemPrompt: "Vous êtes un ingénieur de sécurité. Révisez cette PR pour les vulnérabilités, les modèles non sécurisés, et les problèmes de conformité.",
      maxTurns: 3,
      allowedTools: ["Read", "Grep", "WebSearch"]
    }
  })) {
    messages.push(message);
  }
  
  return messages.find(m => m.type === "result");
}

// Utilisation
const report = await auditPR(123);
console.log(JSON.stringify(report, null, 2));

import subprocess
import asyncio
import json
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def audit_pr(pr_number: int):
    """Agent d'audit de sécurité pour les pull requests avec retour en streaming"""
    # Obtenir le diff de la PR
    pr_diff = subprocess.check_output(
        ["gh", "pr", "diff", str(pr_number)], 
        text=True
    )
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Vous êtes un ingénieur de sécurité. Révisez cette PR pour les vulnérabilités, les modèles non sécurisés, et les problèmes de conformité.",
            max_turns=3,
            allowed_tools=["Read", "Grep", "WebSearch"]
        )
    ) as client:
        print(f"🔍 Audit de la PR #{pr_number}\n")
        await client.query(pr_diff)
        
        findings = []
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        # Diffuser les découvertes au fur et à mesure qu'elles sont découvertes
                        print(block.text, end='', flush=True)
                        findings.append(block.text)
            
            if type(message).__name__ == "ResultMessage":
                return {
                    'pr_number': pr_number,
                    'findings': ''.join(findings),
                    'metadata': {
                        'cost': message.total_cost_usd,
                        'duration': message.duration_ms,
                        'severity': 'high' if 'vulnerability' in ''.join(findings).lower() else 'medium'
                    }
                }

# Utilisation
report = await audit_pr(123)
print(f"\n\nAudit terminé. Gravité : {report['metadata']['severity']}")
print(json.dumps(report, indent=2))

# Révision de document juridique avec persistance de session
session_id=$(claude -p "Démarrer une session de révision juridique" --output-format json | jq -r '.session_id')

# Réviser le contrat en plusieurs étapes
claude -p --resume "$session_id" "Révisez contract.pdf pour les clauses de responsabilité"
claude -p --resume "$session_id" "Vérifiez la conformité avec les exigences RGPD" 
claude -p --resume "$session_id" "Générez un résumé exécutif des risques"

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

async function legalReview() {
  // Démarrer une session de révision juridique
  let sessionId: string;
  
  for await (const message of query({
    prompt: "Démarrer une session de révision juridique",
    options: { maxTurns: 1 }
  })) {
    if (message.type === "system" && message.subtype === "init") {
      sessionId = message.session_id;
    }
  }
  
  // Révision multi-étapes utilisant la même session
  const steps = [
    "Révisez contract.pdf pour les clauses de responsabilité",
    "Vérifiez la conformité avec les exigences RGPD",
    "Générez un résumé exécutif des risques"
  ];
  
  for (const step of steps) {
    for await (const message of query({
      prompt: step,
      options: { resumeSessionId: sessionId, maxTurns: 2 }
    })) {
      if (message.type === "result") {
        console.log(`Étape : ${step}`);
        console.log(message.result);
      }
    }
  }
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def legal_review():
    """Révision de document juridique avec session persistante et streaming"""
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Vous êtes un avocat d'entreprise. Fournissez une analyse juridique détaillée.",
            max_turns=2
        )
    ) as client:
        # Révision multi-étapes dans la même session
        steps = [
            "Révisez contract.pdf pour les clauses de responsabilité",
            "Vérifiez la conformité avec les exigences RGPD", 
            "Générez un résumé exécutif des risques"
        ]
        
        review_results = []
        
        for step in steps:
            print(f"\n📋 {step}\n")
            await client.query(step)
            
            step_result = []
            async for message in client.receive_response():
                if hasattr(message, 'content'):
                    for block in message.content:
                        if hasattr(block, 'text'):
                            text = block.text
                            print(text, end='', flush=True)
                            step_result.append(text)
                
                if type(message).__name__ == "ResultMessage":
                    review_results.append({
                        'step': step,
                        'analysis': ''.join(step_result),
                        'cost': message.total_cost_usd
                    })
        
        # Résumé
        total_cost = sum(r['cost'] for r in review_results)
        print(f"\n\n✅ Révision juridique terminée. Coût total : ${total_cost:.4f}")
        return review_results

# Utilisation
results = await legal_review()