@smoothbuilder/smoothagent-agent-server 0.0.0-stage → 0.3.0

package/dist/types/sdk/generated/ts-server/api/types/AgentHealth.d.ts

@@ -0,0 +1,68 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Saúde do agente: credencial, MCP (testado na hora com `probeMcp`) e boxes.
+ */
+export interface AgentHealth {
+    agentId: string;
+    name: string;
+    provider: string;
+    credential: AgentHealth.Credential;
+    mcp: AgentHealth.Mcp.Item[];
+    boxes: AgentHealth.Boxes.Item[];
+}
+export declare namespace AgentHealth {
+    interface Credential {
+        source: Credential.Source;
+        connectionId: string | null;
+        status: Credential.Status;
+        via: string | null;
+        expiresAt: SmoothAgentApi.Timestamp | null;
+        message: string;
+    }
+    namespace Credential {
+        const Source: {
+            readonly Connection: "connection";
+            readonly User: "user";
+        };
+        type Source = (typeof Source)[keyof typeof Source];
+        const Status: {
+            readonly Ok: "ok";
+            readonly Expired: "expired";
+            readonly Dead: "dead";
+            readonly NotConnected: "not_connected";
+            readonly PerUser: "per_user";
+        };
+        type Status = (typeof Status)[keyof typeof Status];
+    }
+    type Mcp = Mcp.Item[];
+    namespace Mcp {
+        interface Item {
+            name: string;
+            url: string;
+            status: Item.Status;
+            latencyMs?: number | undefined;
+            error?: string | undefined;
+        }
+        namespace Item {
+            const Status: {
+                readonly Online: "online";
+                readonly Offline: "offline";
+                readonly NotProbed: "not_probed";
+            };
+            type Status = (typeof Status)[keyof typeof Status];
+        }
+    }
+    type Boxes = Boxes.Item[];
+    namespace Boxes {
+        interface Item {
+            machineId: string;
+            kind: string;
+            boxKey: string | null;
+            state: string;
+            instanceId: string | null;
+            busy: boolean | null;
+            ramMb: number | null;
+            message: string;
+        }
+    }
+}

package/dist/types/sdk/generated/ts-server/api/types/AgentHooks.d.ts

@@ -0,0 +1,11 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface AgentHooks {
+    preTurn?: SmoothAgentApi.PreTurnHook | undefined;
+    /**
+     * Atalho: cria/atualiza um endpoint de webhook do workspace filtrado por este agente
+     * O endpoint completo (segredo, eventos, testes) é em `/webhook-endpoints` (com `agentId`);
+     * o segredo de assinatura (`whsec_…`) sai por `POST /webhook-endpoints/{id}/rotate-secret`.
+     */
+    webhookUrl?: string | undefined;
+    webhookEvents?: string[] | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/AgentHooksMergePatchUpdateOrCreate.d.ts

@@ -0,0 +1,11 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface AgentHooksMergePatchUpdateOrCreate {
+    preTurn?: (SmoothAgentApi.PreTurnHookMergePatchUpdateOrCreate | null) | undefined;
+    /**
+     * Atalho: cria/atualiza um endpoint de webhook do workspace filtrado por este agente
+     * O endpoint completo (segredo, eventos, testes) é em `/webhook-endpoints` (com `agentId`);
+     * o segredo de assinatura (`whsec_…`) sai por `POST /webhook-endpoints/{id}/rotate-secret`.
+     */
+    webhookUrl?: (string | null) | undefined;
+    webhookEvents?: (string[] | null) | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/AgentLimits.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Limites que O AGENTE configurou. Ausente = sem limite (princípio 10).
+ */
+export interface AgentLimits {
+    /** Teto de um run (turno + subagentes + background), em segundos. */
+    maxRunSeconds?: number | undefined;
+    maxRunCostUsd?: number | undefined;
+    maxTurns?: number | undefined;
+    /** Chats rodando ao mesmo tempo neste agente. */
+    maxConcurrentRuns?: number | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/AgentLimitsMergePatchUpdateOrCreate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Limites que O AGENTE configurou. Ausente = sem limite (princípio 10).
+ */
+export interface AgentLimitsMergePatchUpdateOrCreate {
+    /** Teto de um run (turno + subagentes + background), em segundos. */
+    maxRunSeconds?: (number | null) | undefined;
+    maxRunCostUsd?: (number | null) | undefined;
+    maxTurns?: (number | null) | undefined;
+    /** Chats rodando ao mesmo tempo neste agente. */
+    maxConcurrentRuns?: (number | null) | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/AgentMessageOrigin.d.ts

@@ -0,0 +1,12 @@
+export interface AgentMessageOrigin {
+    kind: AgentMessageOrigin.Kind;
+    agentId: string;
+    displayName?: string | undefined;
+    avatarUrl?: string | undefined;
+}
+export declare namespace AgentMessageOrigin {
+    const Kind: {
+        readonly Agent: "agent";
+    };
+    type Kind = (typeof Kind)[keyof typeof Kind];
+}

package/dist/types/sdk/generated/ts-server/api/types/AgentProviderOption.d.ts

@@ -0,0 +1,11 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Um provedor que o usuário pode usar num agente SEM motor (os que ele tem conectados).
+ */
+export interface AgentProviderOption {
+    provider: SmoothAgentApi.EventsProvider;
+    /** Os modelos que a credencial DELE libera nesse provedor. */
+    models: SmoothAgentApi.ModelInfo[];
+    capabilities: SmoothAgentApi.EventsCapabilities;
+    ready: boolean;
+}

package/dist/types/sdk/generated/ts-server/api/types/AgentPublic.d.ts

@@ -0,0 +1,18 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface AgentPublic {
+    id: string;
+    name: string;
+    /** Ausente = agente SEM motor: as opções estão em `providers` (o chat escolhe uma no create). */
+    provider?: SmoothAgentApi.EventsProvider | undefined;
+    /** Agente com motor: os modelos dele. Sem motor: vazio (ver `providers[].models`). */
+    models: SmoothAgentApi.ModelInfo[];
+    /** Agente sem motor: o que vale nos dois motores; o de cada um está em `providers[].capabilities`. */
+    capabilities: SmoothAgentApi.EventsCapabilities;
+    /** Só agente SEM motor: os provedores que o usuário tem CONECTADOS (vazio = nenhum; `needs` diz o que conectar). */
+    providers?: SmoothAgentApi.AgentProviderOption[] | undefined;
+    theme?: SmoothAgentApi.AgentTheme | undefined;
+    /** O usuário consegue mandar mensagem agora? (`provider_not_connected` se não). */
+    ready: boolean;
+    /** Como conectar o que falta (o mesmo de `/me/providers`). */
+    needs?: SmoothAgentApi.EventsProvider[] | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/AgentTheme.d.ts

@@ -0,0 +1,14 @@
+/**
+ * O que o TOKEN DE USUÁRIO vê do agente: sem prompt, MCP, hooks, credencial, metadata.
+ * `models` = só o que está CONECTADO pra este usuário (credencial do agente > a dele).A cara do chat embutido (paridade v2). Só estes campos.
+ */
+export interface AgentTheme {
+    /** Título no topo do chat (≤ 60). */
+    title?: string | undefined;
+    /** `#rrggbb` */
+    color?: string | undefined;
+    /** URL https do logo. */
+    logoUrl?: string | undefined;
+    /** Mensagem de boas-vindas antes da primeira mensagem (≤ 500). */
+    welcome?: string | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/AgentThemeMergePatchUpdateOrCreate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * O que o TOKEN DE USUÁRIO vê do agente: sem prompt, MCP, hooks, credencial, metadata.
+ * `models` = só o que está CONECTADO pra este usuário (credencial do agente > a dele).A cara do chat embutido (paridade v2). Só estes campos.
+ */
+export interface AgentThemeMergePatchUpdateOrCreate {
+    /** Título no topo do chat (≤ 60). */
+    title?: (string | null) | undefined;
+    /** `#rrggbb` */
+    color?: (string | null) | undefined;
+    /** URL https do logo. */
+    logoUrl?: (string | null) | undefined;
+    /** Mensagem de boas-vindas antes da primeira mensagem (≤ 500). */
+    welcome?: (string | null) | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/ApiKey.d.ts

@@ -0,0 +1,33 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface ApiKey {
+    id: string;
+    name: string;
+    kind: ApiKey.Kind;
+    workspaceId: string | null;
+    scopes: SmoothAgentApi.Scope[];
+    agents: string[] | null;
+    /** Os 4 últimos caracteres do segredo, pra reconhecer. */
+    last4: string;
+    createdAt: SmoothAgentApi.Timestamp;
+    lastUsedAt: SmoothAgentApi.Timestamp | null;
+    expiresAt: SmoothAgentApi.Timestamp | null;
+    revokedAt: SmoothAgentApi.Timestamp | null;
+    /**
+     * Quem criou, quando foi um membro pelo dashboard (preenchido na LISTA). A chave é da organização: continua valendo
+     * depois que o membro sai (padrão Stripe); o remover membro devolve as dele pra oferecer revogar. null = criada por
+     * outra chave/plataforma, ou fora da lista.
+     */
+    createdBy: ApiKey.CreatedBy | null;
+}
+export declare namespace ApiKey {
+    const Kind: {
+        readonly Account: "account";
+        readonly Workspace: "workspace";
+        readonly Restricted: "restricted";
+    };
+    type Kind = (typeof Kind)[keyof typeof Kind];
+    interface CreatedBy {
+        memberId: string;
+        email: string | null;
+    }
+}

package/dist/types/sdk/generated/ts-server/api/types/ApiKeyWithSecret.d.ts

@@ -0,0 +1,35 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface ApiKeyWithSecret {
+    id: string;
+    name: string;
+    kind: ApiKeyWithSecret.Kind;
+    workspaceId: string | null;
+    scopes: SmoothAgentApi.Scope[];
+    agents: string[] | null;
+    /** Os 4 últimos caracteres do segredo, pra reconhecer. */
+    last4: string;
+    createdAt: SmoothAgentApi.Timestamp;
+    lastUsedAt: SmoothAgentApi.Timestamp | null;
+    expiresAt: SmoothAgentApi.Timestamp | null;
+    revokedAt: SmoothAgentApi.Timestamp | null;
+    /**
+     * Quem criou, quando foi um membro pelo dashboard (preenchido na LISTA). A chave é da organização: continua valendo
+     * depois que o membro sai (padrão Stripe); o remover membro devolve as dele pra oferecer revogar. null = criada por
+     * outra chave/plataforma, ou fora da lista.
+     */
+    createdBy: ApiKeyWithSecret.CreatedBy | null;
+    /** `sa_sk_…` (cheia) ou `sa_rk_…` (restrita). Só nesta resposta — nunca mais. */
+    secret: string;
+}
+export declare namespace ApiKeyWithSecret {
+    const Kind: {
+        readonly Account: "account";
+        readonly Workspace: "workspace";
+        readonly Restricted: "restricted";
+    };
+    type Kind = (typeof Kind)[keyof typeof Kind];
+    interface CreatedBy {
+        memberId: string;
+        email: string | null;
+    }
+}

package/dist/types/sdk/generated/ts-server/api/types/BillingLine.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Só PREÇO: nunca custo, margem nem nota interna.
+ */
+export interface BillingLine {
+    service: BillingLine.Service;
+    detail: string;
+    priceUsd: number;
+}
+export declare namespace BillingLine {
+    const Service: {
+        readonly Compute: "compute";
+        readonly Storage: "storage";
+        readonly Logs: "logs";
+        readonly Other: "other";
+        readonly Shared: "shared";
+        readonly Cloudflare: "cloudflare";
+        readonly Llm: "llm";
+    };
+    type Service = (typeof Service)[keyof typeof Service];
+}

package/dist/types/sdk/generated/ts-server/api/types/BillingStatement.d.ts

@@ -0,0 +1,24 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface BillingStatement {
+    period: string;
+    /** true = mês fechado (imutável); false = aberto, calculado até agora. */
+    closed: boolean;
+    workspaceId: string;
+    lines: SmoothAgentApi.BillingLine[];
+    perAgent: BillingStatement.PerAgent.Item[];
+    totalUsd: number;
+    /** Só quando o valor do período ainda pode mudar (fatura do fornecedor incompleta). */
+    note?: string | undefined;
+}
+export declare namespace BillingStatement {
+    type PerAgent = PerAgent.Item[];
+    namespace PerAgent {
+        interface Item {
+            agentId: string;
+            name: string;
+            deleted: boolean;
+            lines: SmoothAgentApi.BillingLine[];
+            totalUsd: number;
+        }
+    }
+}

package/dist/types/sdk/generated/ts-server/api/types/BoxFileContent.d.ts

@@ -0,0 +1,17 @@
+export interface BoxFileContent {
+    path: string;
+    /** `utf8` = texto; `base64` = binário. */
+    encoding: BoxFileContent.Encoding;
+    content: string;
+    sizeBytes: number;
+    /** Arquivo maior que o teto (1 MB): veio só o começo. */
+    truncated: boolean;
+}
+export declare namespace BoxFileContent {
+    /** `utf8` = texto; `base64` = binário. */
+    const Encoding: {
+        readonly Utf8: "utf8";
+        readonly Base64: "base64";
+    };
+    type Encoding = (typeof Encoding)[keyof typeof Encoding];
+}

package/dist/types/sdk/generated/ts-server/api/types/BoxFileEntry.d.ts

@@ -0,0 +1,15 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface BoxFileEntry {
+    name: string;
+    type: BoxFileEntry.Type;
+    sizeBytes?: number | undefined;
+    modifiedAt?: SmoothAgentApi.Timestamp | undefined;
+}
+export declare namespace BoxFileEntry {
+    const Type: {
+        readonly File: "file";
+        readonly Dir: "dir";
+        readonly Symlink: "symlink";
+    };
+    type Type = (typeof Type)[keyof typeof Type];
+}

package/dist/types/sdk/generated/ts-server/api/types/BoxFileList.d.ts

@@ -0,0 +1,5 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface BoxFileList {
+    path: string;
+    entries: SmoothAgentApi.BoxFileEntry[];
+}

package/dist/types/sdk/generated/ts-server/api/types/BoxIncident.d.ts

@@ -0,0 +1,7 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface BoxIncident {
+    at: SmoothAgentApi.Timestamp;
+    type: string;
+    reason: string | null;
+    instanceId: string | null;
+}

package/dist/types/sdk/generated/ts-server/api/types/BoxProfile.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Perfil da box: vale quando o agente sobe a box própria ou do usuário.
+ */
+export interface BoxProfile {
+    vcpu?: number | undefined;
+    ramMb?: number | undefined;
+    /** Layers do Detona, em ordem de precedência. */
+    layers?: string[] | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/BoxProfileMergePatchUpdateOrCreate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Perfil da box: vale quando o agente sobe a box própria ou do usuário.
+ */
+export interface BoxProfileMergePatchUpdateOrCreate {
+    vcpu?: (number | null) | undefined;
+    ramMb?: (number | null) | undefined;
+    /** Layers do Detona, em ordem de precedência. */
+    layers?: (string[] | null) | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/Chat.d.ts

@@ -0,0 +1,39 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface Chat {
+    id: string;
+    workspaceId: string;
+    userId: string;
+    /** O ÚLTIMO agente usado — o que a próxima mensagem usa se ninguém trocar. */
+    agentId: string;
+    provider: SmoothAgentApi.EventsProvider;
+    /** Modelo fixado neste chat. Ausente = o padrão do agente/da conta (o resolvido está em `/selection`). Nunca `null`. */
+    model?: string | undefined;
+    /** Esforço de raciocínio, separado do modelo (P1). Ausente = padrão. */
+    effort?: string | undefined;
+    /** Troca agendada esperando o run ativo completar. */
+    scheduledSwitch: SmoothAgentApi.EventsScheduledSwitch | null;
+    machineId: string;
+    title: string | null;
+    metadata: SmoothAgentApi.Metadata;
+    /** Projeção pra lateral: vem do log, atualizada pelo ingest. */
+    state: Chat.State;
+    /** Cursor do último evento: `String(seq)` (o que a SDK usa pra assinar). */
+    lastEventId: string | null;
+    lastEventSeq: number;
+    /** Respostas do agente (runs fechados) depois do que esta pessoa marcou como lido (P8). */
+    unreadCount: number;
+    /** Até onde esta pessoa leu (`String(seq)`), ou null se nunca marcou. */
+    lastReadEventId: string | null;
+    createdAt: SmoothAgentApi.Timestamp;
+    updatedAt: SmoothAgentApi.Timestamp;
+}
+export declare namespace Chat {
+    /** Projeção pra lateral: vem do log, atualizada pelo ingest. */
+    const State: {
+        readonly Idle: "idle";
+        readonly Starting: "starting";
+        readonly Working: "working";
+        readonly Waiting: "waiting";
+    };
+    type State = (typeof State)[keyof typeof State];
+}

package/dist/types/sdk/generated/ts-server/api/types/ChatContext.d.ts

@@ -0,0 +1,18 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface ChatContext {
+    /** Tokens usados da janela. */
+    usedTokens: number;
+    /** Tamanho da janela em tokens. */
+    limitTokens?: number | undefined;
+    /** pronto, 0–100 */
+    percent?: number | undefined;
+    /** Onde o provedor compacta sozinho. */
+    autoCompactAtTokens?: number | undefined;
+    /** Modelo. */
+    model?: string | undefined;
+    /** quantas compactações no chat */
+    compactions?: number | undefined;
+    /** a janela é deste provedor/modelo (muda na troca) */
+    provider?: SmoothAgentApi.EventsProvider | undefined;
+    updatedAt: SmoothAgentApi.Timestamp | null;
+}

package/dist/types/sdk/generated/ts-server/api/types/ChatDeleted.d.ts

@@ -0,0 +1,15 @@
+/**
+ * O chat apagado: some na hora; `pending` = a limpeza da box ainda corre (sem esperar o Detona), `done` = já foi.
+ */
+export interface ChatDeleted {
+    id: string;
+    deleted: boolean;
+    cleanup: ChatDeleted.Cleanup;
+}
+export declare namespace ChatDeleted {
+    const Cleanup: {
+        readonly Pending: "pending";
+        readonly Done: "done";
+    };
+    type Cleanup = (typeof Cleanup)[keyof typeof Cleanup];
+}

package/dist/types/sdk/generated/ts-server/api/types/ChatDiagnosis.d.ts

@@ -0,0 +1,24 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * O diagnóstico do chat: o culpado de cada turno (paridade v2 `chatDiagnose`).
+ */
+export interface ChatDiagnosis {
+    chatId: string;
+    agentId: string;
+    machineId: string;
+    box: ChatDiagnosis.Box | null;
+    incidents: SmoothAgentApi.BoxIncident[];
+    runs: SmoothAgentApi.RunDiagnosis[];
+    /** Uma frase: o último problema e o culpado, ou "sem problemas". */
+    summary: string;
+}
+export declare namespace ChatDiagnosis {
+    interface Box {
+        boxKey: string;
+        state: string;
+        instanceId: string | null;
+        reason: string | null;
+        ramMb: number | null;
+        ramInUseMb: number | null;
+    }
+}

package/dist/types/sdk/generated/ts-server/api/types/ChatSelection.d.ts

@@ -0,0 +1,40 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Tudo o que o seletor da tela precisa, pronto.
+ */
+export interface ChatSelection {
+    current: ChatSelection.Current;
+    scheduledSwitch: SmoothAgentApi.EventsScheduledSwitch | null;
+    /**
+     * O que dá pra escolher: os agentes que o usuário pode usar, cada um com SÓ os modelos
+     * conectados pra ele (credencial do agente > a do usuário). Agente sem credencial vem com
+     * `ready: false` e `needs` (a tela oferece conectar), nunca escondido sem motivo.
+     */
+    options: SmoothAgentApi.AgentPublic[];
+    /** `false` enquanto há run ativo: a troca seria agendada, não imediata. */
+    switchableNow: boolean;
+}
+export declare namespace ChatSelection {
+    interface Current {
+        agentId: string;
+        agentName: string | null;
+        provider: SmoothAgentApi.EventsProvider;
+        /** O modelo que VAI RODAR, resolvido (chat > agente > padrão da credencial). Ausente só se o provedor não informou nenhum. */
+        model?: string | undefined;
+        modelName?: string | undefined;
+        /** O modelo concreto em que o `model` (alias da assinatura) resolve agora, segundo o CLI. Ausente = `model` já é concreto. */
+        resolvedModel?: string | undefined;
+        /** Esforço separado do modelo (P1). */
+        effort?: string | undefined;
+        /** De onde vem a credencial que roda este chat; null = nenhuma conectada. */
+        credentialVia: Current.CredentialVia | null;
+    }
+    namespace Current {
+        const CredentialVia: {
+            readonly Agent: "agent";
+            readonly Subscription: "subscription";
+            readonly Key: "key";
+        };
+        type CredentialVia = (typeof CredentialVia)[keyof typeof CredentialVia];
+    }
+}

package/dist/types/sdk/generated/ts-server/api/types/ChatTask.d.ts

@@ -0,0 +1,32 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Uma tarefa viva ou recente do chat: subagente ou processo de fundo do agente.
+ */
+export interface ChatTask {
+    id: string;
+    kind: ChatTask.Kind;
+    /** O que o agente disse que é (descrição do subagente, a linha de comando…). */
+    title: string;
+    status: ChatTask.Status;
+    /** O item do log que abriu a tarefa (pular pra ela no histórico). */
+    itemId?: string | undefined;
+    startedAt: SmoothAgentApi.Timestamp;
+    endedAt?: SmoothAgentApi.Timestamp | undefined;
+    exitCode?: number | undefined;
+}
+export declare namespace ChatTask {
+    const Kind: {
+        readonly Subagent: "subagent";
+        readonly Command: "command";
+        readonly Monitor: "monitor";
+        readonly Terminal: "terminal";
+    };
+    type Kind = (typeof Kind)[keyof typeof Kind];
+    const Status: {
+        readonly Running: "running";
+        readonly Completed: "completed";
+        readonly Failed: "failed";
+        readonly Stopped: "stopped";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+}

package/dist/types/sdk/generated/ts-server/api/types/ChatTaskOutput.d.ts

@@ -0,0 +1,9 @@
+export interface ChatTaskOutput {
+    taskId: string;
+    /** Texto a partir de `after` (offset em bytes da saída inteira). */
+    text: string;
+    /** Offset pra pedir o resto (`after`). */
+    next: number;
+    /** A tarefa terminou e não vem mais nada. */
+    done: boolean;
+}

package/dist/types/sdk/generated/ts-server/api/types/ChatUsage.d.ts

@@ -0,0 +1,19 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface ChatUsage {
+    /** Soma de todos os runs do chat (inclui os de outros provedores, separados em `byProvider`). */
+    total: SmoothAgentApi.EventsUsage;
+    byProvider: ChatUsage.ByProvider.Item[];
+    /** O run ativo ou o último. */
+    lastRun: SmoothAgentApi.RunSummary | null;
+}
+export declare namespace ChatUsage {
+    type ByProvider = ByProvider.Item[];
+    namespace ByProvider {
+        interface Item {
+            provider: SmoothAgentApi.EventsProvider;
+            model: string | null;
+            runs: number;
+            usage: SmoothAgentApi.EventsUsage;
+        }
+    }
+}

package/dist/types/sdk/generated/ts-server/api/types/Connection.d.ts

@@ -0,0 +1,10 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface Connection {
+    id: string;
+    workspaceId: string;
+    name: string;
+    providers: SmoothAgentApi.ProviderStatus[];
+    /** Agentes que apontam pra ela (apagar uma conexão em uso = `conflict`). */
+    usedBy: string[];
+    createdAt: SmoothAgentApi.Timestamp;
+}

package/dist/types/sdk/generated/ts-server/api/types/Culprit.d.ts

@@ -0,0 +1,10 @@
+/** Quem precisa agir. */
+export declare const Culprit: {
+    readonly Credential: "credential";
+    readonly Provider: "provider";
+    readonly Resources: "resources";
+    readonly Layer: "layer";
+    readonly Platform: "platform";
+    readonly User: "user";
+};
+export type Culprit = (typeof Culprit)[keyof typeof Culprit];

package/dist/types/sdk/generated/ts-server/api/types/Deleted.d.ts

@@ -0,0 +1,4 @@
+export interface Deleted {
+    id: string;
+    deleted: boolean;
+}

package/dist/types/sdk/generated/ts-server/api/types/DeviceFlow.d.ts

@@ -0,0 +1,11 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Assinatura ChatGPT: o CLI oficial roda `codex login --device-auth` numa box descartável (o WAF
+ * barra o nosso servidor) e devolve URL + código; o usuário autoriza no navegador DELE.
+ */
+export interface DeviceFlow {
+    loginId: string;
+    url: string;
+    userCode: string;
+    expiresAt: SmoothAgentApi.Timestamp;
+}

package/dist/types/sdk/generated/ts-server/api/types/ErrorBody.d.ts

@@ -0,0 +1,12 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface ErrorBody {
+    code: SmoothAgentApi.EventsErrorCode;
+    message: string;
+    retryable: boolean;
+    /** O campo culpado em `invalid_request` (estilo Stripe `param`). */
+    param?: string | undefined;
+    /** Id da requisição (também no header `Request-Id`) — o que o dev manda pro suporte. */
+    requestId: string;
+    /** Dados do código: `reason` (unauthorized/forbidden/box_unavailable), `resetsAt`, `scope` que faltou… */
+    details?: Record<string, unknown> | undefined;
+}

package/dist/types/sdk/generated/ts-server/api/types/Error_.d.ts

@@ -0,0 +1,4 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface Error_ {
+    error: SmoothAgentApi.ErrorBody;
+}