@smoothcodes/agent-client 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,74 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `web_search`: o agente buscou na web, abriu ou procurou numa página. A tela mostra a busca/URL e os resultados.
+ */
+export interface EventsItemWebSearch {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemWebSearch.Status;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    /** Número da tentativa (1 = a primeira). */
+    attempt?: number | undefined;
+    /** subagente = itens com parentItemId */
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    taskId?: SmoothAgentApi.EventsTaskId | undefined;
+    /** trabalho que segue depois do turno: isento da regra do steer */
+    background?: boolean | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** Título curto pra tela. */
+    title?: string | undefined;
+    /** este item substitui aquele (o provedor reescreveu; o outro vem item.retracted) */
+    supersedes?: SmoothAgentApi.EventsItemId | undefined;
+    startedAt?: SmoothAgentApi.EventsTimestamp | undefined;
+    completedAt?: SmoothAgentApi.EventsTimestamp | undefined;
+    native?: SmoothAgentApi.EventsNativeRef | undefined;
+    /** Consulta. */
+    query?: string | undefined;
+    /** Consultas. */
+    queries?: string[] | undefined;
+    /** search (busca), open (abriu página) ou find (procurou na página). */
+    action?: EventsItemWebSearch.Action | undefined;
+    /** URL. */
+    url?: string | undefined;
+    /** Resultados. */
+    results?: EventsItemWebSearch.Results.Item[] | undefined;
+    output?: SmoothAgentApi.EventsToolOutput | undefined;
+    /** Entrada da tool como texto (JSON parcial durante o stream). */
+    inputText?: string | undefined;
+}
+export declare namespace EventsItemWebSearch {
+    /** Estado. */
+    const Status: {
+        readonly InProgress: "in_progress";
+        readonly Waiting: "waiting";
+        readonly Completed: "completed";
+        readonly Failed: "failed";
+        readonly Interrupted: "interrupted";
+        readonly Declined: "declined";
+        readonly Cancelled: "cancelled";
+        readonly Retracted: "retracted";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+    /** search (busca), open (abriu página) ou find (procurou na página). */
+    const Action: {
+        readonly Search: "search";
+        readonly Open: "open";
+        readonly Find: "find";
+    };
+    type Action = (typeof Action)[keyof typeof Action];
+    type Results = Results.Item[];
+    namespace Results {
+        interface Item {
+            /** Título curto pra tela. */
+            title?: string | undefined;
+            /** URL. */
+            url?: string | undefined;
+            /** Trecho. */
+            snippet?: string | undefined;
+            /** Domínio. */
+            domain?: string | undefined;
+            /** o texto cita isto */
+            refId?: string | undefined;
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Uma janela de limite da assinatura/chave (5 h, 7 dias, primária…).
+ */
+export interface EventsLimitWindow {
+    /** five_hour, seven_day, primary, secondary… */
+    id: string;
+    /** Rótulo. */
+    label?: string | undefined;
+    /** Tamanho da janela em minutos. */
+    durationMins?: number | undefined;
+    /** Quanto da janela foi usado (0–100). */
+    usedPercent?: number | undefined;
+    resetsAt?: SmoothAgentApi.EventsTimestamp | undefined;
+    /** ok, warning (perto do limite) ou reached (estourou). */
+    status: EventsLimitWindow.Status;
+}
+export declare namespace EventsLimitWindow {
+    /** ok, warning (perto do limite) ou reached (estourou). */
+    const Status: {
+        readonly Ok: "ok";
+        readonly Warning: "warning";
+        readonly Reached: "reached";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+}

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

@@ -0,0 +1,46 @@
+import type * 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 type * 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,32 @@
+/**
+ * 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=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 type * 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 type * 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 type * 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 type * 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 type * 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 type * 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 type * 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,18 @@
+import type * 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;
+}
+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 type * 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 type * 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 type * 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 type * 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/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,6 @@
+export interface ModelInfo {
+    id: string;
+    name: string;
+    isDefault: boolean;
+    efforts?: string[] | undefined;
+}

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

@@ -0,0 +1,9 @@
+import type * 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 type * 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 connect --code XXXX-XXXX`. */
+    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];
+}