Respuestas en segundo plano

Utiliza el modo background cuando una respuesta pueda tardar mucho tiempo en completarse, como en el uso de herramientas de varios pasos o tareas de generación grandes. La API responde de inmediato con una respuesta en cola, y puedes recuperar el resultado más tarde mediante sondeo o streaming.

Crear una respuesta en segundo plano

Establece background en true y stream en false. La API crea la respuesta, comienza a procesarla de forma asíncrona y responde de inmediato con status: "queued".

mka1 llm responses create \
  --background \
  --model meetkai:functionary-es-mini \
  --input '"Write a 500-word essay about the history of the internet."' \
  -H 'X-On-Behalf-Of: <end-user-id>'

import { SDK } from '@meetkai/mka1';

const mka1 = new SDK({
  bearerAuth: `Bearer ${YOUR_API_KEY}`,
});

const response = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Write a 500-word essay about the history of the internet.',
    background: true,
    stream: false,
  },
});

console.log(response.id, response.status); // resp_abc123 queued

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: '<mka1-api-key>',
  baseURL: 'https://apigw.mka1.com/api/v1/llm/',
  defaultHeaders: { 'X-On-Behalf-Of': '<end-user-id>' },
});

const response = await openai.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: 'Write a 500-word essay about the history of the internet.',
  background: true,
  stream: false,
});

console.log(response.id, response.status); // resp_abc123 queued

using MeetKai.MKA1;
using MeetKai.MKA1.Types.Components;

var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

var res = await sdk.Llm.Responses.CreateAsync(
    body: new ResponsesCreateRequest()
    {
        Model = "meetkai:functionary-es-mini",
        Input = ResponsesCreateRequestInput.CreateStr(
            "Write a 500-word essay about the history of the internet."),
        Background = true,
        Stream = false,
    },
    xOnBehalfOf: "<end-user-id>"
);

Console.WriteLine($"{res.ResponseObject!.Id} {res.ResponseObject!.Status}"); // resp_abc123 queued

from mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

res = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Write a 500-word essay about the history of the internet.",
    background=True,
    stream=False,
    x_on_behalf_of="<end-user-id>",
)

print(res.id, res.status)  # resp_abc123 queued

curl https://apigw.mka1.com/api/v1/llm/responses \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>' \
  --data '{
    "model": "meetkai:functionary-es-mini",
    "input": "Write a 500-word essay about the history of the internet.",
    "background": true,
    "stream": false
  }'

Guarda el id para recuperar el resultado más adelante.

Sondear para obtener el resultado

Llama a GET /responses/{response_id} hasta que el estado alcance un estado terminal.

mka1 llm responses get --response-id resp_abc123

let polled = await mka1.llm.responses.get({
  responseId: response.id,
  xOnBehalfOf: '<end-user-id>',
});

while (polled.status === 'queued' || polled.status === 'in_progress') {
  await new Promise(r => setTimeout(r, 2000));
  polled = await mka1.llm.responses.get({
    responseId: response.id,
    xOnBehalfOf: '<end-user-id>',
  });
}

console.log(polled.status); // completed
console.log(polled.output);

let polled = await openai.responses.retrieve(response.id);

while (polled.status === 'queued' || polled.status === 'in_progress') {
  await new Promise(r => setTimeout(r, 2000));
  polled = await openai.responses.retrieve(response.id);
}

console.log(polled.status); // completed
console.log(polled.output);

var polled = await sdk.Llm.Responses.GetAsync(new GetResponseRequest()
{
    ResponseId = res.ResponseObject!.Id,
    XOnBehalfOf = "<end-user-id>",
});

while (polled.ResponseObject!.Status == "queued" || polled.ResponseObject!.Status == "in_progress")
{
    await Task.Delay(2000);
    polled = await sdk.Llm.Responses.GetAsync(new GetResponseRequest()
    {
        ResponseId = res.ResponseObject!.Id,
        XOnBehalfOf = "<end-user-id>",
    });
}

Console.WriteLine(polled.ResponseObject!.Status); // completed

import time

polled = sdk.llm.responses.get(
    response_id=res.id,
    x_on_behalf_of="<end-user-id>",
)

while polled.status in ("queued", "in_progress"):
    time.sleep(2)
    polled = sdk.llm.responses.get(
        response_id=res.id,
        x_on_behalf_of="<end-user-id>",
    )

print(polled.status)  # completed
print(polled.output)

curl https://apigw.mka1.com/api/v1/llm/responses/resp_abc123 \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>'

Una respuesta pasa por estos estados mientras se procesa:

Estado	Significado
`queued`	La solicitud está esperando ser procesada
`in_progress`	El modelo está generando la salida
`completed`	La generación finalizó correctamente
`failed`	Ocurrió un error durante el procesamiento
`incomplete`	La respuesta se cortó (por ejemplo, límite de tokens)
`cancelled`	La respuesta fue cancelada antes de completarse

Sondea a un intervalo razonable (por ejemplo, cada dos segundos) hasta que el estado ya no sea queued o in_progress.

Recibir eventos de una respuesta en segundo plano

Si deseas actualizaciones en tiempo real en lugar de sondeo, recupera la respuesta con stream establecido en true. La API devuelve eventos enviados por el servidor a medida que se procesa la respuesta.

mka1 llm responses get --response-id resp_abc123 --stream

const streamed = await mka1.llm.responses.get({
  responseId: response.id,
  stream: true,
  xOnBehalfOf: '<end-user-id>',
});

const stream = await openai.responses.retrieve(response.id, {
  stream: true,
});

for await (const event of stream) {
  console.log(event.type);
}

var streamed = await sdk.Llm.Responses.GetAsync(new GetResponseRequest()
{
    ResponseId = res.ResponseObject!.Id,
    Stream = true,
    XOnBehalfOf: "<end-user-id>",
});

streamed = sdk.llm.responses.get(
    response_id=res.id,
    stream=True,
    x_on_behalf_of="<end-user-id>",
)

curl https://apigw.mka1.com/api/v1/llm/responses/resp_abc123?stream=true \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>'

Los eventos llegan a medida que se producen. El flujo se cierra después de un evento terminal como response.completed o response.failed. Si la respuesta ya se ha completado cuando llamas a este endpoint, recibes un solo evento terminal con la respuesta final y el flujo se cierra inmediatamente.

Recibir eventos al momento de la creación

También puedes recibir eventos directamente al crear una respuesta en segundo plano estableciendo tanto background como stream en true.

mka1 llm responses create \
  --background \
  --stream \
  --model meetkai:functionary-es-mini \
  --input '"Write a 500-word essay about the history of the internet."'

const result = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Write a 500-word essay about the history of the internet.',
    background: true,
    stream: true,
  },
});

const stream = await openai.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: 'Write a 500-word essay about the history of the internet.',
  background: true,
  stream: true,
});

for await (const event of stream) {
  console.log(event.type);
  // response.queued → response.created → ... → response.completed
}

var res = await sdk.Llm.Responses.CreateAsync(
    body: new ResponsesCreateRequest()
    {
        Model = "meetkai:functionary-es-mini",
        Input = ResponsesCreateRequestInput.CreateStr(
            "Write a 500-word essay about the history of the internet."),
        Background = true,
        Stream = true,
    },
    xOnBehalfOf: "<end-user-id>"
);

res = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Write a 500-word essay about the history of the internet.",
    background=True,
    stream=True,
    x_on_behalf_of="<end-user-id>",
)

curl https://apigw.mka1.com/api/v1/llm/responses \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>' \
  --data '{
    "model": "meetkai:functionary-es-mini",
    "input": "Write a 500-word essay about the history of the internet.",
    "background": true,
    "stream": true
  }'

El primer evento es response.queued, seguido de response.created, eventos intermedios como response.output_text.delta y finalmente un evento terminal como response.completed. Esto es útil cuando quieres mostrar el progreso en una interfaz de usuario mientras el trabajo se ejecuta en segundo plano. Si el cliente se desconecta, la respuesta sigue procesándose y puede recuperarse más tarde.

Cancelar una respuesta en segundo plano

Si ya no necesitas el resultado, cancela una respuesta en cola o en progreso.

mka1 llm responses cancel --response-id resp_abc123

const cancelled = await mka1.llm.responses.cancel({
  responseId: response.id,
  xOnBehalfOf: '<end-user-id>',
});

console.log(cancelled.status); // cancelled

const cancelled = await openai.responses.cancel(response.id);

console.log(cancelled.status); // cancelled

var cancelled = await sdk.Llm.Responses.CancelAsync(
    responseId: res.ResponseObject!.Id,
    xOnBehalfOf: "<end-user-id>"
);

Console.WriteLine(cancelled.Status); // cancelled

cancelled = sdk.llm.responses.cancel(
    response_id=res.id,
    x_on_behalf_of="<end-user-id>",
)

print(cancelled.status)  # cancelled

curl https://apigw.mka1.com/api/v1/llm/responses/resp_abc123/cancel \
  --request POST \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>'

El estado de la respuesta cambia a cancelled. Las respuestas que ya han finalizado o fallado no pueden ser canceladas.

Próximos pasos

Consulta generar una respuesta para lo básico sobre la creación de respuestas
Consulta gestionar agentes cuando necesites definiciones de agente reutilizables y ejecuciones persistentes
Revisa la referencia de la API de Responses para la lista completa de parámetros y campos de respuesta

​Crear una respuesta en segundo plano

​Sondear para obtener el resultado

​Recibir eventos de una respuesta en segundo plano

​Recibir eventos al momento de la creación

​Cancelar una respuesta en segundo plano

​Próximos pasos