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

package/dist/types/sdk/generated/ts-client/api/types/EventsLimits.d.ts

@@ -0,0 +1,46 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Consumo da assinatura/chave — pronto pra tela
+ */
+export interface EventsLimits {
+    provider: SmoothAgentApi.EventsProvider;
+    /** De onde vem o limite: subscription, key ou agent. */
+    via?: EventsLimits.Via | undefined;
+    /** Plano da assinatura. */
+    plan?: string | undefined;
+    /** Janelas de limite. */
+    windows: SmoothAgentApi.EventsLimitWindow[];
+    /** Créditos restantes. */
+    credits?: EventsLimits.Credits | undefined;
+    /** Uso além do plano. */
+    overage?: EventsLimits.Overage | undefined;
+}
+export declare namespace EventsLimits {
+    /** De onde vem o limite: subscription, key ou agent. */
+    const Via: {
+        readonly Subscription: "subscription";
+        readonly Key: "key";
+        readonly Agent: "agent";
+    };
+    type Via = typeof Via[keyof typeof Via];
+    /**
+     * Créditos restantes.
+     */
+    interface Credits {
+        /** Quanto resta. */
+        remaining?: number | undefined;
+        /** Unidade. */
+        unit?: string | undefined;
+    }
+    /**
+     * Uso além do plano.
+     */
+    interface Overage {
+        /** Estado. */
+        status?: string | undefined;
+        /** Em uso agora. */
+        inUse?: boolean | undefined;
+        /** Por que está desligado. */
+        disabledReason?: string | undefined;
+    }
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsMessageId.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Id de uma mensagem do usuário (`msg_…`); é com ele que o consumo volta do provedor.
+ */
+export type EventsMessageId = string;

package/dist/types/sdk/generated/ts-client/api/types/EventsModelUsage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Consumo de um modelo (dentro de Usage.byModel).
+ */
+export interface EventsModelUsage {
+    /** Tokens de entrada. */
+    inputTokens?: number | undefined;
+    /** Tokens de saída. */
+    outputTokens?: number | undefined;
+    /** Tokens lidos do cache. */
+    cacheReadTokens?: number | undefined;
+    /** Tokens gravados no cache. */
+    cacheWriteTokens?: number | undefined;
+    /** Tokens de raciocínio. */
+    reasoningTokens?: number | undefined;
+    /** Custo em dólares (só com chave de API). */
+    costUsd?: number | undefined;
+    /** Janela de contexto do modelo. */
+    contextWindow?: number | undefined;
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsNativeRef.d.ts

@@ -0,0 +1,17 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Ids do provedor = EVIDÊNCIA, nunca identidade. Pequeno e sempre presente quando existe; o frame inteiro vai em raw.
+ */
+export interface EventsNativeRef {
+    provider: SmoothAgentApi.EventsProvider;
+    /** Id. */
+    id?: string | undefined;
+    /** tipo nativo: tool_use, commandExecution, local_bash… */
+    type?: string | undefined;
+    /** Id da sessão nativa (Claude). */
+    sessionId?: string | undefined;
+    /** Id da thread nativa (Codex). */
+    threadId?: string | undefined;
+    /** Id do turno nativo. */
+    turnId?: string | undefined;
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsOrigin.d.ts

@@ -0,0 +1,37 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * QUEM causou
+ */
+export interface EventsOrigin {
+    /** user = uma interface; agent = o agente (prompt de subagente); provider = o provedor sozinho (wake, peer); schedule = agendamento; system = a plataforma */
+    kind: EventsOrigin.Kind;
+    /** Id do usuário. */
+    userId?: string | undefined;
+    /** a interface/aba */
+    clientId?: string | undefined;
+    /** o token de dispositivo */
+    deviceId?: string | undefined;
+    /** nome do usuário pra tela (users.displayName, definido pelo dev) */
+    displayName?: string | undefined;
+    /** rótulo do dispositivo da sessão (web, celular, runner local…) */
+    deviceName?: string | undefined;
+    /** nome legível (peer, agendamento) */
+    name?: string | undefined;
+    /** kind=agent: agente autor validado no mesmo workspace */
+    agentId?: SmoothAgentApi.EventsAgentId | undefined;
+    /** URL do avatar do autor */
+    avatarUrl?: string | undefined;
+    /** kind=schedule: o agendamento que disparou (schedule_task) */
+    scheduleId?: string | undefined;
+}
+export declare namespace EventsOrigin {
+    /** user = uma interface; agent = o agente (prompt de subagente); provider = o provedor sozinho (wake, peer); schedule = agendamento; system = a plataforma */
+    const Kind: {
+        readonly User: "user";
+        readonly Agent: "agent";
+        readonly Provider: "provider";
+        readonly Schedule: "schedule";
+        readonly System: "system";
+    };
+    type Kind = typeof Kind[keyof typeof Kind];
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsProvider.d.ts

@@ -0,0 +1,4 @@
+/**
+ * claude | codex | fake | …
+ */
+export type EventsProvider = string;

package/dist/types/sdk/generated/ts-client/api/types/EventsRawFrame.d.ts

@@ -0,0 +1,18 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Um frame nativo do provedor, como chegou ou saiu (só com includeRaw).
+ */
+export interface EventsRawFrame {
+    provider: SmoothAgentApi.EventsProvider;
+    /** in = do provedor; out = pro provedor. */
+    direction?: EventsRawFrame.Direction | undefined;
+    frame?: unknown | undefined;
+}
+export declare namespace EventsRawFrame {
+    /** in = do provedor; out = pro provedor. */
+    const Direction: {
+        readonly In: "in";
+        readonly Out: "out";
+    };
+    type Direction = typeof Direction[keyof typeof Direction];
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsRequestId.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Id de um pedido de aprovação ou pergunta (`req_…`).
+ */
+export type EventsRequestId = string;

package/dist/types/sdk/generated/ts-client/api/types/EventsRunAgent.d.ts

@@ -0,0 +1,27 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * QUEM rodou este run — o que o control projeta (runs, uso por provedor)
+ */
+export interface EventsRunAgent {
+    agentId: SmoothAgentApi.EventsAgentId;
+    /** revisão da config do agente que rodou */
+    agentRevision: number;
+    /** Nome do agente pra tela. */
+    agentName?: string | undefined;
+    provider: SmoothAgentApi.EventsProvider;
+    /** Modelo. */
+    model?: string | undefined;
+    /** Esforço de raciocínio (low, medium, high…). */
+    effort?: string | undefined;
+    /** que credencial rodou (sem segredo): a do agente (inclui o provedor fake), a assinatura do usuário ou a chave de API — os mesmos valores do runs/config e do /selection */
+    credentialVia: EventsRunAgent.CredentialVia;
+}
+export declare namespace EventsRunAgent {
+    /** que credencial rodou (sem segredo): a do agente (inclui o provedor fake), a assinatura do usuário ou a chave de API — os mesmos valores do runs/config e do /selection */
+    const CredentialVia: {
+        readonly Agent: "agent";
+        readonly Subscription: "subscription";
+        readonly Key: "key";
+    };
+    type CredentialVia = typeof CredentialVia[keyof typeof CredentialVia];
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsRunId.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Id de um run (`run_…`): um turno do provedor do começo ao fim, com as tentativas.
+ */
+export type EventsRunId = string;

package/dist/types/sdk/generated/ts-client/api/types/EventsRunTrigger.d.ts

@@ -0,0 +1,29 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Por que o run abriu e o que o disparou.
+ */
+export interface EventsRunTrigger {
+    /** por que o run abriu: mensagem, wake (tarefa acabou), agendamento, troca, peer, provedor sem dizer, plataforma */
+    kind: EventsRunTrigger.Kind;
+    /** Mensagens envolvidas. */
+    messageIds?: SmoothAgentApi.EventsMessageId[] | undefined;
+    taskId?: SmoothAgentApi.EventsTaskId | undefined;
+    /** O agendamento. */
+    scheduleId?: string | undefined;
+    switchId?: SmoothAgentApi.EventsSwitchId | undefined;
+    /** Nome. */
+    name?: string | undefined;
+}
+export declare namespace EventsRunTrigger {
+    /** por que o run abriu: mensagem, wake (tarefa acabou), agendamento, troca, peer, provedor sem dizer, plataforma */
+    const Kind: {
+        readonly Message: "message";
+        readonly Wake: "wake";
+        readonly Schedule: "schedule";
+        readonly Handoff: "handoff";
+        readonly Peer: "peer";
+        readonly Provider: "provider";
+        readonly System: "system";
+    };
+    type Kind = typeof Kind[keyof typeof Kind];
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsScheduledSwitch.d.ts

@@ -0,0 +1,11 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * troca pedida com run ativo: efetiva no run.completed/STOP; cancelável
+ */
+export interface EventsScheduledSwitch {
+    switchId: SmoothAgentApi.EventsSwitchId;
+    to: SmoothAgentApi.EventsAgentSelection;
+    by: SmoothAgentApi.EventsOrigin;
+    at: SmoothAgentApi.EventsTimestamp;
+    afterRunId?: SmoothAgentApi.EventsRunId | undefined;
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsStopId.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Id de um STOP (`stop_…`): o mesmo STOP repetido não para duas vezes.
+ */
+export type EventsStopId = string;

package/dist/types/sdk/generated/ts-client/api/types/EventsSwitchId.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Id de uma troca de agente/provedor (`sw_…`).
+ */
+export type EventsSwitchId = string;

package/dist/types/sdk/generated/ts-client/api/types/EventsTask.d.ts

@@ -0,0 +1,45 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Trabalho que vive além do item (subagente, background, monitor)
+ */
+export interface EventsTask {
+    taskId: SmoothAgentApi.EventsTaskId;
+    /** Tipo de tarefa: subagent, command (background), monitor ou other. */
+    kind: EventsTask.Kind;
+    /** Estado da tarefa: running, completed, failed ou stopped. */
+    status: EventsTask.Status;
+    /** Descrição. */
+    description?: string | undefined;
+    /** o agente espera: SEGURA o run; não-awaited segura só a box */
+    awaited: boolean;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    startedAt?: SmoothAgentApi.EventsTimestamp | undefined;
+    endedAt?: SmoothAgentApi.EventsTimestamp | undefined;
+    /** Resumo. */
+    summary?: string | undefined;
+    /** Código de saída. */
+    exitCode?: number | undefined;
+    /** Tem saída guardada pra ler. */
+    hasOutput?: boolean | undefined;
+    progress?: SmoothAgentApi.EventsTaskProgress | undefined;
+    native?: SmoothAgentApi.EventsNativeRef | undefined;
+}
+export declare namespace EventsTask {
+    /** Tipo de tarefa: subagent, command (background), monitor ou other. */
+    const Kind: {
+        readonly Subagent: "subagent";
+        readonly Command: "command";
+        readonly Monitor: "monitor";
+        readonly Other: "other";
+    };
+    type Kind = typeof Kind[keyof typeof Kind];
+    /** Estado da tarefa: running, completed, failed ou stopped. */
+    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-client/api/types/EventsTaskId.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Id de uma tarefa que vive além do item (`tsk_…`): subagente, comando em background, monitor.
+ */
+export type EventsTaskId = string;

package/dist/types/sdk/generated/ts-client/api/types/EventsTaskProgress.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Progresso de uma tarefa ou subagente em andamento.
+ */
+export interface EventsTaskProgress {
+    /** Texto. */
+    text?: string | undefined;
+    /** Tools usadas. */
+    toolUses?: number | undefined;
+    /** Tokens. */
+    tokens?: number | undefined;
+    /** Última tool. */
+    lastTool?: string | undefined;
+    /** Duração em milissegundos. */
+    durationMs?: number | undefined;
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsTimestamp.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Data e hora em ISO 8601 (UTC).
+ */
+export type EventsTimestamp = string;

package/dist/types/sdk/generated/ts-client/api/types/EventsToolOutput.d.ts

@@ -0,0 +1,16 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Saída de uma tool: texto, partes de conteúdo e/ou JSON estruturado.
+ */
+export interface EventsToolOutput {
+    /** Texto. */
+    text?: string | undefined;
+    /** Conteúdo. */
+    content?: SmoothAgentApi.EventsContentPart[] | undefined;
+    /** Saída estruturada (JSON). */
+    structured?: unknown | undefined;
+    /** A tool falhou. */
+    isError?: boolean | undefined;
+    /** A saída foi cortada. */
+    truncated?: boolean | undefined;
+}

package/dist/types/sdk/generated/ts-client/api/types/EventsUsage.d.ts

@@ -0,0 +1,34 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Consumo. Ausente = provedor não informou (nunca estimado).
+ */
+export interface EventsUsage {
+    /** Tokens de entrada. */
+    inputTokens?: number | undefined;
+    /** Tokens de saída. */
+    outputTokens?: number | undefined;
+    /** Tokens lidos do cache. */
+    cacheReadTokens?: number | undefined;
+    /** Tokens gravados no cache. */
+    cacheWriteTokens?: number | undefined;
+    /** Claude: 5m × 1h têm preço diferente */
+    cacheWriteByTtl?: Record<string, number> | undefined;
+    /** standard / priority / fast */
+    serviceTier?: string | undefined;
+    /** Tokens de raciocínio. */
+    reasoningTokens?: number | undefined;
+    /** Buscas na web. */
+    webSearchRequests?: number | undefined;
+    /** Chamadas de tool. */
+    toolCalls?: number | undefined;
+    /** chamadas ao modelo */
+    providerTurns?: number | undefined;
+    /** Duração em milissegundos. */
+    durationMs?: number | undefined;
+    /** Tempo de API em ms. */
+    apiDurationMs?: number | undefined;
+    /** só com chave de API */
+    costUsd?: number | undefined;
+    /** subagente roda noutro modelo */
+    byModel?: Record<string, SmoothAgentApi.EventsModelUsage> | undefined;
+}

package/dist/types/sdk/generated/ts-client/api/types/FileObject.d.ts

@@ -0,0 +1,24 @@
+import * as SmoothAgentApi from "../index.js";
+export interface FileObject {
+    id: string;
+    workspaceId: string;
+    userId: string | null;
+    filename: string;
+    mimeType: string;
+    sizeBytes: number;
+    status: FileObject.Status;
+    createdAt: SmoothAgentApi.Timestamp;
+    /**
+     * Link público do arquivo pronto, pra TELA mostrar direto (img/download), quando a plataforma publica os arquivos
+     * por domínio próprio. Não se adivinha pelo id; morre na hora em que o arquivo é apagado. O agente nunca recebe
+     * este link (recebe o conteúdo).
+     */
+    url?: string | undefined;
+}
+export declare namespace FileObject {
+    const Status: {
+        readonly Uploading: "uploading";
+        readonly Ready: "ready";
+    };
+    type Status = typeof Status[keyof typeof Status];
+}

package/dist/types/sdk/generated/ts-client/api/types/HistoryEntry.d.ts

@@ -0,0 +1,10 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Uma entrada do histórico: o evento que FECHOU um item (ou mensagem/STOP/troca) + o seq dele.
+ */
+export interface HistoryEntry {
+    /** O número do evento que fechou o item — a SDK compara com o ao vivo por ele. */
+    seq: number;
+    eventId: string;
+    event: SmoothAgentApi.EventsEvent;
+}

package/dist/types/sdk/generated/ts-client/api/types/HistoryPage.d.ts

@@ -0,0 +1,24 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Página de ITENS FECHADOS (nunca pedaços), na ordem do log, o mesmo formato do stream.
+ * Um histórico só, mesmo com troca de provedor (os `handoff`/`agent.switched` aparecem no lugar).
+ * Exatamente um âncora: `before`, `after`, `around` ou `anchor=end` (padrão = end).
+ */
+export interface HistoryPage {
+    data: SmoothAgentApi.HistoryEntry[];
+    /** `eventId` do primeiro e do último item da página — os cursores pros dois sentidos. */
+    firstEventId: string | null;
+    lastEventId: string | null;
+    hasBefore: boolean;
+    hasAfter: boolean;
+    /** `around`: o índice do item âncora em `data`. */
+    anchorIndex?: number | undefined;
+    /** Último evento do log no momento da leitura (mesma transação da página). */
+    headEventId: string | null;
+    /**
+     * De onde a SDK assina o ao vivo: `headEventId`, ou (seq do `item.started` do item ainda ABERTO
+     * mais antigo) − 1 — senão os deltas dele, anteriores ao head, se perderiam. A SDK descarta pelo
+     * número o que já veio na página.
+     */
+    liveFromEventId: string | null;
+}

package/dist/types/sdk/generated/ts-client/api/types/LoginStatus.d.ts

@@ -0,0 +1,15 @@
+import * as SmoothAgentApi from "../index.js";
+export interface LoginStatus {
+    loginId: string;
+    status: LoginStatus.Status;
+    error?: SmoothAgentApi.ErrorBody | undefined;
+}
+export declare namespace LoginStatus {
+    const Status: {
+        readonly Pending: "pending";
+        readonly Completed: "completed";
+        readonly Failed: "failed";
+        readonly Expired: "expired";
+    };
+    type Status = typeof Status[keyof typeof Status];
+}

package/dist/types/sdk/generated/ts-client/api/types/Machine.d.ts

@@ -0,0 +1,43 @@
+import * as SmoothAgentApi from "../index.js";
+export interface Machine {
+    id: string;
+    workspaceId: string;
+    userId: string;
+    kind: Machine.Kind;
+    /** Nome do dev (cloud_box) ou do computador (local). Único por (workspace, usuário). */
+    name: string;
+    /** Só nuvem. O perfil da máquina vale pra todo chat que aponta pra ela. */
+    profile?: SmoothAgentApi.BoxProfile | undefined;
+    state: Machine.State;
+    /** Só local: o que o runner reportou ao parear. */
+    device?: Machine.Device | undefined;
+    lastSeenAt: SmoothAgentApi.Timestamp | null;
+    createdAt: SmoothAgentApi.Timestamp;
+}
+export declare namespace Machine {
+    const Kind: {
+        readonly CloudChat: "cloud_chat";
+        readonly CloudBox: "cloud_box";
+        readonly Local: "local";
+    };
+    type Kind = typeof Kind[keyof typeof Kind];
+    const State: {
+        readonly Online: "online";
+        readonly Offline: "offline";
+        readonly Busy: "busy";
+        readonly Waking: "waking";
+        readonly Ready: "ready";
+        readonly Sleeping: "sleeping";
+        readonly Crashed: "crashed";
+    };
+    type State = typeof State[keyof typeof State];
+    /**
+     * Só local: o que o runner reportou ao parear.
+     */
+    interface Device {
+        os: string;
+        arch: string;
+        runnerVersion: string;
+        hostname?: string | undefined;
+    }
+}

package/dist/types/sdk/generated/ts-client/api/types/McpServer.d.ts

@@ -0,0 +1,13 @@
+export interface McpServer {
+    /**
+     * Chave estável (vira o nome da tool `mcp__<name>__…`). `smoothagent` (qualquer caixa, com `-`/`_`) é reservado à
+     * plataforma: 400 `reserved_mcp_name`.
+     */
+    name: string;
+    url: string;
+    /**
+     * Headers enviados ao servidor MCP. Valor pode referenciar segredo: `{{secret:NOME}}`.
+     * Write-only: a leitura devolve só os NOMES dos headers.
+     */
+    headers?: Record<string, string> | undefined;
+}

package/dist/types/sdk/generated/ts-client/api/types/MessageReceipt.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Consulta indexada de uma mensagem aceita, sem varrer eventos.
+ */
+export interface MessageReceipt {
+    messageId: string;
+    status: MessageReceipt.Status;
+    runId?: string | undefined;
+    eventId?: string | undefined;
+}
+export declare namespace MessageReceipt {
+    const Status: {
+        readonly Accepted: "accepted";
+        readonly Queued: "queued";
+        readonly Running: "running";
+        readonly Completed: "completed";
+        readonly Failed: "failed";
+        readonly Stopped: "stopped";
+        readonly NotDelivered: "not_delivered";
+    };
+    type Status = typeof Status[keyof typeof Status];
+}

package/dist/types/sdk/generated/ts-client/api/types/Metadata.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Metadados livres do dev (Stripe): até 50 chaves, valores string ≤ 500.
+ */
+export type Metadata = Record<string, string>;

package/dist/types/sdk/generated/ts-client/api/types/ModelInfo.d.ts

@@ -0,0 +1,12 @@
+export interface ModelInfo {
+    /** O que vai no pedido (`model`): o id do provedor, ou o ALIAS que o CLI da assinatura aceita (`default`, `opus`…). */
+    id: string;
+    name: string;
+    isDefault: boolean;
+    efforts?: string[] | undefined;
+    /**
+     * O modelo concreto em que o alias resolve AGORA, como o próprio CLI diz (Claude: o `initialize`, ex.
+     * `default` → `claude-opus-5-5`). Ausente = o `id` já é o modelo concreto.
+     */
+    resolvedModel?: string | undefined;
+}

package/dist/types/sdk/generated/ts-client/api/types/MyProviderStatus.d.ts

@@ -0,0 +1,61 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Um provedor na lista do usuário: o status + se algum agente que ele pode usar roda nele.
+ */
+export interface MyProviderStatus {
+    provider: SmoothAgentApi.ProviderKind;
+    connected: boolean;
+    /** `agent` = o agente já traz (o usuário não precisa conectar). */
+    via: MyProviderStatus.Via.Item[];
+    /** Só assinatura: quando o access token atual vence (o CLI renova sozinho — doutrina do token). */
+    expiresAt?: (SmoothAgentApi.Timestamp | null) | undefined;
+    /**
+     * Saúde pro dashboard. `ok`; `expiring` = o access token da assinatura venceu, a box renova sozinha no
+     * próximo uso (nada a fazer); `dead` = o provedor recusou a renovação e não há outra viva (reconectar);
+     * `disconnected` = nada conectado.
+     */
+    status: MyProviderStatus.Status;
+    /** Explicação curta pro usuário quando não é `ok`. */
+    message?: string | undefined;
+    /** Os modelos que ESTA credencial libera (extraídos do provedor, nunca catálogo nosso). */
+    models: SmoothAgentApi.ModelInfo[];
+    /** Como conectar o que falta. */
+    connect: MyProviderStatus.Connect.Item[];
+    /**
+     * `true` = algum agente que o usuário pode usar roda neste provedor (o app do cliente filtra por isso pra
+     * mostrar "só o configurado"); `false` = oferecido, mas nenhum agente dele precisa agora.
+     */
+    needed: boolean;
+}
+export declare namespace MyProviderStatus {
+    type Via = Via.Item[];
+    namespace Via {
+        const Item: {
+            readonly Subscription: "subscription";
+            readonly Key: "key";
+            readonly Agent: "agent";
+        };
+        type Item = typeof Item[keyof typeof Item];
+    }
+    /**
+     * Saúde pro dashboard. `ok`; `expiring` = o access token da assinatura venceu, a box renova sozinha no
+     * próximo uso (nada a fazer); `dead` = o provedor recusou a renovação e não há outra viva (reconectar);
+     * `disconnected` = nada conectado.
+     */
+    const Status: {
+        readonly Ok: "ok";
+        readonly Expiring: "expiring";
+        readonly Dead: "dead";
+        readonly Disconnected: "disconnected";
+    };
+    type Status = typeof Status[keyof typeof Status];
+    type Connect = Connect.Item[];
+    namespace Connect {
+        const Item: {
+            readonly Oauth: "oauth";
+            readonly Device: "device";
+            readonly Key: "key";
+        };
+        type Item = typeof Item[keyof typeof Item];
+    }
+}

package/dist/types/sdk/generated/ts-client/api/types/OAuthFlow.d.ts

@@ -0,0 +1,9 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Assinatura Claude: OAuth com cola de código (o client público só aceita o redirect de cola).
+ */
+export interface OAuthFlow {
+    loginId: string;
+    url: string;
+    expiresAt: SmoothAgentApi.Timestamp;
+}

package/dist/types/sdk/generated/ts-client/api/types/Pairing.d.ts

@@ -0,0 +1,18 @@
+import * as SmoothAgentApi from "../index.js";
+export interface Pairing {
+    /** Código curto pra digitar (`XXXX-XXXX`, estilo device flow RFC 8628). */
+    code: string;
+    /** Comando pronto: `npx smoothagent@3 connect --code XXXX-XXXX` (fixa a major do runner). */
+    command: string;
+    expiresAt: SmoothAgentApi.Timestamp;
+    status: Pairing.Status;
+    machineId?: string | undefined;
+}
+export declare namespace Pairing {
+    const Status: {
+        readonly Pending: "pending";
+        readonly Completed: "completed";
+        readonly Expired: "expired";
+    };
+    type Status = typeof Status[keyof typeof Status];
+}