Recettes de prompts pour gpt-6.1-sol : codage, raisonnement, JSON et appels d'outils (avec sorties réelles)

gpt-6.1-sol est un modèle textuel de niveau raisonnement sur hiapi — conversation, codage et raisonnement pas à pas, le tout servi via l'API Responses (POST /v1/responses). Si vous savez déjà l'appeler, cette page est l'étape suivante : une série de recettes de prompts prêtes à copier-coller, couvrant les quatre types de tâches que les gens utilisent réellement le plus — codage, raisonnement, JSON strict et appels d'outils — chacune accompagnée de la sortie exacte que nous avons obtenue en l'exécutant pour cet article. Pour l'authentification, le streaming et l'analyse SSE, commencez par le guide de configuration ; ici, nous nous concentrons uniquement sur les prompts eux-mêmes.

Chaque recette ci-dessous est un corps de requête, à insérer directement dans cette configuration. Le prompt est porté par deux champs : instructions au niveau supérieur (définition du rôle et règles de format) et le tableau input (la tâche elle-même). Aucune théorie ici — les sorties sont collées telles quelles depuis de vrais événements response.completed.

Trois leviers qui influencent la façon dont vous écrivez vos prompts pour gpt-6.1-sol

Avant d'entrer dans les recettes, trois choses à propos de ce modèle façonnent chaque prompt que vous écrirez. Ces trois points ont été confirmés par rapport au contrat live du modèle sur hiapi.

1. Pas de temperature, pas de top_p. Cette configuration d'exécution désactive les deux (ainsi que max_output_tokens). Vous ne pouvez pas régler la déterminisme ou la créativité via l'échantillonnage — le seul levier réglable est votre instructions, votre input et reasoning.effort. Si vous voulez une sortie concise et ressentie comme déterministe, dites-le dans instructions ; vous ne pouvez pas définir temperature: 0.
2. reasoning.effort a cinq niveaux : low, medium, high, xhigh, max (par défaut medium). Un effort plus élevé consomme plus de tokens de raisonnement cachés — et ceux-ci sont facturés comme des tokens de sortie. La recette 2 montre la courbe réelle.
3. Fenêtre de contexte d'environ 1,05 M de tokens (sortie maximale 128 K). La facturation par token est progressive : dès qu'une requête unique dépasse 272 K tokens en entrée, les tarifs d'entrée/sortie doublent environ. Pour les prompts du quotidien, vous êtes loin de cette limite ; pour les tâches à long contexte (recette 5), il vaut la peine de le savoir.

Recette 1 — Codage : générer une fonction selon une spécification

Placez le rôle d'ingénieur et la forme de la sortie dans instructions, et la spécification dans input. La contrainte de forme (« un seul bloc de code clôturé, puis une phrase ») est précisément ce qui empêche le modèle de raisonnement d'envelopper le code dans trois paragraphes de préambule.

{
  "model": "gpt-6.1-sol",
  "instructions": "Tu es un ingénieur Python senior. Renvoie un seul bloc de code Python clôturé, puis une phrase expliquant la complexité. Pas de préambule.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Écris `merge_intervals(intervals: list[list[int]]) -> list[list[int]]` qui fusionne les intervalles fermés qui se chevauchent et renvoie le résultat trié par point de départ. Gère la liste vide. Inclus une docstring." }
    ] }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Ce qu'il renvoie (tel quel) :

def merge_intervals(intervals: list[list[int]]) -> list[list[int]]:
    """Fusionne les intervalles fermés qui se chevauchent, triés par point de départ, et renvoie le résultat.

    La liste d'entrée et ses intervalles ne sont pas modifiés.
    """
    if not intervals:
        return []

    ordered = sorted(intervals, key=lambda interval: interval[0])
    merged = [ordered[0].copy()]

    for start, end in ordered[1:]:
        if start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])

    return merged

La complexité temporelle est O(n log n), la complexité spatiale O(n).

Notez ce que la contrainte a apporté : il gère correctement le cas de la liste vide, copie chaque intervalle avant de le modifier (ordered[0].copy()), donc les données de l'appelant restent intactes, et s'arrête après exactement une phrase d'analyse. Pour ce type de codage mécanique, effort: low suffit — il a utilisé zéro token de raisonnement et a tout de même produit du code correct et non destructif.

Recette 2 — Raisonnement : contrôler le budget de réflexion avec effort

Comme vous ne pouvez pas définir temperature, reasoning.effort est votre principal levier face aux problèmes difficiles. Gardez le prompt identique et changez uniquement effort :

{
  "model": "gpt-6.1-sol",
  "instructions": "Réfléchis étape par étape, puis termine par une ligne `Answer: <value>`.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Une boulangerie vend des cookies par boîtes de 6 et de 11. Quel est le plus grand nombre de cookies qu'il est impossible d'acheter exactement ? Montre le raisonnement." }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Nous avons exécuté le même prompt sur les cinq niveaux d'effort. Chaque niveau a renvoyé la bonne réponse : 49. Ce qui a changé, c'est combien de réflexion il y a consacrée :

reasoning.effort	Tokens de raisonnement	Tokens de sortie totaux	Coût approx.*
low	76	305	≈ 0,0008 $
medium	121	380	≈ 0,0010 $
high	209	427	≈ 0,0011 $
xhigh	626	845	≈ 0,0021 $
max	622	813	≈ 0,0021 $

*Selon les tarifs de base (0,50 $ / 1 M en entrée, 2,50 $ / 1 M en sortie) ; les tokens de raisonnement sont facturés comme de la sortie. Données issues de cette exécution, en date de 2026-10. Consultez la page de tarification pour les tarifs actuels.

La leçon pratique se trouve dans les deux dernières lignes : l'effort monte régulièrement de low à high, puis atteint un plateau — xhigh et max se stabilisent tous deux autour de 620 tokens de raisonnement, car ce problème n'est tout simplement pas assez difficile pour nécessiter plus de réflexion. Pousser l'effort au maximum sur un prompt simple n'apporte pas de meilleure réponse ; cela coûte simplement environ 2,5 fois plus de tokens de sortie pour le même « 49 ». Faites correspondre effort à la difficulté : low/medium pour la plupart des prompts, high et au-delà uniquement lorsque la tâche exige réellement une recherche plus approfondie.

Voici la sortie à medium, pour que vous voyiez la forme que le prompt produit :

Le plus grand nombre est 49 cookies.

1. Preuve que 49 ne peut pas être acheté exactement. Supposons que 49 = 6a + 11b, où a et b sont des entiers non négatifs. En prenant modulo 6 des deux côtés, on obtient 5b ≡ 1 (mod 6), donc b ≡ 5 (mod 6). Donc b vaut au moins 5, mais cinq boîtes de 11 contiennent déjà 55 cookies. C'est impossible.

2. Preuve que tout nombre supérieur à 49 peut être acheté. … Tout entier au moins égal à 50 est l'un des six totaux atteignables consécutifs plus un multiple non négatif de 6.

Answer: 49

La ligne Answer: <value> dans instructions fait vraiment son travail : elle vous permet d'analyser simplement la dernière ligne (text.rsplit("Answer:", 1)[-1].strip()) sans forcer le modèle à jeter son raisonnement.

Recette 3 — JSON strict avec schéma

N'exigez pas du JSON en prose en espérant que ça marche. gpt-6.1-sol prend en charge les sorties structurées strictes : transmettez un text.format avec json_schema, et le modèle est contraint de produire un JSON conforme — sans bloc de code, sans prose superflue.

{
  "model": "gpt-6.1-sol",
  "instructions": "Classe le ticket de support. Réponds uniquement par cet objet JSON.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Ticket : 'Depuis ce matin, l'endpoint de suréchantillonnage 4K renvoie 500 à chaque appel. On lance demain, on est bloqués.'" }
    ] }
  ],
  "text": {
    "format": {
      "type": "json_schema",
      "name": "ticket",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "sentiment": { "type": "string", "enum": ["positive", "neutral", "negative"] },
          "topics": { "type": "array", "items": { "type": "string" } },
          "action_required": { "type": "boolean" }
        },
        "required": ["sentiment", "topics", "action_required"],
        "additionalProperties": false
      }
    }
  },
  "reasoning": { "effort": "low" },
  "stream": true
}

Ce qu'il renvoie (tel quel, sur une ligne) :

{"action_required":true,"sentiment":"negative","topics":["4K upscale endpoint","HTTP 500 errors","Service outage","Launch blocker","Urgent support"]}

Deux choses à intégrer. Premièrement, strict: true garantit les types et les clés requises, mais pas l'ordre des clés — remarquez que action_required apparaît en premier alors que dans le schéma il est listé en dernier, donc analysez par clé, jamais par position. Deuxièmement, vous devez toujours accumuler la réponse à partir des blocs response.output_text.delta comme pour toute autre réponse ; le schéma façonne le contenu, pas le transport.

Recette 4 — Appels d'outils et reprise du résultat

gpt-6.1-sol peut appeler des fonctions et — c'est important — continuer après que vous avez renvoyé le résultat. Déclarez un tableau tools ; lorsque le modèle décide d'appeler, il émet un élément function_call plutôt que du texte.

{
  "model": "gpt-6.1-sol",
  "instructions": "Tu peux appeler des outils. Quand l'utilisateur demande des nouvelles d'une tâche, appelle get_task_status.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Peux-tu vérifier ce qui arrive à task_abc123 ? Il est en pending depuis longtemps." }
    ] }
  ],
  "tools": [
    {
      "type": "function",
      "name": "get_task_status",
      "description": "Interroge le statut d'une tâche asynchrone de génération d'image/vidéo par son id.",
      "parameters": {
        "type": "object",
        "properties": { "task_id": { "type": "string", "description": "Id de la tâche, par exemple 'task_abc123'." } },
        "required": ["task_id"],
        "additionalProperties": false
      }
    }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

La réponse ne contient pas de texte — seulement un appel d'outil, transmis sous forme d'élément function_call dans l'événement final (ses arguments arrivent en flux via des blocs response.function_call_arguments.delta) :

{
  "type": "function_call",
  "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b",
  "name": "get_task_status",
  "arguments": "{\"task_id\":\"task_abc123\"}"
}

Voici maintenant la seconde moitié que la configuration de base ne couvre pas : exécutez votre fonction, puis renvoyez le résultat — ajoutez le function_call du modèle et votre function_call_output (appariés par le même call_id) au tableau input, puis réappelez :

{
  "model": "gpt-6.1-sol",
  "instructions": "Tu peux appeler des outils. Résume le résultat de l'outil à l'utilisateur en une ou deux phrases.",
  "input": [
    { "type": "message", "role": "user", "content": [ { "type": "input_text", "text": "Peux-tu vérifier ce qui arrive à task_abc123 ? Il est en pending depuis longtemps." } ] },
    { "type": "function_call", "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b", "name": "get_task_status", "arguments": "{\"task_id\":\"task_abc123\"}" },
    { "type": "function_call_output", "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b", "output": "{\"status\":\"failed\",\"error\":\"INVALID_REQUEST: image url could not be downloaded\",\"created_at\":\"2026-10-17T06:12:00Z\"}" }
  ],
  "tools": [ { "type": "function", "name": "get_task_status", "description": "Interroge le statut d'une tâche de génération asynchrone par son id.", "parameters": { "type": "object", "properties": { "task_id": { "type": "string" } }, "required": ["task_id"], "additionalProperties": false } } ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Une fois le résultat reçu, il répond en langage clair (tel quel) :

La tâche task_abc123 n'est plus en pending — elle a échoué car l'URL de l'image n'a pas pu être téléchargée (INVALID_REQUEST). Vérifiez que l'URL de l'image est accessible publiquement, puis resoumettez la tâche.

call_id est le liant : votre function_call_output doit reprendre exactement le call_id du function_call du modèle, sinon le tour suivant ne s'y rattachera pas.

Recette 5 — Réponses fondées sur un long contexte

La fenêtre de 1,05 M de tokens sert à alimenter de vrais documents — journaux, changelogs, spécifications — et à répondre à des questions à partir d'eux. Le schéma de prompt qui le garde honnête se trouve dans instructions : forcez-le à répondre uniquement à partir du texte fourni et à citer la source de chaque fait.

{
  "model": "gpt-6.1-sol",
  "instructions": "Réponds strictement à partir du CHANGELOG fourni. Si un fait est absent, dis 'not in the changelog'. Cite la date de chaque fait que tu utilises.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "<collez le CHANGELOG ici>\nQuestion : l'URL de sortie d'une tâche vidéo hier renvoyait mon fichier, mais aujourd'hui elle renvoie 404, et mes appels d'image viennent de renvoyer 402. Quelles deux entrées du changelog expliquent cela, et que dois-je changer ?" }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Face à un court changelog de plateforme, il a extrait exactement les deux entrées pertinentes, cité leurs dates et séparé le « ce qui s'est passé » du « ce qu'il faut changer » (tel quel) :

Deux entrées expliquent ces problèmes :

1. 2026-10-02 — les URL de sortie temporaires expirent. Les URL de sortie sur temp.hiapi.ai sont valides 7 jours, après quoi elles renvoient 404… Changement : téléchargez immédiatement les octets et stockez votre propre copie ; ne faites pas de lien direct. Utilisez expireAt pour suivre l'expiration.

2. 2026-09-20 — un solde vide déclenche un 402 sur les modèles d'image. Les comptes dont le solde est entièrement vide reçoivent désormais HTTP 402 sur tous les modèles d'image… Changement : vérifiez si le solde de votre compte est entièrement vide, et si oui, rechargez.

L'instruction « cite les dates » est une astuce anti-hallucination peu coûteuse : elle rend les hallucinations visibles (un fait sans date à citer est un fait inventé) et rend les réponses auditables. Gardez à l'esprit la tarification progressive — les prompts dont l'entrée dépasse 272 K tokens sont facturés au tarif long contexte plus élevé.

Un piège rencontré lors de cette exécution : décoder le flux en UTF-8

Les modèles de raisonnement adorent les tirets cadratins et les guillemets courbes. Lors de la rédaction de cet article, notre premier lecteur SSE a coupé un caractère UTF-8 multi-octets entre deux blocs réseau, transformant un tiret cadratin propre (« — ») en charabia (« â »). La sortie du modèle était correcte ; c'est le client qui décodait ligne par ligne trop hâtivement. Le correctif consiste à mettre en tampon les octets bruts, à découper sur les sauts de ligne et à décoder chaque ligne complète en UTF-8 — ne décodez jamais un bloc incomplet. Si vous voyez des caractères Ã/â sporadiques dans la sortie de gpt-6.1-sol, la cause est ici, pas dans le modèle.

Questions fréquentes

Quelle est la différence avec le guide de configuration de gpt-6.1-sol ? Le guide de configuration traite de l'appel du modèle — authentification, pourquoi le streaming est obligatoire, analyse SSE. Cette page traite des prompts — les schémas instructions/input/effort pour des tâches concrètes, et les sorties qu'ils produisent.

Puis-je simplement pousser reasoning.effort à max pour obtenir la meilleure réponse ? Ce n'est pas gratuit, et ce n'est souvent pas non plus pour le mieux. Sur notre problème de test, xhigh et max ont tous deux atteint un plateau, autour de 620 tokens de raisonnement, renvoyant la même réponse que high. Les tokens de raisonnement sont facturés comme de la sortie, donc pousser un prompt simple au maximum coûte plus cher pour le même résultat. Réservez high+ aux raisonnements vraiment difficiles.

Comment forcer un JSON valide plutôt que de l'exiger dans le prompt ? Transmettez un text.format avec un json_schema strict (recette 3). Le modèle est contraint aux types et clés requises du schéma. Analysez par nom de clé, car strict ne fixe pas l'ordre des clés.

Pourquoi ne puis-je pas définir temperature ou top_p ? Cette configuration d'exécution désactive les deux (ainsi que max_output_tokens). Façonnez plutôt la sortie via instructions, votre input et reasoning.effort.

Les appels d'outils fonctionnent-ils comme sur les modèles de chat ? Le contrat diffère légèrement : les outils sont déclarés dans le tableau de niveau supérieur tools, le modèle répond avec un élément function_call (pas un message), et vous continuez en ajoutant un function_call_output avec un call_id correspondant (recette 4).

gpt-6.1-sol est-il identique à gpt-5.6-sol ? Ils appartiennent à la même famille Sol et partagent ce contrat Responses-API en streaming uniquement ; gpt-6.1-sol est une génération plus récente. Voir la comparaison gpt-6 Astra vs gpt-5.6 Sol pour comprendre la correspondance entre générations.

Commencez ici

Copiez n'importe quelle recette ci-dessus dans le corps de requête du guide de configuration, remplacez par votre propre tâche, et ajustez reasoning.effort selon la difficulté. La présentation des capacités et le bac à essai en ligne se trouvent sur la page du modèle gpt-6.1-sol ; l'endpoint et le format de requête partagé sont dans la documentation API ; les tarifs par token sont sur la page de tarification. Une seule clé hiapi donne accès à gpt-6.1-sol et à tous les autres modèles de la plateforme.