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

# Délai d’inactivité

export const SandboxConfigHint = () => {
  if (typeof document === "undefined") {
    return null;
  } else {
    return <Note>Before running the example code in this document, please ensure you have properly configured environment variables. For details, please refer to <a href="/docs/fr/guides/sandbox-your-first-agent-sandbox#configure-environment-variables">Configure Environment Variables</a>.</Note>;
  }
};

Vous pouvez configurer un **délai d’inactivité** pour vos sandboxes afin qu’ils s’arrêtent ou se mettent automatiquement en pause lorsqu’aucune connexion active n’est détectée. Cela permet de réduire les coûts en évitant que des sandboxes inutilisés ne s’exécutent indéfiniment.

<SandboxConfigHint />

<Note>
  Le délai d’inactivité est configuré via le champ `metadata` lors de la création d’un sandbox. La clé est `idle_timeout` et la valeur est le nombre de secondes (sous forme de chaîne).
</Note>

## Utilisation de base

Passez la clé `idle_timeout` dans l’objet `metadata` lors de la création d’un sandbox. La valeur correspond à la durée du délai d’inactivité en **secondes** (sous forme de chaîne). Lorsqu’aucun client n’est connecté au sandbox pendant la durée spécifiée, le sandbox est automatiquement arrêté définitivement ou mis en pause.

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox/code-interpreter'

  // Create a sandbox that will be automatically killed after 60 seconds of inactivity.
  const sandbox = await Sandbox.create({
    metadata: {
      idle_timeout: '60',
    },
  })

  // The sandbox is running...
  // After 60 seconds with no active connections, it will be killed automatically.
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.code_interpreter import Sandbox

  # Create a sandbox that will be automatically killed after 60 seconds of inactivity.
  sandbox = Sandbox.create(
      metadata={
          "idle_timeout": "60",
      },
  )

  # The sandbox is running...
  # After 60 seconds with no active connections, it will be killed automatically.
  ```
</CodeGroup>

## Fonctionnement du délai d’inactivité

La fonctionnalité de délai d’inactivité surveille les connexions actives à votre sandbox :

1. **Lorsqu’aucune connexion n’est active** — l’heure de fin du sandbox est définie sur `current_time + idle_timeout_seconds`.
2. **Lorsqu’une connexion redevient active** — l’heure de fin du sandbox est restaurée à la durée de vie maximale d’origine du sandbox.
3. **Lorsque le délai d’inactivité s’écoule sans aucune reconnexion** — le sandbox est arrêté définitivement (ou mis en pause si `autoPause` est activé).

Cela signifie qu’un sandbox ne sera pas arrêté tant qu’au moins un client actif y est connecté (par exemple, via `Sandbox.connect()` ou des connexions WebSocket/HTTP ouvertes).

## Mettre en pause au lieu d’arrêter définitivement

Par défaut, un sandbox inactif est **arrêté définitivement** lorsque le délai d’inactivité expire. Si vous souhaitez plutôt que le sandbox soit **mis en pause** afin de pouvoir le reprendre plus tard, activez l’option `autoPause` :

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox/code-interpreter'

  // Create a sandbox that will be paused (instead of killed) after 60 seconds of inactivity.
  const sandbox = await Sandbox.create({
    metadata: {
      idle_timeout: '60',
    },
    autoPause: true,
  })

  // After 60 seconds of inactivity, the sandbox will be paused.
  // You can resume it later with Sandbox.connect().
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.code_interpreter import Sandbox

  # Create a sandbox that will be paused (instead of killed) after 60 seconds of inactivity.
  sandbox = Sandbox.create(
      metadata={
          "idle_timeout": "60",
      },
      auto_pause=True,
  )

  # After 60 seconds of inactivity, the sandbox will be paused.
  # You can resume it later with Sandbox.connect().
  ```
</CodeGroup>

<Note>
  Lorsque `autoPause` est activé, l’état du sandbox passe à `paused` à l’expiration du délai d’inactivité. Vous pouvez vous y [connecter](/docs/fr/guides/sandbox-connect) plus tard pour reprendre l’exécution.
</Note>

## Combinaison avec d’autres métadonnées

La clé de métadonnées `idle_timeout` peut être combinée avec d’autres clés de métadonnées que vous utilisez peut-être déjà :

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox/code-interpreter'

  const sandbox = await Sandbox.create({
    metadata: {
      idle_timeout: '120',
      env: 'production',
      userId: 'user-123',
    },
  })

  console.log('Sandbox ID:', sandbox.sandboxId)
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.code_interpreter import Sandbox

  sandbox = Sandbox.create(
      metadata={
          "idle_timeout": "120",
          "env": "production",
          "user_id": "user-123",
      },
  )

  print("Sandbox ID:", sandbox.sandbox_id)
  ```
</CodeGroup>

## Contraintes de délai

| Contrainte     | Valeur                  | Description                                                                                                                             |
| -------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| **Minimum**    | 30 secondes             | Les valeurs inférieures à 30 secondes sont traitées comme « inactivité désactivée » afin d’éviter des cycles rapides de démarrage/stop. |
| **Par défaut** | Désactivé (0)           | Si `idle_timeout` n’est pas spécifié, la fonctionnalité est désactivée et le sandbox s’exécute jusqu’à sa durée de vie maximale.        |
| **Maximum**    | Durée de vie du sandbox | Le délai d’inactivité ne peut pas dépasser le paramètre `timeout` (durée de vie maximale) configuré pour le sandbox.                    |

<Warning>
  Si vous définissez `idle_timeout` sur une valeur inférieure au seuil minimal (30 secondes), la fonctionnalité de délai d’inactivité sera **désactivée silencieusement** pour ce sandbox. Le sandbox s’exécutera jusqu’à l’expiration de sa durée de vie maximale.
</Warning>

## Désactiver le délai d’inactivité

Pour désactiver explicitement le délai d’inactivité pour un sandbox, omettez simplement la clé `idle_timeout` des métadonnées, ou définissez-la sur `"0"` :

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox/code-interpreter'

  // No idle timeout — sandbox runs until its maximum lifetime.
  const sandbox = await Sandbox.create({
    metadata: {
      idle_timeout: '0',
    },
  })

  // Alternatively, omit idle_timeout entirely:
  const sandbox2 = await Sandbox.create()
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.code_interpreter import Sandbox

  # No idle timeout — sandbox runs until its maximum lifetime.
  sandbox = Sandbox.create(
      metadata={
          "idle_timeout": "0",
      },
  )

  # Alternatively, omit idle_timeout entirely:
  sandbox2 = Sandbox.create()
  ```
</CodeGroup>

## Cas d’utilisation courants

### Tâches d’exécution de courte durée

Utilisez un délai d’inactivité court pour les sandboxes qui exécutent des tâches ponctuelles et n’ont pas besoin de persister après la déconnexion du client :

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox/code-interpreter'

  const sandbox = await Sandbox.create({
    metadata: { idle_timeout: '60' },
  })

  // Execute code and get results...
  const result = await sandbox.runCode('print("Hello!")')

  // Disconnect — sandbox will be killed after 60 seconds of inactivity.
  await sandbox.kill()
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.code_interpreter import Sandbox

  sandbox = Sandbox.create(
      metadata={"idle_timeout": "60"},
  )

  # Execute code and get results...
  result = sandbox.run_code('print("Hello!")')

  # Disconnect — sandbox will be killed after 60 seconds of inactivity.
  sandbox.kill()
  ```
</CodeGroup>

### Sessions interactives de longue durée

Utilisez un délai d’inactivité plus long pour les sandboxes utilisés dans des sessions interactives où les utilisateurs peuvent s’absenter temporairement :

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox/code-interpreter'

  const sandbox = await Sandbox.create({
    metadata: { idle_timeout: '600' }, // 10 minutes
    autoPause: true,
  })

  // The sandbox will pause after 10 minutes of inactivity,
  // and can be resumed when the user returns.
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.code_interpreter import Sandbox

  sandbox = Sandbox.create(
      metadata={"idle_timeout": "600"},  # 10 minutes
      auto_pause=True,
  )

  # The sandbox will pause after 10 minutes of inactivity,
  # and can be resumed when the user returns.
  ```
</CodeGroup>