> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Référence du schéma d’Appel

> Référence sur la structure et les propriétés de l’objet Appel

Cette référence décrit le schéma de l’objet Appel dans W\&B Weave : ses propriétés, la manière d’écrire des données personnalisées dans le dictionnaire `summary` pendant l’exécution, et la manière de lire les données de synthèse une fois un Appel terminé. Consultez cette page lorsque vous devez inspecter, filtrer ou enrichir les données que Weave enregistre pour chaque Appel. Pour savoir comment interroger les Appels, voir [Interroger et exporter des Appels](/fr/products/wandb/weave/guides/tracking/querying-calls).

<h2 id="call-properties">
  Propriétés des Appels
</h2>

Le tableau suivant présente les principales propriétés d’un Appel dans Weave. Pour l’implémentation complète, consultez les ressources suivantes :

* [class: CallSchema](/fr/products/wandb/weave/reference/python-sdk/trace_server/trace_server_interface#class-callschema) dans le SDK Python
* [Interface: CallSchema](/fr/products/wandb/weave/reference/typescript-sdk/interfaces/callschema) dans le SDK TypeScript

| Propriété | Type | Description |
| - | - | - |
| `id` | string (uuid) | Identifiant unique de l’Appel |
| `project_id` | string (facultatif) | Identifiant du projet associé |
| `op_name` | string | Nom de l’opération (peut être une référence) |
| `display_name` | string (facultatif) | Nom lisible de l’Appel |
| `trace_id` | string (uuid) | Identifiant de la trace à laquelle appartient cet Appel |
| `parent_id` | string (uuid) | Identifiant de l’Appel parent |
| `started_at` | datetime | Horodatage du début de l’Appel |
| `attributes` | Dict\[str, Any] | Métadonnées définies par l’utilisateur concernant l’Appel *(en lecture seule pendant l’exécution)* |
| `inputs` | Dict\[str, Any] | Paramètres d’entrée de l’Appel |
| `ended_at` | datetime (facultatif) | Horodatage de la fin de l’Appel |
| `exception` | string (facultatif) | Message d’erreur si l’Appel a échoué |
| `output` | Any (facultatif) | Résultat de l’Appel |
| `summary` | Optional\[SummaryMap] | Informations de synthèse après l’exécution. Vous pouvez les modifier pendant l’exécution pour enregistrer des métriques personnalisées. |
| `wb_user_id` | Optional\[str] | ID de l’utilisateur W\&B associé |
| `wb_run_id` | Optional\[str] | ID du run W\&B associé |
| `deleted_at` | datetime (facultatif) | Horodatage de la suppression de l’Appel, le cas échéant |

<h2 id="property-details">
  Détails des propriétés
</h2>

Les propriétés de `CallSchema` vous aident à suivre et à gérer les Appels :

* Les propriétés `id`, `trace_id` et `parent_id` permettent d’organiser les Appels et de les relier entre eux au sein du système.
* Les informations temporelles (`started_at`, `ended_at`) facilitent l’analyse des performances.
* Les propriétés `attributes` et `inputs` fournissent le contexte de l’Appel. Les attributs sont figés dès le démarrage de l’Appel ; définissez-les donc avant l’invocation à l’aide du gestionnaire de contexte `weave.attributes()`. `output` et `summary` capturent les résultats.
* Utilisez `wb_user_id` et `wb_run_id` pour associer l’Appel à un utilisateur et à un run W\&B.

Ensemble, ces propriétés permettent un suivi et une analyse détaillés des Appels dans l’ensemble de votre projet.

<h2 id="use-call-summary">
  Utiliser la synthèse d’un Appel
</h2>

Utilisez la propriété `summary` pour joindre à un Appel des données personnalisées postérieures à l’exécution, afin de pouvoir les analyser ultérieurement aux côtés des métriques intégrées de Weave. Il s’agit d’un dictionnaire dans lequel vous pouvez écrire pendant l’exécution d’un Appel. À la fin de l’Appel, Weave fusionne en profondeur vos valeurs avec ses propres données calculées, puis stocke le résultat.

Le dictionnaire comporte deux zones :

* Vos clés personnalisées : tout ce que vous écrivez directement dans `call.summary`, par exemple `call.summary["accuracy"] = 0.95`. Ces clés se trouvent au premier niveau du dict de synthèse.
* `summary["weave"]` : un namespace réservé que Weave renseigne automatiquement à la fin de l’Appel. N’écrivez pas directement dans cette clé.

Weave capture également les nombres bruts de jetons LLM issus de la réponse du modèle dans `summary["usage"]` (indexés par nom de modèle). Il s’agit de données sources transmises telles quelles par le fournisseur, et non d’un calcul effectué par Weave. Le champ `costs` de `summary["weave"]` correspond à ce que Weave déduit de ces données d’utilisation à l’aide de la tarification des jetons.

Champs calculés par Weave dans `summary["weave"]` :

| Champ | Description |
| - | - |
| `status` | Statut d’exécution : `SUCCESS`, `ERROR`, `RUNNING` ou `DESCENDANT_ERROR` (l’Appel a réussi, mais un Appel enfant a échoué). |
| `latency_ms` | Durée en millisecondes entre `started_at` et `ended_at`. `null` si `status` vaut `RUNNING`. |
| `costs` | Ventilation des coûts par modèle, déduite de `summary["usage"]` et des données de tarification des jetons. Voir [Suivre les coûts](/fr/products/wandb/weave/guides/tracking/costs). |
| `trace_name` | Nom lisible de l’op, extrait de l’URI de référence interne de l’op. Utilisé pour l’affichage et le filtrage. |

<h3 id="write-during-a-call">
  Écrire pendant un Appel
</h3>

Vous pouvez ajouter des valeurs de données personnalisées pendant l’exécution de votre Appel à l’aide du dictionnaire `summary`.

<Tabs>
  <Tab title="Python">
    En Python, attribuez des valeurs à `call.summary` à n’importe quel moment de l’exécution à l’aide de `weave.get_current_call()`.

    ```python lines theme={"system"}
    import weave

    @weave.op()
    def my_op(x):
        result = do_work(x)
        call = weave.get_current_call()
        # Ajouter des valeurs de données personnalisées à la synthèse.
        call.summary["accuracy"] = 0.95
        call.summary["num_retries"] = 2
        return result
    ```
  </Tab>

  <Tab title="TypeScript">
    En TypeScript, fournissez une fonction `summarize` en option de `op()`. Elle reçoit le résultat final et renvoie les données de synthèse à la fin de l’Appel.

    ```typescript twoslash lines theme={"system"}
    // @noErrors
    const myOp = weave.op(
      async (x: any) => {
        const result = await doWork(x);
        return result;
      },
      {
        name: 'my_op',
        summarize: (result) => ({
          accuracy: result.accuracy,
          numRetries: result.numRetries,
        }),
      }
    );
    ```
  </Tab>
</Tabs>

<h3 id="read-summary-data">
  Lire les données de synthèse
</h3>

Utilisez `getCall` pour récupérer un Appel unique à partir de son ID, ou `getCalls` pour récupérer plusieurs Appels. Dans les deux cas, `summary` est le même dictionnaire fusionné.

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    import weave
    client = weave.init("my-team/my-project")

    # Récupérer un appel unique à partir de son ID.
    call = client.get_call("[CALL-ID]")
    weave_summary = (call.summary or {}).get("weave", {})

    print(weave_summary.get("status"))       # Enum TraceStatus : SUCCESS, ERROR, RUNNING ou DESCENDANT_ERROR.
    print(weave_summary.get("latency_ms"))   # Null si l’appel est toujours en cours d’exécution.
    print(weave_summary.get("costs"))        # Ventilation des coûts par modèle.
    print(call.summary.get("usage"))         # Nombres bruts de jetons renvoyés par le fournisseur de LLM.
    print(call.summary.get("accuracy"))      # Votre champ personnalisé.

    # Parcourir plusieurs appels avec un filtrage côté serveur.
    for call in client.get_calls(filter={"op_names": ["weave:///my-team/my-project/op/my_op:*"]}):
        s = call.summary or {}
        weave_s = s.get("weave", {})
        print(call.id, weave_s.get("status"), weave_s.get("latency_ms"), s.get("accuracy"))
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript twoslash lines theme={"system"}
    // @noErrors
    import * as weave from 'weave';
    const client = await weave.init('my-team/my-project');

    // Récupérer un appel unique à partir de son ID.
    const call = await client.getCall('[CALL-ID]');
    const weaveSummary = call.summary?.weave;

    console.log(weaveSummary?.status);       // "success", "error", "running" ou "descendant_error".
    console.log(weaveSummary?.latency_ms);   // Undefined si l’appel est toujours en cours d’exécution.
    console.log(weaveSummary?.costs);        // Ventilation des coûts par modèle.
    console.log(call.summary?.usage);        // Nombres bruts de jetons renvoyés par le fournisseur de LLM.
    console.log(call.summary?.accuracy);     // Votre champ personnalisé.

    // Récupérer plusieurs appels avec un filtrage côté serveur.
    const calls = await client.getCalls({ filter: { op_names: ['weave:///my-team/my-project/op/my_op:*'] } });
    for (const call of calls) {
      const weaveS = call.summary?.weave;
      console.log(call.id, weaveS?.status, weaveS?.latency_ms, call.summary?.accuracy);
    }
    ```
  </Tab>
</Tabs>


## Related topics

- [Interroger et exporter des appels](/fr/products/wandb/weave/guides/tracking/querying-calls.md)