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

# OpenClaw

> Connectez OpenClaw à FlexInference via son processus d'intégration de fournisseur personnalisé ou son fichier de configuration.

OpenClaw se connecte à tout point de terminaison compatible OpenAI via un fournisseur personnalisé. Le processus d'intégration crée l'entrée pour vous, et le fichier de configuration la conserve par la suite.

OpenClaw n'a pas de champ de délai par requête qui lui soit propre, le délai est donc associé à la clé. Créez-en une d'abord (voir [clés d'agent](/fr/agent-keys)).

## Configurez ceci avec un agent

Ouvrez le bloc ci-dessous et copiez-le dans n'importe quel agent de codage. L'invite ne vous demandera jamais votre clé API : l'agent configure tout le reste, puis affiche la ligne d'exportation que vous devrez exécuter vous-même.

<Accordion title="Copier l'invite de configuration de l'agent">
  ```text theme={null}
  Configure OpenClaw to send its requests to FlexInference through a custom provider. Use the OpenClaw CLI, not hand-edited JSON, so every write is schema-validated.

  You will never see or handle my API key. OpenClaw will read it from the `FLEXINFERENCE_API_KEY` environment variable through a secret reference, and I export that myself. Do not ask me for the key, do not pass it on any command line, and do not read it from my environment.

  Ask whether to use my default OpenClaw profile or a separate one. A separate profile isolates config, state, gateway port, and workspace, and is the safe way to try this. Prefix every command with `--profile flex` if I choose one.

  1. Confirm which config file is active with `openclaw config file`.

  2. Tell me to export the key first, and stop until I confirm. Print this line; do not run it and do not ask for the value:

  export FLEXINFERENCE_API_KEY=<paste your key here>

  3. Write the provider entry. It carries no credential. The model row is required, because OpenClaw refuses a third-party provider that declares no `models`; step 5 replaces it with the full catalog:

  openclaw config set models.providers.flexinference --merge --strict-json '{"baseUrl":"https://api.flexinference.com/v1","api":"openai-completions","models":[{"id":"gpt-5.6-sol","name":"GPT-5.6 Sol","compat":{"supportsUsageInStreaming":true}}]}'

  4. Declare an environment secrets provider, then point the provider's apiKey at it. Both commands pass only the VARIABLE NAME, never the value:

  openclaw config set secrets.providers.default \
    --provider-source env --provider-allowlist FLEXINFERENCE_API_KEY

  openclaw config set models.providers.flexinference.apiKey \
    --ref-provider default --ref-source env --ref-id FLEXINFERENCE_API_KEY

  5. Fill the model list from the live FlexInference catalog rather than by hand:

  curl -s https://api.flexinference.com/v1/models \
    -H "Authorization: Bearer $FLEXINFERENCE_API_KEY" \
  | jq '{models:{providers:{flexinference:{models:
      [.data[] | {id, name: .id, compat: {supportsUsageInStreaming: true}}]}}}}' \
  | openclaw config patch --stdin

  Run every write with `--dry-run` first and show me the diff before applying it.

  6. Verify with `openclaw models list --provider flexinference`, then run `openclaw security audit`.

  Rules that matter, do not deviate:
  - Never pass my key as an argument to an `openclaw` command, and never write it into a config file. `openclaw onboard --custom-api-key` does both, which is why step 4 uses a reference instead.
  - Step 5 is the one place the key expands, into curl's `-H` argument, where a same-user process can read it. That is a deliberate trade for a single catalog read. Do not extend it to any other command.
  - The provider id must be `flexinference` in every command. If an earlier setup derived `custom-api-flexinference-com` from the host, tell me, and use that id consistently instead of creating a second provider.
  - `api` must be `openai-completions`. That is the only adapter FlexInference's Chat Completions surface works with here.
  - The base URL must end in `/v1`.
  - You MUST list models explicitly. OpenClaw only lets its own built-in provider ids omit `models`, and it will never call `GET /v1/models` for a provider defined in config. Model discovery is a plugin capability and does not apply here.
  - Every model row needs `compat: { supportsUsageInStreaming: true }`. OpenClaw makes streaming usage opt-in for third-party endpoints, and without it every streamed turn reports zero tokens and no cost.
  - Leave `"mode": "merge"` alone so my existing providers survive.
  - Step 4 resolves the reference at write time, so it fails if I have not exported the variable yet. That failure is expected, not a reason to fall back to a literal key.
  - FlexInference's catalog publishes no context window or token ceiling, so generated rows carry neither. Do not invent values; leave them out unless I give you numbers.

  Report what you changed and which config file you wrote.
  ```
</Accordion>

## Intégrer un fournisseur personnalisé

1. Démarrez la configuration guidée.

   ```bash theme={null}
   openclaw onboard
   ```

2. Choisissez l'option de fournisseur personnalisé lorsqu'il vous demande l'authentification. C'est `custom-api-key`.

3. Saisissez le routeur comme URL de base, en incluant le suffixe `/v1`.

   ```text theme={null}
   https://api.flexinference.com/v1
   ```

4. Collez votre clé d'agent.

5. Laissez le mode de compatibilité sur `openai`. C'est notre interface de Chat Completions.

6. Saisissez un ID de modèle que nous exécutons, tel que `gpt-5.6-sol`.

L'invite ne place jamais votre clé sur une ligne de commande, c'est pourquoi c'est le chemin indiqué ici.

`openclaw onboard --non-interactive` existe également, mais son mode d'authentification `custom-api-key` lit les informations d'identification depuis `--custom-api-key`, de sorte que le secret se retrouve dans l'historique de votre shell et dans les arguments du processus. Scriptez plutôt la configuration avec des commandes de configuration et une référence de secret, ce qui donne le même résultat sans l'exposition.

Quelle que soit la méthode que vous choisissez, définissez vous-même l'ID du fournisseur :

```bash theme={null}
openclaw config set models.providers.flexinference --merge --strict-json \
  '{"baseUrl":"https://api.flexinference.com/v1","api":"openai-completions","models":[{"id":"gpt-5.6-sol","name":"GPT-5.6 Sol","compat":{"supportsUsageInStreaming":true}}]}'
```

Laissé à lui-même, OpenClaw dérive l'ID de l'hôte et se retrouve avec `custom-api-flexinference-com`, et chaque commande ultérieure sur cette page nécessiterait ce nom à la place.

L'écriture inclut une ligne de modèle car c'est obligatoire. OpenClaw refuse un fournisseur tiers qui ne déclare aucun `models`, donc une écriture avec seulement `baseUrl` échoue à la validation du schéma. Remplacez toute la ligne dans la section suivante.

Le mode de compatibilité correspond à `api`. `openai` écrit `openai-completions`, qui est celui avec lequel notre point de terminaison Chat Completions fonctionne. Les autres choix sont `openai-responses` et `anthropic`.

## Le fichier de configuration

Le processus d'intégration écrit dans `~/.openclaw/openclaw.json` sous `models.providers`. Affichez le chemin utilisé par OpenClaw avec `openclaw config file`.

```json theme={null}
{
  "models": {
    "mode": "merge",
    "providers": {
      "flexinference": {
        "baseUrl": "https://api.flexinference.com/v1",
        "api": "openai-completions",
        "apiKey": {
          "source": "env",
          "provider": "default",
          "id": "FLEXINFERENCE_API_KEY"
        },
        "models": [
          {
            "id": "gpt-5.6-sol",
            "name": "GPT-5.6 Sol",
            "contextWindow": 400000,
            "maxTokens": 128000,
            "input": ["text", "image"],
            "compat": { "supportsUsageInStreaming": true }
          }
        ]
      }
    }
  }
}
```

`"mode": "merge"` conserve vos fournisseurs intégrés et ajoute celui-ci à côté.

`api` doit être `openai-completions`. Le mode de compatibilité `openai` du processus d'intégration écrit exactement cela.

`apiKey` accepte également une chaîne de caractères simple, ce que le processus d'intégration écrit. La référence montrée ici maintient le secret hors du fichier. Voir garder la clé hors du fichier de configuration.

**Listez vos modèles vous-même.** Seuls les ID de fournisseur intégrés d'OpenClaw peuvent omettre `models`. Un ID tiers doit déclarer à la fois `baseUrl` et `models`, alors ajoutez une ligne par modèle que vous souhaitez dans le sélecteur.

**Définissez `compat.supportsUsageInStreaming`.** OpenClaw rend l'utilisation du streaming optionnelle pour un point de terminaison tiers, car certains serveurs le refusent. Sans cet indicateur, nous ne recevons jamais la demande de cadre d'utilisation, de sorte que chaque tour diffusé rapporte zéro jeton et aucun coût.

## Remplir la liste des modèles à partir de notre catalogue

OpenClaw n'appellera pas `GET /v1/models` pour un fournisseur que vous définissez dans la configuration. La découverte de modèles est une capacité de plugin, et les plugins fournis qui l'ont sont les seuls à l'utiliser. Un fournisseur défini par la configuration lit son tableau `models` et rien d'autre.

Générez plutôt ce tableau à partir de notre catalogue, et écrivez-le en une seule commande.

```bash theme={null}
export FLEXINFERENCE_API_KEY=<your agent key>

curl -s https://api.flexinference.com/v1/models \
  -H "Authorization: Bearer $FLEXINFERENCE_API_KEY" \
| jq '{models:{providers:{flexinference:{models:
    [.data[] | {id, name: .id, compat: {supportsUsageInStreaming: true}}]}}}}' \
| openclaw config patch --stdin
```

`config patch` fusionne les objets et remplace les tableaux, ce qui échange la liste des modèles et laisse `baseUrl` et `apiKey` intacts. Ajoutez `--dry-run` pour voir l'écriture d'abord.

Ne conservez que les modèles qui concourent dans le niveau le moins cher en filtrant sur l'indicateur propre au catalogue.

```bash theme={null}
jq '[.data[] | select(.flexinference.flex_race) | {id, name: .id}]'
```

Notre catalogue ne publie aucune fenêtre de contexte ni de plafond de jetons, donc les lignes créées de cette manière n'en ont pas. Ajoutez `contextWindow` et `maxTokens` vous-même là où les valeurs par défaut d'OpenClaw ne correspondent pas au modèle.

Réexécutez la commande chaque fois que notre catalogue change. Vérifiez le résultat :

```bash theme={null}
openclaw models list --provider flexinference
```

## Configuration globale et profils

OpenClaw conserve une configuration par profil, et non une par dossier. Le répertoire de travail ne modifie jamais le fichier qu'il lit.

| Portée        | Chemin de configuration     | Comment le sélectionner |
| ------------- | --------------------------- | ----------------------- |
| Par défaut    | `~/.openclaw/openclaw.json` | par défaut              |
| Nommé         | `~/.openclaw-<name>/`       | `--profile <name>`      |
| Développement | `~/.openclaw-dev/`          | `--dev`                 |
| Explicite     | n'importe quel chemin       | `OPENCLAW_CONFIG_PATH`  |

Utilisez un profil nommé pour essayer FlexInference sans modifier votre configuration habituelle.

```bash theme={null}
openclaw --profile flex onboard
```

Un profil isole l'état ainsi que la configuration, de sorte que son port de passerelle et son espace de travail sont également séparés.

## Garder la clé hors du fichier de configuration

Le processus d'intégration écrit la clé dans `openclaw.json` en texte brut. Définissez plutôt `apiKey` sur une référence de secret, et la configuration stocke le nom de la variable plutôt que sa valeur.

1. Exportez la clé dans le shell à partir duquel vous exécuterez ces commandes.

   ```bash theme={null}
   export FLEXINFERENCE_API_KEY=<your agent key>
   ```

2. Déclarez un fournisseur de secrets d'environnement et autorisez cette variable.

   ```bash theme={null}
   openclaw config set secrets.providers.default \
     --provider-source env --provider-allowlist FLEXINFERENCE_API_KEY
   ```

3. Pointez l' `apiKey` du fournisseur vers celle-ci.

   ```bash theme={null}
   openclaw config set models.providers.flexinference.apiKey \
     --ref-provider default --ref-source env --ref-id FLEXINFERENCE_API_KEY
   ```

La configuration contient alors `{"source": "env", "provider": "default", "id": "FLEXINFERENCE_API_KEY"}` et aucun secret. La clé n'atteint jamais non plus une ligne de commande, car l'étape 3 ne transmet que le nom de la variable.

OpenClaw résout la référence lorsque vous exécutez l'étape 3, alors exportez d'abord la variable. Une variable manquante ou vide fait échouer l'écriture avec `SecretRefResolutionError` plutôt que de stocker quelque chose de corrompu. Ajoutez `--dry-run` pour vérifier sans écrire.

Vérifiez ce qui est exposé avec l'audit intégré.

```bash theme={null}
openclaw security audit
```

## Confirmer l'application de la clé

Chaque réponse est accompagnée de `x-flexinference-defaults-applied`. OpenClaw n'affiche pas les en-têtes de réponse, alors lisez plutôt la requête dans le tableau de bord sous **Logs**.

## Dépannage

**Le sélecteur de modèles est incomplet, ou un modèle est manquant.** Un fournisseur défini par la configuration n'appelle jamais `GET /v1/models`, il n'affiche donc que les lignes que vous avez écrites. Régénérez la liste à partir de notre catalogue.

**Les tours signalent zéro jeton et aucun coût.** OpenClaw ne nous a pas demandé l'utilisation du streaming, nous n'avons donc envoyé aucun cadre d'utilisation. Définissez `compat.supportsUsageInStreaming` sur `true` pour chaque ligne de modèle.

**Un ID de modèle est refusé.** Les lignes que vous avez écrites manuellement peuvent différer de ce que nous exécutons, car l' `id` est envoyé exactement tel quel. Régénérez la liste à partir de notre catalogue plutôt que de modifier les ID.

**Les modifications de configuration ne prennent pas effet.** La passerelle conserve l'ancienne configuration. Redémarrez-la et confirmez que vous avez modifié le fichier affiché par `openclaw config file`.

Consultez [erreurs](/fr/errors) pour chaque refus que nous renvoyons, et [clés d'agent](/fr/agent-keys) pour ceux qui ne sont pas spécifiques à OpenClaw.