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

# Crear Respuesta

> Crea una respuesta usando el formato de la Responses API de OpenAI

La Responses API es la API de conversación con estado más reciente de OpenAI. TokenLab admite este formato como una vía opcional avanzada para modelos compatibles; use `POST /v1/chat/completions` como la ruta predeterminada compatible con OpenAI a menos que necesite explícitamente el comportamiento específico de Responses.

## Cuerpo de la solicitud

<ParamField body="model" type="string" required>
  ID del modelo a usar. Vea [Modelos](https://tokenlab.sh/es/models) para las opciones disponibles.
</ParamField>

<ParamField body="input" type="array" required>
  Una lista de elementos de entrada que componen la conversación.

  Cada elemento puede ser:

  * `message`: Un mensaje de la conversación con role y content
  * `function_call`: Una solicitud de llamada a función
  * `function_call_output`: Salida de una llamada a función

  Para entrada multimodal, `message.content` puede ser una cadena de texto simple o un arreglo de bloques de contenido. Para modelos con capacidad de imágenes, como las variantes GPT-5.4, pase las imágenes como bloques `input_image` en lugar de incrustar URLs o cadenas Base64 directamente en texto plano.

  Ejemplos de bloques de contenido:

  * `{ "type": "input_text", "text": "Describe this image" }`
  * `{ "type": "input_image", "image_url": "https://example.com/image.jpg" }`
  * `{ "type": "input_image", "image_url": "data:image/png;base64,..." }`
</ParamField>

<ParamField body="instructions" type="string">
  Instrucciones del sistema para el modelo (equivalente al mensaje del sistema).
</ParamField>

<ParamField body="max_output_tokens" type="integer">
  Número máximo de tokens a generar.
</ParamField>

<ParamField body="temperature" type="number" default="1">
  Temperatura de muestreo entre 0 y 2.
</ParamField>

<ParamField body="tools" type="array">
  Una lista de herramientas que el modelo puede invocar.

  Para herramientas alojadas `image_generation` que usan el modelo de herramienta de imagen predeterminado o establecen explícitamente `model: "gpt-image-2"`, TokenLab elimina `input_fidelity` antes de reenviar la solicitud porque GPT Image 2 ya trata las entradas de imagen con alta fidelidad. No envíes `background: "transparent"` para esta herramienta; TokenLab no lo elimina silenciosamente porque eso cambia la semántica de salida.
</ParamField>

<ParamField body="stream" type="boolean" default="false">
  Si es true, devuelve un flujo de eventos.
</ParamField>

<ParamField body="previous_response_id" type="string">
  ID de una respuesta previa desde la cual continuar la conversación.
</ParamField>

<ParamField body="store" type="boolean" default="true">
  Si se debe almacenar la respuesta para recuperación posterior.
</ParamField>

<ParamField body="metadata" type="object">
  Metadatos para adjuntar a la respuesta con fines de seguimiento.
</ParamField>

<ParamField body="text" type="object">
  Opciones de configuración de generación de texto. El comportamiento de `text.format` depende del modelo seleccionado y de la ruta enrutada; no está garantizado de forma uniforme en todos los modelos.
</ParamField>

<ParamField body="parallel_tool_calls" type="boolean" default="true">
  Si se permiten múltiples llamadas a herramientas en paralelo.
</ParamField>

<ParamField body="top_p" type="number">
  Parámetro de muestreo por núcleo (nucleus sampling) (0-1).
</ParamField>

<ParamField body="reasoning" type="object">
  Configuración de razonamiento para modelos con capacidades de razonamiento, como las variantes de la familia GPT-5.

  * `effort` (string): Nivel de esfuerzo de razonamiento (`low`, `medium`, `high`)
</ParamField>

## Respuesta

<ResponseField name="id" type="string">
  Identificador único de la respuesta.
</ResponseField>

<ResponseField name="object" type="string">
  Siempre `response`.
</ResponseField>

<ResponseField name="created" type="integer">
  Marca de tiempo Unix de cuando se creó la respuesta.
</ResponseField>

<ResponseField name="output" type="array">
  Lista de elementos de salida generados por el modelo.
</ResponseField>

<ResponseField name="usage" type="object">
  Estadísticas de uso de tokens.
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.tokenlab.sh/v1/responses" \
    -H "Authorization: Bearer sk-your-api-key" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-4o",
      "input": [
        {"type": "message", "role": "user", "content": "Hello!"}
      ],
      "max_output_tokens": 1000
    }'
  ```

  ```python Python theme={null}
  from openai import OpenAI

  client = OpenAI(
      api_key="sk-your-api-key",
      base_url="https://api.tokenlab.sh/v1"
  )

  response = client.responses.create(
      model="gpt-4o",
      input=[
          {"type": "message", "role": "user", "content": "Hello!"}
      ],
      max_output_tokens=1000
  )

  print(response.output)
  ```

  ```javascript JavaScript theme={null}
  import OpenAI from 'openai';

  const client = new OpenAI({
    apiKey: 'sk-your-api-key',
    baseURL: 'https://api.tokenlab.sh/v1'
  });

  const response = await client.responses.create({
    model: 'gpt-4o',
    input: [
      { type: 'message', role: 'user', content: 'Hello!' }
    ],
    max_output_tokens: 1000
  });

  console.log(response.output);
  ```

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

  import (
      "bytes"
      "encoding/json"
      "fmt"
      "net/http"
  )

  func main() {
      payload := map[string]interface{}{
          "model": "gpt-4o",
          "input": []map[string]interface{}{
              {"type": "message", "role": "user", "content": "Hello!"},
          },
          "max_output_tokens": 1000,
      }
      body, _ := json.Marshal(payload)

      req, _ := http.NewRequest("POST", "https://api.tokenlab.sh/v1/responses", bytes.NewBuffer(body))
      req.Header.Set("Authorization", "Bearer sk-your-api-key")
      req.Header.Set("Content-Type", "application/json")

      client := &http.Client{}
      resp, _ := client.Do(req)
      defer resp.Body.Close()

      var result map[string]interface{}
      json.NewDecoder(resp.Body).Decode(&result)
      fmt.Println(result["output"])
  }
  ```

  ```php PHP theme={null}
  <?php
  $ch = curl_init('https://api.tokenlab.sh/v1/responses');

  curl_setopt_array($ch, [
      CURLOPT_RETURNTRANSFER => true,
      CURLOPT_POST => true,
      CURLOPT_HTTPHEADER => [
          'Content-Type: application/json',
          'Authorization: Bearer sk-your-api-key'
      ],
      CURLOPT_POSTFIELDS => json_encode([
          'model' => 'gpt-4o',
          'input' => [
              ['type' => 'message', 'role' => 'user', 'content' => 'Hello!']
          ],
          'max_output_tokens' => 1000
      ])
  ]);

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

  $data = json_decode($response, true);
  print_r($data['output']);
  ```

  ## Ejemplo de entrada de visión

  Use modelos con capacidad para imágenes colocando las imágenes dentro de `message.content` como bloques `input_image`. El valor de `image_url` puede ser una URL pública o una URL de datos Base64.

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

  ```json theme={null}
  {
    "model": "gpt-5.4",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [
          {
            "type": "input_text",
            "text": "Please describe this image."
          },
          {
            "type": "input_image",
            "image_url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ..."
          }
        ]
      }
    ]
  }
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "resp_abc123",
    "object": "response",
    "created": 1706000000,
    "model": "gpt-4o",
    "output": [
      {
        "type": "message",
        "role": "assistant",
        "content": [
          {"type": "text", "text": "Hello! How can I help you today?"}
        ]
      }
    ],
    "usage": {
      "input_tokens": 10,
      "output_tokens": 12,
      "total_tokens": 22
    }
  }
  ```
</ResponseExample>