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

# Usa GPT 6.1 Sol con Comfy Router

> Llama a openai/gpt-6.1-sol a través de Comfy Router: endpoint, forma de la solicitud y respuesta que devuelve Router.

Referencia de API para `openai/gpt-6.1-sol`, servida por Comfy Router de OpenAI.

**Entrada:** Texto, Imagen · **Salida:** Texto

## Inicio rápido

Crea una clave en [tu espacio de trabajo de Comfy](https://platform.comfy.org/profile/api-keys?onboarding=router) y expórtala como `COMFY_API_KEY`. Los fragmentos de Python y TypeScript usan los SDK de Comfy (`pip install comfy-sdk` y `npm install @comfyorg/sdk`); el fragmento de cURL es la misma llamada sobre HTTP directo.

**ID del modelo:** `openai/gpt-6.1-sol`

**Endpoint:** `POST https://api.comfy.org/v2/models/openai/gpt-6.1-sol`

> [tab] Esperar el resultado
>
> ```python Python theme={null}
> from comfy_sdk import Comfy
>
> # Lee COMFY_API_KEY del entorno.
> # El SDK crea automáticamente una clave de idempotencia y la reutiliza para los reintentos automáticos.
> with Comfy() as client:
>     result = client.models.run(
>         "openai/gpt-6.1-sol",
>         {
>             "input": "Reply with the single word: ok",
>             "max_output_tokens": 1024,
>         },
>     )
>
> print(result)
> ```
>
> ```typescript TypeScript theme={null}
> import { comfy } from "@comfyorg/sdk";
>
> // Lee COMFY_API_KEY del entorno.
> // El SDK crea automáticamente una clave de idempotencia y la reutiliza para los reintentos automáticos.
> const { data } = await comfy.models.run("openai/gpt-6.1-sol", {
>   input: "Reply with the single word: ok",
>   max_output_tokens: 1024,
> });
>
> console.log(data);
> ```
>
> ```bash cURL theme={null}
> curl https://api.comfy.org/v2/models/openai/gpt-6.1-sol \
>   -H "X-API-Key: $COMFY_API_KEY" \
>   -H "Idempotency-Key: $(uuidgen)" \
>   -H "Content-Type: application/json" \
>   -d "{\"input\": \"Reply with the single word: ok\", \"max_output_tokens\": 1024}"
> ```

> [tab] Enviar a la cola y recoger más tarde
>
> El mismo cuerpo, enviado a `POST https://api.comfy.org/v2/models/openai/gpt-6.1-sol/requests`. Router responde `201` con un `request_id` en cuanto se admite la ejecución, y el resultado se recoge cuando está listo, desde este proceso o desde otro. [Queued delivery](https://docs.comfy.org/es/development/comfy-router/queue.md) explica el estado, la cancelación y la recogida del resultado.
>
> ```python Python theme={null}
> import asyncio
> from comfy_sdk import AsyncComfy
>
> # Lee COMFY_API_KEY del entorno.
> # Cada llamada a submit() genera su propia Idempotency-Key y la reutiliza para los reintentos automáticos.
> async def main():
>     async with AsyncComfy() as client:
>         handle = await client.models.submit(
>             "openai/gpt-6.1-sol",
>             {
>                 "input": "Reply with the single word: ok",
>                 "max_output_tokens": 1024,
>             },
>         )
>         print("request_id:", handle.request_id)  # junto con el ID del modelo, es todo lo que necesita otro proceso
>
>         # Consulta hasta que la solicitud se complete, esperando el Retry-After que indica el servidor.
>         async for update in handle.iter_events():
>             print(update.status, update.queue_position)
>
>         # La carga útil propia del proveedor, el mismo valor que devuelve models.run().
>         # Una solicitud que falló o se canceló lanza aquí el error tipado de Router.
>         result = await handle.get()
>
>     print(result)
>
> asyncio.run(main())
> ```
>
> ```typescript TypeScript theme={null}
> import { comfy } from "@comfyorg/sdk";
>
> // Lee COMFY_API_KEY del entorno.
> // Cada llamada a submit() genera su propia Idempotency-Key y la reutiliza para los reintentos automáticos.
> const handle = await comfy.models.submit("openai/gpt-6.1-sol", {
>   input: "Reply with the single word: ok",
>   max_output_tokens: 1024,
> });
> console.log("requestId:", handle.requestId); // junto con el ID del modelo, es todo lo que necesita otro proceso
>
> // Consulta hasta que la solicitud se complete, esperando el Retry-After que indica el servidor.
> for await (const update of handle.events()) {
>   console.log(update.status, update.queuePosition);
> }
>
> // El mismo resultado que devuelve models.run(). Una solicitud que falló o se canceló se rechaza aquí.
> const result = await handle.get();
>
> console.log(result.data);
> ```
>
> ```bash cURL theme={null}
> # 1. Envía. Router responde 201 con request_id, status_url, response_url y cancel_url.
> curl https://api.comfy.org/v2/models/openai/gpt-6.1-sol/requests \
>   -H "X-API-Key: $COMFY_API_KEY" \
>   -H "Idempotency-Key: $(uuidgen)" \
>   -H "Content-Type: application/json" \
>   -d "{\"input\": \"Reply with the single word: ok\", \"max_output_tokens\": 1024}"
>
> # 2. Consulta hasta que el estado sea COMPLETED, esperando los segundos de Retry-After que indica cada respuesta.
> REQUEST_ID="<request_id from the 201 body>"
> curl -i https://api.comfy.org/v2/models/openai/gpt-6.1-sol/requests/$REQUEST_ID/status \
>   -H "X-API-Key: $COMFY_API_KEY"
>
> # 3. Recoge. 200 con la salida nativa del modelo, 202 con el cuerpo de estado mientras aún se ejecuta.
> curl https://api.comfy.org/v2/models/openai/gpt-6.1-sol/requests/$REQUEST_ID \
>   -H "X-API-Key: $COMFY_API_KEY"
> ```

## Esquema

### Entrada

**include** `string[]`

Datos de salida adicionales para incluir en la respuesta del modelo.

**input** `string | object[]` *required*

Entradas de texto, imagen o archivo para el modelo, que se usan para generar una respuesta. El único campo de este contrato que Router no puede suministrar, y la única entrada en `required` a continuación.

**instructions** `string`

Inserta un mensaje de sistema (o de desarrollador) como el primer elemento en el contexto del modelo.

**max\_output\_tokens** `integer`

Un límite superior para la cantidad de tokens generados en una respuesta, incluidos los tokens de salida visibles y los tokens de razonamiento. En un id de razonamiento, este límite superior se comparte con los tokens de razonamiento ocultos, así que un valor pequeño puede consumir todo el presupuesto antes de que se genere cualquier texto visible. Por eso los casos de prueba de humo de razonamiento envían 1024, mientras que los de chat envían 16.

Rango: `1` a `…`

**model** `string`

Identificador de modelo de OpenAI. En Comfy Router este campo es OPCIONAL y Router lo rellena desde el segmento de ruta `{model}`; un `null` explícito se reemplaza de la misma forma. Se rechaza cualquier valor que no coincida con la ruta.

**parallel\_tool\_calls** `boolean`

Si se permite que el modelo ejecute llamadas a herramientas en paralelo.

**previous\_response\_id** `string`

El ID de una respuesta anterior, para conversaciones de varios turnos.

**reasoning** `object`

SOLO PARA EL NIVEL DE RAZONAMIENTO. Configuración para modelos de razonamiento, p. ej. `{"effort": "medium"}`. Router lo reenvía sin cambios; consulta la guía de razonamiento de OpenAI para conocer las claves aceptadas. Un id del nivel de chat lo ignora.

**store** `boolean`

Si OpenAI almacena la respuesta generada para recuperarla más tarde.

**stream** `boolean`

Se declara para que no se rechace a quien lo envíe, pero es INERTE en esta superficie: Router lo FIJA en `false` antes del despacho, porque captura la respuesta del proveedor en lugar de retransmitir un `text/event-stream`, que Router no puede decodificar. Por eso OpenAI facturaría una generación en streaming y nadie la contabilizaría. Ninguna superficie de Comfy entrega el stream: la entrada `POST /proxy/openai/v1/responses` de v1 rechaza `stream: true` con un 400 y nunca reenvía la solicitud al proveedor, así que omite el campo o envía `false` en cualquiera de las dos superficies y lee la respuesta completada como un solo cuerpo JSON.

**temperature** `number`

Temperatura de muestreo. SOLO PARA EL NIVEL DE CHAT: los ids de razonamiento de la serie o (`o1`, `o1-pro`, `o3`, `o4-mini`) rechazan este parámetro en OpenAI. Router no lo rechaza por ellos (consulta la nota de este componente sobre por qué los dos niveles comparten un esquema), así que OpenAI responde con su propio error a una llamada de razonamiento que lo envíe.

Rango: `0` a `2`

**text** `object`

Configuración del formato de salida, p. ej. `{"format": {"type": "json_schema", ...}}` para Structured Outputs. Router lo reenvía sin cambios.

**tool\_choice** `string | object`

Cómo debe seleccionar el modelo qué herramienta usar. Ya sea un modo de tipo cadena o un objeto que nombra una herramienta.

**tools** `object[]`

Definiciones de herramientas que el modelo puede llamar. Router no restringe la taxonomía de herramientas; consulta la referencia de la API Responses de OpenAI para conocer las formas aceptadas.

**top\_p** `number`

Corte del muestreo de núcleo. SOLO PARA EL NIVEL DE CHAT, en los mismos términos que `temperature`.

Rango: `0` a `1`

**truncation** `string`

Estrategia de truncamiento cuando el contexto supera la ventana del modelo. El enum SÍ se aplica aquí, a diferencia de los tres vocabularios anteriores, porque estos dos valores son el conjunto completo que documenta OpenAI y no ha aumentado. Un `null` explícito todavía se acepta, en los mismos términos que los campos anteriores.

Valores posibles: `auto`, `disabled`

**usage** `object`

Estructura de uso de tokens. Está presente en este contrato porque la operación de v1 la declara en el cuerpo de la solicitud; OpenAI la completa en la RESPUESTA, así que un llamador no tiene motivo para enviarla.

Generado a partir del esquema que Router sirve en `GET /v2/models/openai/gpt-6.1-sol/openapi.json`, el mismo documento con el que valida una llamada antes de que la solicitud llegue al proveedor.#

### Salida

**instructions** `string`

Inserta un mensaje de sistema (o de desarrollador) como el primer elemento en el contexto del modelo.

Cuando lo uses junto con `previous_response_id`, las instrucciones de una respuesta anterior no se trasladarán a la siguiente respuesta. Esto facilita reemplazar los mensajes de sistema (o de desarrollador) en respuestas nuevas.

**max\_output\_tokens** `integer`

Un límite superior para la cantidad de tokens que puede generar una respuesta, incluidos los tokens de salida visibles y los [tokens de razonamiento](https://platform.openai.com/docs/guides/reasoning).

**model** `string`

El modelo que se usa para generar la respuesta

**temperature** `number` (default: 1)

Controla la aleatoriedad de la respuesta

Rango: `0` a `2`

**top\_p** `number` (default: 1)

Controla la diversidad de la respuesta mediante muestreo de núcleo

Rango: `0` a `1`

**truncation** `string` (default: "disabled")

La estrategia de truncamiento que se usa para la respuesta del modelo.

* `auto`: Si el contexto de esta respuesta y de las anteriores supera el tamaño de la ventana de contexto del modelo, el modelo truncará la respuesta para ajustarla a la ventana de contexto descartando elementos de entrada en medio de la conversación.
* `disabled` (predeterminado): Si una respuesta del modelo supera el tamaño de la ventana de contexto de un modelo, la solicitud fallará con un error 400.

  Valores posibles: `auto`, `disabled`

**previous\_response\_id** `string`

El ID único de la respuesta anterior al modelo. Úsalo para
crear conversaciones de varios turnos. Aprende más sobre el
[estado de la conversación](https://platform.openai.com/docs/guides/conversation-state).

**reasoning** `object`

**Solo para modelos de la serie o**

Opciones de configuración para los
[modelos de razonamiento](https://platform.openai.com/docs/guides/reasoning).

**reasoning.context** `string`

Controla qué elementos de razonamiento se vuelven a mostrar al modelo en turnos posteriores, p. ej., `auto`, `current_turn` o `all_turns`.

**reasoning.effort** `string` (default: "medium")

**Solo para modelos de la serie o**

Limita el esfuerzo dedicado al razonamiento para los
[modelos de razonamiento](https://platform.openai.com/docs/guides/reasoning).
Los valores admitidos actualmente son `low`, `medium` y `high`. Reducir
el esfuerzo de razonamiento puede dar como resultado respuestas más rápidas y menos tokens usados
en razonamiento dentro de una respuesta.

Valores posibles: `low`, `medium`, `high`

**reasoning.generate\_summary** `string`

**Obsoleto:** usa `summary` en su lugar.

Un resumen del razonamiento realizado por el modelo. Esto puede ser
útil para depurar y comprender el proceso de razonamiento del modelo.
Uno de `auto`, `concise` o `detailed`.

Valores posibles: `auto`, `concise`, `detailed`

**reasoning.mode** `string`

El modo de razonamiento usado para la respuesta.

**reasoning.summary** `string`

Un resumen del razonamiento realizado por el modelo. Esto puede ser
útil para depurar y comprender el proceso de razonamiento del modelo.
Uno de `auto`, `concise` o `detailed`.

Valores posibles: `auto`, `concise`, `detailed`

**text** `object`

**text.format** `object`

Un objeto que especifica el formato que el modelo debe generar.

Configurar `{ "type": "json_schema" }` habilita las salidas estructuradas,
lo que garantiza que el modelo coincida con el esquema JSON que proporcionaste. Aprende más en la
[guía de salidas estructuradas](https://platform.openai.com/docs/guides/structured-outputs).

El formato predeterminado es `{ "type": "text" }` sin opciones adicionales.

**No recomendado para gpt-4o y modelos más recientes:**

Configurar `{ "type": "json_object" }` habilita el modo JSON anterior, que
garantiza que el mensaje que genera el modelo sea JSON válido. Se prefiere usar `json_schema`
en los modelos que lo admiten.

**text.verbosity** `string`

Limita la verbosidad de la respuesta del modelo. Uno de `low`, `medium` o `high`.

**tool\_choice** \`\`none`, `auto`, `required` | object`

Cómo debe seleccionar el modelo qué herramienta (o herramientas) usar al generar
una respuesta. Consulta el parámetro `tools` para ver cómo especificar qué herramientas
puede llamar el modelo.

**tools** `object[]`

**background** `boolean`

Indica si la respuesta del modelo se ejecuta en segundo plano.

**billing** `object`

Información de facturación de la respuesta.

**billing.payer** `string`

La parte responsable de pagar por la respuesta.

**completed\_at** `number`

Marca de tiempo Unix (en segundos) de cuándo se completó esta respuesta. Solo está presente cuando el estado es `completed`.

**created\_at** `number`

Marca de tiempo Unix (en segundos) de cuándo se creó esta respuesta.

**error** `object`

Objeto de error que se devuelve cuando el modelo no logra generar una respuesta.

**error.code** `string` *required*

El código de error de la respuesta.

Valores posibles: `server_error`, `rate_limit_exceeded`, `invalid_prompt`, `vector_store_timeout`, `invalid_image`, `invalid_image_format`, `invalid_base64_image`, `invalid_image_url`, `image_too_large`, `image_too_small`, `image_parse_error`, `image_content_policy_violation`, `invalid_image_mode`, `image_file_too_large`, `unsupported_image_media_type`, `empty_image_file`, `failed_to_download_image`, `image_file_not_found`

**error.message** `string` *required*

Una descripción del error legible por humanos.

**frequency\_penalty** `number`

Penaliza los tokens nuevos según su frecuencia existente en el texto hasta el momento.

**id** `string`

Identificador único de esta respuesta.

**incomplete\_details** `object`

Detalles sobre por qué la respuesta está incompleta.

**incomplete\_details.reason** `string`

El motivo por el cual la respuesta está incompleta.

Valores posibles: `max_output_tokens`, `content_filter`

**max\_tool\_calls** `integer`

El número máximo total de llamadas a herramientas integradas que puede procesar una respuesta.

**metadata** `object`

Conjunto de pares clave-valor que puedes adjuntar a la respuesta.

**moderation** `object`

Resultados de moderación para la entrada y la salida de la respuesta, si se solicitaron finalizaciones moderadas.

**object** `string`

El tipo de objeto de este recurso; siempre se establece en `response`.

Valores posibles: `response`

**output** `object[]`

Un arreglo de elementos de contenido generados por el modelo.

* La longitud y el orden de los elementos del arreglo `output` dependen de la respuesta del modelo.
* En lugar de acceder al primer elemento del arreglo `output` y suponer que es un mensaje `assistant` con el contenido generado por el modelo, considera usar la propiedad `output_text` cuando los SDK la admitan.

**output\_text** `string`

Propiedad de conveniencia exclusiva de los SDK que contiene la salida de texto agregada de todos los elementos `output_text` del arreglo `output`, si hay alguno. Compatible con los SDK de Python y JavaScript.

**parallel\_tool\_calls** `boolean` (default: true)

Indica si el modelo puede ejecutar llamadas a herramientas en paralelo.

**presence\_penalty** `number`

Penaliza los tokens nuevos según si aparecen en el texto hasta el momento.

**prompt\_cache\_key** `string`

OpenAI lo usa para almacenar en caché las respuestas de solicitudes similares y optimizar la tasa de aciertos de la caché. Reemplaza el campo `user`.

**prompt\_cache\_retention** `string`

La política de retención de la caché de prompts, p. ej., `in_memory` o `24h`.

**safety\_identifier** `string`

Un identificador estable que ayuda a detectar a los usuarios de tu aplicación que podrían estar infringiendo las políticas de uso de OpenAI.

**service\_tier** `string`

El nivel de procesamiento usado para atender la solicitud, p. ej., `auto`, `default`, `flex`, `scale` o `priority`.

**status** `string`

El estado de la generación de la respuesta. Uno de `completed`, `failed`, `in_progress`, `cancelled`, `queued` o `incomplete`.

Valores posibles: `completed`, `failed`, `in_progress`, `cancelled`, `queued`, `incomplete`

**store** `boolean`

Indica si la respuesta se almacena para recuperarla más tarde mediante la API.

**tool\_usage** `object`

Uso de tokens y solicitudes desglosado por herramienta integrada.

**tool\_usage.image\_gen** `object`

Uso de tokens de la herramienta de generación de imágenes.

**tool\_usage.image\_gen.input\_tokens** `integer`

**tool\_usage.image\_gen.input\_tokens\_details** `object`

**tool\_usage.image\_gen.input\_tokens\_details.image\_tokens** `integer`

**tool\_usage.image\_gen.input\_tokens\_details.text\_tokens** `integer`

**tool\_usage.image\_gen.output\_tokens** `integer`

**tool\_usage.image\_gen.output\_tokens\_details** `object`

**tool\_usage.image\_gen.output\_tokens\_details.image\_tokens** `integer`

**tool\_usage.image\_gen.output\_tokens\_details.text\_tokens** `integer`

**tool\_usage.image\_gen.total\_tokens** `integer`

**tool\_usage.web\_search** `object`

Uso de la herramienta de búsqueda web.

**tool\_usage.web\_search.num\_requests** `integer`

**top\_logprobs** `integer`

El número máximo de tokens más probables que se devolverán en cada posición de token, cada uno con una probabilidad logarítmica asociada.

**usage** `object`

Representa los detalles de uso de tokens, incluidos los tokens de entrada, los tokens de salida, un desglose de los tokens de salida y el total de tokens usados.

**usage.input\_tokens** `integer` *required*

El número de tokens de entrada.

**usage.input\_tokens\_details** `object` *required*

Un desglose detallado de los tokens de entrada.

**usage.input\_tokens\_details.cache\_write\_tokens** `integer`

El número de tokens de entrada que se escribieron en la caché.

**usage.input\_tokens\_details.cache\_write\_tokens\_details** `object`

Las escrituras en caché desglosadas por la vida útil de la caché. Los dos conteos suman `cache_write_tokens`.

**usage.input\_tokens\_details.cache\_write\_tokens\_details.ttl\_12h\_tokens** `integer`

El número de tokens de entrada escritos en la caché con la vida útil de 12 horas.

**usage.input\_tokens\_details.cache\_write\_tokens\_details.ttl\_30m\_tokens** `integer`

El número de tokens de entrada escritos en la caché con la vida útil de 30 minutos.

**usage.input\_tokens\_details.cached\_tokens** `integer` *required*

El número de tokens que se recuperaron de la caché.
[Más sobre el almacenamiento en caché de prompts](https://platform.openai.com/docs/guides/prompt-caching).

**usage.output\_tokens** `integer` *required*

El número de tokens de salida.

**usage.output\_tokens\_details** `object` *required*

Un desglose detallado de los tokens de salida.

**usage.output\_tokens\_details.reasoning\_tokens** `integer` *required*

El número de tokens de razonamiento.

**usage.total\_tokens** `integer` *required*

El número total de tokens utilizados.

**user** `string`

Identificador obsoleto del usuario final. Reemplazado por `safety_identifier` y `prompt_cache_key`.

## Ejemplos

### Entrada

```json theme={null}
{
  "input": "Reply with the single word: ok",
  "max_output_tokens": 1024
}
```

### Salida

```json theme={null}
{
  "completed_at": 1767225601,
  "created_at": 1767225600,
  "id": "resp_0a1b2c3d4e5f6a7b8c9d0e1f",
  "object": "response",
  "output": [
    {
      "content": [
        {
          "annotations": [],
          "text": "ok",
          "type": "output_text"
        }
      ],
      "id": "msg_0a1b2c3d4e5f6a7b8c9d0e1f",
      "role": "assistant",
      "status": "completed",
      "type": "message"
    }
  ],
  "output_text": "ok",
  "status": "completed",
  "usage": {
    "input_tokens": 14,
    "input_tokens_details": {
      "cached_tokens": 0
    },
    "output_tokens": 2,
    "output_tokens_details": {
      "reasoning_tokens": 0
    },
    "total_tokens": 16
  }
}
```

## Antes de lanzar

Los SDK crean una `Idempotency-Key` y la reutilizan para los reintentos automáticos. Para los reintentos manuales, reutiliza la clave original. Router puede mantener la conexión abierta hasta 10 minutos.

Cuando una solicitud falla, Router envía un encabezado de respuesta `X-Comfy-Error-Type` que explica el motivo. Un `422` significa que Router rechazó la entrada antes de llamar al proveedor, y un `413` significa que el cuerpo de la solicitud era más grande de lo que Router acepta. Descarga los recursos generados de inmediato, porque [las URL de resultados pueden caducar](https://docs.comfy.org/es/development/comfy-router/reference.md#recursos-del-resultado).

Cualquier límite de tamaño mencionado en la descripción de un campo más arriba es el límite propio del proveedor para ese campo, citado de la especificación del proveedor. Router aplica un tope aparte al cuerpo completo de la solicitud, con el que cuentan los medios codificados en base64: consulta [tamaño del cuerpo de la solicitud](https://docs.comfy.org/es/development/comfy-router/limitations.md#los-cuerpos-de-las-solicitudes-tienen-un-límite).

Esta página documenta un modelo socio al que se llama a través de Comfy Router. El mismo paquete `comfy-sdk` / `@comfyorg/sdk` también incluye un segundo cliente, para ejecutar todo un gráfico de flujo de trabajo de ComfyUI en Comfy Cloud: `Comfy(api_key=...)` / `new Comfy({ apiKey })`, con `client.workflows`, `client.assets` y `client.jobs`. Consulta [SDK de Comfy](https://docs.comfy.org/es/development/api-development/sdks.md).

> [card] [Encabezados](https://docs.comfy.org/es/development/comfy-router/headers.md)
>
> Autenticación, idempotencia, IDs de solicitud, agrupaciones de errores, ritmo de reintentos y límites de gasto.

> [card] [Uso de la API de Router](https://docs.comfy.org/es/development/comfy-router/api.md)
>
> Descubrimiento de modelos, errores de validación, reintentos y facturación.

> [card] [Limitaciones](https://docs.comfy.org/es/development/comfy-router/limitations.md)
>
> Lo que Router no hace hoy y qué usar en su lugar.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.