Recetas de prompts para gpt-6.1-sol: programación, razonamiento, JSON y llamadas a herramientas (con salidas reales)

gpt-6.1-sol es el modelo de texto de nivel razonamiento en hiapi: conversación, programación y razonamiento paso a paso, todo servido a través de la Responses API (POST /v1/responses). Si ya sabes cómo llamarlo, esta página es el siguiente paso: un conjunto de recetas de prompts listas para copiar y pegar que cubren las cuatro clases de tareas que la gente realmente usa más —programación, razonamiento, JSON estricto y llamadas a herramientas— y cada receta incluye la salida exacta que obtuvimos al ejecutarla de verdad para este artículo. Para autenticación, streaming y análisis de SSE, empieza por la guía de configuración; aquí nos centramos solo en los prompts.

Cada receta a continuación es un cuerpo de petición que puedes colocar tal cual en esa configuración. El prompt se transporta en dos campos: el instructions de nivel superior (rol y reglas de formato) y el array input (la tarea en sí). Aquí no hay nada teórico: las salidas están pegadas literalmente de eventos reales de response.completed.

Tres palancas que condicionan cómo escribes prompts para gpt-6.1-sol

Antes de entrar en las recetas, hay tres cosas sobre este modelo que moldean cada prompt que escribes. Las tres se han confirmado contra el contrato en vivo del modelo en hiapi.

1. No hay temperature ni top_p. Esta configuración de despliegue desactiva ambos (y también max_output_tokens). No puedes ajustar la determinación o la creatividad mediante muestreo: las únicas palancas disponibles son tus instructions, tu input y reasoning.effort. Si quieres una salida concisa y que se sienta determinista, dilo en instructions; no puedes establecer temperature: 0.
2. reasoning.effort tiene cinco niveles: low, medium, high, xhigh, max (por defecto medium). Un effort mayor consume más tokens de razonamiento ocultos, y esos se facturan como tokens de salida. La receta 2 muestra la curva real.
3. Ventana de contexto de ~1.05M tokens (salida máxima de 128K). La facturación por token es escalonada: en cuanto la entrada de una sola petición supera los 272K tokens, las tarifas de entrada/salida se duplican aproximadamente. Para prompts cotidianos estás muy lejos de ese umbral; para tareas de contexto largo (receta 5), merece la pena saberlo.

Receta 1 — Programación: generar una función según especificación

Pon el rol de ingeniero y la forma de la salida en instructions, y la especificación en input. Restringir la forma («un único bloque de código cercado, luego una frase») es precisamente lo que impide que el modelo de razonamiento envuelva el código en tres párrafos de preámbulo.

{
  "model": "gpt-6.1-sol",
  "instructions": "Eres un ingeniero sénior de Python. Devuelve un único bloque de código Python cercado y, después, una frase sobre la complejidad. Sin preámbulo.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Escribe `merge_intervals(intervals: list[list[int]]) -> list[list[int]]` que fusione intervalos cerrados solapados y los devuelva ordenados por punto de inicio. Gestiona la lista vacía. Incluye un docstring." }
    ] }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Lo que devolvió (tal cual):

def merge_intervals(intervals: list[list[int]]) -> list[list[int]]:
    """Fusiona intervalos cerrados solapados y los devuelve ordenados por punto de inicio.

    Ni la lista de entrada ni los intervalos que contiene se modifican.
    """
    if not intervals:
        return []

    ordered = sorted(intervals, key=lambda interval: interval[0])
    merged = [ordered[0].copy()]

    for start, end in ordered[1:]:
        if start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])

    return merged

Complejidad temporal O(n log n), complejidad espacial O(n).

Fíjate en lo que logró la restricción: gestionó correctamente el caso de la lista vacía, copió cada intervalo antes de modificarlo (ordered[0].copy()) para que los datos del llamador no se alteraran, y se detuvo exactamente tras una frase de análisis. Para esta programación mecánica, effort: low es suficiente: usó cero tokens de razonamiento y aun así produjo código correcto y sin modificación in situ.

Receta 2 — Razonamiento: controlar el presupuesto de pensamiento con effort

Como no puedes establecer temperature, reasoning.effort es tu palanca principal para los problemas difíciles. Mantén el prompt igual y cambia solo effort:

{
  "model": "gpt-6.1-sol",
  "instructions": "Piensa paso a paso y termina con una línea `Answer: <value>`.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Una panadería vende galletas en cajas de 6 y de 11. ¿Cuál es la mayor cantidad de galletas que no se puede comprar exactamente? Muestra el razonamiento." }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Ejecutamos el mismo prompt en los cinco niveles de effort. Cada nivel devolvió la respuesta correcta, 49. Lo que cambió fue cuánto pensamiento le costó:

reasoning.effort	Tokens de razonamiento	Tokens de salida totales	Costo aproximado*
low	76	305	≈ $0.0008
medium	121	380	≈ $0.0010
high	209	427	≈ $0.0011
xhigh	626	845	≈ $0.0021
max	622	813	≈ $0.0021

*Con las tarifas del tramo base ($0.50 / 1M de entrada, $2.50 / 1M de salida); los tokens de razonamiento se facturan como salida. Datos de esta ejecución, a fecha de 2026-10. Consulta las tarifas vigentes en la página de precios.

La lección práctica está en las dos últimas filas: el effort sube de forma constante de low a high y luego se estabiliza: tanto xhigh como max aterrizan en unos 620 tokens de razonamiento, porque el problema simplemente no es lo bastante difícil como para necesitar más pensamiento. Llevar al máximo el effort de un prompt sencillo no compra mejores respuestas; solo gasta unos 2.5 veces más tokens de salida para el mismo «49». Ajusta effort a la dificultad: low/medium para la mayoría de los prompts, y high o superior solo cuando la tarea realmente requiera una búsqueda más profunda.

Esta es la salida de medium, para que veas qué forma produjo el prompt:

El número mayor es 49 galletas.

1. Demostrar que 49 no se puede comprar exactamente. Supón que 49 = 6a + 11b, con a y b enteros no negativos. Tomando módulo 6 en ambos lados se obtiene 5b ≡ 1 (mod 6), por lo que b ≡ 5 (mod 6). Así que b es al menos 5, pero cinco cajas de 11 ya contienen 55 galletas. Eso es imposible.

2. Demostrar que todo número superior a 49 se puede comprar. … todo entero de al menos 50 es uno de seis totales alcanzables consecutivos más un múltiplo no negativo de 6.

Answer: 49

La línea Answer: <value> en instructions sí hace su trabajo: te permite analizar simplemente la última línea (text.rsplit("Answer:", 1)[-1].strip()) sin obligar al modelo a descartar su razonamiento.

Receta 3 — JSON estricto con esquema

No pidas JSON en prosa y luego cruces los dedos. gpt-6.1-sol soporta salidas estructuradas estrictas: pasa un text.format con json_schema y el modelo queda restringido a emitir JSON conforme: sin cercas de código, sin prosa sobrante.

{
  "model": "gpt-6.1-sol",
  "instructions": "Clasifica el ticket de soporte. Responde solo con el objeto JSON.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Ticket: 'Desde esta mañana, el endpoint de superresolución 4K devuelve 500 en cada llamada. Lanzamos mañana y esto nos bloquea.'" }
    ] }
  ],
  "text": {
    "format": {
      "type": "json_schema",
      "name": "ticket",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "sentiment": { "type": "string", "enum": ["positive", "neutral", "negative"] },
          "topics": { "type": "array", "items": { "type": "string" } },
          "action_required": { "type": "boolean" }
        },
        "required": ["sentiment", "topics", "action_required"],
        "additionalProperties": false
      }
    }
  },
  "reasoning": { "effort": "low" },
  "stream": true
}

Lo que devolvió (tal cual, en una sola línea):

{"action_required":true,"sentiment":"negative","topics":["4K upscale endpoint","HTTP 500 errors","Service outage","Launch blocker","Urgent support"]}

Hay dos cosas que interiorizar. Primera, strict: true garantiza tipos y claves obligatorias, pero no garantiza el orden de las claves: fíjate en que action_required aparece primero aunque en el esquema figura al final, así que analiza por clave, nunca por posición. Segunda, sigues teniendo que acumular la respuesta a partir de los bloques response.output_text.delta como con cualquier otra respuesta; el esquema moldea el contenido, no el transporte.

Receta 4 — Llamadas a herramientas y continuación con resultados

gpt-6.1-sol puede llamar a funciones y, lo importante, continuar después de que le devuelvas un resultado. Declara un array tools; cuando el modelo decide llamar, emite un elemento function_call en lugar de texto.

{
  "model": "gpt-6.1-sol",
  "instructions": "Puedes llamar a herramientas. Cuando el usuario pregunte por una tarea, llama a get_task_status.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "¿Puedes ver qué pasa con task_abc123? Lleva mucho tiempo en pending." }
    ] }
  ],
  "tools": [
    {
      "type": "function",
      "name": "get_task_status",
      "description": "Consulta el estado de una tarea asíncrona de generación de imagen/vídeo por su id.",
      "parameters": {
        "type": "object",
        "properties": { "task_id": { "type": "string", "description": "id de la tarea, por ejemplo 'task_abc123'." } },
        "required": ["task_id"],
        "additionalProperties": false
      }
    }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

La respuesta no trajo texto: solo una llamada a herramienta, entregada como elemento function_call en el evento final (sus argumentos llegan en streaming mediante bloques response.function_call_arguments.delta):

{
  "type": "function_call",
  "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b",
  "name": "get_task_status",
  "arguments": "{\"task_id\":\"task_abc123\"}"
}

Ahora llega la segunda mitad que la configuración básica no cubre: ejecuta tu función y devuelve el resultado: añade el function_call del modelo y tu function_call_output (vinculado con el mismo call_id) al array input y vuelve a llamar:

{
  "model": "gpt-6.1-sol",
  "instructions": "Puedes llamar a herramientas. Resume el resultado de la herramienta al usuario en una o dos frases.",
  "input": [
    { "type": "message", "role": "user", "content": [ { "type": "input_text", "text": "¿Puedes ver qué pasa con task_abc123? Lleva mucho tiempo en pending." } ] },
    { "type": "function_call", "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b", "name": "get_task_status", "arguments": "{\"task_id\":\"task_abc123\"}" },
    { "type": "function_call_output", "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b", "output": "{\"status\":\"failed\",\"error\":\"INVALID_REQUEST: image url could not be downloaded\",\"created_at\":\"2026-10-17T06:12:00Z\"}" }
  ],
  "tools": [ { "type": "function", "name": "get_task_status", "description": "Consulta el estado de una tarea de generación asíncrona por su id.", "parameters": { "type": "object", "properties": { "task_id": { "type": "string" } }, "required": ["task_id"], "additionalProperties": false } } ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Con el resultado en mano, responde en lenguaje llano (tal cual):

La tarea task_abc123 ya no está en pending: falló porque la URL de la imagen no se pudo descargar (INVALID_REQUEST). Comprueba que la URL de la imagen sea accesible públicamente y vuelve a enviar la tarea.

El call_id es el pegamento: tu function_call_output debe repetir el call_id exacto del function_call del modelo, o el turno de continuación no se vinculará a él.

Receta 5 — Respuestas fundamentadas en contexto largo

La ventana de 1.05M tokens sirve para alimentar material real —logs, changelogs, documentos de especificación— y responder preguntas a partir de él. El patrón de prompt que lo mantiene honesto está en instructions: obligarlo a responder solo según el texto proporcionado y a citar la fuente de cada hecho.

{
  "model": "gpt-6.1-sol",
  "instructions": "Responde estrictamente según el CHANGELOG proporcionado. Si un hecho no está, di 'not in the changelog'. Cita la fecha de cada hecho que uses.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "<pega aquí el CHANGELOG>\nPregunta: la URL de salida de una tarea de vídeo me devolvió mi archivo ayer, pero hoy da 404, y además mis llamadas de imagen acaban de empezar a devolver 402. ¿Qué dos entradas del changelog lo explican y qué debería cambiar?" }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Dado un breve changelog de la plataforma, extrajo exactamente las dos entradas relevantes, citó sus fechas y separó «qué pasó» de «qué cambiar» (tal cual):

Dos entradas explican los problemas:

1. 2026-10-02 — Las URLs de salida temporales caducan. Las URLs de salida en temp.hiapi.ai son válidas durante 7 días y después devuelven 404… Cambio: descarga los bytes de inmediato y guarda tu propia copia; no enlaces en caliente. Usa expireAt para seguir la caducidad.

2. 2026-09-20 — El saldo a cero provoca 402 en los modelos de imagen. Las cuentas con saldo totalmente vacío ahora reciben HTTP 402 en todos los modelos de imagen… Cambio: comprueba si el saldo de tu cuenta está totalmente vacío y, si es así, recárgala.

La instrucción «cita las fechas» es un truco barato de fundamentación: hace visible la alucinación (un hecho sin fecha que citar es un hecho que se inventó) y hace que la respuesta sea auditable. Ten presente el precio escalonado: los prompts con más de 272K tokens de entrada se facturan a la tarifa más alta de contexto largo.

Un escollo de esta ejecución: decodificar el stream como UTF-8

A los modelos de razonamiento les encantan las rayas largas y las comillas tipográficas. Al escribir este artículo, nuestro primer lector de SSE dividió un carácter UTF-8 multibyte entre dos fragmentos de red, convirtiendo una raya larga limpia («—») en basura («â»). La salida del modelo estaba bien; fue el cliente el que decodificó por líneas con demasiada avidez. La solución es almacenar los bytes en bruto, dividir por saltos de línea y decodificar cada línea completa como UTF-8, sin decodificar fragmentos incompletos. Si en tu salida de gpt-6.1-sol aparecen caracteres sueltos Ã/â, la causa está aquí, no en el modelo.

Preguntas frecuentes

¿En qué se diferencia esto de la guía de configuración de gpt-6.1-sol? La guía de configuración trata de llamar al modelo: autenticación, por qué debes usar streaming, análisis de SSE. Esta página trata de darle prompts: patrones de instructions/input/effort para tareas concretas, y las salidas que producen.

¿No basta con poner reasoning.effort en max para obtener las mejores respuestas? No es gratis, y a menudo tampoco es mejorar. En nuestro problema de prueba, xhigh y max se estabilizaron en unos 620 tokens de razonamiento y devolvieron la misma respuesta que high. Los tokens de razonamiento se facturan como salida, así que llevar al máximo un prompt sencillo cuesta más dinero por el mismo resultado. Reserva high+ para razonamiento realmente difícil.

¿Cómo fuerzo un JSON válido en lugar de pedirlo en el prompt? Pasa un text.format con json_schema strict (receta 3). El modelo queda restringido a los tipos y claves obligatorias del esquema. Analiza por nombre de clave, porque strict no fija el orden de las claves.

¿Por qué no puedo establecer temperature o top_p? Esta configuración de despliegue desactiva ambos (y también max_output_tokens). En su lugar, moldea la salida mediante instructions, tu input y reasoning.effort.

¿Las llamadas a herramientas funcionan igual que en los modelos de chat? El contrato es algo distinto: las herramientas se declaran en el array tools de nivel superior, el modelo responde con un elemento function_call (no un mensaje) y continúas añadiendo un function_call_output con el call_id correspondiente (receta 4).

¿Es gpt-6.1-sol lo mismo que gpt-5.6-sol? Pertenecen a la misma familia Sol y comparten este contrato de Responses API solo con streaming; gpt-6.1-sol es una generación más reciente. Consulta gpt-6 Astra frente a gpt-5.6 Sol para ver cómo se corresponden las generaciones.

Empieza aquí

Copia cualquiera de las recetas anteriores en el cuerpo de la petición de la guía de configuración, sustituye por tu propia tarea y ajusta reasoning.effort según la dificultad. La introducción de capacidades y el cuadro de prueba en línea están en la página del modelo gpt-6.1-sol; los endpoints y el formato de petición compartido, en la documentación de la API; y las tarifas por token, en la página de precios. Una sola clave de hiapi da acceso a gpt-6.1-sol y a todos los demás modelos de la plataforma.