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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * O buraco `(after, until]` em JSON (a SDK busca o que faltou antes de mostrar o seguinte).
+ */
+export interface EventRange {
+    events: SmoothAgentApi.EventsEvent[];
+    range: EventRange.Range;
+    upToDate: boolean;
+}
+export declare namespace EventRange {
+    interface Range {
+        from: number;
+        to: number;
+    }
+}

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

@@ -0,0 +1,4 @@
+/**
+ * id do agente (formato do control)
+ */
+export type EventsAgentId = string;

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

@@ -0,0 +1,14 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * agente + provedor + modelo (o que roda / o que foi escolhido)
+ */
+export interface EventsAgentSelection {
+    agentId: SmoothAgentApi.EventsAgentId;
+    /** 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;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Uma opção de resposta a um pedido de aprovação (vocabulário do ACP).
+ */
+export interface EventsApprovalOption {
+    /** Id. */
+    id: string;
+    /** Rótulo. */
+    label?: string | undefined;
+    /** ACP */
+    kind: EventsApprovalOption.Kind;
+    /** o que o "sempre" grava */
+    detail?: unknown | undefined;
+}
+export declare namespace EventsApprovalOption {
+    /** ACP */
+    const Kind: {
+        readonly AllowOnce: "allow_once";
+        readonly AllowAlways: "allow_always";
+        readonly RejectOnce: "reject_once";
+        readonly RejectAlways: "reject_always";
+        readonly Other: "other";
+    };
+    type Kind = typeof Kind[keyof typeof Kind];
+}

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

@@ -0,0 +1,146 @@
+/**
+ * O que o provedor suporta, declarado no initialize; vai em agent.get(). Versionado.
+ */
+export interface EventsCapabilities {
+    version: number;
+    /** Raciocínio. */
+    reasoning?: boolean | undefined;
+    /** Mostra resumo do raciocínio. */
+    reasoningSummary?: boolean | undefined;
+    /** Mostra plano (todo list). */
+    plans?: boolean | undefined;
+    /** Propõe plano pra aprovar. */
+    proposedPlans?: boolean | undefined;
+    /** Pede aprovação. */
+    approvals?: boolean | undefined;
+    /** Perguntas. */
+    questions?: boolean | undefined;
+    /** Roda subagentes. */
+    subagents?: boolean | undefined;
+    /** Trabalho que segue depois do turno. */
+    background?: boolean | undefined;
+    /** o provedor abre turno sozinho quando uma tarefa acaba */
+    wakeTurns?: boolean | undefined;
+    /** Para uma tarefa sem parar o run. */
+    taskStop?: boolean | undefined;
+    /** Agenda (schedule_task). */
+    timers?: boolean | undefined;
+    /** Mostra mudança de arquivo. */
+    fileChanges?: boolean | undefined;
+    /** Quantidade de imagens. */
+    images?: boolean | undefined;
+    /** Lista/lê arquivos da box. */
+    boxFiles?: boolean | undefined;
+    /** Informa a janela de contexto. */
+    contextUsage?: boolean | undefined;
+    /** Informa os limites. */
+    usageLimits?: boolean | undefined;
+    /** Informa custo. */
+    costReporting?: boolean | undefined;
+    /** Roda tools em paralelo. */
+    parallelTools?: boolean | undefined;
+    /** Como entra mensagem com turno rodando: native (steer do provedor), restart (interrompe e reinicia) ou none. */
+    steering: EventsCapabilities.Steering;
+    /** onde o steer nativo entra */
+    steerBoundary?: EventsCapabilities.SteerBoundary | undefined;
+    /** retirar steer entregue e não lido: Claude interrupt{cancel_queued} = sim */
+    steerRecall?: boolean | undefined;
+    /** Codex: espera o turno */
+    steerDuringCompaction?: EventsCapabilities.SteerDuringCompaction | undefined;
+    /** o que o steer nativo corta: nada (Claude next: espera a tool), a resposta em curso (Codex 0.163: o adaptador fecha o item interrupted antes do message.consumed), ou tools em andamento */
+    steerInterrupts?: EventsCapabilities.SteerInterrupts | undefined;
+    /** Como o STOP para o turno: native (pedido ao provedor) ou kill (mata o processo). */
+    interrupt?: EventsCapabilities.Interrupt | undefined;
+    /** Como sabemos que o provedor leu a mensagem: echo, item ou order. */
+    consumptionSignal?: EventsCapabilities.ConsumptionSignal | undefined;
+    /** O que chega em pedaços (deltas) enquanto o item está aberto. */
+    streaming?: EventsCapabilities.Streaming | undefined;
+    /** Troca de modelo na mesma sessão. */
+    modelSwitchInSession?: boolean | undefined;
+    /** troca dos servidores MCP (config do agente): live = setMcpServers no processo vivo, mesma sessão, só entre turnos (Claude mcp_set_servers); restart = a box reinicia o processo com resume; none/ausente = idem restart */
+    mcpSwitch?: EventsCapabilities.McpSwitch | undefined;
+    /** troca de esforço: live = na mesma sessão, vale a partir do PRÓXIMO turno, nunca no meio de um (Claude apply_flag_settings{effortLevel}, Codex por turn/start); restart = precisa reiniciar o processo (com --resume); none = não troca */
+    effortSwitch?: EventsCapabilities.EffortSwitch | undefined;
+    /** Retomar a sessão nativa. */
+    resume?: boolean | undefined;
+    /** como recebe o histórico numa troca de provedor (Claude: .jsonl sintético + --resume) */
+    handoffInject?: EventsCapabilities.HandoffInject | undefined;
+}
+export declare namespace EventsCapabilities {
+    /** Como entra mensagem com turno rodando: native (steer do provedor), restart (interrompe e reinicia) ou none. */
+    const Steering: {
+        readonly Native: "native";
+        readonly Restart: "restart";
+        readonly None: "none";
+    };
+    type Steering = typeof Steering[keyof typeof Steering];
+    /** onde o steer nativo entra */
+    const SteerBoundary: {
+        readonly Tool: "tool";
+        readonly ModelCall: "model_call";
+        readonly Turn: "turn";
+    };
+    type SteerBoundary = typeof SteerBoundary[keyof typeof SteerBoundary];
+    /** Codex: espera o turno */
+    const SteerDuringCompaction: {
+        readonly Joins: "joins";
+        readonly WaitsTurn: "waits_turn";
+    };
+    type SteerDuringCompaction = typeof SteerDuringCompaction[keyof typeof SteerDuringCompaction];
+    /** o que o steer nativo corta: nada (Claude next: espera a tool), a resposta em curso (Codex 0.163: o adaptador fecha o item interrupted antes do message.consumed), ou tools em andamento */
+    const SteerInterrupts: {
+        readonly Nothing: "nothing";
+        readonly Response: "response";
+        readonly Tools: "tools";
+    };
+    type SteerInterrupts = typeof SteerInterrupts[keyof typeof SteerInterrupts];
+    /** Como o STOP para o turno: native (pedido ao provedor) ou kill (mata o processo). */
+    const Interrupt: {
+        readonly Native: "native";
+        readonly Kill: "kill";
+    };
+    type Interrupt = typeof Interrupt[keyof typeof Interrupt];
+    /** Como sabemos que o provedor leu a mensagem: echo, item ou order. */
+    const ConsumptionSignal: {
+        readonly Echo: "echo";
+        readonly Item: "item";
+        readonly Order: "order";
+    };
+    type ConsumptionSignal = typeof ConsumptionSignal[keyof typeof ConsumptionSignal];
+    /**
+     * O que chega em pedaços (deltas) enquanto o item está aberto.
+     */
+    interface Streaming {
+        /** Texto. */
+        text?: boolean | undefined;
+        /** Raciocínio. */
+        reasoning?: boolean | undefined;
+        /** Entrada da tool em pedaços. */
+        toolInput?: boolean | undefined;
+        /** Saída de comando em pedaços. */
+        commandOutput?: boolean | undefined;
+        /** Texto do plano em pedaços. */
+        planText?: boolean | undefined;
+    }
+    /** troca dos servidores MCP (config do agente): live = setMcpServers no processo vivo, mesma sessão, só entre turnos (Claude mcp_set_servers); restart = a box reinicia o processo com resume; none/ausente = idem restart */
+    const McpSwitch: {
+        readonly Live: "live";
+        readonly Restart: "restart";
+        readonly None: "none";
+    };
+    type McpSwitch = typeof McpSwitch[keyof typeof McpSwitch];
+    /** troca de esforço: live = na mesma sessão, vale a partir do PRÓXIMO turno, nunca no meio de um (Claude apply_flag_settings{effortLevel}, Codex por turn/start); restart = precisa reiniciar o processo (com --resume); none = não troca */
+    const EffortSwitch: {
+        readonly Live: "live";
+        readonly Restart: "restart";
+        readonly None: "none";
+    };
+    type EffortSwitch = typeof EffortSwitch[keyof typeof EffortSwitch];
+    /** como recebe o histórico numa troca de provedor (Claude: .jsonl sintético + --resume) */
+    const HandoffInject: {
+        readonly NativeHistory: "native_history";
+        readonly ContextMessage: "context_message";
+        readonly None: "none";
+    };
+    type HandoffInject = typeof HandoffInject[keyof typeof HandoffInject];
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Id do chat (`chat_…`).
+ */
+export type EventsChatId = string;

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

@@ -0,0 +1,15 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Parte de arquivo: enviado (fileId) ou um caminho na box.
+ */
+export interface EventsContentFile {
+    fileId?: SmoothAgentApi.EventsFileId | undefined;
+    /** Caminho do arquivo. */
+    path?: string | undefined;
+    /** Nome. */
+    name?: string | undefined;
+    /** Tipo MIME. */
+    mimeType?: string | undefined;
+    /** link público do arquivo enviado, pra TELA mostrar (img/download); nunca vai pro modelo */
+    url?: string | undefined;
+}

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

@@ -0,0 +1,11 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Parte de imagem: por arquivo enviado (fileId) ou por URL.
+ */
+export interface EventsContentImage {
+    fileId?: SmoothAgentApi.EventsFileId | undefined;
+    /** URL. */
+    url?: string | undefined;
+    /** Tipo MIME. */
+    mimeType?: string | undefined;
+}

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

@@ -0,0 +1,19 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Uma parte do conteúdo de uma mensagem ou saída. Tipo desconhecido: ignorar.
+ */
+export type EventsContentPart = SmoothAgentApi.EventsContentPart.Text | SmoothAgentApi.EventsContentPart.Image | SmoothAgentApi.EventsContentPart.File | SmoothAgentApi.EventsContentPart.Resource;
+export declare namespace EventsContentPart {
+    interface Text extends SmoothAgentApi.EventsContentText {
+        type: "text";
+    }
+    interface Image extends SmoothAgentApi.EventsContentImage {
+        type: "image";
+    }
+    interface File extends SmoothAgentApi.EventsContentFile {
+        type: "file";
+    }
+    interface Resource extends SmoothAgentApi.EventsContentResource {
+        type: "resource";
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Parte de recurso (MCP resource): uri e, quando houver, o texto.
+ */
+export interface EventsContentResource {
+    /** URI do recurso. */
+    uri: string;
+    /** Nome. */
+    name?: string | undefined;
+    /** Tipo MIME. */
+    mimeType?: string | undefined;
+    /** Texto. */
+    text?: string | undefined;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Parte de texto.
+ */
+export interface EventsContentText {
+    /** Texto. */
+    text: string;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * anexo a um campo string do item aberto
+ */
+export interface EventsDelta {
+    /** Caminho do arquivo. */
+    path: EventsDelta.Path;
+    /** Índice no array. */
+    index?: number | undefined;
+    /** Texto a anexar. */
+    append: string;
+}
+export declare namespace EventsDelta {
+    /** Caminho do arquivo. */
+    const Path: {
+        readonly Text: "text";
+        readonly Summary: "summary";
+        readonly InputText: "inputText";
+        readonly Output: "output";
+    };
+    type Path = typeof Path[keyof typeof Path];
+}

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

@@ -0,0 +1,21 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `agent.switch_failed`: sai quando uma troca pedida não pôde ser aplicada (sem credencial, sem grant, provedor fora). A tela avisa com o erro e o chat segue no agente de antes.
+ */
+export interface EventsEAgentSwitchFailed {
+    /** = 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.EventsEAgentSwitchFailedData;
+}

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

@@ -0,0 +1,9 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `agent.switch_failed`.
+ */
+export interface EventsEAgentSwitchFailedData {
+    switchId?: SmoothAgentApi.EventsSwitchId | undefined;
+    to: SmoothAgentApi.EventsAgentSelection;
+    error: SmoothAgentApi.EventsFailure;
+}

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

@@ -0,0 +1,21 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `agent.switched`: sai quando a troca de agente/provedor/modelo é APLICADA no chat (na hora, ou antes do próximo turno se estava agendada). A tela troca o agente mostrado e pode pôr um divisor "agora com X"; mensagens novas já vão pro agente novo.
+ */
+export interface EventsEAgentSwitched {
+    /** = 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.EventsEAgentSwitchedData;
+}

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

@@ -0,0 +1,12 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `agent.switched`.
+ */
+export interface EventsEAgentSwitchedData {
+    switchId?: SmoothAgentApi.EventsSwitchId | undefined;
+    from?: SmoothAgentApi.EventsAgentSelection | undefined;
+    to: SmoothAgentApi.EventsAgentSelection;
+    by?: SmoothAgentApi.EventsOrigin | undefined;
+    /** estava agendada (run ativo) */
+    scheduled?: boolean | undefined;
+}

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

@@ -0,0 +1,21 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `chat.state`: sai sempre que o estado do chat muda (idle, starting, working, waiting). A tela troca o indicador (trabalhando, esperando você, parado) e decide se mostra o STOP.
+ */
+export interface EventsEChatState {
+    /** = 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.EventsEChatStateData;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Dados (`data`) do evento `chat.state`.
+ */
+export interface EventsEChatStateData {
+    /** Estado do chat: idle (parado), starting (pedido aceito, provedor ainda não começou), working (rodando), waiting (esperando resposta do usuário). */
+    state: EventsEChatStateData.State;
+}
+export declare namespace EventsEChatStateData {
+    /** Estado do chat: idle (parado), starting (pedido aceito, provedor ainda não começou), working (rodando), waiting (esperando resposta do usuário). */
+    const State: {
+        readonly Idle: "idle";
+        readonly Starting: "starting";
+        readonly Working: "working";
+        readonly Waiting: "waiting";
+    };
+    type State = typeof State[keyof typeof State];
+}

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

@@ -0,0 +1,21 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `context.updated`: sai quando o uso da janela de contexto do modelo muda (fim de turno, compactação). A tela atualiza o medidor de contexto (usado / limite / %).
+ */
+export interface EventsEContextUpdated {
+    /** = 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.EventsEContextUpdatedData;
+}

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

@@ -0,0 +1,20 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * janela de contexto (sempre com provedor e, quando houver, modelo)
+ */
+export interface EventsEContextUpdatedData {
+    /** Tokens usados da janela. */
+    usedTokens: number;
+    /** Tamanho da janela em tokens. */
+    limitTokens?: number | undefined;
+    /** pronto, 0–100 */
+    percent?: number | undefined;
+    /** Onde o provedor compacta sozinho. */
+    autoCompactAtTokens?: number | undefined;
+    /** Modelo. */
+    model?: string | undefined;
+    /** quantas compactações no chat */
+    compactions?: number | undefined;
+    /** a janela é deste provedor/modelo (o control projeta) */
+    provider: SmoothAgentApi.EventsProvider;
+}

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

@@ -0,0 +1,21 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `error`: sai quando um erro acontece sem fechar o turno, normalmente antes de uma nova tentativa automática (willRetry, attempt/maxAttempts). A tela mostra "tentando de novo (n de m)"; se não houver retry, o run.completed failed vem em seguida.
+ */
+export interface EventsEError {
+    /** = 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.EventsEErrorData;
+}

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

@@ -0,0 +1,13 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `error`.
+ */
+export interface EventsEErrorData {
+    error: SmoothAgentApi.EventsFailure;
+    /** Vai tentar de novo sozinho. */
+    willRetry?: boolean | undefined;
+    /** Número da tentativa (1 = a primeira). */
+    attempt?: number | undefined;
+    /** Teto de tentativas. */
+    maxAttempts?: number | undefined;
+}

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

@@ -0,0 +1,21 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Evento `item.completed`: sai quando o item fecha e traz o item INTEIRO, final (substitui tudo que veio em pedaços). A tela troca o item pelo final; é o que fica no histórico e o que volta depois do F5.
+ */
+export interface EventsEItemCompleted {
+    /** = 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.EventsEItemCompletedData;
+}

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

@@ -0,0 +1,8 @@
+import * as SmoothAgentApi from "../index.js";
+/**
+ * Dados (`data`) do evento `item.completed`.
+ */
+export interface EventsEItemCompletedData {
+    /** o item INTEIRO; depois disso é imutável */
+    item: SmoothAgentApi.EventsItem;
+}

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

@@ -0,0 +1,21 @@
+import * 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-server/api/types/EventsEItemDeltaData.d.ts

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

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

@@ -0,0 +1,21 @@
+import * 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-server/api/types/EventsEItemRetractedData.d.ts

@@ -0,0 +1,18 @@
+import * 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-server/api/types/EventsEItemStarted.d.ts

@@ -0,0 +1,21 @@
+import * 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;
+}