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

# API tous modèles GLM - Référence complète Chat Completions

> - Appelez les modèles de la série GLM via le protocole OpenAI Chat Completions, le modèle précis étant choisi avec le paramètre `model`
- Traitement synchrone qui renvoie le contenu de la conversation en temps réel
- **Conversation textuelle** : conversation contextuelle à un ou plusieurs tours ; `glm-5.3-flash` prend en plus en charge l'entrée image
- **Invite système** : personnalisez le rôle et le comportement de l'IA via un message `role=system`
- **Réflexion approfondie** : `thinking.type` contrôle la chaîne de pensée et `reasoning_effort` règle l'intensité du raisonnement ; le raisonnement est renvoyé dans `reasoning_content`
- **Streaming** : les réponses en flux SSE sont prises en charge (`stream=true`)
- **Appels d'outils** : Function Calling et recherche web pris en charge (`web_search`, jusqu'à 128 outils)
- **Sortie structurée** : activez le mode JSON via `response_format`

**À propos des réponses en streaming** : avec `stream=true`, les résultats arrivent par Server-Sent Events, chaque message ayant le format `data: {JSON}`, le flux se terminant par `data: [DONE]`. Chaque bloc de données (`ChatCompletionChunk`) contient `id`, `created`, `model`, `choices` et, en option, `usage` et `content_filter` ; à l'intérieur, `choices[].delta` renvoie de façon incrémentale `role` / `content` / `reasoning_content` / `tool_calls`, et `choices[].finish_reason` indique le motif d'arrêt dans le dernier bloc.

<Note>
  **BaseURL** : la BaseURL par défaut est `https://direct.evolink.ai`, qui offre une meilleure prise en charge des modèles textuels et des connexions de longue durée. `https://api.evolink.ai` est le point de terminaison principal pour les services multimodaux et sert d'adresse de repli pour les modèles textuels.
</Note>

<Note>
  **Le contrôle de la réflexion varie selon le modèle** : `glm-5.3` et `glm-5.3-flash` réfléchissent toujours et ne peuvent pas être désactivés ; pour `reasoning_effort`, les trois niveaux `low` / `high` / `max` prennent effet et les autres sont rétrogradés automatiquement vers le niveau disponible le plus proche (`xhigh` → `max`, `medium` → `high`, `minimal` / `none` → `low`, la réflexion se poursuit et est facturée en sortie). `glm-5.2` peut désactiver la réflexion via `thinking.type: "disabled"` et prend en charge davantage de niveaux de raisonnement. Voir les descriptions des champs `thinking` et `reasoning_effort` pour le détail.
</Note>

<Note>
  **Entrée image** : prise en charge uniquement par `glm-5.3-flash`, via des blocs de contenu `image_url` dans `messages[].content[]`. Envoyer des blocs image à un autre modèle renvoie une erreur.
</Note>


## OpenAPI

````yaml fr/api-manual/language-series/glm/chat-completions/chat-completions-reference.json POST /v1/chat/completions
openapi: 3.1.0
info:
  title: API tous modèles GLM - Référence complète Chat Completions
  description: >-
    Référence complète de l'API pour appeler les modèles de texte Zhipu GLM via
    l'API Chat Completions compatible OpenAI.


    **Modèles couverts** : `glm-5.3`, `glm-5.3-flash`, `glm-5.2` (sélectionnés
    avec le paramètre `model`)


    **Capacités communes** :

    - Fenêtre de contexte de 1M tokens, jusqu'à **131 072 tokens** (128K) en
    sortie, avec un minimum recommandé de **1 024 tokens**

    - Réflexion approfondie : `thinking` contrôle la chaîne de pensée et
    `reasoning_effort` règle l'intensité du raisonnement ; le raisonnement est
    renvoyé dans `reasoning_content`

    - Appels d'outils : Function Calling et recherche web (jusqu'à 128 outils)

    - Streaming : réponses en flux SSE

    - Sortie structurée : les formats de réponse `text` et `json_object`

    - Cache de contexte : cache de préfixe implicite que les requêtes répétées
    de même préfixe touchent automatiquement, comptabilisé dans
    `usage.prompt_tokens_details.cached_tokens`


    **Les différences entre modèles** (contrôle de la réflexion, entrée image)
    sont décrites ci-dessous dans les champs `model` et `thinking` /
    `reasoning_effort`.
  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 conversation par IA
paths:
  /v1/chat/completions:
    post:
      tags:
        - Complétion de chat
      summary: Complétion de conversation GLM (tous modèles, compatible OpenAI)
      description: >-
        - Appelez les modèles de la série GLM via le protocole OpenAI Chat
        Completions, le modèle précis étant choisi avec le paramètre `model`

        - Traitement synchrone qui renvoie le contenu de la conversation en
        temps réel

        - **Conversation textuelle** : conversation contextuelle à un ou
        plusieurs tours ; `glm-5.3-flash` prend en plus en charge l'entrée image

        - **Invite système** : personnalisez le rôle et le comportement de l'IA
        via un message `role=system`

        - **Réflexion approfondie** : `thinking.type` contrôle la chaîne de
        pensée et `reasoning_effort` règle l'intensité du raisonnement ; le
        raisonnement est renvoyé dans `reasoning_content`

        - **Streaming** : les réponses en flux SSE sont prises en charge
        (`stream=true`)

        - **Appels d'outils** : Function Calling et recherche web pris en charge
        (`web_search`, jusqu'à 128 outils)

        - **Sortie structurée** : activez le mode JSON via `response_format`


        **À propos des réponses en streaming** : avec `stream=true`, les
        résultats arrivent par Server-Sent Events, chaque message ayant le
        format `data: {JSON}`, le flux se terminant par `data: [DONE]`. Chaque
        bloc de données (`ChatCompletionChunk`) contient `id`, `created`,
        `model`, `choices` et, en option, `usage` et `content_filter` ; à
        l'intérieur, `choices[].delta` renvoie de façon incrémentale `role` /
        `content` / `reasoning_content` / `tool_calls`, et
        `choices[].finish_reason` indique le motif d'arrêt dans le dernier bloc.
      operationId: createChatCompletionGLM
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ChatCompletionRequest'
            examples:
              simple_text:
                summary: Conversation textuelle sur un seul tour
                value:
                  model: glm-5.3
                  messages:
                    - role: user
                      content: Veuillez vous présenter
              multi_turn:
                summary: Conversation multi-tours (compréhension du contexte)
                value:
                  model: glm-5.3
                  messages:
                    - role: user
                      content: Qu'est-ce que Python ?
                    - role: assistant
                      content: Python est un langage de programmation de haut niveau...
                    - role: user
                      content: Quels sont ses avantages ?
              system_prompt:
                summary: Utilisation des invites système
                value:
                  model: glm-5.3
                  messages:
                    - role: system
                      content: >-
                        Vous êtes un assistant de programmation Python
                        professionnel. Répondez aux questions de manière
                        concise.
                    - role: user
                      content: Comment lire un fichier ?
              deep_thinking:
                summary: >-
                  Activer la réflexion approfondie et ajuster l'intensité du
                  raisonnement
                value:
                  model: glm-5.3
                  messages:
                    - role: user
                      content: >-
                        Un fermier doit faire traverser une rivière à un loup,
                        une chèvre et un chou, mais ne peut en transporter qu'un
                        seul à la fois. Comment traverser en toute sécurité ?
                  thinking:
                    type: enabled
                  reasoning_effort: max
              function_calling:
                summary: Appel d'outil (Function Calling)
                value:
                  model: glm-5.3
                  messages:
                    - role: user
                      content: Quel temps fait-il à Pékin aujourd'hui ?
                  tools:
                    - type: function
                      function:
                        name: get_weather
                        description: Interroger 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, par exemple : Pékin'
                          required:
                            - city
                  tool_choice: auto
              web_search:
                summary: Activer l'outil de recherche web
                value:
                  model: glm-5.3
                  messages:
                    - role: user
                      content: >-
                        Aide-moi à trouver les actualités sur l'intelligence
                        artificielle de la dernière semaine
                  tools:
                    - type: web_search
                      web_search:
                        enable: true
                        count: 10
                        search_recency_filter: oneWeek
                description: >-
                  Lorsque le modèle estime avoir besoin du web, il effectue une
                  recherche automatiquement et les résultats sont intégrés au
                  contexte pour le raisonnement. Les résultats sont facturés
                  comme tokens d'entrée, et le service de recherche lui-même est
                  facturé à l'appel (voir la page de tarification) ; aucun frais
                  de recherche ne s'applique si le modèle ne déclenche pas de
                  recherche.
              json_mode:
                summary: Sortie structurée JSON
                value:
                  model: glm-5.3
                  messages:
                    - role: system
                      content: >-
                        Veuillez répondre au format JSON, en incluant les deux
                        champs name et age.
                    - role: user
                      content: Jean Dupont, 28 ans
                  response_format:
                    type: json_object
              streaming:
                summary: Sortie en streaming (SSE)
                value:
                  model: glm-5.3
                  messages:
                    - role: user
                      content: Écris un court poème sur le printemps
                  stream: true
              disable_thinking_glm52_only:
                summary: Désactiver la réflexion approfondie (uniquement glm-5.2)
                value:
                  model: glm-5.2
                  messages:
                    - role: user
                      content: Résumez la théorie de la relativité en une phrase.
                  thinking:
                    type: disabled
                description: >-
                  Seul `glm-5.2` peut désactiver la réflexion. Envoyer
                  `thinking.type: "disabled"` à `glm-5.3` ou `glm-5.3-flash`
                  renvoie une erreur — utilisez plutôt `reasoning_effort:
                  "low"`.
              low_effort:
                summary: >-
                  Réduire le coût de réflexion (alternative à la désactivation
                  de la réflexion sur la série glm-5.3)
                description: >-
                  La série `glm-5.3` ne peut pas désactiver la réflexion ;
                  utilisez `reasoning_effort: "low"` pour réduire l'intensité du
                  raisonnement au minimum.
                value:
                  model: glm-5.3
                  messages:
                    - role: user
                      content: Expliquez HTTP en une phrase
                  thinking:
                    type: enabled
                  reasoning_effort: low
                  max_tokens: 1024
              vision_flash:
                summary: Entrée image (uniquement glm-5.3-flash)
                description: >-
                  `glm-5.3-flash` prend en charge la vision nativement ; les
                  images sont transmises via des blocs de contenu `image_url`,
                  avec une URL publique ou une URL de données Base64.
                value:
                  model: glm-5.3-flash
                  messages:
                    - role: user
                      content:
                        - type: text
                          text: Qu'y a-t-il sur cette image ?
                        - type: image_url
                          image_url:
                            url: https://example.com/photo.jpg
                  max_tokens: 1024
      responses:
        '200':
          description: Génération de conversation réussie
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ChatCompletionResponse'
        '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 autorisé, jeton invalide ou expiré
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 401
                  message: Invalid or expired token
                  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_error
                  fallback_suggestion: https://evolink.ai/dashboard/billing
        '403':
          description: Accès refusé
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 403
                  message: Access denied for this model
                  type: permission_error
                  param: model
        '404':
          description: Ressource introuvable
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 404
                  message: Specified model not found
                  type: not_found_error
                  param: model
                  fallback_suggestion: glm-5.3
        '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
                  fallback_suggestion: retry after 60 seconds
        '500':
          description: Erreur interne du serveur
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 500
                  message: Internal server error
                  type: internal_server_error
                  fallback_suggestion: try again later
        '502':
          description: Erreur du service en amont
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 502
                  message: Upstream AI service unavailable
                  type: upstream_error
                  fallback_suggestion: try different model
        '503':
          description: Service temporairement indisponible
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 503
                  message: Service temporarily unavailable
                  type: service_unavailable_error
                  fallback_suggestion: retry after 30 seconds
components:
  schemas:
    ChatCompletionRequest:
      type: object
      required:
        - model
        - messages
      properties:
        model:
          type: string
          description: >
            Modèle à appeler :


            | ID du modèle | Positionnement | Contrôle de la réflexion | Entrée
            image |

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

            | `glm-5.3` | Modèle phare, progression générale sur l'ingénierie
            logicielle complexe et les tâches d'agent, avec des capacités de
            programmation nettement supérieures à la génération précédente ;
            contexte de 1M | Réfléchit toujours, non désactivable ; pour
            `reasoning_effort`, seuls `low` / `high` / `max` prennent effet, les
            autres niveaux sont rétrogradés automatiquement | Non prise en
            charge |

            | `glm-5.3-flash` | Modèle multimodal léger à architecture hybride
            d'attention creuse et linéaire, coût très faible et vision native ;
            contexte de 1M | Identique à `glm-5.3` | **Prise en charge**, voir
            le champ `messages` |

            | `glm-5.2` | Modèle phare de la génération précédente, raisonnement
            complexe et contexte très long ; contexte de 1M | Désactivable via
            `thinking.type: "disabled"` ; `reasoning_effort` accepte les 7
            niveaux | Non prise en charge |
          enum:
            - glm-5.3
            - glm-5.3-flash
            - glm-5.2
          default: glm-5.3
          example: glm-5.3
        messages:
          type: array
          description: >-
            Liste des messages de la conversation, contenant l'intégralité du
            contexte de la conversation en cours


            Prend en charge quatre rôles : `system`, `user`, `assistant`,
            `tool`. Les messages de rôles différents ont des structures de
            champs différentes ; sélectionnez le rôle correspondant pour le
            consulter. Doit contenir au moins 1 message, et ne peut pas contenir
            uniquement des messages système ou des messages de l'assistant.
          items:
            oneOf:
              - $ref: '#/components/schemas/SystemMessage'
              - $ref: '#/components/schemas/UserMessage'
              - $ref: '#/components/schemas/AssistantRequestMessage'
              - $ref: '#/components/schemas/ToolMessage'
            discriminator:
              propertyName: role
              mapping:
                system:
                  $ref: '#/components/schemas/SystemMessage'
                user:
                  $ref: '#/components/schemas/UserMessage'
                assistant:
                  $ref: '#/components/schemas/AssistantRequestMessage'
                tool:
                  $ref: '#/components/schemas/ToolMessage'
          minItems: 1
        stream:
          type: boolean
          description: >-
            Indique s'il faut activer le mode de sortie en streaming


            - `false` : le modèle génère la réponse complète puis la renvoie en
            une seule fois (par défaut), adapté aux textes courts et au
            traitement par lots

            - `true` : renvoie le contenu en temps réel bloc par bloc via
            Server-Sent Events (SSE), adapté au chat et aux textes longs ;
            `data: [DONE]` est renvoyé à la fin du flux
          default: false
          example: false
        thinking:
          type: object
          description: Contrôle l'activation de la chaîne de pensée (Chain of Thought)
          properties:
            type:
              type: string
              description: >-
                Interrupteur de la chaîne de pensée


                - `enabled` : activer la réflexion approfondie (comportement par
                défaut de tous les modèles)

                - `disabled` : désactiver la réflexion approfondie, le modèle
                répond directement


                **Seul `glm-5.2` prend en charge `disabled`.** `glm-5.3` et
                `glm-5.3-flash` réfléchissent toujours et renvoient une erreur
                si `disabled` est transmis.


                Pour réduire le coût de réflexion sur la série `glm-5.3`,
                utilisez plutôt `reasoning_effort: "low"`.


                **Migration depuis `glm-5.2`** : si votre code fixe
                `thinking.type: "disabled"`, vous devez le passer à `"enabled"`
                avant de basculer sur `glm-5.3` (en ajoutant `reasoning_effort:
                "low"` si vous souhaitez réduire le coût de réflexion), sans
                quoi la requête échoue immédiatement.


                Notez que ces deux champs se comportent **différemment** : un
                niveau de `reasoning_effort` non pris en charge par la série est
                rétrogradé automatiquement, sans erreur, alors que
                `thinking.type` est un interrupteur explicite — `disabled`
                provoque toujours une erreur et n'est jamais réécrit
                silencieusement. Passer `reasoning_effort` de `none` à `low` ne
                suffit donc pas : `thinking.type` doit être modifié également.
              enum:
                - enabled
                - disabled
              default: enabled
            clear_thinking:
              type: boolean
              description: >-
                Indique s'il faut effacer le `reasoning_content` des tours de
                conversation historiques


                - `true` (par défaut) : ignore/supprime le `reasoning_content`
                des tours historiques, et n'utilise que le contenu non lié au
                raisonnement (texte visible utilisateur/assistant, appels
                d'outils et résultats, etc.) comme contexte, ce qui peut réduire
                la longueur du contexte et le coût

                - `false` : conserve le `reasoning_content` des tours
                historiques et le fournit au modèle avec le contexte (Preserved
                Thinking) ; dans ce cas, le `reasoning_content` historique doit
                être transmis dans `messages` de manière **complète, non
                modifiée et dans l'ordre d'origine** ; toute absence,
                troncature, réécriture ou réorganisation dégradera les
                performances ou empêchera son effet

                - Remarque : ce paramètre n'affecte que la réflexion historique
                entre les tours, il ne modifie pas le fait que le tour en cours
                produise ou non une réflexion
              default: true
              example: true
        reasoning_effort:
          type: string
          description: >-
            Contrôle l'intensité du raisonnement du modèle ; n'agit que lorsque
            `thinking` est actif, `max` par défaut


            **Les valeurs prises en charge diffèrent selon le modèle** :


            | Valeur | `glm-5.3` / `glm-5.3-flash` | `glm-5.2` |

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

            | `max` | Raisonnement approfondi (par défaut) | Raisonnement
            approfondi |

            | `high` | Raisonnement renforcé | Raisonnement renforcé |

            | `low` | Raisonnement léger | Équivalent à `high` |

            | `xhigh` | Rétrogradé en `max` | Équivalent à `max` |

            | `medium` | Rétrogradé en `high` | Équivalent à `high` |

            | `minimal` | Rétrogradé en `low` (réfléchit quand même) | Renonce à
            réfléchir |

            | `none` | Rétrogradé en `low` (réfléchit quand même) | Renonce à
            réfléchir |


            La série `glm-5.3` réfléchit toujours et seuls les trois niveaux
            `low` / `high` / `max` prennent réellement effet ; les quatre autres
            ne provoquent pas d'erreur mais sont rétrogradés automatiquement
            vers le niveau disponible le plus proche (`xhigh` → `max`, `medium`
            → `high`, `minimal` / `none` → `low`).


            **La série `glm-5.3` ne peut pas désactiver la réflexion.**
            Transmettre `minimal` ou `none` ne fait que descendre au niveau le
            plus bas, `low` : le modèle continue de produire des tokens de
            réflexion, **facturés au tarif de sortie**. Si vous utilisez ces
            deux niveaux pour réduire les coûts, notez la différence avec
            `glm-5.2` : sur `glm-5.2`, ils suppriment réellement la réflexion.


            Pour les tâches complexes comme la programmation, `max` est
            recommandé.
          enum:
            - max
            - xhigh
            - high
            - medium
            - low
            - minimal
            - none
          default: max
          example: max
        do_sample:
          type: boolean
          description: >-
            Indique s'il faut activer la stratégie d'échantillonnage


            - `true` (par défaut) : utilise `temperature` / `top_p` pour un
            échantillonnage aléatoire, sortie plus variée

            - `false` : sélectionne toujours le mot le plus probable (décodage
            glouton), sortie plus déterministe ; dans ce cas, `temperature` et
            `top_p` sont ignorés


            Pour les tâches nécessitant cohérence et reproductibilité (comme la
            génération de code, la traduction), il est recommandé de définir
            cette valeur sur `false`
          default: true
          example: true
        temperature:
          type: number
          format: float
          description: >-
            Température d'échantillonnage, contrôle le caractère aléatoire et la
            créativité de la sortie


            **Remarques** :

            - Plage : `[0.0, 1.0]`, limitée à deux décimales

            - Valeurs plus élevées (par ex. 0.8) : plus aléatoire et plus
            créatif, adapté à l'écriture créative

            - Valeurs plus basses (par ex. 0.2) : plus stable et plus
            déterministe, adapté aux questions factuelles et à la génération de
            code

            - Valeur par défaut : `1.0`


            **Recommandation** : n'ajustez pas simultanément `temperature` et
            `top_p`
          minimum: 0
          maximum: 1
          default: 1
          example: 1
        top_p:
          type: number
          format: float
          description: >-
            Paramètre d'échantillonnage par noyau (Nucleus Sampling), une
            méthode alternative à l'échantillonnage par `temperature`


            **Remarques** :

            - Plage : `[0.01, 1.0]`, limitée à deux décimales

            - Le modèle ne considère que les mots candidats dont la probabilité
            cumulée atteint `top_p` ; par exemple, 0.1 signifie ne considérer
            que les 10 % de mots les plus probables

            - Des valeurs plus petites produisent une sortie plus ciblée et plus
            cohérente ; des valeurs plus grandes augmentent la diversité

            - Valeur par défaut : `0.95`


            **Recommandation** : n'ajustez pas simultanément `temperature` et
            `top_p`
          minimum: 0.01
          maximum: 1
          default: 0.95
          example: 0.95
        max_tokens:
          type: integer
          description: >-
            Limite maximale du nombre de tokens de sortie du modèle


            **Remarque** :

            - La série GLM prend en charge jusqu'à **131 072 tokens** (128K) en
            sortie ; il est conseillé de ne pas descendre sous `1024`

            - Lorsque `thinking` est actif, les tokens de la chaîne de pensée
            comptent aussi dans cette limite

            - Si la génération est tronquée pour cause de `length`, essayez
            d'augmenter cette valeur
          minimum: 1
          maximum: 131072
          example: 1024
        tools:
          type: array
          description: >-
            Liste des outils que le modèle peut appeler


            **Remarque** :

            - L'appel de fonctions (`function`) et la recherche web
            (`web_search`) sont pris en charge

            - Jusqu'à 128 fonctions

            - Parmi eux, `web_search` est **facturé séparément à l'appel**
            lorsqu'une recherche a effectivement lieu ; les autres outils
            n'entraînent pas de frais supplémentaires
          items:
            oneOf:
              - $ref: '#/components/schemas/FunctionTool'
              - $ref: '#/components/schemas/WebSearchTool'
            discriminator:
              propertyName: type
              mapping:
                function:
                  $ref: '#/components/schemas/FunctionTool'
                web_search:
                  $ref: '#/components/schemas/WebSearchTool'
          maxItems: 128
        tool_choice:
          type: string
          description: >-
            Contrôle la manière dont le modèle choisit quelle fonction appeler


            **Remarques** : n'a d'effet que lorsque le type d'outil est
            `function`, par défaut et uniquement `auto` est pris en charge (le
            modèle décide automatiquement s'il faut appeler un outil)
          enum:
            - auto
          default: auto
          example: auto
        stop:
          type: array
          description: >-
            Liste des mots d'arrêt


            **Remarques** :

            - Lorsque le texte généré par le modèle rencontre la chaîne
            spécifiée, la génération s'arrête immédiatement (le mot d'arrêt
            lui-même n'est pas inclus dans le texte renvoyé)

            - Actuellement, un seul mot d'arrêt est pris en charge, au format
            `["stop_word1"]`, par exemple `["Human:"]`
          items:
            type: string
          maxItems: 4
          example:
            - 'Human:'
        response_format:
          type: object
          description: >-
            Spécifie le format de sortie de la réponse du modèle, par défaut
            `text`


            **Remarques** :

            - `{ "type": "json_object" }` active le mode JSON, le modèle renvoie
            des données au format JSON valide, adapté aux scénarios d'extraction
            de données structurées, etc.

            - Lors de l'utilisation du mode JSON, il est recommandé de demander
            explicitement une sortie JSON dans le message `system` ou `user`
          required:
            - type
          properties:
            type:
              type: string
              description: |-
                Type de format de sortie

                - `text` : sortie en texte brut (par défaut)
                - `json_object` : sortie au format JSON
              enum:
                - text
                - json_object
              default: text
        request_id:
          type: string
          description: >-
            Identifiant unique de la requête


            **Remarques** :

            - Transmis par le client, longueur de 6 à 64 caractères, il est
            recommandé d'utiliser le format UUID pour garantir l'unicité

            - S'il n'est pas fourni, la plateforme le génère automatiquement
          minLength: 6
          maxLength: 64
          example: req-7f3a2c1e8b9d4f0a
        user_id:
          type: string
          description: >-
            Identifiant unique de l'utilisateur final


            **Remarques** : longueur de 6 à 128 caractères, il est recommandé
            d'utiliser un identifiant unique ne contenant pas d'informations
            sensibles ; cela peut aider la plateforme à surveiller et détecter
            les comportements abusifs
          minLength: 6
          maxLength: 128
          example: user-abc123456
    ChatCompletionResponse:
      type: object
      properties:
        id:
          type: string
          description: '`ID` de la tâche'
          example: chatcmpl-a6613b56-c61c-94ba-9a9f-43d4cdc7d77a
        object:
          type: string
          description: Type de réponse
          enum:
            - chat.completion
          example: chat.completion
        request_id:
          type: string
          description: >-
            `ID` de la requête (retransmis lorsque `request_id` est fourni dans
            la requête)
          example: req-7f3a2c1e8b9d4f0a
        created:
          type: integer
          description: Heure de création de la requête, horodatage `Unix` (secondes)
          example: 1777021417
        model:
          type: string
          description: Nom du modèle
          example: glm-5.3
        choices:
          type: array
          description: Liste des réponses du modèle
          items:
            $ref: '#/components/schemas/Choice'
        usage:
          $ref: '#/components/schemas/Usage'
        web_search:
          type: array
          description: >-
            Informations relatives à la recherche web, renvoyées lors de
            l'utilisation de l'outil `web_search` et qu'une recherche est
            effectuée
          items:
            $ref: '#/components/schemas/WebSearchResult'
        content_filter:
          type: array
          description: Informations relatives à la sécurité du contenu
          items:
            $ref: '#/components/schemas/ContentFilter'
    ErrorResponse:
      type: object
      properties:
        error:
          type: object
          properties:
            code:
              type: integer
              description: Code d'erreur de statut HTTP
            message:
              type: string
              description: Description de l'erreur
            type:
              type: string
              description: Type d'erreur
            param:
              type: string
              description: Nom du paramètre concerné
            fallback_suggestion:
              type: string
              description: Suggestion lorsqu'une erreur se produit
    SystemMessage:
      title: System Message
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - system
          description: Identifiant de rôle, fixé à `system`
        content:
          type: string
          description: >-
            Contenu de l'invite système, utilisé pour définir le rôle et le
            comportement de l'IA
    UserMessage:
      title: User Message
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - user
          description: Identifiant de rôle, fixé à `user`
        content:
          description: >-
            Contenu du message utilisateur.


            - **Chaîne** : texte brut, pris en charge par tous les modèles

            - **Tableau de blocs de contenu** : texte et images mélangés, **pris
            en charge uniquement par `glm-5.3-flash`**


            Envoyer des blocs de contenu image à `glm-5.3` ou `glm-5.2` renvoie
            une erreur.
          oneOf:
            - type: string
              title: Texte brut
              description: Contenu du message en texte brut
              example: Bonjour, veuillez vous présenter
            - type: array
              title: Tableau de blocs de contenu (uniquement glm-5.3-flash)
              description: >-
                Texte et images mélangés. Les images sont transmises via des
                blocs `image_url`, avec une URL publique (recommandée) ou une
                URL de données Base64 ; pour plusieurs images, utilisez
                plusieurs blocs `image_url`.
              items:
                $ref: '#/components/schemas/ContentPart'
    AssistantRequestMessage:
      title: Assistant Message
      type: object
      description: Message de l'assistant, peut contenir des appels d'outils
      required:
        - role
      properties:
        role:
          type: string
          enum:
            - assistant
          description: Identifiant de rôle, fixé à `assistant`
        content:
          type:
            - string
            - 'null'
          description: >-
            Contenu du message de l'assistant


            **Remarques** : utilisé pour transmettre les réponses historiques de
            l'assistant dans les conversations multi-tours ; généralement `null`
            lorsque `tool_calls` est présent
        reasoning_content:
          type:
            - string
            - 'null'
          description: >-
            Contenu historique de la chaîne de pensée


            **Remarques** : requis uniquement lorsque
            `thinking.clear_thinking=false` (Preserved Thinking) ; retransmet
            tel quel le `reasoning_content` de la réponse du tour précédent ;
            par défaut (`clear_thinking=true`), aucune retransmission n'est
            nécessaire
        tool_calls:
          type: array
          description: >-
            Liste des appels d'outils


            Utilisée pour transmettre les informations historiques d'appels
            d'outils dans les conversations multi-tours ; lorsque ce champ est
            fourni, `content` est généralement vide
          items:
            type: object
            required:
              - id
              - type
            properties:
              id:
                type: string
                description: ID de l'appel d'outil
              type:
                type: string
                enum:
                  - function
                  - web_search
                description: Type d'outil
              function:
                type: object
                description: >-
                  Informations sur l'appel de fonction, non vides lorsque `type`
                  est `function`
                required:
                  - name
                  - arguments
                properties:
                  name:
                    type: string
                    description: Nom de la fonction
                  arguments:
                    type: string
                    description: Arguments de la fonction (chaîne au format JSON)
    ToolMessage:
      title: Tool Message
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - tool
          description: Identifiant de rôle, fixé à `tool`
        content:
          type: string
          description: Contenu du résultat de l'appel d'outil
        tool_call_id:
          type: string
          description: >-
            Indique l'`ID` de l'appel d'outil correspondant à ce message
            (correspond à l'`id` renvoyé dans `tool_calls` du message assistant)
    FunctionTool:
      title: Outil Function
      type: object
      required:
        - type
        - function
      additionalProperties: false
      properties:
        type:
          type: string
          enum:
            - function
          default: function
          description: Type d'outil, fixé à `function`
        function:
          type: object
          required:
            - name
            - description
            - parameters
          properties:
            name:
              type: string
              description: >-
                Nom de la fonction à appeler


                **Remarques** : doit être composé des caractères `a-z`, `A-Z`,
                `0-9`, ou inclure des traits de soulignement et des tirets ;
                longueur maximale de 64 caractères
              minLength: 1
              maxLength: 64
              pattern: ^[a-zA-Z0-9_-]+$
            description:
              type: string
              description: >-
                Description de la fonctionnalité de la fonction, pour aider le
                modèle à choisir quand et comment appeler la fonction
            parameters:
              type: object
              description: >-
                Paramètres d'entrée de la fonction, décrits sous forme d'objet
                JSON Schema
    WebSearchTool:
      title: Outil Web Search (recherche web)
      type: object
      required:
        - type
        - web_search
      additionalProperties: false
      properties:
        type:
          type: string
          enum:
            - web_search
          default: web_search
          description: Type d'outil, fixé à `web_search`
        web_search:
          type: object
          required:
            - enable
          properties:
            enable:
              type: boolean
              description: >-
                Indique s'il faut activer la fonction de recherche, définir sur
                `true` lorsqu'elle est activée
              default: false
            search_query:
              type: string
              description: >-
                Mot-clé personnalisé pour forcer le déclenchement de la
                recherche
            search_intent:
              type: boolean
              description: >-
                Indique s'il faut effectuer la reconnaissance de l'intention de
                recherche, exécutée par défaut


                - `true` : effectue la reconnaissance de l'intention de
                recherche, et exécute la recherche après avoir détecté une
                intention de recherche

                - `false` : ignore la reconnaissance d'intention et exécute
                directement la recherche
            count:
              type: integer
              description: >-
                Nombre de résultats renvoyés, dans la plage `1-50`, par défaut
                `10`.


                Ce nombre a un impact direct sur le coût : les résultats sont
                intégrés à `prompt_tokens` et facturés au tarif d'entrée, et une
                valeur de `50` peut porter une seule requête à plusieurs
                dizaines de milliers de tokens d'entrée. À moins d'avoir
                réellement besoin d'un rappel plus large, conservez la valeur
                par défaut.
              minimum: 1
              maximum: 50
              default: 10
            search_domain_filter:
              type: string
              description: >-
                Liste blanche de noms de domaine pour limiter les résultats de
                recherche (par ex. `www.example.com`)
            search_recency_filter:
              type: string
              description: >-
                Limite la plage temporelle des résultats de recherche, par
                défaut `noLimit`
              enum:
                - oneDay
                - oneWeek
                - oneMonth
                - oneYear
                - noLimit
              default: noLimit
            content_size:
              type: string
              description: >-
                Contrôle le nombre de mots du résumé des pages web, par défaut
                `medium`


                - `medium` : renvoie des informations de résumé, suffisantes
                pour les besoins de raisonnement de base

                - `high` : maximise le contexte, informations plus détaillées
              enum:
                - medium
                - high
              default: medium
            result_sequence:
              type: string
              description: >-
                Position de renvoi des résultats de recherche (avant ou après la
                réponse du modèle), par défaut `after`
              enum:
                - before
                - after
              default: after
            search_result:
              type: boolean
              description: >-
                Indique s'il faut renvoyer le détail des sources de recherche
                dans la réponse, `false` par défaut.


                Avec `true`, la réponse comporte au premier niveau un tableau
                `web_search` listant les sources trouvées pour cette requête
                (titre, lien, source média, date de publication, résumé, etc.) ;
                avec la valeur par défaut, ce champ est absent de la réponse.


                Ce paramètre n'agit que sur le contenu de la réponse : il ne
                détermine ni le déclenchement de la recherche ni la facturation.
              default: false
              example: true
            require_search:
              type: boolean
              description: >-
                Indique s'il faut forcer la réponse à se baser sur les résultats
                de recherche, par défaut `false`
              default: false
            search_prompt:
              type: string
              description: >-
                `Prompt` utilisé pour personnaliser le traitement des résultats
                de recherche ; le modèle par défaut est utilisé s'il n'est pas
                transmis
      description: >-
        Outil de recherche web. Une fois activé, le modèle peut consulter le web
        au besoin et intégrer les résultats au contexte.


        **Facturation** : la part des résultats intégrée au contexte compte dans
        `prompt_tokens` au tarif d'entrée ; le service de recherche lui-même est
        **facturé séparément à l'appel** et réglé indépendamment de la
        consommation de tokens — voir la page de tarification. C'est le modèle
        qui décide de déclencher une recherche selon l'intention détectée, et
        aucun frais de ce type ne s'applique si aucune recherche n'a lieu.
    Choice:
      type: object
      properties:
        index:
          type: integer
          description: Index du résultat
          example: 0
        message:
          $ref: '#/components/schemas/AssistantMessage'
        finish_reason:
          type: string
          description: >-
            Raison de fin du raisonnement


            - `stop` : fin naturelle ou déclenchement d'un mot d'arrêt

            - `tool_calls` : le modèle a invoqué une fonction (appel d'outil)

            - `length` : limite de longueur de tokens atteinte

            - `sensitive` : contenu intercepté par la modération de sécurité
            (veuillez juger et décider de retirer ou non le contenu public)

            - `network_error` : anomalie d'inférence du modèle

            - `model_context_window_exceeded` : dépassement de la fenêtre de
            contexte du modèle
          enum:
            - stop
            - tool_calls
            - length
            - sensitive
            - network_error
            - model_context_window_exceeded
          example: stop
    Usage:
      type: object
      description: Statistiques d'utilisation des tokens renvoyées à la fin de l'appel
      properties:
        prompt_tokens:
          type: integer
          description: Nombre de tokens en entrée de l'utilisateur
          example: 24
        completion_tokens:
          type: integer
          description: >-
            Nombre de tokens en sortie (y compris la partie `reasoning_tokens`
            de la chaîne de pensée)
          example: 346
        total_tokens:
          type: integer
          description: Nombre total de tokens = prompt_tokens + completion_tokens
          example: 370
        prompt_tokens_details:
          type: object
          description: Détail des tokens d'entrée
          properties:
            cached_tokens:
              type: integer
              description: >-
                Nombre de tokens d'entrée servis par le cache de contexte.


                La série GLM utilise un **cache de préfixe implicite** : les
                requêtes répétées ayant le même préfixe le touchent
                automatiquement, sans paramètre supplémentaire ; la partie mise
                en cache est facturée au tarif du cache, nettement inférieur au
                tarif d'entrée sans cache. La première requête renvoie 0, puis
                les requêtes de même préfixe touchent le cache.
              example: 0
        completion_tokens_details:
          type: object
          description: Détail des tokens de sortie
          properties:
            reasoning_tokens:
              type: integer
              description: >-
                Nombre de tokens produits par la chaîne de pensée (réflexion
                approfondie), comptabilisés dans `completion_tokens`
              example: 321
    WebSearchResult:
      type: object
      description: Résultat unique de recherche web
      properties:
        icon:
          type: string
          description: Icône du site source
        title:
          type: string
          description: Titre du résultat de recherche
        link:
          type: string
          description: Lien de la page web du résultat de recherche
        media:
          type: string
          description: Nom de la source média de la page web du résultat de recherche
        publish_date:
          type: string
          description: Date de publication du site web
        content:
          type: string
          description: Contenu textuel cité de la page web du résultat de recherche
        refer:
          type: string
          description: Numéro de l'indice
    ContentFilter:
      type: object
      description: Informations de sécurité du contenu
      properties:
        role:
          type: string
          description: |-
            Étape d'application de la sécurité

            - `assistant` : inférence du modèle
            - `user` : entrée de l'utilisateur
            - `history` : contexte historique
          enum:
            - assistant
            - user
            - history
        level:
          type: integer
          description: >-
            Niveau de gravité `0-3`, `0` indique le plus grave, `3` indique le
            plus léger
          minimum: 0
          maximum: 3
    ContentPart:
      title: Content Part
      type: object
      description: >-
        Bloc de contenu multimodal. **Seul `glm-5.3-flash` prend en charge les
        blocs image.**
      required:
        - type
      properties:
        type:
          type: string
          enum:
            - text
            - image_url
          description: |-
            Type de bloc de contenu

            - `text` : texte
            - `image_url` : image (uniquement `glm-5.3-flash`)
        text:
          type: string
          description: Contenu textuel, obligatoire lorsque `type=text`
          example: Qu'y a-t-il sur cette image ?
        image_url:
          type: object
          description: Contenu de l'image, obligatoire lorsque `type=image_url`
          required:
            - url
          properties:
            url:
              type: string
              description: >-
                Adresse de l'image. Une URL HTTPS publique (recommandée) ou une
                URL de données Base64 (`data:image/png;base64,...`) est prise en
                charge
              example: https://example.com/photo.jpg
    AssistantMessage:
      type: object
      properties:
        role:
          type: string
          description: Rôle de la conversation en cours, par défaut `assistant`
          enum:
            - assistant
          example: assistant
        content:
          type:
            - string
            - 'null'
          description: >-
            Contenu textuel de la conversation


            **Remarques** : peut être `null` lors de l'appel d'outils
            (`tool_calls`), sinon renvoie le contenu de la réponse du modèle
          example: >-
            Bonjour ! Je suis GLM-5.3, et je peux vous aider à réaliser diverses
            tâches comme la conversation, le raisonnement, la rédaction, le
            code, etc.
        reasoning_content:
          type: string
          description: >-
            Contenu de la chaîne de pensée


            **Remarques** : renvoyé lorsque `thinking` est activé, enregistre le
            processus de raisonnement du modèle
          example: Laissez-moi d'abord analyser ce problème...
        tool_calls:
          type: array
          description: >-
            Informations sur les appels d'outils générés (renvoyées lorsque le
            modèle décide d'appeler un outil)
          items:
            type: object
            properties:
              id:
                type: string
                description: Identifiant unique de l'appel d'outil
              type:
                type: string
                description: Type d'appel d'outil
                enum:
                  - function
              function:
                type: object
                description: >-
                  Informations sur l'appel de fonction (contient le nom de
                  fonction généré et les arguments au format JSON)
                properties:
                  name:
                    type: string
                    description: Nom de la fonction générée
                  arguments:
                    type: string
                    description: >-
                      Chaîne au format JSON des arguments de l'appel de
                      fonction, veuillez valider les arguments avant d'appeler
                      la fonction
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        ##Toutes les API nécessitent une authentification par 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

        ```

````