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

# DeepSeek V4 - API Responses

> - Appel des modèles DeepSeek V4 via le protocole OpenAI Responses
- Prend en charge `deepseek-v4-flash` (rapide et polyvalent) et `deepseek-v4-pro` (raisonnement approfondi)
- **Formes d'entrée** : `input` peut être du texte brut ou un tableau d'éléments d'entrée (message, appel de fonction, résultat de fonction, réflexion, historique de recherche)
- **Instructions système** : transmises via `instructions`, équivalentes à un message system placé en tête
- **Mode réflexion** : contrôlé par `reasoning.effort` ; le contenu de réflexion est renvoyé sous forme d'élément de sortie `reasoning`
- **Sortie en flux** : prend en charge les événements SSE sémantiques et se termine par `response.completed` ; **`[DONE]` n'est pas envoyé**
- **Appel d'outils** : prend en charge le Function Calling et la recherche web intégrée `web_search`
- **Sortie structurée** : activée via `text.format` pour un objet JSON ou un JSON Schema
- **Cache de contexte** : les requêtes partageant un préfixe atteignent automatiquement le cache et réduisent fortement le coût d'entrée

**Événements de flux** : `response.created`, `response.output_item.added`, `response.reasoning_text.delta`, `response.output_text.delta` ; les événements terminaux sont `response.completed` / `response.incomplete` / `response.failed`. Chaque événement porte un `sequence_number` servant au classement.

**Champs sans effet** : les champs OpenAI suivants peuvent être envoyés sans erreur, mais n'ont aucun effet réel.

| Champ | Comportement |
| --- | --- |
| `store` | Toujours `false`, les réponses ne sont pas stockées |
| `previous_response_id` | Toujours `null`, la reprise de conversation n'est pas prise en charge |
| `conversation` | Non pris en charge |
| `background` / `metadata` / `include` | Ignoré |
| `prompt` / `truncation` / `service_tier` | Ignoré |
| `safety_identifier` / `context_management` | Ignoré |
| `stream_options` | Ignoré |
| `parallel_tool_calls` | Ignoré, les appels d'outils parallèles sont toujours actifs |
| `max_tool_calls` | Ignoré |
| Outils `file_search` / `code_interpreter` / `mcp` | Ignoré |

**Autres limitations** :
- Les outils personnalisés (`type: custom`) ne prennent en charge que `apply_patch`
- L'outil `web_search` ignore `search_context_size` et `user_location`
- Les blocs de contenu image et fichier sont convertis en espaces réservés ; DeepSeek V4 n'est pas un modèle de vision
- Une entrée dépassant la fenêtre de contexte renvoie directement 400, sans troncature automatique

<Note>
  **BaseURL** : La BaseURL par défaut est `https://direct.evolink.ai`, qui offre une meilleure prise en charge des modèles de texte et des connexions persistantes. `https://api.evolink.ai` est le point d'accès principal pour les services multimodaux et sert d'adresse de secours pour les modèles de texte.
</Note>


## OpenAPI

````yaml fr/api-manual/language-series/deepseek-v4/deepseek-v4-responses.json POST /v1/responses
openapi: 3.1.0
info:
  title: DeepSeek V4 documentation complète des paramètres (API Responses)
  description: >-
    Référence API complète du point de terminaison Responses de la série
    DeepSeek V4 (`deepseek-v4-flash` / `deepseek-v4-pro`).


    **Capacités du modèle** :

    - Longueur de contexte : **1 000 000 tokens** (1M)

    - Sortie maximale : **384 000 tokens** (384K)

    - Mode réflexion : contrôlé par `reasoning.effort` ; `deepseek-v4-pro`
    excelle dans le raisonnement complexe

    - Cache de contexte sur disque : les correspondances sont automatiques et
    les correspondances et non-correspondances sont facturées séparément

    - Recherche web intégrée : l'outil `web_search` est exécuté côté serveur,
    sans intervention du client


    **Note de protocole** : ce point de terminaison est entièrement compatible
    avec le protocole de l'API OpenAI Responses. Le corps de la requête est
    conservé tel quel, sans réorganisation ni suppression de champs, de sorte
    que les champs d'extension non déclarés et le préfixe de cache ne sont pas
    affectés.


    **Sans état** : DeepSeek Responses ne conserve aucune session ; les
    conversations multi-tours exigent que le client envoie l'historique complet
    à chaque requête.


    **Paliers de facturation (UC/1K tokens, unité interne EvoLink)** :

    | Modèle | Entrée en cache | Entrée hors cache | Sortie |

    | --- | --- | --- | --- |

    | deepseek-v4-flash | 2 | 100 | 200 |

    | deepseek-v4-pro | 3 | 300 | 600 |
  license:
    name: MIT
  version: 1.0.0
servers:
  - url: https://direct.evolink.ai
    description: Production (recommandée)
  - url: https://api.evolink.ai
    description: URL alternative
security:
  - bearerAuth: []
tags:
  - name: Complétion de chat
    description: Points de terminaison liés à la génération de conversations IA
paths:
  /v1/responses:
    post:
      tags:
        - Complétion de chat
      summary: API Responses DeepSeek V4 (compatible OpenAI)
      description: >-
        - Appel des modèles DeepSeek V4 via le protocole OpenAI Responses

        - Prend en charge `deepseek-v4-flash` (rapide et polyvalent) et
        `deepseek-v4-pro` (raisonnement approfondi)

        - **Formes d'entrée** : `input` peut être du texte brut ou un tableau
        d'éléments d'entrée (message, appel de fonction, résultat de fonction,
        réflexion, historique de recherche)

        - **Instructions système** : transmises via `instructions`, équivalentes
        à un message system placé en tête

        - **Mode réflexion** : contrôlé par `reasoning.effort` ; le contenu de
        réflexion est renvoyé sous forme d'élément de sortie `reasoning`

        - **Sortie en flux** : prend en charge les événements SSE sémantiques et
        se termine par `response.completed` ; **`[DONE]` n'est pas envoyé**

        - **Appel d'outils** : prend en charge le Function Calling et la
        recherche web intégrée `web_search`

        - **Sortie structurée** : activée via `text.format` pour un objet JSON
        ou un JSON Schema

        - **Cache de contexte** : les requêtes partageant un préfixe atteignent
        automatiquement le cache et réduisent fortement le coût d'entrée


        **Événements de flux** : `response.created`,
        `response.output_item.added`, `response.reasoning_text.delta`,
        `response.output_text.delta` ; les événements terminaux sont
        `response.completed` / `response.incomplete` / `response.failed`. Chaque
        événement porte un `sequence_number` servant au classement.


        **Champs sans effet** : les champs OpenAI suivants peuvent être envoyés
        sans erreur, mais n'ont aucun effet réel.


        | Champ | Comportement |

        | --- | --- |

        | `store` | Toujours `false`, les réponses ne sont pas stockées |

        | `previous_response_id` | Toujours `null`, la reprise de conversation
        n'est pas prise en charge |

        | `conversation` | Non pris en charge |

        | `background` / `metadata` / `include` | Ignoré |

        | `prompt` / `truncation` / `service_tier` | Ignoré |

        | `safety_identifier` / `context_management` | Ignoré |

        | `stream_options` | Ignoré |

        | `parallel_tool_calls` | Ignoré, les appels d'outils parallèles sont
        toujours actifs |

        | `max_tool_calls` | Ignoré |

        | Outils `file_search` / `code_interpreter` / `mcp` | Ignoré |


        **Autres limitations** :

        - Les outils personnalisés (`type: custom`) ne prennent en charge que
        `apply_patch`

        - L'outil `web_search` ignore `search_context_size` et `user_location`

        - Les blocs de contenu image et fichier sont convertis en espaces
        réservés ; DeepSeek V4 n'est pas un modèle de vision

        - Une entrée dépassant la fenêtre de contexte renvoie directement 400,
        sans troncature automatique
      operationId: createResponseDeepSeekV4
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ResponsesRequest'
            examples:
              simple_text:
                summary: Conversation textuelle à un tour (Flash)
                value:
                  model: deepseek-v4-flash
                  input: Présente Hangzhou en une phrase.
              with_instructions:
                summary: Utilisation d'instructions système
                value:
                  model: deepseek-v4-flash
                  instructions: >-
                    Tu es un rédacteur technique rigoureux. Garde les réponses
                    concises.
                  input: Explique ce qu'est la mise en cache du contexte.
              multi_turn:
                summary: Conversation multi-tours (tableau d'éléments d'entrée)
                value:
                  model: deepseek-v4-flash
                  input:
                    - type: message
                      role: user
                      content: Propose-moi trois noms de produit.
                    - type: message
                      role: assistant
                      content: Perchenuage, Étoile du matin, Ventplume.
                    - type: message
                      role: user
                      content: Donne-moi cinq synonymes du deuxième.
              reasoning_effort:
                summary: Modèle Pro avec un effort de raisonnement élevé
                value:
                  model: deepseek-v4-pro
                  input: >-
                    Un bassin possède un tuyau d'arrivée qui le remplit en 3
                    heures et un tuyau d'évacuation qui le vide en 5 heures.
                    Combien de temps faut-il pour le remplir si les deux sont
                    ouverts en même temps ? Détaille le raisonnement.
                  reasoning:
                    effort: high
              disable_thinking:
                summary: Réflexion désactivée (réponse directe uniquement)
                value:
                  model: deepseek-v4-flash
                  input: >-
                    Combien de temps dure environ le train à grande vitesse de
                    Pékin à Shanghai ?
                  reasoning:
                    effort: none
              json_schema:
                summary: Sortie structurée (JSON Schema)
                value:
                  model: deepseek-v4-flash
                  input: >-
                    Extrais la personne et la ville de cette phrase : Zhang Wei
                    part en déplacement professionnel à Chengdu la semaine
                    prochaine.
                  text:
                    format:
                      type: json_schema
                      name: extraction
                      schema:
                        type: object
                        properties:
                          person:
                            type: string
                          city:
                            type: string
                        required:
                          - person
                          - city
              function_calling:
                summary: Appel d'outil Function Calling
                value:
                  model: deepseek-v4-flash
                  input: Quel temps fait-il à Hangzhou en ce moment ?
                  tools:
                    - type: function
                      name: get_weather
                      description: Interroge la météo en temps réel d'une ville donnée
                      parameters:
                        type: object
                        properties:
                          city:
                            type: string
                            description: Nom de la ville
                        required:
                          - city
                  tool_choice: auto
              web_search:
                summary: Recherche web intégrée (exécutée côté serveur)
                value:
                  model: deepseek-v4-flash
                  input: >-
                    Résume les actualités importantes de cette semaine dans le
                    domaine de l'intelligence artificielle.
                  tools:
                    - type: web_search
              streaming:
                summary: Sortie en flux
                value:
                  model: deepseek-v4-flash
                  input: Écris un court poème sur l'automne.
                  stream: true
      responses:
        '200':
          description: Génération réussie
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponsesResponse'
              example:
                id: resp_9f2c1a4b8e7d
                object: response
                created_at: 1755000000
                status: completed
                model: deepseek-v4-flash
                output:
                  - id: rs_2b7f
                    type: reasoning
                    summary: []
                    content:
                      - type: reasoning_text
                        text: >-
                          L'utilisateur souhaite une présentation en une phrase
                          couvrant à la fois la géographie et la culture.
                  - id: msg_5d1a
                    type: message
                    role: assistant
                    status: completed
                    content:
                      - type: output_text
                        text: >-
                          Hangzhou est la capitale de la province du Zhejiang,
                          réputée pour le lac de l'Ouest et son économie
                          numérique.
                        annotations: []
                error: null
                incomplete_details: null
                usage:
                  input_tokens: 694
                  input_tokens_details:
                    cached_tokens: 640
                  output_tokens: 20
                  output_tokens_details:
                    reasoning_tokens: 10
                  total_tokens: 714
        '400':
          description: Paramètres de requête invalides
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 400
                  message: Invalid request parameters
                  type: invalid_request_error
        '401':
          description: Non authentifié, jeton invalide ou expiré
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 401
                  message: Invalid authentication credentials
                  type: authentication_error
        '402':
          description: Quota insuffisant, recharge requise
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 402
                  message: Insufficient quota
                  type: insufficient_quota
        '403':
          description: Pas d'autorisation d'accès à ce modèle
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 403
                  message: Model access denied
                  type: permission_error
        '404':
          description: Ressource introuvable
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 404
                  message: Model not found
                  type: not_found_error
        '413':
          description: Corps de requête trop volumineux
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 413
                  message: Request entity too large
                  type: invalid_request_error
        '429':
          description: Limite de débit dépassée
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 429
                  message: Rate limit exceeded
                  type: rate_limit_error
        '500':
          description: Erreur interne du serveur
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 500
                  message: Internal server error
                  type: server_error
        '502':
          description: Erreur de passerelle
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 502
                  message: Bad gateway
                  type: server_error
        '503':
          description: Service temporairement indisponible
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 503
                  message: Service temporarily unavailable
                  type: server_error
components:
  schemas:
    ResponsesRequest:
      type: object
      required:
        - model
      properties:
        model:
          type: string
          description: >-
            ID du modèle


            - `deepseek-v4-flash` : rapide et polyvalent, adapté aux
            conversations courantes, aux résumés et à l'extraction

            - `deepseek-v4-pro` : raisonnement approfondi, adapté aux
            mathématiques complexes, au code et à la planification en plusieurs
            étapes
          enum:
            - deepseek-v4-flash
            - deepseek-v4-pro
          default: deepseek-v4-flash
          example: deepseek-v4-flash
        input:
          type:
            - string
            - array
          description: >-
            Entrée du modèle. Au moins l'un des champs `input` et `instructions`
            doit être fourni.


            - **Forme chaîne** : l'ensemble du texte est traité comme un unique
            message `user`

            - **Forme tableau** : liste d'éléments d'entrée prenant en charge
            cinq types — `message`, `function_call`, `function_call_output`,
            `reasoning`, `web_search_call`


            **Conversations multi-tours** : le point de terminaison étant sans
            état, poursuivre une conversation impose de placer l'historique
            complet dans le tableau.
          items:
            $ref: '#/components/schemas/InputItem'
          example: Présente Hangzhou en une phrase.
        instructions:
          type: string
          description: >-
            Instructions de niveau système, équivalentes à un message system
            inséré tout au début ; sert à définir le rôle, le ton et les
            contraintes de sortie.
          example: Tu es un rédacteur technique rigoureux. Garde les réponses concises.
        stream:
          type: boolean
          description: >-
            Indique si la réponse est diffusée en flux


            - `false` (par défaut) : renvoie l'objet de réponse complet en une
            fois

            - `true` : envoie des événements SSE sémantiques ; l'événement final
            est `response.completed` / `response.incomplete` /
            `response.failed`, et **`[DONE]` n'est pas envoyé**
          default: false
          example: false
        max_output_tokens:
          type: integer
          description: >-
            Nombre maximal de tokens de sortie pour cette génération (tokens de
            réflexion inclus). Plage de 1 à 393216 (384K). Laissé vide, le
            modèle décide lui-même.
          minimum: 1
          maximum: 393216
          example: 4096
        temperature:
          type: number
          description: >-
            Température d'échantillonnage ; plus elle est élevée, plus la sortie
            est aléatoire. **Sans effet en mode réflexion.**
          minimum: 0
          maximum: 2
          default: 1
          example: 1
        top_p:
          type: number
          description: >-
            Seuil d'échantillonnage nucleus ; il est conseillé de n'ajuster que
            celui-ci ou `temperature`. **Sans effet en mode réflexion.**
          maximum: 1
          default: 1
          example: 1
        top_logprobs:
          type: integer
          description: >-
            Renvoie à chaque position les tokens candidats les plus probables et
            leurs probabilités logarithmiques.
          minimum: 0
          maximum: 20
          example: 0
        reasoning:
          type: object
          description: >-
            Configuration du mode réflexion. DeepSeek V4 active la réflexion par
            défaut ; le contenu de réflexion est renvoyé comme élément de sortie
            `reasoning`, et ses tokens comptent dans la sortie et sont facturés
            au tarif de sortie.
          properties:
            effort:
              type: string
              description: >-
                Effort de raisonnement


                - `none` : réflexion désactivée, réponse directe

                - `minimal` / `low` / `medium` : effort réduit

                - `high` (par défaut) : raisonnement approfondi standard

                - `xhigh` / `max` : effort maximal ; la durée et les tokens de
                sortie augmentent nettement
              enum:
                - none
                - minimal
                - low
                - medium
                - high
                - xhigh
                - max
              default: high
              example: high
            max_output_tokens:
              type:
                - integer
                - 'null'
              description: >-
                Limite supérieure de tokens de sortie pour la phase de réflexion
                ; laissée vide, aucune limite supplémentaire ne s'applique.
            summary:
              type: string
              description: >-
                Peut être transmis, mais aucun résumé de réflexion n'est généré,
                ce champ est donc sans effet.
        text:
          type: object
          description: Configuration du format de sortie textuelle.
          properties:
            format:
              type: object
              description: >-
                Format de sortie


                - `text` (par défaut) : texte libre

                - `json_object` : produit un objet JSON valide ; **le prompt
                doit mentionner JSON**

                - `json_schema` : suit le JSON Schema fourni ; `name` et
                `schema` sont tous deux requis
              properties:
                type:
                  type: string
                  enum:
                    - text
                    - json_object
                    - json_schema
                  default: text
                  description: Type de format de sortie
                name:
                  type: string
                  description: Nom du schéma ; obligatoire en mode `json_schema`
                schema:
                  type: object
                  description: >-
                    Définition du JSON Schema ; obligatoire en mode
                    `json_schema`
                strict:
                  type: boolean
                  description: Indique s'il faut respecter strictement le schéma
        tools:
          type: array
          description: >-
            Liste des outils que le modèle peut appeler. Les outils de type
            fonction sont exécutés par le client, qui renvoie le résultat sous
            forme de `function_call_output` ; `web_search` est exécuté
            directement côté serveur, sans intervention du client.
          items:
            $ref: '#/components/schemas/Tool'
        tool_choice:
          type:
            - string
            - object
          description: >-
            Stratégie d'appel d'outils


            - `none` : appel d'outils interdit

            - `auto` (par défaut) : le modèle décide

            - `required` : au moins un outil doit être appelé

            - `{"type": "function", "name": "get_weather"}` : force l'appel
            d'une fonction précise

            - `{"type": "web_search"}` : force une recherche web
          example: auto
    ResponsesResponse:
      type: object
      description: Objet de réponse du point de terminaison Responses.
      properties:
        id:
          type: string
          description: Identifiant unique de cette réponse
          example: resp_9f2c1a4b8e7d
        object:
          type: string
          description: Type d'objet, toujours `response`
          example: response
        created_at:
          type: integer
          description: Date de création sous forme d'horodatage Unix (secondes)
          example: 1755000000
        status:
          type: string
          description: >-
            État de la réponse


            - `completed` : terminée normalement

            - `in_progress` : génération en cours

            - `incomplete` : tronquée, par exemple pour cause de longueur ; voir
            `incomplete_details`

            - `failed` : échec de la génération ; voir `error`
          enum:
            - in_progress
            - completed
            - incomplete
            - failed
          example: completed
        model:
          type: string
          description: ID du modèle ayant réellement produit cette réponse
          example: deepseek-v4-flash
        output:
          type: array
          description: >-
            Liste des éléments de sortie, dans l'ordre de génération. Champs par
            type :


            - `reasoning` : le processus de réflexion, avec `id`, `status`,
            `content` (liste de blocs `reasoning_text`) et `summary`

            - `message` : la réponse finale, avec `id`, `status`, `role` et
            `content` (liste de blocs `output_text`)

            - `function_call` : un appel de fonction du modèle, avec `id`,
            `status`, `call_id`, `name` et `arguments` ; le client l'exécute
            puis renvoie le résultat sous forme de `function_call_output`

            - `web_search_call` : un historique de recherche web exécutée côté
            serveur, avec `id`, `status` et `action` (décrivant la recherche
            effectuée)
          items:
            type: object
        error:
          type:
            - object
            - 'null'
          description: Motif de l'échec ; `null` en cas de succès
        incomplete_details:
          type:
            - object
            - 'null'
          description: Motif de la troncature ; `null` si la réponse n'est pas tronquée
        usage:
          $ref: '#/components/schemas/Usage'
    ErrorResponse:
      type: object
      description: Réponse d'erreur
      properties:
        error:
          type: object
          properties:
            code:
              type: integer
              description: Code de statut HTTP
              example: 400
            message:
              type: string
              description: Description de l'erreur
              example: Invalid request parameters
            type:
              type: string
              description: Type d'erreur
              example: invalid_request_error
    InputItem:
      type: object
      title: Élément d'entrée
      description: >-
        Un élément unique du tableau `input`. `type` en détermine la
        signification.
      required:
        - type
      properties:
        type:
          type: string
          description: >-
            Type d'élément d'entrée


            - `message` : un message de conversation

            - `function_call` : un appel de fonction émis précédemment par le
            modèle

            - `function_call_output` : le résultat de l'exécution d'une fonction

            - `reasoning` : un contenu de réflexion antérieur

            - `web_search_call` : un historique de recherche web antérieur
          enum:
            - message
            - function_call
            - function_call_output
            - reasoning
            - web_search_call
          example: message
        role:
          type: string
          description: >-
            Rôle du message, utilisé uniquement avec `type: message`.
            `developer` est traité comme `system`.
          enum:
            - user
            - assistant
            - system
            - developer
          example: user
        content:
          type:
            - string
            - array
          description: >-
            Contenu du message, utilisé uniquement avec `type: message`. Peut
            être du texte brut ou un tableau de blocs de contenu ; le type de
            bloc côté entrée est `input_text`. **Les blocs image et fichier tels
            que `input_image` ne déclenchent pas d'erreur mais sont remplacés
            par un texte de substitution** — DeepSeek V4 ne possède pas de
            capacité visuelle.
          example: Présente Hangzhou en une phrase.
        call_id:
          type: string
          description: >-
            Identifiant d'appel de fonction ; `function_call` et
            `function_call_output` sont appariés grâce à lui.
        name:
          type: string
          description: >-
            Nom de la fonction appelée, utilisé uniquement avec `type:
            function_call`.
        arguments:
          type: string
          description: >-
            Arguments de l'appel de fonction sous forme de chaîne JSON, utilisés
            uniquement avec `type: function_call`.
        output:
          type: string
          description: >-
            Résultat de l'exécution de la fonction, utilisé uniquement avec
            `type: function_call_output`.
    Tool:
      type: object
      title: Définition d'outil
      required:
        - type
      properties:
        type:
          type: string
          description: >-
            Type d'outil


            - `function` : une fonction personnalisée exécutée par le client

            - `web_search` / `web_search_2025_08_26` : recherche web exécutée
            côté serveur ; `search_context_size` et `user_location` sont ignorés

            - `custom` : `apply_patch` uniquement


            `file_search`, `code_interpreter` et `mcp` sont ignorés.
          enum:
            - function
            - web_search
            - web_search_2025_08_26
            - custom
          example: function
        name:
          type: string
          description: >-
            Nom de l'outil, 128 caractères au maximum, limité aux lettres,
            chiffres, `-` et `_`, et unique au sein d'une requête.
          maxLength: 128
          example: get_weather
        description:
          type: string
          description: >-
            Description de l'usage de l'outil ; une description claire aide le
            modèle à décider quand l'appeler.
          example: Interroge la météo en temps réel d'une ville donnée
        parameters:
          type: object
          description: Définition des paramètres au format JSON Schema.
          example:
            type: object
            properties:
              city:
                type: string
                description: Nom de la ville
            required:
              - city
    Usage:
      type: object
      description: >-
        Statistiques d'utilisation des tokens (avec les détails de cache et de
        raisonnement)
      properties:
        input_tokens:
          type: integer
          description: >-
            Nombre total de tokens d'entrée (correspondances et
            non-correspondances de cache incluses)
          example: 694
        input_tokens_details:
          type: object
          description: Détail des tokens d'entrée
          properties:
            cached_tokens:
              type: integer
              description: >-
                Nombre de tokens ayant atteint le cache de contexte


                **Remarque** : la part en cache est facturée au **tarif de
                correspondance de cache** (Flash 2 UC/1K, Pro 3 UC/1K) ; la part
                hors cache vaut `input_tokens - cached_tokens` et est facturée
                au **tarif d'entrée standard** (Flash 100 UC/1K, Pro 300 UC/1K)
              example: 640
        output_tokens:
          type: integer
          description: Nombre de tokens de sortie (part de réflexion incluse)
          example: 20
        output_tokens_details:
          type: object
          description: Détail des tokens de sortie
          properties:
            reasoning_tokens:
              type: integer
              description: >-
                Nombre de tokens de raisonnement produits par le mode réflexion
                (comptés en sortie et facturés au tarif de sortie)
              example: 10
        total_tokens:
          type: integer
          description: Nombre total de tokens = input_tokens + output_tokens
          example: 714
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        ##Toutes les API nécessitent une authentification Bearer Token##


        **Obtenir une clé API** :


        Visitez la [Page de gestion des clés
        API](https://evolink.ai/dashboard/keys) pour obtenir votre clé API


        **Ajouter à l'en-tête de requête** :

        ```

        Authorization: Bearer YOUR_API_KEY

        ```

````