Loading...
    • Construire
    • Admin
    • Modèles et tarification
    • SDKs clients
    • Référence API
    Search...
    ⌘K
    Premiers pas
    Introduction à ClaudeDémarrage rapide
    Construire avec Claude
    Aperçu des fonctionnalitésUtiliser l'API MessagesGérer les raisons d'arrêt
    Capacités du modèle
    Réflexion étendueRéflexion adaptativeEffortMode rapide (bêta : aperçu de recherche)Sorties structuréesCitationsMessages en streamingTraitement par lotsRésultats de rechercheRefus en streamingSupport multilingueEmbeddings
    Outils
    AperçuFonctionnement de l'utilisation des outilsOutil de recherche webOutil de récupération webOutil d'exécution de codeOutil de mémoireOutil BashOutil d'utilisation de l'ordinateurOutil d'édition de texte
    Infrastructure des outils
    Recherche d'outilsAppel d'outils programmatiqueStreaming d'outils précis
    Gestion du contexte
    Fenêtres de contexteCompactionÉdition du contexteMise en cache des promptsComptage de tokens
    Travailler avec des fichiers
    Files APISupport PDFImages et vision
    Compétences
    AperçuDémarrage rapideMeilleures pratiquesCompétences pour l'entrepriseCompétences dans l'API
    MCP
    Serveurs MCP distantsConnecteur MCP
    Ingénierie des prompts
    AperçuMeilleures pratiques de promptingOutils de prompting dans la Console
    Tester et évaluer
    Définir le succès et créer des évaluationsUtiliser l'outil d'évaluation dans la ConsoleRéduire la latence
    Renforcer les garde-fous
    Réduire les hallucinationsAugmenter la cohérence des sortiesAtténuer les jailbreaksRéduire les fuites de prompt
    Ressources
    Glossaire
    Notes de version
    Claude Platform
    Console
    Log in
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...

    Solutions

    • AI agents
    • Code modernization
    • Coding
    • Customer support
    • Education
    • Financial services
    • Government
    • Life sciences

    Partners

    • Amazon Bedrock
    • Google Cloud's Vertex AI

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Company

    • Anthropic
    • Careers
    • Economic Futures
    • Research
    • News
    • Responsible Scaling Policy
    • Security and compliance
    • Transparency

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Help and security

    • Availability
    • Status
    • Support
    • Discord

    Terms and policies

    • Privacy policy
    • Responsible disclosure policy
    • Terms of service: Commercial
    • Terms of service: Consumer
    • Usage policy
    Déléguer du travail à votre agent

    Flux d'événements de session

    Envoyez des événements, diffusez des réponses et interrompez ou redirigez votre session en cours d'exécution.

    Was this page helpful?

    • Types d'événements
    • Intégration des événements
    • Scénarios supplémentaires
    • Gestion des appels d'outils personnalisés
    • Confirmation d'outil
    • Suivi de l'utilisation

    La communication avec les agents gérés Claude est basée sur des événements. Vous envoyez des événements utilisateur à l'agent et recevez en retour des événements d'agent et de session pour suivre l'état.

    Toutes les requêtes API Managed Agents nécessitent l'en-tête bêta managed-agents-2026-04-01. Le SDK définit automatiquement l'en-tête bêta.

    Types d'événements

    Les événements circulent dans deux directions.

    • Les événements utilisateur sont ce que vous envoyez à l'agent pour démarrer une session et la piloter au fur et à mesure de sa progression.
    • Les événements de session, les événements de span et les événements d'agent vous sont envoyés pour la visibilité sur l'état de votre session et la progression de l'agent.

    Les chaînes de type d'événement suivent la convention de nommage {domain}.{action}.

    Chaque événement inclut un horodatage processed_at indiquant quand l'événement a été enregistré côté serveur. Si processed_at est null, cela signifie que l'événement a été mis en file d'attente par le harnais et sera traité après la fin du traitement des événements précédents.

    Consultez la référence API des événements de session pour le schéma complet de chaque type d'événement.

    Intégration des événements

    Scénarios supplémentaires

    Gestion des appels d'outils personnalisés

    Lorsque l'agent invoque un outil personnalisé :

    1. La session émet un événement agent.custom_tool_use contenant le nom et l'entrée de l'outil.
    2. La session se met en pause avec un événement session.status_idle contenant stop_reason: requires_action. Les identifiants d'événements bloquants se trouvent dans le tableau stop_reason.requires_action.event_ids.
    3. Exécutez l'outil dans votre système et envoyez un événement user.custom_tool_result pour chacun, en passant l'identifiant d'événement dans le paramètre custom_tool_use_id avec le contenu du résultat.
    4. Une fois tous les événements bloquants résolus, la session revient à l'état running.

    Confirmation d'outil

    Lorsqu'une politique de permission exige une confirmation avant l'exécution d'un outil :

    1. La session émet un événement agent.tool_use ou agent.mcp_tool_use.
    2. La session se met en pause avec un événement session.status_idle contenant stop_reason: requires_action. Les identifiants d'événements bloquants se trouvent dans le tableau stop_reason.requires_action.event_ids.
    3. Envoyez un événement user.tool_confirmation pour chacun, en passant l'identifiant d'événement dans le paramètre tool_use_id. Définissez result sur "allow" ou "deny". Utilisez deny_message pour expliquer un refus.
    4. Une fois tous les événements bloquants résolus, la session repasse à l'état running.

    Suivi de l'utilisation

    L'objet session inclut un champ usage avec des statistiques cumulatives de tokens. Récupérez la session après qu'elle soit passée à l'état inactif pour lire les derniers totaux, et utilisez-les pour suivre les coûts, appliquer des budgets ou surveiller la consommation.

    {
      "id": "sesn_01...",
      "status": "idle",
      "usage": {
        "input_tokens": 5000,
        "output_tokens": 3200,
        "cache_creation_input_tokens": 2000,
        "cache_read_input_tokens": 20000
      }
    }

    input_tokens indique les tokens d'entrée non mis en cache et output_tokens indique le total des tokens de sortie pour tous les appels de modèle dans la session. Les champs cache_creation_input_tokens et cache_read_input_tokens reflètent l'activité de mise en cache des prompts. Les entrées de cache utilisent un TTL de 5 minutes, de sorte que les tours consécutifs dans cette fenêtre bénéficient des lectures de cache, ce qui réduit le coût par token.

    exec {fd}< <(curl -sS -N --fail-with-body \
      "https://api.anthropic.com/v1/sessions/$SESSION_ID/stream?beta=true" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      -H "Accept: text/event-stream")
    
    while IFS= read -r -u "$fd" line; do
      [[ $line == data:* ]] || continue
      data="${line#data: }"
      [[ $(jq -r '.type' <<<"$data") == "session.status_idle" ]] || continue
      case $(jq -r '.stop_reason.type // empty' <<<"$data") in
        requires_action)
          while IFS= read -r event_id; do
            # Rechercher l'événement d'utilisation d'outil personnalisé et l'exécuter
            result=$(call_tool "$event_id")
            # Renvoyer le résultat
            jq -n --arg id "$event_id" --arg result "$result" \
              '{events: [{type: "user.custom_tool_result", custom_tool_use_id: $id, content: [{type: "text", text: $result}]}]}' |
              curl -sS --fail-with-body \
                "https://api.anthropic.com/v1/sessions/$SESSION_ID/events?beta=true" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01" \
                -H "anthropic-beta: managed-agents-2026-04-01" \
                -H "content-type: application/json" \
                -d @-
          done < <(jq -r '.stop_reason.event_ids[]' <<<"$data")
          ;;
        end_turn)
          break
          ;;
      esac
    done
    exec {fd}<&-
    exec {fd}< <(curl -sS -N --fail-with-body \
      "https://api.anthropic.com/v1/sessions/$SESSION_ID/stream?beta=true" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      -H "Accept: text/event-stream")
    
    while IFS= read -r -u "$fd" line; do
      [[ $line == data:* ]] || continue
      data="${line#data: }"
      [[ $(jq -r '.type' <<<"$data") == "session.status_idle" ]] || continue
      case $(jq -r '.stop_reason.type // empty' <<<"$data") in
        requires_action)
          while IFS= read -r event_id; do
            # Approve the pending tool call
            jq -n --arg id "$event_id" \
              '{events: [{type: "user.tool_confirmation", tool_use_id: $id, result: "allow"}]}' |
              curl -sS --fail-with-body \
                "https://api.anthropic.com/v1/sessions/$SESSION_ID/events?beta=true" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01" \
                -H "anthropic-beta: managed-agents-2026-04-01" \
                -H "content-type: application/json" \
                -d @-
          done < <(jq -r '.stop_reason.event_ids[]' <<<"$data")
          ;;
        end_turn)
          break
          ;;
      esac
    done
    exec {fd}<&-