> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mka1.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Respuestas en segundo plano
> Ejecuta respuestas de larga duración en segundo plano y recupera los resultados mediante sondeo o streaming.
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"`.
```bash CLI theme={null}
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: '
```
```ts MKA1 SDK theme={null}
import { SDK } from '@meetkai/mka1';
const mka1 = new SDK({
bearerAuth: `Bearer ${YOUR_API_KEY}`,
});
const response = await mka1.llm.responses.create({
xOnBehalfOf: '',
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
```
```ts OpenAI SDK theme={null}
import OpenAI from 'openai';
const openai = new OpenAI({
apiKey: '',
baseURL: 'https://apigw.mka1.com/api/v1/llm/',
defaultHeaders: { 'X-On-Behalf-Of': '' },
});
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
```
```csharp C# SDK theme={null}
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: ""
);
Console.WriteLine($"{res.ResponseObject!.Id} {res.ResponseObject!.Status}"); // resp_abc123 queued
```
```python Python SDK theme={null}
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="",
)
print(res.id, res.status) # resp_abc123 queued
```
```bash bash theme={null}
curl https://apigw.mka1.com/api/v1/llm/responses \
--request POST \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ' \
--header 'X-On-Behalf-Of: ' \
--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.
```bash CLI theme={null}
mka1 llm responses get --response-id resp_abc123
```
```ts MKA1 SDK theme={null}
let polled = await mka1.llm.responses.get({
responseId: response.id,
xOnBehalfOf: '',
});
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: '',
});
}
console.log(polled.status); // completed
console.log(polled.output);
```
```ts OpenAI SDK theme={null}
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);
```
```csharp C# SDK theme={null}
var polled = await sdk.Llm.Responses.GetAsync(new GetResponseRequest()
{
ResponseId = res.ResponseObject!.Id,
XOnBehalfOf = "",
});
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 = "",
});
}
Console.WriteLine(polled.ResponseObject!.Status); // completed
```
```python Python SDK theme={null}
import time
polled = sdk.llm.responses.get(
response_id=res.id,
x_on_behalf_of="",
)
while polled.status in ("queued", "in_progress"):
time.sleep(2)
polled = sdk.llm.responses.get(
response_id=res.id,
x_on_behalf_of="",
)
print(polled.status) # completed
print(polled.output)
```
```bash bash theme={null}
curl https://apigw.mka1.com/api/v1/llm/responses/resp_abc123 \
--header 'Authorization: Bearer ' \
--header 'X-On-Behalf-Of: '
```
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.
```bash CLI theme={null}
mka1 llm responses get --response-id resp_abc123 --stream
```
```ts MKA1 SDK theme={null}
const streamed = await mka1.llm.responses.get({
responseId: response.id,
stream: true,
xOnBehalfOf: '',
});
```
```ts OpenAI SDK theme={null}
const stream = await openai.responses.retrieve(response.id, {
stream: true,
});
for await (const event of stream) {
console.log(event.type);
}
```
```csharp C# SDK theme={null}
var streamed = await sdk.Llm.Responses.GetAsync(new GetResponseRequest()
{
ResponseId = res.ResponseObject!.Id,
Stream = true,
XOnBehalfOf: "",
});
```
```python Python SDK theme={null}
streamed = sdk.llm.responses.get(
response_id=res.id,
stream=True,
x_on_behalf_of="",
)
```
```bash bash theme={null}
curl https://apigw.mka1.com/api/v1/llm/responses/resp_abc123?stream=true \
--header 'Authorization: Bearer ' \
--header 'X-On-Behalf-Of: '
```
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`.
```bash CLI theme={null}
mka1 llm responses create \
--background \
--stream \
--model meetkai:functionary-es-mini \
--input '"Write a 500-word essay about the history of the internet."'
```
```ts MKA1 SDK theme={null}
const result = await mka1.llm.responses.create({
xOnBehalfOf: '',
responsesCreateRequest: {
model: 'meetkai:functionary-es-mini',
input: 'Write a 500-word essay about the history of the internet.',
background: true,
stream: true,
},
});
```
```ts OpenAI SDK theme={null}
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
}
```
```csharp C# SDK theme={null}
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: ""
);
```
```python Python SDK theme={null}
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="",
)
```
```bash bash theme={null}
curl https://apigw.mka1.com/api/v1/llm/responses \
--request POST \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ' \
--header 'X-On-Behalf-Of: ' \
--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.
```bash CLI theme={null}
mka1 llm responses cancel --response-id resp_abc123
```
```ts MKA1 SDK theme={null}
const cancelled = await mka1.llm.responses.cancel({
responseId: response.id,
xOnBehalfOf: '',
});
console.log(cancelled.status); // cancelled
```
```ts OpenAI SDK theme={null}
const cancelled = await openai.responses.cancel(response.id);
console.log(cancelled.status); // cancelled
```
```csharp C# SDK theme={null}
var cancelled = await sdk.Llm.Responses.CancelAsync(
responseId: res.ResponseObject!.Id,
xOnBehalfOf: ""
);
Console.WriteLine(cancelled.Status); // cancelled
```
```python Python SDK theme={null}
cancelled = sdk.llm.responses.cancel(
response_id=res.id,
x_on_behalf_of="",
)
print(cancelled.status) # cancelled
```
```bash bash theme={null}
curl https://apigw.mka1.com/api/v1/llm/responses/resp_abc123/cancel \
--request POST \
--header 'Authorization: Bearer ' \
--header 'X-On-Behalf-Of: '
```
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](/es/docs/generate-a-response) para lo básico sobre la creación de respuestas
* Consulta [gestionar agentes](/es/docs/managing-agents) cuando necesites definiciones de agente reutilizables y ejecuciones persistentes
* Revisa la [referencia de la API de Responses](/es/api-reference/introduction) para la lista completa de parámetros y campos de respuesta