Primeiros passos

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-pt',
    input: 'Resuma este ticket de suporte.',
  },
}) 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-pt",
    input="Resuma este ticket de suporte.",
    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 é o JWT de curta duração — use-o 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 é o JWT de curta duração — use-o 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>" } — depois envie Authorization: Bearer <jwt>

const result = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Qual é a capital da França?',
  },
}) as ResponseObject;
console.log(result.outputText);

res = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Qual é a capital da França?",
)

mka1 llm responses create \
  --model meetkai:functionary-pt \
  --input '"Qual é a capital da França?"' \
  -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-pt", "input": "Qual é a capital da França?" }'

const result = await sdk.llm.responses.create({
  xOnBehalfOf: '<end-user-id>', // opcional — atribua a solicitação a um dos seus usuários finais
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Escreva um resumo de uma frase da API MKA1.',
  },
});

res = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Escreva um resumo de uma frase da API MKA1.",
    http_headers={"X-On-Behalf-Of": "<end-user-id>"},
)

const stream = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Escreva três tópicos de notas de lançamento para nossa atualização de documentação.',
    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-pt",
    input="Escreva três tópicos de notas de lançamento para nossa atualização de documentação.",
    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', // compatível com visão — 'auto' descarta imagens atualmente
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Descreva o que você vê nesta imagem.' },
          {
            type: 'input_image',
            imageUrl: 'https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg',
          },
        ],
      },
    ],
  },
});

res = sdk.llm.responses.create(
    model="openai:gpt-4.1",  # compatível com visão — 'auto' descarta imagens atualmente
    input=[
        {
            "type": "message",
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Descreva o que você vê nesta imagem."},
                {
                    "type": "input_image",
                    "image_url": "https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg",
                },
            ],
        },
    ],
    x_on_behalf_of="<end-user-id>",  # opcional — atribua a solicitação a um dos seus usuários finais
)

const queued = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Escreva uma história de duas frases sobre a máquina de fax.',
    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-pt",
    input="Escreva uma história de duas frases sobre a máquina de fax.",
    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-pt',
    input: 'Resuma este relatório 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-pt",
    input="Resuma este relatório 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. Crie uma conversa (metadados opcionais para seu próprio roteamento)
const conv = await sdk.llm.conversations.create({
  xOnBehalfOf: '<end-user-id>',
  createConversationRequest: {
    metadata: { session_id: 'web-42', channel: 'support' },
  },
});

// 2. (Opcional) grave o histórico explicitamente antes de chamar Responses
await sdk.llm.conversations.createItems({
  conversationId: conv.id,
  xOnBehalfOf: '<end-user-id>',
  createItemsRequest: {
    items: [
      { type: 'message', role: 'user', content: 'Resuma o ticket de suporte mais recente.' },
    ],
  },
});

// 3. Continue o fluxo — anexe a conversa para que o modelo tenha histórico
const result = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    conversation: conv.id,
    input: 'Transforme esse resumo em uma resposta pronta para o cliente.',
  },
});

# 1. Crie uma conversa (metadados opcionais para seu próprio roteamento)
conv = sdk.llm.conversations.create(
    metadata={"session_id": "web-42", "channel": "support"},
    x_on_behalf_of="<end-user-id>",
)

# 2. (Opcional) grave o histórico explicitamente antes de chamar Responses
sdk.llm.conversations.create_items(
    conversation_id=conv.id,
    items=[
        {"type": "message", "role": "user", "content": "Resuma o ticket de suporte mais recente."},
    ],
    x_on_behalf_of="<end-user-id>",
)

# 3. Continue o fluxo — anexe a conversa para que o modelo tenha histórico
result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    conversation=conv.id,
    input="Transforme esse resumo em uma resposta pronta para o cliente.",
)

// Sessão 1: armazene um fato
await sdk.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Lembre-se disto: minha cor favorita é azul.',
    tools: [{ type: 'history' }],
    store: true,
  },
});

// Sessão 2 (minutos ou dias depois — a indexação leva cerca de 1–2 min): lembre-se dele
const recalled = await sdk.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Qual é a minha cor favorita?',
    tools: [{ type: 'history' }],
    store: true,
  },
});
// → "Sua cor favorita é azul."

# Sessão 1: armazene um fato
sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Lembre-se disto: minha cor favorita é azul.",
    tools=[{"type": "history"}],
    store=True,
    x_on_behalf_of="user-123",
)

# Sessão 2 (minutos ou dias depois — a indexação leva cerca de 1–2 min): lembre-se dele
recalled = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Qual é a minha cor favorita?",
    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 → por exemplo, 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 → por exemplo, file_1783481291595_r19s7ueog7o

const vectorStore = await sdk.llm.vectorStores.create({
  xOnBehalfOf: '<end-user-id>',
  createVectorStoreRequest: {
    name: 'Base de conhecimento de suporte',
    description: 'Manuais de suporte indexados e documentos da central de ajuda',
    fileIds: [result.id],
    expiresAfter: { anchor: 'last_active_at', days: 30 },
  },
});

vector_store = sdk.llm.vector_stores.create(
    name="Base de conhecimento de suporte",
    description="Manuais de suporte indexados e documentos da central de ajuda",
    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: 'Como redefino minha senha?',
    maxNumResults: 5,
  },
});

results = sdk.llm.vector_stores.search(
    vector_store_id=vector_store.id,
    query="Como redefino minha senha?",
    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'],
};

// Extração pontual — o esquema é uma string JSON aqui
const res = await sdk.llm.extract.extract({
  requestBody: {
    model: 'openai:gpt-4.1', // 'auto' atualmente retorna 500 neste endpoint
    prompt: 'Extraia o título do documento, a expiração do link de redefinição e o e-mail de suporte.',
    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"],
}

# Extração pontual — o esquema é uma string JSON aqui
with open("support-manual.txt", "rb") as fh:
    res = sdk.llm.extract.extract(
        model="openai:gpt-4.1",  # 'auto' atualmente retorna 500 neste endpoint
        prompt="Extraia o título do documento, a expiração do link de redefinição e o e-mail de suporte.",
        schema=json.dumps(schema),
        file={"file_name": "support-manual.txt", "content": fh.read()},
    )
# res.success, res.data, res.metadata

// Modelo reutilizável — o esquema é um objeto aqui; o id chega em data.id
const created = await sdk.llm.extract.createSchema({
  extractionSchema: {
    name: 'support-manual',
    description: 'Extraia fatos do manual de suporte',
    schema,
  },
});

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

# Modelo reutilizável — o esquema é um dict aqui; o id chega em data.id
created = sdk.llm.extract.create_schema(
    name="support-manual",
    description="Extraia fatos do manual de suporte",
    schema=schema,
)

out = sdk.llm.extract.extract_with_schema(
    schema_id=created.data.id,
    model="openai:gpt-4.1",
    prompt="Extraia os 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: 'Pesquisa informações atuais sobre lançamentos antes de responder.',
    model: 'meetkai:functionary-pt',
    instructions: 'Use a pesquisa na web quando a pergunta depender de informações externas atuais.',
    tools: [{ type: 'web_search', searchContextSize: 'medium' }],
    metadata: { team: 'docs' },
  },
});
console.log(agent.id);

agent = sdk.agents.create_agent(
    name="release-research-agent",
    description="Pesquisa informações atuais sobre lançamentos antes de responder.",
    model="meetkai:functionary-pt",
    instructions="Use a pesquisa na web quando a pergunta depender de informações externas atuais.",
    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: "Qual é a versão estável atual do Bun? Use a pesquisa na 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="Qual é a versão estável atual do Bun? Use a pesquisa na 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")

// Atualize o agente — isso confirma a versão 2
await sdk.agents.updateAgent({
  agentId: agent.id,
  updateAgentRequest: { instructions: 'Responda com detalhes exaustivos.' },
});

// Inspecione o histórico
const versions = await sdk.agentVersions.listAgentVersions({ agentId: agent.id });
// versions.data → [ { version: 2, isCurrent: true, … }, { version: 1, … } ]

// Busque uma versão completa
const v2 = await sdk.agentVersions.getAgentVersion({ agentId: agent.id, version: 2 });

// Reverta para v1 — adiciona v3 com restoredFromVersion: 1
await sdk.agentVersions.rollbackAgentVersion({ agentId: agent.id, version: 1 });

sdk.agents.update_agent(agent_id=agent.id, instructions="Responda com detalhes exaustivos.")

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)
# o histórico agora é v3 (atual, restored_from_version=1), v2, v1

const response = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    instructions: 'Use ferramentas do Linear quando o usuário perguntar sobre tarefas, bugs ou projetos.',
    input: 'Liste o problema mais recente do Linear atribuído a mim.',
    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-pt",
    instructions="Use ferramentas do Linear quando o usuário perguntar sobre tarefas, bugs ou projetos.",
    input="Liste o problema mais recente do Linear atribuído a mim.",
    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 }, // tempo limite de inatividade, renovado a cada comando
});
const sessionId = created.session.sessionId;
const sessionToken = created.sessionToken;

// Consulte até que o contêiner esteja no ar
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)  # tempo limite de inatividade, renovado a cada comando
session_id = created.session.session_id
session_token = created.session_token

# Consulte até que o contêiner esteja no ar
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: 'Olá, {{name}}! Bem-vindo à {{company}}.',
  },
});

const rendered = await sdk.llm.prompts.get({
  id: prompt.id,
  variables: JSON.stringify({ name: 'Alice', company: 'Acme' }),
});
console.log(rendered.renderedTemplate); // "Olá, Alice! Bem-vindo à Acme."

prompt = sdk.llm.prompts.create(
    name="greeting",
    template="Olá, {{name}}! Bem-vindo à {{company}}.",
)

rendered = sdk.llm.prompts.get(
    id=prompt.id,
    variables=json.dumps({"name": "Alice", "company": "Acme"}),
)
print(rendered.rendered_template)  # "Olá, Alice! Bem-vindo à Acme."

const { headers, result } = await sdk.llm.speech.speak({
  textToSpeechRequest: {
    text: 'Bem-vindo ao guia de fala da API MKA1.',
    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="Bem-vindo ao guia de fala da API MKA1.",
    language="en",
)
# res.headers["x-language-code"] → ["en"]; res.result transmite os bytes WAV

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

// Variante de baixa latência
const streamed = await sdk.llm.speech.speakStreaming({
  textToSpeechStreamingRequest: {
    text: 'Comece a falar esta resposta assim que o áudio estiver pronto.',
    language: 'en',
    format: 'mp3',
  },
});

# Variante de baixa latência — observe format_ com sublinhado final
streamed = sdk.llm.speech.speak_streaming(
    text="Comece a falar esta resposta assim que o áudio estiver pronto.",
    language="en",
    format_="mp3",
)

const result = await sdk.llm.speech.transcribe({
  language: 'en',
  prompt: 'Este é um podcast técnico sobre aprendizado de máquina.',
  temperature: 0.2,
  requestBody: { file: await openAsBlob('episode.wav') },
});

console.log(result.text);       // transcrição
console.log(result.confidence); // confiança da detecção

with open("episode.wav", "rb") as fh:
    result = sdk.llm.speech.transcribe(
        file={"file_name": "episode.wav", "content": fh.read()},
        language="en",
        prompt="Este é um podcast técnico sobre aprendizado de máquina.",
        temperature=0.2,
    )

print(result.text)        # transcrição
print(result.confidence)  # confiança da detecção

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

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

now = int(time.time())
spend = sdk.usage.costs(
    start_time=now - 7 * 24 * 3600,  # últimos 7 dias (segundos unix)
    end_time=now,
    group_by="model,api_key_id",  # dimensões separadas por vírgula
)
# spend.data → linhas com model, api_key_id, team_id, external_user_id, org_id, cost

// Teto mensal em um usuário final: avise em 80%, bloqueie em 100%
const budget = await sdk.budgets.setExternalUser({
  id: 'customer-4821', // o id X-On-Behalf-Of que você envia nas solicitações dele
  requestBody: {
    period: 'monthly',
    limit: 20, // unidades principais da moeda do cluster (consulte Preços acima)
    thresholds: [
      { pct: 80, action: 'alert' },
      { pct: 100, action: 'block' },
    ],
  },
});
console.log(budget.id, budget.spend.status); // "ok"

// Leia-o de volta com seu medidor de gasto em tempo real
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);
}

# Teto mensal em um usuário final: avise em 80%, bloqueie em 100%
budget = sdk.budgets.set_external_user(
    id="customer-4821",  # o id X-On-Behalf-Of que você envia nas solicitações dele
    period="monthly",
    limit=20,  # unidades principais da moeda do cluster (consulte Preços acima)
    thresholds=[
        {"pct": 80, "action": "alert"},
        {"pct": 100, "action": "block"},
    ],
)
print(budget.id, budget.spend.status)  # "ok"

# Leia-o de volta com seu medidor de gasto em tempo real
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 dias (segundos unix)
  endTime: now,
  bucketWidth: '1d',
  groupBy: 'model',
});
// usage.data → um intervalo por dia, cada um com resultados por modelo
// (tokens de entrada/saída, contagens de solicitações)

now = int(time.time())
usage = sdk.llm.usage.responses(
    start_time=now - 7 * 24 * 3600,  # últimos 7 dias (segundos unix)
    end_time=now,
    bucket_width="1d",
    group_by="model",
)
# usage.data → um intervalo por dia, cada um com resultados por modelo