@smoothcodes/agent-client 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `item.delta`: sai muitas vezes enquanto um item aberto cresce (texto chegando, saída de comando, entrada da tool em stream). A tela anexa o pedaço ao item pelo id; pode não ser guardado depois que o item fecha.
+ */
+export interface EventsEItemDelta {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsEItemDeltaData;
+}

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

@@ -0,0 +1,7 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `item.delta`.
+ */
+export interface EventsEItemDeltaData {
+    delta: SmoothAgentApi.EventsDelta;
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `item.retracted`: sai quando um item já mostrado deixa de valer (o provedor reescreveu, outro item o substitui, ou rollback). A tela tira o item (ou marca como substituído) pelo id.
+ */
+export interface EventsEItemRetracted {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsEItemRetractedData;
+}

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

@@ -0,0 +1,18 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `item.retracted`.
+ */
+export interface EventsEItemRetractedData {
+    /** Por que o item saiu: superseded (outro o substitui), provider_rewrite ou rollback. */
+    reason?: EventsEItemRetractedData.Reason | undefined;
+    supersededBy?: SmoothAgentApi.EventsItemId | undefined;
+}
+export declare namespace EventsEItemRetractedData {
+    /** Por que o item saiu: superseded (outro o substitui), provider_rewrite ou rollback. */
+    const Reason: {
+        readonly Superseded: "superseded";
+        readonly ProviderRewrite: "provider_rewrite";
+        readonly Rollback: "rollback";
+    };
+    type Reason = (typeof Reason)[keyof typeof Reason];
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `item.started`: sai quando um item novo abre na timeline (mensagem lida, texto, raciocínio, tool, comando, aprovação…), com o item parcial. A tela insere o item na posição dele (por id) e mostra como "em andamento".
+ */
+export interface EventsEItemStarted {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsEItemStartedData;
+}

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

@@ -0,0 +1,8 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `item.started`.
+ */
+export interface EventsEItemStartedData {
+    /** parcial */
+    item: SmoothAgentApi.EventsItem;
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `item.updated`: sai quando um campo de um item AINDA ABERTO muda sem ser texto em stream (status, progresso, título). A tela faz merge raso no item pelo id.
+ */
+export interface EventsEItemUpdated {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsEItemUpdatedData;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Dados (`data`) do evento `item.updated`.
+ */
+export interface EventsEItemUpdatedData {
+    /** merge raso; só item ABERTO */
+    patch: Record<string, unknown>;
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `limits.updated`: sai quando o provedor informa consumo novo da assinatura/chave (janelas de 5 h, 7 dias…). A tela atualiza o aviso de limite (ok, perto, estourou) e quando reseta.
+ */
+export interface EventsELimitsUpdated {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsLimits;
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `notice`: sai quando há um aviso que não é erro do turno (ex.: um MCP indisponível, uma config ignorada). A tela mostra um aviso discreto com o nível e o texto; não para nada.
+ */
+export interface EventsENotice {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsENoticeData;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Dados (`data`) do evento `notice`.
+ */
+export interface EventsENoticeData {
+    /** Gravidade do aviso. */
+    level: EventsENoticeData.Level;
+    /** Código do aviso (ex.: mcp_unavailable). */
+    code?: string | undefined;
+    /** Texto do aviso pra tela. */
+    message: string;
+}
+export declare namespace EventsENoticeData {
+    /** Gravidade do aviso. */
+    const Level: {
+        readonly Info: "info";
+        readonly Warning: "warning";
+    };
+    type Level = (typeof Level)[keyof typeof Level];
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `run.completed`: sai UMA vez por turno, quando ele acaba de verdade (completed, stopped por STOP, ou failed com o código de erro — limite, crédito, credencial…). A tela fecha o bloco do turno, tira o "trabalhando" e, se failed, mostra o erro pronto.
+ */
+export interface EventsERunCompleted {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsERunCompletedData;
+}

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

@@ -0,0 +1,35 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `run.completed`.
+ */
+export interface EventsERunCompletedData {
+    runId: SmoothAgentApi.EventsRunId;
+    /** Como o run fechou: completed, stopped (STOP) ou failed. */
+    status: EventsERunCompletedData.Status;
+    /** Tentativas feitas. */
+    attempts?: number | undefined;
+    usage?: SmoothAgentApi.EventsUsage | undefined;
+    error?: SmoothAgentApi.EventsFailure | undefined;
+    /** O STOP que fechou. */
+    stop?: EventsERunCompletedData.Stop | undefined;
+    /** nativo da última chamada: end_turn, max_tokens… */
+    stopReason?: string | undefined;
+    /** Duração em milissegundos. */
+    durationMs?: number | undefined;
+}
+export declare namespace EventsERunCompletedData {
+    /** Como o run fechou: completed, stopped (STOP) ou failed. */
+    const Status: {
+        readonly Completed: "completed";
+        readonly Stopped: "stopped";
+        readonly Failed: "failed";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+    /**
+     * O STOP que fechou.
+     */
+    interface Stop {
+        stopId?: SmoothAgentApi.EventsStopId | undefined;
+        by?: SmoothAgentApi.EventsOrigin | undefined;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `run.started`: sai quando o agente começa um turno (ou uma nova tentativa dele: retry, auth_retry, steer que reinicia). A tela abre o bloco do turno e mostra "trabalhando"; o que vier com este runId pertence a ele.
+ */
+export interface EventsERunStarted {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsERunStartedData;
+}

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

@@ -0,0 +1,23 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `run.started`.
+ */
+export interface EventsERunStartedData {
+    runId: SmoothAgentApi.EventsRunId;
+    /** Tentativa deste run (1 = a primeira; sobe em retry e auth_retry). */
+    attempt: number;
+    /** Por que esta tentativa abriu: initial, steer_restart (steer que reinicia), retry (erro recuperável), auth_retry (depois do 401, M1). */
+    reason: EventsERunStartedData.Reason;
+    trigger: SmoothAgentApi.EventsRunTrigger;
+    agent: SmoothAgentApi.EventsRunAgent;
+}
+export declare namespace EventsERunStartedData {
+    /** Por que esta tentativa abriu: initial, steer_restart (steer que reinicia), retry (erro recuperável), auth_retry (depois do 401, M1). */
+    const Reason: {
+        readonly Initial: "initial";
+        readonly SteerRestart: "steer_restart";
+        readonly Retry: "retry";
+        readonly AuthRetry: "auth_retry";
+    };
+    type Reason = (typeof Reason)[keyof typeof Reason];
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `run.waiting`: sai quando o turno para esperando algo de fora: uma aprovação/pergunta (`input`), uma tarefa em background (`task`) ou um agendamento (`timer`). A tela destaca o pedido aberto (requestIds) ou mostra o que está esperando; o turno continua aberto.
+ */
+export interface EventsERunWaiting {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsERunWaitingData;
+}

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

@@ -0,0 +1,22 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `run.waiting`.
+ */
+export interface EventsERunWaitingData {
+    /** O que o run espera: input (aprovação/pergunta), task (tarefa em background) ou timer (agendamento). */
+    reason: EventsERunWaitingData.Reason;
+    /** Pedidos (aprovação/pergunta) envolvidos. */
+    requestIds?: SmoothAgentApi.EventsRequestId[] | undefined;
+    /** Tarefas envolvidas. */
+    taskIds?: SmoothAgentApi.EventsTaskId[] | undefined;
+    wakeAt?: SmoothAgentApi.EventsTimestamp | undefined;
+}
+export declare namespace EventsERunWaitingData {
+    /** O que o run espera: input (aprovação/pergunta), task (tarefa em background) ou timer (agendamento). */
+    const Reason: {
+        readonly Input: "input";
+        readonly Task: "task";
+        readonly Timer: "timer";
+    };
+    type Reason = (typeof Reason)[keyof typeof Reason];
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `session.started`: sai quando a box abre uma sessão do provedor no chat (1º turno, reset, troca de agente, sessão perdida, processo reiniciado ou resume). A tela pode mostrar um divisor "sessão nova" com o provedor/modelo; não mexe nos itens.
+ */
+export interface EventsESessionStarted {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsESessionStartedData;
+}

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

@@ -0,0 +1,46 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `session.started`.
+ */
+export interface EventsESessionStartedData {
+    provider: SmoothAgentApi.EventsProvider;
+    /** Modelo da sessão, quando o provedor informa. */
+    model?: string | undefined;
+    /** true = retomou a sessão nativa existente (resume); false = sessão nova. */
+    resumed: boolean;
+    /** session_lost = a sessão nativa sumiu (conta reconectada, chat noutra máquina): sessão NOVA do mesmo provedor, reinjetada com o histórico do log */
+    reason?: EventsESessionStartedData.Reason | undefined;
+    agent?: SmoothAgentApi.EventsAgentSelection | undefined;
+    /** reason=reset com clearHistory (R7): o reducer tira do estado os itens FECHADOS, os runs e as tarefas fechadas; mantém selection, usage, limits, context e o que está aberto */
+    clearHistory?: boolean | undefined;
+    native?: SmoothAgentApi.EventsNativeRef | undefined;
+    /** Versão do engine do provedor. */
+    providerVersion?: string | undefined;
+    /** Servidores MCP e o estado de cada um. */
+    mcpServers?: EventsESessionStartedData.McpServers.Item[] | undefined;
+    /** Quantidade de tools. */
+    tools?: number | undefined;
+}
+export declare namespace EventsESessionStartedData {
+    /** session_lost = a sessão nativa sumiu (conta reconectada, chat noutra máquina): sessão NOVA do mesmo provedor, reinjetada com o histórico do log */
+    const Reason: {
+        readonly First: "first";
+        readonly Reset: "reset";
+        readonly Switch: "switch";
+        readonly SessionLost: "session_lost";
+        readonly ProcessRestart: "process_restart";
+        readonly Resume: "resume";
+    };
+    type Reason = (typeof Reason)[keyof typeof Reason];
+    type McpServers = McpServers.Item[];
+    namespace McpServers {
+        interface Item {
+            /** Nome. */
+            name: string;
+            /** Estado. */
+            status: string;
+            /** Quantidade de tools. */
+            tools?: number | undefined;
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `task.updated`: sai quando uma tarefa que vive além do item (subagente, comando em background, monitor) muda de estado ou progresso. A tela atualiza o painel de tarefas; tarefa running mantém o chat ocupado mesmo sem turno.
+ */
+export interface EventsETaskUpdated {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsETaskUpdatedData;
+}

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

@@ -0,0 +1,7 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `task.updated`.
+ */
+export interface EventsETaskUpdatedData {
+    task: SmoothAgentApi.EventsTask;
+}

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

@@ -0,0 +1,21 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `usage.updated`: sai durante o turno quando o consumo parcial (tokens/custo) do run em andamento muda. A tela atualiza o contador do turno; o total fechado vem no run.completed.
+ */
+export interface EventsEUsageUpdated {
+    /** = String(seq) */
+    id: string;
+    /** cursor inteiro contíguo por chat */
+    seq: number;
+    /** fencing: a concessão que numerou */
+    epoch?: number | undefined;
+    chatId: SmoothAgentApi.EventsChatId;
+    ts: SmoothAgentApi.EventsTimestamp;
+    runId?: SmoothAgentApi.EventsRunId | undefined;
+    itemId?: SmoothAgentApi.EventsItemId | undefined;
+    parentItemId?: SmoothAgentApi.EventsItemId | undefined;
+    origin?: SmoothAgentApi.EventsOrigin | undefined;
+    /** só com includeRaw */
+    raw?: SmoothAgentApi.EventsRawFrame[] | undefined;
+    data: SmoothAgentApi.EventsEUsageUpdatedData;
+}

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

@@ -0,0 +1,9 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `usage.updated`.
+ */
+export interface EventsEUsageUpdatedData {
+    runId: SmoothAgentApi.EventsRunId;
+    /** parcial do run em andamento */
+    usage: SmoothAgentApi.EventsUsage;
+}

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

@@ -0,0 +1,21 @@
+/** Conjunto fechado. O status HTTP de cada código está em x-http (request_expired = 410: o pedido de aprovação/pergunta morreu num acordar cold). Gerador: enum com caso "desconhecido" (valor novo não pode quebrar app). */
+export declare const EventsErrorCode: {
+    readonly Unauthorized: "unauthorized";
+    readonly Forbidden: "forbidden";
+    readonly NotFound: "not_found";
+    readonly InvalidRequest: "invalid_request";
+    readonly ProviderNotConnected: "provider_not_connected";
+    readonly ProviderAuthExpired: "provider_auth_expired";
+    readonly ProviderError: "provider_error";
+    readonly UsageLimitReached: "usage_limit_reached";
+    readonly PlanLimit: "plan_limit";
+    readonly RateLimited: "rate_limited";
+    readonly BoxUnavailable: "box_unavailable";
+    readonly Conflict: "conflict";
+    readonly MachineOffline: "machine_offline";
+    readonly RequestExpired: "request_expired";
+    readonly NoRun: "no_run";
+    readonly QueueFull: "queue_full";
+    readonly Internal: "internal";
+};
+export type EventsErrorCode = (typeof EventsErrorCode)[keyof typeof EventsErrorCode];

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

@@ -0,0 +1,61 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * TIMELINE: numerado por quem tem a concessão; histórico, stream e F5
+ */
+export type EventsEvent = SmoothAgentApi.EventsEvent.SessionStarted | SmoothAgentApi.EventsEvent.ChatState | SmoothAgentApi.EventsEvent.RunStarted | SmoothAgentApi.EventsEvent.RunWaiting | SmoothAgentApi.EventsEvent.RunCompleted | SmoothAgentApi.EventsEvent.UsageUpdated | SmoothAgentApi.EventsEvent.ItemStarted | SmoothAgentApi.EventsEvent.ItemDelta | SmoothAgentApi.EventsEvent.ItemUpdated | SmoothAgentApi.EventsEvent.ItemCompleted | SmoothAgentApi.EventsEvent.ItemRetracted | SmoothAgentApi.EventsEvent.TaskUpdated | SmoothAgentApi.EventsEvent.ContextUpdated | SmoothAgentApi.EventsEvent.LimitsUpdated | SmoothAgentApi.EventsEvent.AgentSwitched | SmoothAgentApi.EventsEvent.AgentSwitchFailed | SmoothAgentApi.EventsEvent.Notice | SmoothAgentApi.EventsEvent.Error;
+export declare namespace EventsEvent {
+    interface SessionStarted extends SmoothAgentApi.EventsESessionStarted {
+        type: "session.started";
+    }
+    interface ChatState extends SmoothAgentApi.EventsEChatState {
+        type: "chat.state";
+    }
+    interface RunStarted extends SmoothAgentApi.EventsERunStarted {
+        type: "run.started";
+    }
+    interface RunWaiting extends SmoothAgentApi.EventsERunWaiting {
+        type: "run.waiting";
+    }
+    interface RunCompleted extends SmoothAgentApi.EventsERunCompleted {
+        type: "run.completed";
+    }
+    interface UsageUpdated extends SmoothAgentApi.EventsEUsageUpdated {
+        type: "usage.updated";
+    }
+    interface ItemStarted extends SmoothAgentApi.EventsEItemStarted {
+        type: "item.started";
+    }
+    interface ItemDelta extends SmoothAgentApi.EventsEItemDelta {
+        type: "item.delta";
+    }
+    interface ItemUpdated extends SmoothAgentApi.EventsEItemUpdated {
+        type: "item.updated";
+    }
+    interface ItemCompleted extends SmoothAgentApi.EventsEItemCompleted {
+        type: "item.completed";
+    }
+    interface ItemRetracted extends SmoothAgentApi.EventsEItemRetracted {
+        type: "item.retracted";
+    }
+    interface TaskUpdated extends SmoothAgentApi.EventsETaskUpdated {
+        type: "task.updated";
+    }
+    interface ContextUpdated extends SmoothAgentApi.EventsEContextUpdated {
+        type: "context.updated";
+    }
+    interface LimitsUpdated extends SmoothAgentApi.EventsELimitsUpdated {
+        type: "limits.updated";
+    }
+    interface AgentSwitched extends SmoothAgentApi.EventsEAgentSwitched {
+        type: "agent.switched";
+    }
+    interface AgentSwitchFailed extends SmoothAgentApi.EventsEAgentSwitchFailed {
+        type: "agent.switch_failed";
+    }
+    interface Notice extends SmoothAgentApi.EventsENotice {
+        type: "notice";
+    }
+    interface Error extends SmoothAgentApi.EventsEError {
+        type: "error";
+    }
+}

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

@@ -0,0 +1,17 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Uma falha pronta pra tela: código de erro, motivo fino e mensagem sem segredo.
+ */
+export interface EventsFailure {
+    code: SmoothAgentApi.EventsErrorCode;
+    reason?: SmoothAgentApi.EventsFailureReason | undefined;
+    /** SEM segredo */
+    message: string;
+    /** Tentar de novo pode dar certo. */
+    retryable?: boolean | undefined;
+    resetsAt?: SmoothAgentApi.EventsTimestamp | undefined;
+    /** Status HTTP que o provedor devolveu. */
+    httpStatus?: number | undefined;
+    /** Detalhes extras (sem segredo). */
+    details?: Record<string, unknown> | undefined;
+}

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

@@ -0,0 +1,16 @@
+/** O motivo fino que o adaptador identificou. Valor desconhecido = tratar como unknown. */
+export declare const EventsFailureReason: {
+    readonly NoCredit: "no_credit";
+    readonly SubscriptionLimit: "subscription_limit";
+    readonly RateLimited: "rate_limited";
+    readonly OutOfMemory: "out_of_memory";
+    readonly ContextWindowExceeded: "context_window_exceeded";
+    readonly AuthFailed: "auth_failed";
+    readonly ProviderCrashed: "provider_crashed";
+    readonly MaxTurns: "max_turns";
+    readonly Network: "network";
+    readonly RequestExpired: "request_expired";
+    readonly GrantRevoked: "grant_revoked";
+    readonly Unknown: "unknown";
+};
+export type EventsFailureReason = (typeof EventsFailureReason)[keyof typeof EventsFailureReason];

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

@@ -0,0 +1,4 @@
+/**
+ * Id de um arquivo enviado (`file_…`).
+ */
+export type EventsFileId = string;

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

@@ -0,0 +1,29 @@
+/**
+ * o que foi reinjetado na sessão nova
+ */
+export interface EventsHandoffInjected {
+    /** primeiro evento reinjetado */
+    fromSeq?: number | undefined;
+    /** último */
+    toSeq?: number | undefined;
+    /** Mensagens. */
+    messages?: number | undefined;
+    /** Quantidade de itens. */
+    items?: number | undefined;
+    /** medido ou estimado — ver estimated */
+    tokens?: number | undefined;
+    /** tokens é estimativa do adaptador, não contagem do provedor */
+    estimated?: boolean | undefined;
+    /** Quantidade de imagens. */
+    images?: number | undefined;
+    /** Por onde. */
+    via?: EventsHandoffInjected.Via | undefined;
+}
+export declare namespace EventsHandoffInjected {
+    /** Por onde. */
+    const Via: {
+        readonly NativeHistory: "native_history";
+        readonly ContextMessage: "context_message";
+    };
+    type Via = (typeof Via)[keyof typeof Via];
+}