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

# OpenAI Multimodal Responses API

>  - Entièrement compatible avec le format de l'API OpenAI Responses
- Prend en charge l'entrée multimodale avec texte et images
- Prend en charge les extensions d'outils : recherche web, recherche de fichiers, function calling, MCP distant 

<RequestExample>
  ```bash cURL theme={null}
  curl https://gccai.heqingsong.uk/v1/responses \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <token>" \
    -d '{
      "model": "gpt-5.2-pro",
      "input": [
        {
          "role": "user",
          "content": [
            {
              "type": "input_text",
              "text": "What is in this image?"
            },
            {
              "type": "input_image",
              "image_url": "https://openai-documentation.vercel.app/images/cat_and_otter.png"
            }
          ]
        }
      ]
    }'
  ```

  ```python Python theme={null}
  import requests
  import os

  url = "https://gccai.heqingsong.uk/v1/responses"

  payload = {
      "model": "gpt-5.2-pro",
      "input": [
          {
              "role": "user",
              "content": [
                  {
                      "type": "input_text",
                      "text": "What is in this image?"
                  },
                  {
                      "type": "input_image",
                      "image_url": "https://openai-documentation.vercel.app/images/cat_and_otter.png"
                  }
              ]
          }
      ]
  }

  headers = {
      "Authorization": f"Bearer {os.environ.get('OPENAI_API_KEY')}",
      "Content-Type": "application/json"
  }

  response = requests.post(url, json=payload, headers=headers)

  print(response.json())
  ```

  ```javascript JavaScript theme={null}
  const url = "https://gccai.heqingsong.uk/v1/responses";

  const payload = {
    model: "gpt-5.2-pro",
    input: [
      {
        role: "user",
        content: [
          {
            type: "input_text",
            text: "What is in this image?"
          },
          {
            type: "input_image",
            image_url: "https://openai-documentation.vercel.app/images/cat_and_otter.png"
          }
        ]
      }
    ]
  };

  const headers = {
    "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`,
    "Content-Type": "application/json"
  };

  fetch(url, {
    method: "POST",
    headers: headers,
    body: JSON.stringify(payload)
  })
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error('Error:', error));
  ```

  ```go Go theme={null}
  package main

  import (
      "bytes"
      "encoding/json"
      "fmt"
      "io/ioutil"
      "net/http"
      "os"
  )

  func main() {
      url := "https://gccai.heqingsong.uk/v1/responses"

      payload := map[string]interface{}{
          "model": "gpt-5.2-pro",
          "input": []map[string]interface{}{
              {
                  "role": "user",
                  "content": []map[string]string{
                      {
                          "type": "input_text",
                          "text": "What is in this image?",
                      },
                      {
                          "type":      "input_image",
                          "image_url": "https://openai-documentation.vercel.app/images/cat_and_otter.png",
                      },
                  },
              },
          },
      }

      jsonData, _ := json.Marshal(payload)

      req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
      req.Header.Set("Authorization", "Bearer "+os.Getenv("OPENAI_API_KEY"))
      req.Header.Set("Content-Type", "application/json")

      client := &http.Client{}
      resp, err := client.Do(req)
      if err != nil {
          panic(err)
      }
      defer resp.Body.Close()

      body, _ := ioutil.ReadAll(resp.Body)
      fmt.Println(string(body))
  }
  ```

  ```java Java theme={null}
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;
  import java.net.URI;

  public class Main {
      public static void main(String[] args) throws Exception {
          String url = "https://gccai.heqingsong.uk/v1/responses";
          String apiKey = System.getenv("OPENAI_API_KEY");

          String payload = """
          {
            "model": "gpt-5.2-pro",
            "input": [
              {
                "role": "user",
                "content": [
                  {
                    "type": "input_text",
                    "text": "What is in this image?"
                  },
                  {
                    "type": "input_image",
                    "image_url": "https://openai-documentation.vercel.app/images/cat_and_otter.png"
                  }
                ]
              }
            ]
          }
          """;

          HttpClient client = HttpClient.newHttpClient();
          HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create(url))
              .header("Authorization", "Bearer " + apiKey)
              .header("Content-Type", "application/json")
              .POST(HttpRequest.BodyPublishers.ofString(payload))
              .build();

          HttpResponse<String> response = client.send(request,
              HttpResponse.BodyHandlers.ofString());

          System.out.println(response.body());
      }
  }
  ```

  ```php PHP theme={null}
  <?php

  $url = "https://gccai.heqingsong.uk/v1/responses";
  $apiKey = getenv('OPENAI_API_KEY');

  $payload = [
      "model" => "gpt-5.2-pro",
      "input" => [
          [
              "role" => "user",
              "content" => [
                  [
                      "type" => "input_text",
                      "text" => "What is in this image?"
                  ],
                  [
                      "type" => "input_image",
                      "image_url" => "https://openai-documentation.vercel.app/images/cat_and_otter.png"
                  ]
              ]
          ]
      ]
  ];

  $ch = curl_init($url);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_POST, true);
  curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      "Authorization: Bearer " . $apiKey,
      "Content-Type: application/json"
  ]);

  $response = curl_exec($ch);
  curl_close($ch);

  echo $response;
  ?>
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'
  require 'uri'

  url = URI("https://gccai.heqingsong.uk/v1/responses")
  api_key = ENV['OPENAI_API_KEY']

  payload = {
    model: "gpt-5.2-pro",
    input: [
      {
        role: "user",
        content: [
          {
            type: "input_text",
            text: "What is in this image?"
          },
          {
            type: "input_image",
            image_url: "https://openai-documentation.vercel.app/images/cat_and_otter.png"
          }
        ]
      }
    ]
  }

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(url)
  request["Authorization"] = "Bearer #{api_key}"
  request["Content-Type"] = "application/json"
  request.body = payload.to_json

  response = http.request(request)
  puts response.body
  ```

  ```swift Swift theme={null}
  import Foundation

  let url = URL(string: "https://gccai.heqingsong.uk/v1/responses")!
  let apiKey = ProcessInfo.processInfo.environment["OPENAI_API_KEY"] ?? ""

  let payload: [String: Any] = [
      "model": "gpt-5.2-pro",
      "input": [
          [
              "role": "user",
              "content": [
                  [
                      "type": "input_text",
                      "text": "What is in this image?"
                  ],
                  [
                      "type": "input_image",
                      "image_url": "https://openai-documentation.vercel.app/images/cat_and_otter.png"
                  ]
              ]
          ]
      ]
  ]

  var request = URLRequest(url: url)
  request.httpMethod = "POST"
  request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
  request.setValue("application/json", forHTTPHeaderField: "Content-Type")
  request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

  let task = URLSession.shared.dataTask(with: request) { data, response, error in
      if let error = error {
          print("Error: \(error)")
          return
      }

      if let data = data, let responseString = String(data: data, encoding: .utf8) {
          print(responseString)
      }
  }

  task.resume()
  ```

  ```csharp C# theme={null}
  using System;
  using System.Net.Http;
  using System.Text;
  using System.Threading.Tasks;

  class Program
  {
      static async Task Main(string[] args)
      {
          var url = "https://gccai.heqingsong.uk/v1/responses";
          var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");

          var payload = @"{
              ""model"": ""gpt-5.2-pro"",
              ""input"": [
                  {
                      ""role"": ""user"",
                      ""content"": [
                          {
                              ""type"": ""input_text"",
                              ""text"": ""What is in this image?""
                          },
                          {
                              ""type"": ""input_image"",
                              ""image_url"": ""https://openai-documentation.vercel.app/images/cat_and_otter.png""
                          }
                      ]
                  }
              ]
          }";

          using var client = new HttpClient();
          client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");

          var content = new StringContent(payload, Encoding.UTF8, "application/json");
          var response = await client.PostAsync(url, content);
          var result = await response.Content.ReadAsStringAsync();

          Console.WriteLine(result);
      }
  }
  ```

  ```c C theme={null}
  #include <stdio.h>
  #include <curl/curl.h>
  #include <stdlib.h>

  int main(void) {
      CURL *curl;
      CURLcode res;
      const char *api_key = getenv("OPENAI_API_KEY");

      curl_global_init(CURL_GLOBAL_DEFAULT);
      curl = curl_easy_init();

      if(curl) {
          const char *url = "https://gccai.heqingsong.uk/v1/responses";
          const char *payload = "{"
              "\"model\":\"gpt-5.2-pro\","
              "\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is in this image?\"},{\"type\":\"input_image\",\"image_url\":\"https://openai-documentation.vercel.app/images/cat_and_otter.png\"}]}]"
          "}";

          char auth_header[256];
          snprintf(auth_header, sizeof(auth_header), "Authorization: Bearer %s", api_key);

          struct curl_slist *headers = NULL;
          headers = curl_slist_append(headers, auth_header);
          headers = curl_slist_append(headers, "Content-Type: application/json");

          curl_easy_setopt(curl, CURLOPT_URL, url);
          curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
          curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

          res = curl_easy_perform(curl);

          if(res != CURLE_OK) {
              fprintf(stderr, "curl_easy_perform() failed: %s\n",
                      curl_easy_strerror(res));
          }

          curl_slist_free_all(headers);
          curl_easy_cleanup(curl);
      }

      curl_global_cleanup();
      return 0;
  }
  ```

  ```objectivec Objective-C theme={null}
  #import <Foundation/Foundation.h>

  int main(int argc, const char * argv[]) {
      @autoreleasepool {
          NSURL *url = [NSURL URLWithString:@"https://gccai.heqingsong.uk/v1/responses"];
          NSString *apiKey = [NSProcessInfo processInfo].environment[@"OPENAI_API_KEY"];

          NSDictionary *payload = @{
              @"model": @"gpt-5.2-pro",
              @"input": @[
                  @{
                      @"role": @"user",
                      @"content": @[
                          @{
                              @"type": @"input_text",
                              @"text": @"What is in this image?"
                          },
                          @{
                              @"type": @"input_image",
                              @"image_url": @"https://openai-documentation.vercel.app/images/cat_and_otter.png"
                          }
                      ]
                  }
              ]
          };

          NSError *error;
          NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
                                                            options:0
                                                              error:&error];

          NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
          [request setHTTPMethod:@"POST"];
          [request setValue:[NSString stringWithFormat:@"Bearer %@", apiKey]
              forHTTPHeaderField:@"Authorization"];
          [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
          [request setHTTPBody:jsonData];

          NSURLSessionDataTask *task = [[NSURLSession sharedSession]
              dataTaskWithRequest:request
              completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                  if (error) {
                      NSLog(@"Error: %@", error);
                      return;
                  }
                  NSString *result = [[NSString alloc] initWithData:data
                                                          encoding:NSUTF8StringEncoding];
                  NSLog(@"%@", result);
              }];

          [task resume];
          [[NSRunLoop mainRunLoop] run];
      }
      return 0;
  }
  ```

  ```ocaml OCaml theme={null}
  (* Requires cohttp and yojson libraries *)
  open Lwt
  open Cohttp
  open Cohttp_lwt_unix

  let url = "https://gccai.heqingsong.uk/v1/responses"
  let api_key = Sys.getenv "OPENAI_API_KEY"

  let payload = {|{
    "model": "gpt-5.2-pro",
    "input": [
      {
        "role": "user",
        "content": [
          {
            "type": "input_text",
            "text": "What is in this image?"
          },
          {
            "type": "input_image",
            "image_url": "https://openai-documentation.vercel.app/images/cat_and_otter.png"
          }
        ]
      }
    ]
  }|}

  let () =
    let headers = Header.init ()
      |> fun h -> Header.add h "Authorization" ("Bearer " ^ api_key)
      |> fun h -> Header.add h "Content-Type" "application/json"
    in
    let body = Cohttp_lwt.Body.of_string payload in

    let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
      body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
      print_endline body_str
    in
    Lwt_main.run response
  ```

  ```dart Dart theme={null}
  import 'dart:convert';
  import 'dart:io';
  import 'package:http/http.dart' as http;

  void main() async {
    final url = Uri.parse('https://gccai.heqingsong.uk/v1/responses');
    final apiKey = Platform.environment['OPENAI_API_KEY'];

    final payload = {
      'model': 'gpt-5.2-pro',
      'input': [
        {
          'role': 'user',
          'content': [
            {
              'type': 'input_text',
              'text': 'What is in this image?'
            },
            {
              'type': 'input_image',
              'image_url': 'https://openai-documentation.vercel.app/images/cat_and_otter.png'
            }
          ]
        }
      ]
    };

    final response = await http.post(
      url,
      headers: {
        'Authorization': 'Bearer $apiKey',
        'Content-Type': 'application/json',
      },
      body: jsonEncode(payload),
    );

    print(response.body);
  }
  ```

  ```r R theme={null}
  library(httr)
  library(jsonlite)

  url <- "https://gccai.heqingsong.uk/v1/responses"
  api_key <- Sys.getenv("OPENAI_API_KEY")

  payload <- list(
    model = "gpt-5.2-pro",
    input = list(
      list(
        role = "user",
        content = list(
          list(
            type = "input_text",
            text = "What is in this image?"
          ),
          list(
            type = "input_image",
            image_url = "https://openai-documentation.vercel.app/images/cat_and_otter.png"
          )
        )
      )
    )
  )

  response <- POST(
    url,
    add_headers(
      Authorization = paste("Bearer", api_key),
      `Content-Type` = "application/json"
    ),
    body = toJSON(payload, auto_unbox = TRUE),
    encode = "raw"
  )

  cat(content(response, "text"))
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "code": 200,
    "data": {
      "id": "resp-9876543210",
      "object": "response",
      "created": 1677652288,
      "model": "gpt-5.2-pro",
      "choices": [
        {
          "index": 0,
          "message": {
            "role": "assistant",
            "content": "This image shows a cat and an otter. They appear to be interacting with each other in a very cute and heartwarming scene. The cat and otter seem to be getting along well."
          },
          "finish_reason": "stop"
        }
      ],
      "usage": {
        "prompt_tokens": 156,
        "completion_tokens": 45,
        "total_tokens": 201
      }
    }
  }
  ```

  ```json 400 theme={null}
  {
    "error": {
      "code": 400,
      "message": "Invalid request parameters",
      "type": "invalid_request_error"
    }
  }
  ```

  ```json 401 theme={null}
  {
    "error": {
      "code": 401,
      "message": "Authentication failed, please check your API key",
      "type": "authentication_error"
    }
  }
  ```

  ```json 402 theme={null}
  {
    "error": {
      "code": 402,
      "message": "Insufficient account balance, please top up and try again",
      "type": "payment_required"
    }
  }
  ```

  ```json 403 theme={null}
  {
    "error": {
      "code": 403,
      "message": "Access forbidden, you do not have permission to access this resource",
      "type": "permission_error"
    }
  }
  ```

  ```json 429 theme={null}
  {
    "error": {
      "code": 429,
      "message": "Too many requests, please try again later",
      "type": "rate_limit_error"
    }
  }
  ```

  ```json 500 theme={null}
  {
    "error": {
      "code": 500,
      "message": "Internal server error, please try again later",
      "type": "server_error"
    }
  }
  ```

  ```json 502 theme={null}
  {
    "error": {
      "code": 502,
      "message": "Gateway error, server temporarily unavailable",
      "type": "bad_gateway"
    }
  }
  ```
</ResponseExample>

## Autorisations

<ParamField header="Authorization" type="string" required>
  \##Toutes les API nécessitent une authentification par Bearer Token##

  Obtenir la clé API :

  Rendez-vous sur la [page de gestion des clés API](https://gccai.heqingsong.uk/keys) pour obtenir votre clé API

  Ajouter dans l'en-tête de la requête :

  ```
  Authorization: Bearer YOUR_API_KEY
  ```
</ParamField>

## Body

<ParamField body="model" type="string" required default="gpt-5.2-pro">
  Nom du modèle

  Les modèles pris en charge incluent :

  * `gpt-5.2-pro`
  * `gpt-5.2-codex`
  * D'autres modèles à venir prochainement...
</ParamField>

<ParamField body="input" type="array" required>
  Liste des contenus d'entrée

  Tableau d'entrée, chaque élément contient les champs `role` et `content`.

  **💡 Remplissage rapide (zone « Try it ») :**

  1. Cliquez sur « + Add an item » pour ajouter un élément d'entrée
  2. Saisissez dans `role` : `user` (message utilisateur), `assistant` (réponse de l'IA) ou `system` (invite système)
  3. `content` ajouter des blocs de contenu (peuvent inclure du texte et des images)

  <Expandable title="Détails des champs">
    <ParamField body="role" type="string" required default="user">
      Type de rôle

      Options : `user` (message utilisateur), `assistant` (réponse de l'IA, pour conversations multi-tours), `system` (invite système, pour définir le comportement de l'IA)
    </ParamField>

    <ParamField body="content" type="array" required>
      Tableau de contenu

      Prend en charge plusieurs types de blocs de contenu, peut inclure du texte et des images.

      <Expandable title="Types de blocs de contenu">
        <ParamField body="type" type="string" required>
          Type de contenu

          Options :

          * `input_text` : entrée texte
          * `input_image` : entrée image
        </ParamField>

        <ParamField body="text" type="string">
          Contenu textuel

          Utilisé lorsque `type` est `input_text`, indiquez le contenu textuel
        </ParamField>

        <ParamField body="image_url" type="string">
          URL de l'image

          Utilisé lorsque `type` est `input_image`, indiquez l'URL de l'image ou l'encodage Base64

          Prend en charge deux formats :

          **1. URL complète de l'image**

          * URL d'image publiquement accessible (http\:// ou https\://)
          * Exemple : `https://example.com/image.jpg`

          **2. Format encodé en Base64**

          * **Vous devez utiliser le format Data URI complet**
          * Format : `data:image/{format};base64,{base64_data}`
          * Formats d'image pris en charge : jpeg, png, gif, webp
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="temperature" type="number">
  Contrôle l'aléa de la sortie, plage 0–2

  * Les valeurs plus faibles (par ex. 0.2) rendent la sortie plus déterministe
  * Les valeurs plus élevées (par ex. 1.8) rendent la sortie plus aléatoire

  Par défaut : 1.0
</ParamField>

<ParamField body="max_tokens" type="integer">
  Nombre maximal de tokens à générer

  Les différents modèles ont des limites maximales différentes, veuillez consulter la documentation du modèle concerné
</ParamField>

<ParamField body="stream" type="boolean">
  Utiliser ou non la sortie en streaming

  * `true` : réponse en streaming (format SSE)
  * `false` : renvoyer la réponse complète en une seule fois

  Par défaut : false
</ParamField>

<ParamField body="top_p" type="number">
  Paramètre d'échantillonnage par noyau (nucleus sampling), plage 0–1

  Contrôle la diversité du texte généré, recommandé comme alternative à temperature

  Par défaut : 1.0
</ParamField>

<ParamField body="tools" type="array">
  Liste d'outils pour étendre les capacités du modèle

  Types d'outils pris en charge :

  * **Recherche web** (`web_search`) : recherche d'informations sur Internet en temps réel
  * **Recherche de fichiers** (`file_search`) : recherche dans le contenu des fichiers téléversés
  * **Function Calling** (`function`) : appel de fonctions personnalisées
  * **MCP distant** (`remote_mcp`) : connexion à des services distants Model Context Protocol

  Exemple : `[{"type": "web_search"}]`
</ParamField>

## Response

<ResponseField name="id" type="string">
  Identifiant unique de la réponse
</ResponseField>

<ResponseField name="object" type="string">
  Type d'objet, fixé à `response`
</ResponseField>

<ResponseField name="created" type="integer">
  Horodatage de création
</ResponseField>

<ResponseField name="model" type="string">
  Nom du modèle réellement utilisé
</ResponseField>

<ResponseField name="choices" type="array">
  Liste des réponses générées

  <Expandable title="Propriétés">
    <ResponseField name="index" type="integer">
      Index du choix
    </ResponseField>

    <ResponseField name="message" type="object">
      Contenu du message

      <Expandable title="Propriétés">
        <ResponseField name="role" type="string">
          Type de rôle (assistant)
        </ResponseField>

        <ResponseField name="content" type="string">
          Contenu textuel généré
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="finish_reason" type="string">
      Raison de la fin

      Valeurs possibles :

      * `stop` — complétion naturelle
      * `length` — longueur maximale atteinte
      * `content_filter` — filtrage de contenu
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="usage" type="object">
  Statistiques d'utilisation des tokens

  <Expandable title="Propriétés">
    <ResponseField name="prompt_tokens" type="integer">
      Nombre de tokens en entrée
    </ResponseField>

    <ResponseField name="completion_tokens" type="integer">
      Nombre de tokens en sortie
    </ResponseField>

    <ResponseField name="total_tokens" type="integer">
      Nombre total de tokens
    </ResponseField>
  </Expandable>
</ResponseField>

## Exemples d'utilisation

### Entrée texte uniquement

```json theme={null}
{
  "model": "gpt-5.2-pro",
  "input": [
    {
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": "Hello, introduce artificial intelligence"
        }
      ]
    }
  ]
}
```

### Utilisation de l'outil de recherche web

```json theme={null}
{
  "model": "gpt-5.2-pro",
  "tools": [{"type": "web_search"}],
  "input": "What positive news is there today?"
}
```

```bash cURL Example theme={null}
curl "https://gccai.heqingsong.uk/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <token>" \
    -d '{
        "model": "gpt-5.2-pro",
        "tools": [{"type": "web_search"}],
        "input": "What positive news is there today?"
    }'
```

### Compréhension d'images

```json theme={null}
{
  "model": "gpt-5.2-pro",
  "input": [
    {
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": "Describe this image"
        },
        {
          "type": "input_image",
          "image_url": "https://example.com/image.jpg"
        }
      ]
    }
  ]
}
```

### Analyse multi-images

```json theme={null}
{
  "model": "gpt-5.2-pro",
  "input": [
    {
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": "Compare the similarities and differences of these two images"
        },
        {
          "type": "input_image",
          "image_url": "https://example.com/image1.jpg"
        },
        {
          "type": "input_image",
          "image_url": "https://example.com/image2.jpg"
        }
      ]
    }
  ]
}
```

### Image encodée en Base64

```json theme={null}
{
  "model": "gpt-5.2-pro",
  "input": [
    {
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": "Analyze this image"
        },
        {
          "type": "input_image",
          "image_url": "data:image/jpeg;base64,/9j/4AAQSkZJRg..."
        }
      ]
    }
  ]
}
```

### Utilisation de l'outil de recherche de fichiers

```json theme={null}
{
  "model": "gpt-5.2-pro",
  "tools": [{"type": "file_search"}],
  "input": "Based on uploaded documents, summarize the company's quarterly performance"
}
```

### Utilisation du Function Calling

```json theme={null}
{
  "model": "gpt-5.2-pro",
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get weather information for a specified city",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {
              "type": "string",
              "description": "City name, e.g.: Beijing"
            },
            "unit": {
              "type": "string",
              "enum": ["celsius", "fahrenheit"],
              "description": "Temperature unit"
            }
          },
          "required": ["city"]
        }
      }
    }
  ],
  "input": "What's the weather like in Beijing today?"
}
```

### Utilisation du MCP distant

```json theme={null}
{
  "model": "gpt-5.2-pro",
  "tools": [
    {
      "type": "remote_mcp",
      "remote_mcp": {
        "url": "https://mcp.example.com/api",
        "auth_token": "your_mcp_token"
      }
    }
  ],
  "input": "Query user information in the database"
}
```

### Combinaison de plusieurs outils

```json theme={null}
{
  "model": "gpt-5.2-pro",
  "tools": [
    {"type": "web_search"},
    {"type": "file_search"},
    {
      "type": "function",
      "function": {
        "name": "calculate",
        "description": "Perform mathematical calculations",
        "parameters": {
          "type": "object",
          "properties": {
            "expression": {
              "type": "string",
              "description": "Mathematical expression"
            }
          },
          "required": ["expression"]
        }
      }
    }
  ],
  "input": "Search for the latest Bitcoin price and calculate the total value of 100 Bitcoins"
}
```

## Spécifications des types de contenu

### input\_text

Type d'entrée texte

**Propriétés :**

* `type` : fixé à `"input_text"`
* `text` : contenu textuel (chaîne)

### input\_image

Type d'entrée image

**Propriétés :**

* `type` : fixé à `"input_image"`
* `image_url` : URL de l'image ou Data URI encodé en Base64

**Formats d'image pris en charge :**

* JPEG
* PNG
* GIF
* WebP

**Limites de taille d'image :**

* Taille maximale du fichier : 20 Mo
* Résolution recommandée : pas plus de 2048x2048 pixels

## Détails d'utilisation des outils

### Recherche web

L'outil de recherche web permet au modèle d'accéder aux informations Internet en temps réel.

**Exemple de configuration :**

```json theme={null}
{
  "tools": [{"type": "web_search"}]
}
```

**Cas d'usage :**

* Consulter les dernières actualités et événements en cours
* Obtenir des données en temps réel (actions, météo, taux de change, etc.)
* Rechercher la dernière documentation technique
* Vérifier des informations factuelles

### Recherche de fichiers

L'outil de recherche de fichiers permet au modèle de rechercher des informations pertinentes dans les documents téléversés.

**Exemple de configuration :**

```json theme={null}
{
  "tools": [{"type": "file_search"}]
}
```

**Cas d'usage :**

* Analyser les documents internes de l'entreprise
* Rechercher dans les spécifications techniques et manuels
* Requêtes sur les contrats et documents juridiques
* Systèmes de questions-réponses sur base de connaissances

### Function Calling

Définissez des fonctions personnalisées pour permettre au modèle d'appeler des API externes ou d'effectuer des opérations spécifiques.

**Exemple de configuration complet :**

```json theme={null}
{
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_stock_price",
        "description": "Get real-time stock price",
        "parameters": {
          "type": "object",
          "properties": {
            "symbol": {
              "type": "string",
              "description": "Stock symbol, e.g.: AAPL"
            },
            "currency": {
              "type": "string",
              "enum": ["USD", "CNY"],
              "description": "Currency unit",
              "default": "USD"
            }
          },
          "required": ["symbol"]
        }
      }
    }
  ]
}
```

**Description des paramètres :**

* `name` : nom de la fonction (obligatoire)
* `description` : description de la fonction (obligatoire)
* `parameters` : définition des paramètres au format JSON Schema
  * `type` : type de paramètre
  * `properties` : définitions des propriétés des paramètres
  * `required` : liste des paramètres obligatoires

**Cas d'usage :**

* Appel d'API tierces
* Exécution de requêtes en base de données
* Déclenchement de processus métier
* Intégration avec des systèmes internes

### MCP distant

Connexion à des services distants Model Context Protocol (MCP) pour étendre les capacités du modèle.

**Exemple de configuration :**

```json theme={null}
{
  "tools": [
    {
      "type": "remote_mcp",
      "remote_mcp": {
        "url": "https://your-mcp-server.com/api",
        "auth_token": "your_auth_token",
        "timeout": 30
      }
    }
  ]
}
```

**Description des paramètres :**

* `url` : adresse du serveur MCP (obligatoire)
* `auth_token` : jeton d'authentification (optionnel)
* `timeout` : délai d'expiration en secondes, par défaut 30 secondes

**Cas d'usage :**

* Connexion à des services IA d'entreprise
* Utilisation de modèles spécifiques à un domaine
* Accès à des sources de données protégées
* Intégration de systèmes IA distribués

## Format de réponse lors de l'utilisation d'outils

Lorsque le modèle utilise des outils, le format de réponse inclut les informations d'appel d'outil :

```json theme={null}
{
  "id": "resp-123456",
  "object": "response",
  "created": 1677652288,
  "model": "gpt-5.2-pro",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"city\": \"Beijing\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ]
}
```

**Flux de travail de l'appel d'outil :**

1. Le modèle reçoit l'entrée utilisateur
2. Analyse si des outils sont nécessaires
3. Si oui, renvoie une requête d'appel d'outil
4. Le client exécute l'appel d'outil
5. Renvoie les résultats de l'outil au modèle
6. Le modèle génère la réponse finale

## Remarques importantes

1. **Exigences relatives aux URL d'images** :
   * Doit être une URL publiquement accessible
   * Ou utiliser le format Data URI encodé en Base64

2. **Facturation des tokens** :
   * Les images consomment des tokens selon leur résolution
   * Les images en haute résolution sont automatiquement redimensionnées pour optimiser les coûts
   * Les appels d'outils consomment également des tokens supplémentaires

3. **Ordre du contenu** :
   * L'ordre des éléments dans le tableau content influence la compréhension du modèle
   * Il est recommandé de placer d'abord les instructions textuelles, puis les images

4. **Combinaisons multimodales** :
   * Plusieurs textes et images peuvent être mélangés dans une même requête
   * Prise en charge des conversations multi-tours avec cohérence du contexte

5. **Limitations d'utilisation des outils** :
   * Lors de l'utilisation simultanée de plusieurs outils, le modèle sélectionne intelligemment l'outil le plus approprié
   * Le function calling nécessite des définitions de fonctions et des descriptions de paramètres claires
   * Les résultats de la recherche web peuvent être limités par région et par période

6. **Compatibilité API** :
   * Entièrement compatible avec le format de l'API OpenAI Responses
   * Migration transparente du code OpenAI existant
   * Prend en charge toutes les fonctionnalités d'extension d'outils OpenAI