> ## 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.

# SubAgent

> La classe SubAgent enregistre un appel d’agent délégué sous la forme d’un span invoke_agent imbriqué.

```python theme={"system"}
class SubAgent(BaseModel): ...
```

Un appel d’agent délégué au sein d’un tour de conversation.

Correspond à un span OTel invoke\_agent imbriqué dans la même trace.

`SubAgent` est un modèle Pydantic. Lors de sa construction, vous pouvez définir chacun des champs ci-dessous sous forme d’argument nommé.

`SubAgent` est un gestionnaire de contexte et peut être utilisé dans une instruction `with`.

<h2 id="fields">
  Champs
</h2>

| Champ | Type | Par défaut |
| - | - | - |
| `name` | `str` | `''` |
| `model` | `str` | `''` |
| `agent_id` | `str` | `''` |
| `agent_description` | `str` | `''` |
| `agent_version` | `str` | `''` |
| `system_instructions` | `list[str]` | `[]` |
| `input_messages` | `list[Message]` | `[]` |
| `output_messages` | `list[Message]` | `[]` |
| `tool_name` | `str` | `''` |
| `tool_call_id` | `str` | `''` |
| `tool_call_arguments` | `JSONString` | `''` |
| `tool_call_result` | `JSONString` | `''` |
| `started_at` | `Union[datetime, None]` | `None` |
| `ended_at` | `Union[datetime, None]` | `None` |

<h2 id="methods">
  Méthodes
</h2>

<h3 id="start_llm">
  start\_llm
</h3>

```python theme={"system"}
def start_llm(
    *,
    model: str = '',
    provider_name: str = '',
    system_instructions: Union[list[str], None] = None,
) -> LLM: ...
```

Démarre un appel LLM au sein de ce sous-agent.

Définit la contextvar `_current_llm` afin que le LLM soit accessible via
`get_current_llm()`, qu'un gestionnaire de contexte soit utilisé ou non.
Rattache le parent OTel du LLM au span de ce SubAgent si l'on est déjà
entré dans le SubAgent.

<h3 id="start_tool">
  start\_tool
</h3>

```python theme={"system"}
def start_tool(*, name: str, arguments: str = '', tool_call_id: str = '') -> Tool: ...
```

Démarre une exécution d'outil au sein de ce sous-agent.

Rattache le parent OTel du Tool au span de ce SubAgent lorsque l'on est entré dans le SubAgent.

<h3 id="start_subagent">
  start\_subagent
</h3>

```python theme={"system"}
def start_subagent(
    *,
    name: str,
    model: str = '',
    set_current: bool = True,
) -> SubAgent: ...
```

Démarre un sous-agent imbriqué sous celui-ci.

Rattache le parent OTel du SubAgent imbriqué au span de ce SubAgent lorsque
le contexte de ce SubAgent a été ouvert.

<h3 id="record">
  record
</h3>

```python theme={"system"}
def record(
    *,
    name: Union[str, None] = None,
    model: Union[str, None] = None,
    system_instructions: Union[list[str], None] = None,
    input_messages: Union[list[Message], None] = None,
    output_messages: Union[list[Message], None] = None,
    tool_name: Union[str, None] = None,
    tool_call_id: Union[str, None] = None,
    tool_call_arguments: Union[str, None] = None,
    tool_call_result: Union[str, None] = None,
    agent_id: Union[str, None] = None,
    agent_description: Union[str, None] = None,
    agent_version: Union[str, None] = None,
) -> SubAgent: ...
```

Définit plusieurs champs du sous-agent en un seul appel.

Remplace par un seul appel à arguments nommés les affectations champ par champ qu’un agent instrumenté manuellement
doit sinon effectuer sur un sous-agent (`system_instructions`, `agent_id`,
...). Seuls les champs explicitement transmis
(différents de `None`) sont appliqués ; les valeurs existantes sont conservées. Renvoie
`self` pour permettre le chaînage. Fonctionne comme `Turn.record` / `LLM.record`.

Remarque : en mode streaming (`with`), le span du sous-agent est nommé
d’après `name` lors de `__enter__`. Si le nom du span doit refléter cette valeur, définissez donc `name` via `start_subagent`
/ `turn.subagent` plutôt que via `record`. `record` met toutefois à jour l’attribut
`gen_ai.agent.name`.

<h3 id="end">
  end
</h3>

```python theme={"system"}
def end() -> None: ...
```

<h3 id="start">
  start
</h3>

```python theme={"system"}
def start(*, set_current: bool = True) -> Self: ...
```

Démarre le span de ce sous-agent. Équivaut à `__enter__` sans le `with`.

Passez `set_current=False` à `start_subagent` lorsque plusieurs sous-agents peuvent s'exécuter
simultanément. `end()` se détache via `ContextVar.reset`, ce qui
corrompt silencieusement la pile de contexte ambiante lorsque des spans qui se chevauchent
ne se terminent pas dans l'ordre LIFO : le span restant au même niveau cesse d'être le span courant,
et le dernier détachement restaure un span déjà terminé. Dans tous les cas, les enfants créés
via `start_llm` / `start_tool` / `start_subagent` s'imbriquent sous
ce span, car ces fabriques transmettent explicitement un contexte
parent.

<h3 id="record_error">
  record\_error
</h3>

```python theme={"system"}
def record_error(error: BaseException) -> Self: ...
```

Enregistre un échec sans terminer le span ; appelez `end()` le moment venu.

<h3 id="set_attributes">
  set\_attributes
</h3>

```python theme={"system"}
def set_attributes(attributes: dict[str, Any]) -> Self: ...
```

Ajoute des attributs OTel arbitraires à ce span.

Passez un dict, que vous ayez une seule clé ou plusieurs ; pour une seule clé,
utilisez `span.set_attributes({"weave.tag": "value"})`. Équivalent de la méthode
`Span.set_attributes` d'OTel.

Doit être appelée une fois le span démarré par une fabrique `start_*`, par `start()` ou par `with`,
et avant sa fin. En dehors de cette fenêtre, l'appel est sans effet
et journalise un avertissement. Pour l'ingestion par lots, renseignez directement les champs déclarés de l'objet
et passez-le à `log_turn` / `log_conversation`.