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

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. Credencial que falta ou venceu (provider_not_connected / provider_auth_expired): o provedor DELA vem em `details.provider`, que pode diferir do provedor do agente.
+ */
+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). Com `code` provider_not_connected ou provider_auth_expired, `details.provider` é o provedor da CREDENCIAL que falta ou venceu — pode ser diferente de `run.agent.provider` (ex.: um agente fake que roda com a credencial Claude do usuário): é ele que a tela manda conectar/reconectar. */
+    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];
+}

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

@@ -0,0 +1,24 @@
+/**
+ * o que NÃO passou
+ */
+export interface EventsHandoffLost {
+    /** Primeiro seq. */
+    fromSeq?: number | undefined;
+    /** Último seq. */
+    toSeq?: number | undefined;
+    /** Quantidade de itens. */
+    items?: number | undefined;
+    /** Quantidade de imagens. */
+    images?: number | undefined;
+    /** Motivo. */
+    reason?: EventsHandoffLost.Reason | undefined;
+}
+export declare namespace EventsHandoffLost {
+    /** Motivo. */
+    const Reason: {
+        readonly Budget: "budget";
+        readonly SummarizerUnavailable: "summarizer_unavailable";
+        readonly UnsupportedContent: "unsupported_content";
+    };
+    type Reason = (typeof Reason)[keyof typeof Reason];
+}

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

@@ -0,0 +1,52 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Uma mensagem na inbox (pendente, na fila ou não entregue), antes de o provedor ler.
+ */
+export interface EventsInboxEntry {
+    messageId: SmoothAgentApi.EventsMessageId;
+    /** Id do lado do cliente (idempotência). */
+    clientMessageId?: string | undefined;
+    /** Conteúdo da mensagem. */
+    content: SmoothAgentApi.EventsContentPart[];
+    /** Como a mensagem entra: auto (começa ou vira steer), steer (no turno em andamento) ou queue (fila). */
+    mode: EventsInboxEntry.Mode;
+    origin: SmoothAgentApi.EventsOrigin;
+    createdAt: SmoothAgentApi.EventsTimestamp;
+    /** o metadata da mensagem (anexado pelo realtime na saída) */
+    metadata?: Record<string, string> | undefined;
+    /** taken = a box pegou (o "visto"); some da inbox quando o provedor LÊ (vira user_message no seq) */
+    status?: EventsInboxEntry.Status | undefined;
+    /** a box pegou mas o provedor não pode ler agora (Codex compactando: espera o turno) */
+    waitingFor?: EventsInboxEntry.WaitingFor | undefined;
+    /** só em notDelivered: not_consumed = a box pediu pra dormir várias vezes sem o provedor ler (o teto). Ausente = STOP antes do turno. Valor desconhecido = mostrar genérico */
+    notDeliveredReason?: EventsInboxEntry.NotDeliveredReason | undefined;
+    /** steer não lido no STOP voltou pro topo */
+    requeued?: boolean | undefined;
+    editedAt?: SmoothAgentApi.EventsTimestamp | undefined;
+}
+export declare namespace EventsInboxEntry {
+    /** Como a mensagem entra: auto (começa ou vira steer), steer (no turno em andamento) ou queue (fila). */
+    const Mode: {
+        readonly Auto: "auto";
+        readonly Steer: "steer";
+        readonly Queue: "queue";
+    };
+    type Mode = (typeof Mode)[keyof typeof Mode];
+    /** taken = a box pegou (o "visto"); some da inbox quando o provedor LÊ (vira user_message no seq) */
+    const Status: {
+        readonly Pending: "pending";
+        readonly Taken: "taken";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+    /** a box pegou mas o provedor não pode ler agora (Codex compactando: espera o turno) */
+    const WaitingFor: {
+        readonly Compaction: "compaction";
+        readonly TurnEnd: "turn_end";
+    };
+    type WaitingFor = (typeof WaitingFor)[keyof typeof WaitingFor];
+    /** só em notDelivered: not_consumed = a box pediu pra dormir várias vezes sem o provedor ler (o teto). Ausente = STOP antes do turno. Valor desconhecido = mostrar genérico */
+    const NotDeliveredReason: {
+        readonly NotConsumed: "not_consumed";
+    };
+    type NotDeliveredReason = (typeof NotDeliveredReason)[keyof typeof NotDeliveredReason];
+}

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

@@ -0,0 +1,50 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * DEPRECATED (use QueueState). Pendentes, fila, STOP pendente, troca agendada — dono: o log. Duas trocas: a segunda SUBSTITUI a agendada (baseVersion; velha = conflict).
+ */
+export interface EventsInboxState {
+    /** versão própria da inbox (ordem dos comandos; base do conflict) */
+    version: number;
+    /** auto/steer ainda não lidos */
+    pending: SmoothAgentApi.EventsInboxEntry[];
+    /** a fila visível, em ordem */
+    queue: SmoothAgentApi.EventsInboxEntry[];
+    /** STOP antes do turno: reenviar/descartar */
+    notDelivered: SmoothAgentApi.EventsInboxEntry[];
+    /** Respostas gravadas. */
+    responses?: EventsInboxState.Responses.Item[] | undefined;
+    stopPending?: SmoothAgentApi.EventsStopId | undefined;
+    /** fila parada: só anda quando o usuário manda algo/enviar agora */
+    held?: EventsInboxState.Held | undefined;
+    scheduledSwitch?: SmoothAgentApi.EventsScheduledSwitch | undefined;
+}
+export declare namespace EventsInboxState {
+    type Responses = Responses.Item[];
+    namespace Responses {
+        interface Item {
+            requestId: SmoothAgentApi.EventsRequestId;
+            answer?: unknown | undefined;
+            origin: SmoothAgentApi.EventsOrigin;
+        }
+    }
+    /**
+     * fila parada: só anda quando o usuário manda algo/enviar agora
+     */
+    interface Held {
+        /** Motivo. */
+        reason: Held.Reason;
+        since?: SmoothAgentApi.EventsTimestamp | undefined;
+    }
+    namespace Held {
+        /** Motivo. */
+        const Reason: {
+            readonly Stop: "stop";
+            readonly Limit: "limit";
+            readonly NoCredit: "no_credit";
+            readonly Auth: "auth";
+            readonly Error: "error";
+            readonly WakeFailed: "wake_failed";
+        };
+        type Reason = (typeof Reason)[keyof typeof Reason];
+    }
+}