Primeros pasos

import { SDK } from '@meetkai/mka1';
import type { ResponseObject } from '@meetkai/mka1/models/components';
import { CreateAcceptEnum } from '@meetkai/mka1/sdk/responses';
import { EventStream } from '@meetkai/mka1/lib/event-streams';
import { writeFileSync } from 'node:fs';
import { openAsBlob } from 'node:fs';

const sdk = new SDK({ bearerAuth: 'Bearer <mka1-api-key>' });

const result = await sdk.llm.responses.create({
  xOnBehalfOf: 'user_123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Resuma este ticket de soporte.',
  },
}) as ResponseObject;
console.log(result.outputText);

from meetkai_mka1 import SDK
import time
import os
import json

sdk = SDK(bearer_auth="Bearer <mka1-api-key>")

response = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Resuma este ticket de soporte.",
    x_on_behalf_of="user_123",
)

const jwt = await sdk.auth.apiKeys.exchangeToken({
  requestBody: {
    audience: 'https://your-app.example.com',
    externalUserId: 'user_123',
  },
});

// jwt.token es el JWT de corta duración — úselo como bearer
const asEndUser = new SDK({ bearerAuth: `Bearer ${jwt.token}` });

jwt = sdk.auth.api_keys.exchange_token(
    audience="https://your-app.example.com",
    external_user_id="user_123",
)

# jwt.token es el JWT de corta duración — úselo como bearer
as_end_user = SDK(bearer_auth=f"Bearer {jwt.token}")

curl -X POST https://apigw.mka1.com/api/v1/authentication/api-keys/exchange-token \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{ "audience": "https://your-app.example.com", "externalUserId": "user_123" }'
# → { "token": "<jwt>" } — luego envíe Authorization: Bearer <jwt>

const result = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: '¿Cuál es la capital de Francia?',
  },
}) as ResponseObject;
console.log(result.outputText);

res = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="¿Cuál es la capital de Francia?",
)

mka1 llm responses create \
  --model meetkai:functionary-es-mini \
  --input '"¿Cuál es la capital de Francia?"' \
  -H '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 YOUR_API_KEY' \
  --data '{ "model": "meetkai:functionary-es-mini", "input": "¿Cuál es la capital de Francia?" }'

const result = await sdk.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Escriba un resumen de una frase de la API de MKA1.',
  },
});

res = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Escriba un resumen de una frase de la API de MKA1.",
    http_headers={"X-On-Behalf-Of": "<end-user-id>"},
)

const stream = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Escriba tres viñetas de notas de versión para nuestra actualización de docs.',
    stream: true,
  },
}, { acceptHeaderOverride: CreateAcceptEnum.textEventStream });

if (stream instanceof EventStream) {
  for await (const event of stream) {
    if (event.data.type === 'response.output_text.delta') {
      process.stdout.write(event.data.delta);
    }
  }
}

stream = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Escriba tres viñetas de notas de versión para nuestra actualización de docs.",
    stream=True,
)

for event in stream:
    if event.data.type == "response.output_text.delta":
        print(event.data.delta, end="", flush=True)

const result = await sdk.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'openai:gpt-4.1', // con visión — 'auto' descarta imágenes hoy
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Describa lo que ve en esta imagen.' },
          {
            type: 'input_image',
            imageUrl: 'https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg',
          },
        ],
      },
    ],
  },
});

res = sdk.llm.responses.create(
    model="openai:gpt-4.1",  # con visión — 'auto' descarta imágenes hoy
    input=[
        {
            "type": "message",
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describa lo que ve en esta imagen."},
                {
                    "type": "input_image",
                    "image_url": "https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg",
                },
            ],
        },
    ],
    x_on_behalf_of="<end-user-id>",
)

const queued = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Escriba una historia del fax en dos frases.',
    background: true,
    stream: false,
  },
}) as ResponseObject;

// queued.status === 'queued'

let response = queued;
while (response.status === 'queued' || response.status === 'in_progress') {
  await new Promise((r) => setTimeout(r, 2000));
  response = await sdk.llm.responses.get({ responseId: queued.id }) as ResponseObject;
}
console.log(response.outputText);

queued = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Escriba una historia del fax en dos frases.",
    background=True,
    stream=False,
)  # queued.status == "queued"

response = queued
while response.status in ("queued", "in_progress"):
    time.sleep(2)
    response = sdk.llm.responses.get(response_id=queued.id)

print(response.output_text)

const queued = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Resuma este informe de 80 páginas…',
    background: true,
    stream: false,
    webhookUrl: 'https://your-app.example.com/hooks/mka1',
    webhookSecret: process.env.MKA1_WEBHOOK_SECRET,
  },
}) as ResponseObject;

queued = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Resuma este informe de 80 páginas…",
    background=True,
    stream=False,
    webhook_url="https://your-app.example.com/hooks/mka1",
    webhook_secret=os.environ["MKA1_WEBHOOK_SECRET"],
)

// 1. Cree una conversación (metadatos opcionales para su propio enrutamiento)
const conv = await sdk.llm.conversations.create({
  xOnBehalfOf: '<end-user-id>',
  createConversationRequest: {
    metadata: { session_id: 'web-42', channel: 'support' },
  },
});

// 2. (Opcional) escriba historial explícitamente antes de llamar a Responses
await sdk.llm.conversations.createItems({
  conversationId: conv.id,
  xOnBehalfOf: '<end-user-id>',
  createItemsRequest: {
    items: [
      { type: 'message', role: 'user', content: 'Resuma el último ticket de soporte.' },
    ],
  },
});

// 3. Continúe el flujo — adjunte la conversación para que el modelo tenga historial
const result = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    conversation: conv.id,
    input: 'Convierta ese resumen en una respuesta lista para el cliente.',
  },
});

# 1. Cree una conversación (metadatos opcionales para su propio enrutamiento)
conv = sdk.llm.conversations.create(
    metadata={"session_id": "web-42", "channel": "support"},
    x_on_behalf_of="<end-user-id>",
)

# 2. (Opcional) escriba historial explícitamente antes de llamar a Responses
sdk.llm.conversations.create_items(
    conversation_id=conv.id,
    items=[
        {"type": "message", "role": "user", "content": "Resuma el último ticket de soporte."},
    ],
    x_on_behalf_of="<end-user-id>",
)

# 3. Continúe el flujo — adjunte la conversación para que el modelo tenga historial
result = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    conversation=conv.id,
    input="Convierta ese resumen en una respuesta lista para el cliente.",
)

// Sesión 1: guarde un dato
await sdk.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Recuerda esto: mi color favorito es azul.',
    tools: [{ type: 'history' }],
    store: true,
  },
});

// Sesión 2 (minutos o días después — la indexación tarda ~1–2 min): recupérelo
const recalled = await sdk.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: '¿Cuál es mi color favorito?',
    tools: [{ type: 'history' }],
    store: true,
  },
});
// → "Tu color favorito es azul."

# Sesión 1: guarde un dato
sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Recuerda esto: mi color favorito es azul.",
    tools=[{"type": "history"}],
    store=True,
    x_on_behalf_of="user-123",
)

# Sesión 2 (minutos o días después — la indexación tarda ~1–2 min): recupérelo
recalled = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="¿Cuál es mi color favorito?",
    tools=[{"type": "history"}],
    store=True,
    x_on_behalf_of="user-123",
)

const file = Bun.file('./support-manual.pdf');

const result = await sdk.llm.files.upload({
  xOnBehalfOf: '<end-user-id>',
  requestBody: { file, purpose: 'assistants' },
});
// result.id → p. ej. file_1783478060914_iemq10dh5h

with open("support-manual.pdf", "rb") as fh:
    result = sdk.llm.files.upload(
        file={"file_name": "support-manual.pdf", "content": fh.read()},
        purpose="assistants",
        x_on_behalf_of="<end-user-id>",
    )
# result.id → p. ej. file_1783481291595_r19s7ueog7o

const vectorStore = await sdk.llm.vectorStores.create({
  xOnBehalfOf: '<end-user-id>',
  createVectorStoreRequest: {
    name: 'Base de conocimiento de soporte',
    description: 'Manuales de soporte y documentos del centro de ayuda indexados',
    fileIds: [result.id],
    expiresAfter: { anchor: 'last_active_at', days: 30 },
  },
});

vector_store = sdk.llm.vector_stores.create(
    name="Base de conocimiento de soporte",
    description="Manuales de soporte y documentos del centro de ayuda indexados",
    file_ids=[result.id],
    expires_after={"anchor": "last_active_at", "days": 30},
    x_on_behalf_of="<end-user-id>",
)

const second = await sdk.llm.files.upload({
  xOnBehalfOf: '<end-user-id>',
  requestBody: { file: Bun.file('./help-center-faq.pdf'), purpose: 'assistants' },
});

const vsFile = await sdk.llm.vectorStores.createFile({
  vectorStoreId: vectorStore.id,
  xOnBehalfOf: '<end-user-id>',
  createVectorStoreFileRequest: {
    fileId: second.id,
    attributes: { category: 'faq', version: '2.0' },
  },
});

with open("help-center-faq.pdf", "rb") as fh:
    second = sdk.llm.files.upload(
        file={"file_name": "help-center-faq.pdf", "content": fh.read()},
        purpose="assistants",
        x_on_behalf_of="<end-user-id>",
    )

vs_file = sdk.llm.vector_stores.create_file(
    vector_store_id=vector_store.id,
    file_id=second.id,
    attributes={"category": "faq", "version": "2.0"},
    x_on_behalf_of="<end-user-id>",
)

const results = await sdk.llm.vectorStores.search({
  vectorStoreId: vectorStore.id,
  xOnBehalfOf: '<end-user-id>',
  searchVectorStoreRequest: {
    query: '¿Cómo restablezco mi contraseña?',
    maxNumResults: 5,
  },
});

results = sdk.llm.vector_stores.search(
    vector_store_id=vector_store.id,
    query="¿Cómo restablezco mi contraseña?",
    max_num_results=5,
    x_on_behalf_of="<end-user-id>",
)

const schema = {
  type: 'object',
  properties: {
    document_title: { type: 'string' },
    reset_link_expiry_minutes: { type: 'number' },
    support_email: { type: 'string' },
  },
  required: ['document_title'],
};

// Extracción puntual — aquí el esquema es una cadena JSON
const res = await sdk.llm.extract.extract({
  requestBody: {
    model: 'openai:gpt-4.1', // 'auto' actualmente devuelve 500 en este endpoint
    prompt: 'Extraiga el título del documento, la caducidad del enlace de restablecimiento y el correo de soporte.',
    schema: JSON.stringify(schema),
    file: Bun.file('./support-manual.txt'),
  },
});
// → { success, data: {…}, metadata: {…} }

schema = {
    "type": "object",
    "properties": {
        "document_title": {"type": "string"},
        "reset_link_expiry_minutes": {"type": "number"},
        "support_email": {"type": "string"},
    },
    "required": ["document_title"],
}

# Extracción puntual — aquí el esquema es una cadena JSON
with open("support-manual.txt", "rb") as fh:
    res = sdk.llm.extract.extract(
        model="openai:gpt-4.1",  # 'auto' actualmente devuelve 500 en este endpoint
        prompt="Extraiga el título del documento, la caducidad del enlace de restablecimiento y el correo de soporte.",
        schema=json.dumps(schema),
        file={"file_name": "support-manual.txt", "content": fh.read()},
    )
# res.success, res.data, res.metadata

// Plantilla reutilizable — aquí el esquema es un objeto; el id llega bajo data.id
const created = await sdk.llm.extract.createSchema({
  extractionSchema: {
    name: 'support-manual',
    description: 'Extraer datos del manual de soporte',
    schema,
  },
});

const out = await sdk.llm.extract.extractWithSchema({
  schemaId: created.data.id,
  requestBody: {
    model: 'openai:gpt-4.1',
    prompt: 'Extraiga los campos.',
    file: Bun.file('./support-manual.txt'),
  },
});

# Plantilla reutilizable — aquí el esquema es un dict; el id llega bajo data.id
created = sdk.llm.extract.create_schema(
    name="support-manual",
    description="Extraer datos del manual de soporte",
    schema=schema,
)

out = sdk.llm.extract.extract_with_schema(
    schema_id=created.data.id,
    model="openai:gpt-4.1",
    prompt="Extraiga los campos.",
    file={"file_name": "support-manual.txt", "content": open("support-manual.txt", "rb").read()},
)

const agent = await sdk.agents.createAgent({
  createAgentRequest: {
    name: 'release-research-agent',
    description: 'Busca información actual de versiones antes de responder.',
    model: 'meetkai:functionary-es-mini',
    instructions: 'Use la búsqueda web cuando la pregunta dependa de información externa actual.',
    tools: [{ type: 'web_search', searchContextSize: 'medium' }],
    metadata: { team: 'docs' },
  },
});
console.log(agent.id);

agent = sdk.agents.create_agent(
    name="release-research-agent",
    description="Busca información actual de versiones antes de responder.",
    model="meetkai:functionary-es-mini",
    instructions="Use la búsqueda web cuando la pregunta dependa de información externa actual.",
    tools=[{"type": "web_search", "search_context_size": "medium"}],
    metadata={"team": "docs"},
)

print(agent.id)

const run = await sdk.agentRuns.createAgentRun({
  agentId: agent.id,
  createAgentRunRequest: {
    input: '¿Cuál es la versión estable actual de Bun? Use la búsqueda web antes de responder.',
    metadata: { request_source: 'docs' },
  },
});

console.log(run.gatewayResponseId);
console.log(run.status);

run = sdk.agent_runs.create_agent_run(
    agent_id="agt_123",
    input="¿Cuál es la versión estable actual de Bun? Use la búsqueda web antes de responder.",
    metadata={"request_source": "docs"},
)

print(run.gateway_response_id)
print(run.status)

const agents = await sdk.agents.listAgents({});
const runs = await sdk.agentRuns.listAgentRuns({ agentId: agent.id });

agents = sdk.agents.list_agents()
runs = sdk.agent_runs.list_agent_runs(agent_id="agt_123")

// Actualice el agente — esto confirma la versión 2
await sdk.agents.updateAgent({
  agentId: agent.id,
  updateAgentRequest: { instructions: 'Responda con detalle exhaustivo.' },
});

// Inspeccione el historial
const versions = await sdk.agentVersions.listAgentVersions({ agentId: agent.id });
// versions.data → [ { version: 2, isCurrent: true, … }, { version: 1, … } ]

// Obtenga una versión completa
const v2 = await sdk.agentVersions.getAgentVersion({ agentId: agent.id, version: 2 });

// Revierta a v1 — añade v3 con restoredFromVersion: 1
await sdk.agentVersions.rollbackAgentVersion({ agentId: agent.id, version: 1 });

sdk.agents.update_agent(agent_id=agent.id, instructions="Responda con detalle exhaustivo.")

versions = sdk.agent_versions.list_agent_versions(agent_id=agent.id)
# versions.data → [AgentVersion(version=2, is_current=True, …), AgentVersion(version=1, …)]

v2 = sdk.agent_versions.get_agent_version(agent_id=agent.id, version=2)

sdk.agent_versions.rollback_agent_version(agent_id=agent.id, version=1)
# el historial ahora es v3 (actual, restored_from_version=1), v2, v1

const response = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    instructions: 'Use las herramientas de Linear cuando el usuario pregunte sobre tareas, errores o proyectos.',
    input: 'Liste mi issue de Linear más reciente asignado a mí.',
    tools: [
      {
        type: 'mcp',
        serverLabel: 'Linear MCP',
        serverUrl: 'https://mcp.linear.app/mcp',
        allowedTools: ['issues.list'],
        headers: { Authorization: `Bearer ${process.env.LINEAR_API_KEY}` },
        requireApproval: 'never',
      },
    ],
  },
}) as ResponseObject;

console.log(response.outputText);

response = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    instructions="Use las herramientas de Linear cuando el usuario pregunte sobre tareas, errores o proyectos.",
    input="Liste mi issue de Linear más reciente asignado a mí.",
    tools=[
        {
            "type": "mcp",
            "server_label": "Linear MCP",
            "server_url": "https://mcp.linear.app/mcp",
            "allowed_tools": ["issues.list"],
            "headers": {"Authorization": f"Bearer {os.environ['LINEAR_API_KEY']}"},
            "require_approval": "never",
        },
    ],
)

print(response.output_text)

const schedule = await sdk.agentSchedules.createAgentSchedule({
  agentId: agent.id,
  createAgentScheduleRequest: {
    name: 'weekday-morning-briefing',
    schedule: {
      type: 'cron',
      cronExpression: '0 9 * * 1-5',
      timezone: 'America/Los_Angeles',
    },
    input: 'Summarize the release notes published in the last 24 hours.',
  },
});

console.log(schedule.id, schedule.status);

schedule = sdk.agent_schedules.create_agent_schedule(
    agent_id=agent.id,
    name="weekday-morning-briefing",
    schedule={
        "type": "cron",
        "cron_expression": "0 9 * * 1-5",
        "timezone": "America/Los_Angeles",
    },
    input="Summarize the release notes published in the last 24 hours.",
)

print(schedule.id, schedule.status)

const created = await sdk.sandbox.create({
  createSessionRequest: { sessionId: 'getting-started-demo', ttlSeconds: 300 }, // tiempo máximo de inactividad, renovado con cada comando
});
const sessionId = created.session.sessionId;
const sessionToken = created.sessionToken;

// Sondee hasta que el contenedor esté en marcha
let status = created.session.status;
while (status === 'pending' || status === 'provisioning' || status === 'queued') {
  await new Promise((r) => setTimeout(r, 2000));
  status = (await sdk.sandbox.get({ sessionId })).status;
}

const result = await sdk.sandbox.runCommand({
  sessionId,
  commandRequest: { sessionId, sessionToken, command: 'echo', args: ['hello from the sandbox'] },
});
console.log(result.exitCode, result.stdout);

await sdk.sandbox.terminate({
  sessionId,
  terminateSessionRequest: { sessionId, sessionToken },
});

created = sdk.sandbox.create(session_id="getting-started-demo", ttl_seconds=300)  # tiempo máximo de inactividad, renovado con cada comando
session_id = created.session.session_id
session_token = created.session_token

# Sondee hasta que el contenedor esté en marcha
status = created.session.status
while status in ("pending", "provisioning", "queued"):
    time.sleep(2)
    status = sdk.sandbox.get(session_id=session_id).status

result = sdk.sandbox.run_command(
    session_id_param=session_id,
    session_id=session_id,
    session_token=session_token,
    command="echo",
    args=["hello from the sandbox"],
)
print(result.exit_code, result.stdout)

sdk.sandbox.terminate(
    session_id_param=session_id,
    session_id=session_id,
    session_token=session_token,
)

const prompt = await sdk.llm.prompts.create({
  createPromptRequest: {
    name: 'greeting',
    template: '¡Hola, {{name}}! Bienvenido a {{company}}.',
  },
});

const rendered = await sdk.llm.prompts.get({
  id: prompt.id,
  variables: JSON.stringify({ name: 'Alice', company: 'Acme' }),
});
console.log(rendered.renderedTemplate); // "¡Hola, Alice! Bienvenido a Acme."

prompt = sdk.llm.prompts.create(
    name="greeting",
    template="¡Hola, {{name}}! Bienvenido a {{company}}.",
)

rendered = sdk.llm.prompts.get(
    id=prompt.id,
    variables=json.dumps({"name": "Alice", "company": "Acme"}),
)
print(rendered.rendered_template)  # "¡Hola, Alice! Bienvenido a Acme."

const { headers, result } = await sdk.llm.speech.speak({
  textToSpeechRequest: {
    text: 'Welcome to the MKA1 API speech guide.',
    language: 'en',
  },
});
// headers['x-language-code'] → ['en']

const chunks = [];
for await (const chunk of result) chunks.push(chunk);
writeFileSync('speech.wav', Buffer.concat(chunks));

res = sdk.llm.speech.speak(
    text="Welcome to the MKA1 API speech guide.",
    language="en",
)
# res.headers["x-language-code"] → ["en"]; res.result transmite los bytes WAV

with open("speech.wav", "wb") as fh:
    fh.write(res.result.read())

// Variante de baja latencia
const streamed = await sdk.llm.speech.speakStreaming({
  textToSpeechStreamingRequest: {
    text: 'Start speaking this response as soon as audio is ready.',
    language: 'en',
    format: 'mp3',
  },
});

# Variante de baja latencia — note format_ con guion bajo final
streamed = sdk.llm.speech.speak_streaming(
    text="Start speaking this response as soon as audio is ready.",
    language="en",
    format_="mp3",
)

const result = await sdk.llm.speech.transcribe({
  language: 'en',
  prompt: 'This is a technical podcast about machine learning.',
  temperature: 0.2,
  requestBody: { file: await openAsBlob('episode.wav') },
});

console.log(result.text);       // transcripción
console.log(result.confidence); // confianza de la detección

with open("episode.wav", "rb") as fh:
    result = sdk.llm.speech.transcribe(
        file={"file_name": "episode.wav", "content": fh.read()},
        language="en",
        prompt="This is a technical podcast about machine learning.",
        temperature=0.2,
    )

print(result.text)        # transcripción
print(result.confidence)  # confianza de la detección

const now = Math.floor(Date.now() / 1000);

const spend = await sdk.usage.costs({
  startTime: now - 7 * 24 * 60 * 60, // últimos 7 días (segundos unix)
  endTime: now,
  groupBy: 'model,api_key_id', // dimensiones separadas por comas
});
// spend.data → [{ model, apiKeyId, teamId, externalUserId, orgId, cost }, …]

now = int(time.time())
spend = sdk.usage.costs(
    start_time=now - 7 * 24 * 3600,  # últimos 7 días (segundos unix)
    end_time=now,
    group_by="model,api_key_id",  # dimensiones separadas por comas
)
# spend.data → filas con model, api_key_id, team_id, external_user_id, org_id, cost

// Tope mensual en un usuario final: advertir al 80%, bloquear al 100%
const budget = await sdk.budgets.setExternalUser({
  id: 'customer-4821', // el id X-On-Behalf-Of que envía en sus solicitudes
  requestBody: {
    period: 'monthly',
    limit: 20, // unidades mayores de la moneda del clúster (vea Precios arriba)
    thresholds: [
      { pct: 80, action: 'alert' },
      { pct: 100, action: 'block' },
    ],
  },
});
console.log(budget.id, budget.spend.status); // "ok"

// Vuelva a leerlo con su medidor de gasto en vivo
const { data } = await sdk.budgets.getExternalUser({ id: 'customer-4821' });
for (const row of data) {
  console.log(row.owner, row.period, row.spend.pct, row.spend.status);
}

# Tope mensual en un usuario final: advertir al 80%, bloquear al 100%
budget = sdk.budgets.set_external_user(
    id="customer-4821",  # el id X-On-Behalf-Of que envía en sus solicitudes
    period="monthly",
    limit=20,  # unidades mayores de la moneda del clúster (vea Precios arriba)
    thresholds=[
        {"pct": 80, "action": "alert"},
        {"pct": 100, "action": "block"},
    ],
)
print(budget.id, budget.spend.status)  # "ok"

# Vuelva a leerlo con su medidor de gasto en vivo
budgets = sdk.budgets.get_external_user(id="customer-4821")
for row in budgets.data:
    print(row.owner, row.period, row.spend.pct, row.spend.status)

const now = Math.floor(Date.now() / 1000);

const usage = await sdk.llm.usage.responses({
  startTime: now - 7 * 24 * 60 * 60, // últimos 7 días (segundos unix)
  endTime: now,
  bucketWidth: '1d',
  groupBy: 'model',
});
// usage.data → un bucket por día, cada uno con resultados por modelo
// (tokens de entrada/salida, conteos de solicitudes)

now = int(time.time())
usage = sdk.llm.usage.responses(
    start_time=now - 7 * 24 * 3600,  # últimos 7 días (segundos unix)
    end_time=now,
    bucket_width="1d",
    group_by="model",
)
# usage.data → un bucket por día, cada uno con resultados por modelo