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

# Fonctions de span

> Fonctions de niveau module permettant de démarrer, de terminer et de récupérer la conversation, le tour de conversation et l’appel LLM en cours.

Accédez-y via le module `tracing` :

```python theme={"system"}
from coreweave.forge.agentlens import tracing
```

<h2 id="start_conversation">
  start\_conversation
</h2>

```python theme={"system"}
def start_conversation(
    *,
    agent_name: str = '',
    model: str = '',
    conversation_id: str = '',
    conversation_name: str = '',
    include_content: bool = True,
    continue_parent_trace: bool = False,
    attributes: Attributes = None,
) -> Conversation: ...
```

Crée et active une conversation. Définit la contextvar pour permettre l’accès entre modules.

Les `attributes` sont ajoutés à chaque span émis par cette conversation (par exemple une
identité d’intégration comme `weave.integration.*`). Utilisez des clés personnalisées,
hors conventions sémantiques : définissez les champs de convention sémantique via les paramètres typés
(`conversation_name`, `model`, ...). Une clé qui entre en conflit avec un attribut
`gen_ai.*` / `weave.*` propre à un span n’est pas prise en charge ; la valeur
retenue dépend du chemin d’exécution (streaming ou `log_turn`).

<h2 id="start_turn">
  start\_turn
</h2>

```python theme={"system"}
def start_turn(
    *,
    user_message: str = '',
    model: str = '',
    agent_name: str = '',
    system_instructions: Union[list[str], None] = None,
) -> Turn: ...
```

Crée et active un tour de conversation. Utilise la conversation courante si elle est disponible.

Démarre le span et en fait le span courant. Sans conversation, le tour de conversation
n’a pas d’identifiant de conversation. Terminez-le avec `end_turn()`, `end()` ou `with`.

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

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

Crée et active un appel LLM. Utilise le tour de conversation en cours s’il est disponible.

Démarre le span et en fait le span courant, même en l’absence de tour de conversation actif.

Transmettez `provider_name` explicitement. Le SDK ne le déduit pas de
l’identifiant du modèle : une déduction fondée sur le préfixe attribue à tort les modèles fine-tunés par les utilisateurs
(par exemple un modèle nommé `text-...`) et inscrit dans la télémétrie des hypothèses sur les futurs
noms de modèles, qu’il est coûteux de corriger après coup.

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

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

Crée et démarre un span d'exécution d'outil.

Le span OTel de l'outil devient automatiquement l'enfant du span
courant dans le contexte OTel, généralement un span Turn s'il en existe un actif. Aucune
délégation explicite au Turn n'est nécessaire : la propagation parent-enfant s'effectue
via le contexte OTel, et non via les contextvars du SDK Conversation.

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

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

Crée et démarre un span d’appel de sous-agent.

Le span OTel du SubAgent devient automatiquement l’enfant du span
courant dans le contexte OTel, généralement un span Turn s’il y en a un actif.
Même structure que `start_tool` : le contexte OTel gère la propagation
parent-enfant, sans qu’aucune délégation explicite soit nécessaire.

<h2 id="end_conversation">
  end\_conversation
</h2>

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

Termine la conversation en cours (issue de la contextvar).

<h2 id="end_turn">
  end\_turn
</h2>

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

Termine le tour de conversation en cours (à partir de la contextvar).

<h2 id="end_llm">
  end\_llm
</h2>

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

Termine l’appel LLM en cours (à partir de la contextvar).

<h2 id="get_current_conversation">
  get\_current\_conversation
</h2>

```python theme={"system"}
def get_current_conversation() -> Union[Conversation, None]: ...
```

Renvoie la conversation active à partir de la contextvar, ou None.

<h2 id="get_current_turn">
  get\_current\_turn
</h2>

```python theme={"system"}
def get_current_turn() -> Union[Turn, None]: ...
```

Renvoie le tour de conversation actif à partir de la contextvar, ou None.

<h2 id="get_current_llm">
  get\_current\_llm
</h2>

```python theme={"system"}
def get_current_llm() -> Union[LLM, None]: ...
```

Renvoie l’appel LLM actif depuis la contextvar, ou None.