Primeiros passos

import type { ResponseObject } from '@meetkai/mka1/models/components';

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

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

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 jwt = await mka1.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(body={
    "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}")

mka1 llm responses create \
  --model meetkai:functionary-pt \
  --input '"Qual é a capital da França?"' \
  -H 'X-On-Behalf-Of: <end-user-id>'

import { SDK } from '@meetkai/mka1';
import type { ResponseObject } from '@meetkai/mka1/models/components';

const mka1 = new SDK({ bearerAuth: 'Bearer YOUR_API_KEY' });

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

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

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

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?" }'

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

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

const result = await mka1.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.',
  },
});

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

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>"},
)

import { CreateAcceptEnum } from '@meetkai/mka1/sdk/responses';
import { EventStream } from '@meetkai/mka1/lib/event-streams';

const stream = await mka1.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 mka1.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
)

import type { ResponseObject } from '@meetkai/mka1/models/components';

const queued = await mka1.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 mka1.llm.responses.get({ responseId: queued.id }) as ResponseObject;
}
console.log(response.outputText);

import time

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 mka1.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;

import os

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"],
)

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

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

// 1. Crie uma conversa (metadados opcionais para seu próprio roteamento)
const conv = await mka1.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 mka1.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 mka1.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 mka1.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 mka1.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",
)

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

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

from meetkai_mka1 import SDK

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

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

const result = await mka1.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 mka1.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 mka1.llm.files.upload({
  xOnBehalfOf: '<end-user-id>',
  requestBody: { file: Bun.file('./help-center-faq.pdf'), purpose: 'assistants' },
});

const vsFile = await mka1.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 mka1.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 mka1.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: {…} }

import json

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 mka1.llm.extract.createSchema({
  extractionSchema: {
    name: 'support-manual',
    description: 'Extraia fatos do manual de suporte',
    schema,
  },
});

const out = await mka1.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()},
)

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

const mka1 = new SDK({ bearerAuth: 'Bearer YOUR_API_KEY' });

const agent = await mka1.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);

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

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 mka1.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 mka1.agents.listAgents({});
const runs = await mka1.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 mka1.agents.updateAgent({
  agentId: agent.id,
  updateAgentRequest: { instructions: 'Responda com detalhes exaustivos.' },
});

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

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

// Reverta para v1 — adiciona v3 com restoredFromVersion: 1
await mka1.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

import type { ResponseObject } from '@meetkai/mka1/models/components';

const response = await mka1.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);

import os

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)

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

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

const prompt = await mka1.llm.prompts.create({
  createPromptRequest: {
    name: 'greeting',
    template: 'Olá, {{name}}! Bem-vindo à {{company}}.',
  },
});

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

import json

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."

import { SDK } from '@meetkai/mka1';
import { writeFileSync } from 'node:fs';

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

const { headers, result } = await mka1.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 mka1.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",
)

import { openAsBlob } from 'node:fs';

const result = await mka1.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 mka1.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 }, …]

import time

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

// Autoorçamento mensal em uma chave de API: avise em 80%, bloqueie em 100%
await mka1.budgets.setApiKey({
  apiKeyId: 'ak_…',
  requestBody: {
    period: 'monthly',
    limit: 250, // na moeda do seu cluster — consulte budgets.getCurrency()
    thresholds: [
      { pct: 80, action: 'alert' },
      { pct: 100, action: 'block' },
    ],
    webhookUrl: 'https://your-app.example.com/hooks/budget',
    webhookSecret: process.env.MKA1_WEBHOOK_SECRET,
  },
});

const budgets = await mka1.budgets.getApiKey({ apiKeyId: 'ak_…' });
const events = await mka1.budgets.apiKeyEvents({ apiKeyId: 'ak_…' });
await mka1.budgets.deleteApiKey({ apiKeyId: 'ak_…', owner: 'org' });

// Variantes no nível da organização: budgets.setOrg / getOrg / deleteOrg / orgEvents ({ orgId, … })

sdk.budgets.set_api_key(
    api_key_id="ak_…",
    period="monthly",
    limit=250,
    thresholds=[
        {"pct": 80, "action": "alert"},
        {"pct": 100, "action": "block"},
    ],
)

budgets = sdk.budgets.get_api_key(api_key_id="ak_…")
events = sdk.budgets.api_key_events(api_key_id="ak_…")
sdk.budgets.delete_api_key(api_key_id="ak_…", owner="org")

# Variantes no nível da organização: set_org / get_org / delete_org / org_events (org_id=…)

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

const usage = await mka1.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)

import time

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

// 1. Registre o modelo a servir (fixe uma revisão para implantações reproduzíveis)
await mka1.serving.models.register({
  modelRegister: { name: 'qwen-7b', source: 'Qwen/Qwen2.5-7B-Instruct' },
});

// 2. Implante-o atrás de um endpoint com escalonamento automático
const deployment = await mka1.serving.deployments.create({
  deploymentCreate: {
    name: 'qwen-7b-prod',
    model: 'qwen-7b',
    engine: 'vllm',
    accelerator: { type: 'H100', count: 1, fallback: ['A100'] },
    scaling: { minContainers: 1, maxContainers: 4, maxConcurrentInputs: 32 },
    engineArgs: ['--max-model-len', '8192'],
    endpointAuth: true,
  },
});
// a URL do endpoint aparece na implantação assim que ela está pronta

// 3. Opere-o
await mka1.serving.deployments.updateScaling({
  deploymentId: deployment.id,
  scaling: { minContainers: 2, maxContainers: 8 }, // aplica no local — sem nova revisão
});

const logs = await mka1.serving.deployments.getLogs({ deploymentId: deployment.id, tail: 100 });

await mka1.serving.deployments.rollback({
  deploymentId: deployment.id,
  deploymentRollbackRequest: { revision: 1 }, // alterações de configuração criam revisões
});

# 1. Registre o modelo a servir (fixe uma revisão para implantações reproduzíveis)
sdk.serving.models.register(name="qwen-7b", source="Qwen/Qwen2.5-7B-Instruct")

# 2. Implante-o atrás de um endpoint com escalonamento automático
deployment = sdk.serving.deployments.create(
    name="qwen-7b-prod",
    model="qwen-7b",
    engine="vllm",
    accelerator={"type": "H100", "count": 1, "fallback": ["A100"]},
    scaling={"min_containers": 1, "max_containers": 4, "max_concurrent_inputs": 32},
    engine_args=["--max-model-len", "8192"],
    endpoint_auth=True,
)
# a URL do endpoint aparece na implantação assim que ela está pronta

# 3. Opere-o
sdk.serving.deployments.update_scaling(
    deployment_id=deployment.id,
    min_containers=2,
    max_containers=8,  # aplica no local — sem nova revisão
)

logs = sdk.serving.deployments.get_logs(deployment_id=deployment.id, tail=100)

sdk.serving.deployments.rollback(deployment_id=deployment.id, revision=1)