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

package/dist/types/sdk/generated/ts-server/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];
+    }
+}

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

@@ -0,0 +1,64 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Um item da timeline (mensagem, texto, tool, comando, aprovação…), discriminado por `kind`. Kind desconhecido: renderizar genérico.
+ */
+export type EventsItem = SmoothAgentApi.EventsItem.UserMessage | SmoothAgentApi.EventsItem.Text | SmoothAgentApi.EventsItem.Reasoning | SmoothAgentApi.EventsItem.ToolCall | SmoothAgentApi.EventsItem.Command | SmoothAgentApi.EventsItem.FileChange | SmoothAgentApi.EventsItem.FileSearch | SmoothAgentApi.EventsItem.WebSearch | SmoothAgentApi.EventsItem.Plan | SmoothAgentApi.EventsItem.ProposedPlan | SmoothAgentApi.EventsItem.Subagent | SmoothAgentApi.EventsItem.Notification | SmoothAgentApi.EventsItem.Timer | SmoothAgentApi.EventsItem.Approval | SmoothAgentApi.EventsItem.Question | SmoothAgentApi.EventsItem.Compaction | SmoothAgentApi.EventsItem.Handoff | SmoothAgentApi.EventsItem.Hook | SmoothAgentApi.EventsItem.Error;
+export declare namespace EventsItem {
+    interface UserMessage extends SmoothAgentApi.EventsItemUserMessage {
+        kind: "user_message";
+    }
+    interface Text extends SmoothAgentApi.EventsItemText {
+        kind: "text";
+    }
+    interface Reasoning extends SmoothAgentApi.EventsItemReasoning {
+        kind: "reasoning";
+    }
+    interface ToolCall extends SmoothAgentApi.EventsItemToolCall {
+        kind: "tool_call";
+    }
+    interface Command extends SmoothAgentApi.EventsItemCommand {
+        kind: "command";
+    }
+    interface FileChange extends SmoothAgentApi.EventsItemFileChange {
+        kind: "file_change";
+    }
+    interface FileSearch extends SmoothAgentApi.EventsItemFileSearch {
+        kind: "file_search";
+    }
+    interface WebSearch extends SmoothAgentApi.EventsItemWebSearch {
+        kind: "web_search";
+    }
+    interface Plan extends SmoothAgentApi.EventsItemPlan {
+        kind: "plan";
+    }
+    interface ProposedPlan extends SmoothAgentApi.EventsItemProposedPlan {
+        kind: "proposed_plan";
+    }
+    interface Subagent extends SmoothAgentApi.EventsItemSubagent {
+        kind: "subagent";
+    }
+    interface Notification extends SmoothAgentApi.EventsItemNotification {
+        kind: "notification";
+    }
+    interface Timer extends SmoothAgentApi.EventsItemTimer {
+        kind: "timer";
+    }
+    interface Approval extends SmoothAgentApi.EventsItemApproval {
+        kind: "approval";
+    }
+    interface Question extends SmoothAgentApi.EventsItemQuestion {
+        kind: "question";
+    }
+    interface Compaction extends SmoothAgentApi.EventsItemCompaction {
+        kind: "compaction";
+    }
+    interface Handoff extends SmoothAgentApi.EventsItemHandoff {
+        kind: "handoff";
+    }
+    interface Hook extends SmoothAgentApi.EventsItemHook {
+        kind: "hook";
+    }
+    interface Error extends SmoothAgentApi.EventsItemError {
+        kind: "error";
+    }
+}

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

@@ -0,0 +1,93 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `approval`: o agente pede permissão pra uma ação (comando, edição, ferramenta) e o turno para em run.waiting. A tela mostra o cartão com a ação e as opções; a resposta vai por `respond` com o requestId, e o item fecha com a decisão.
+ */
+export interface EventsItemApproval {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemApproval.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;
+    requestId?: SmoothAgentApi.EventsRequestId | undefined;
+    targetItemId?: SmoothAgentApi.EventsItemId | undefined;
+    /** O que o agente quer fazer. */
+    action?: EventsItemApproval.Action | undefined;
+    /** As opções de resposta. */
+    options?: SmoothAgentApi.EventsApprovalOption[] | undefined;
+    /** A resposta dada (presente depois de respondido). */
+    decision?: EventsItemApproval.Decision | undefined;
+    /** false = callback morreu (cold) → request_expired */
+    respondable?: boolean | undefined;
+}
+export declare namespace EventsItemApproval {
+    /** 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];
+    /**
+     * O que o agente quer fazer.
+     */
+    interface Action {
+        /** Tipo (discriminador). */
+        kind: Action.Kind;
+        /** Linha de comando. */
+        command?: string | undefined;
+        /** Pasta de trabalho. */
+        cwd?: string | undefined;
+        /** Arquivos. */
+        paths?: string[] | undefined;
+        /** Nome da tool. */
+        toolName?: string | undefined;
+        /** Entrada (JSON). */
+        input?: unknown | undefined;
+        /** Motivo. */
+        reason?: string | undefined;
+    }
+    namespace Action {
+        /** Tipo (discriminador). */
+        const Kind: {
+            readonly Command: "command";
+            readonly FileChange: "file_change";
+            readonly Tool: "tool";
+            readonly Network: "network";
+            readonly Permissions: "permissions";
+            readonly Other: "other";
+        };
+        type Kind = (typeof Kind)[keyof typeof Kind];
+    }
+    /**
+     * A resposta dada (presente depois de respondido).
+     */
+    interface Decision {
+        /** Opção escolhida. */
+        optionId: string;
+        /** Tipo (discriminador). */
+        kind?: string | undefined;
+        /** Comentário do usuário junto da resposta. */
+        feedback?: string | undefined;
+        by?: SmoothAgentApi.EventsOrigin | undefined;
+        at?: SmoothAgentApi.EventsTimestamp | undefined;
+    }
+}

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

@@ -0,0 +1,74 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `command`: o agente roda um comando de shell; a saída chega por item.delta e o item fecha com o exitCode (ou segue em background como tarefa). A tela mostra o comando, a saída ao vivo e o código de saída.
+ */
+export interface EventsItemCommand {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemCommand.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;
+    /** Linha de comando. */
+    command?: string | undefined;
+    /** Descrição. */
+    description?: string | undefined;
+    /** Pasta de trabalho. */
+    cwd?: string | undefined;
+    /** Saída. */
+    output?: string | undefined;
+    /** Código de saída. */
+    exitCode?: number | undefined;
+    /** Duração em milissegundos. */
+    durationMs?: number | undefined;
+    /** Id do processo. */
+    processId?: string | undefined;
+    /** É um monitor (vigia em background). */
+    monitor?: boolean | undefined;
+    /** Codex commandActions */
+    actions?: EventsItemCommand.Actions.Item[] | undefined;
+    /** Origem. */
+    source?: string | undefined;
+    /** Entrada da tool como texto (JSON parcial durante o stream). */
+    inputText?: string | undefined;
+}
+export declare namespace EventsItemCommand {
+    /** 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];
+    type Actions = Actions.Item[];
+    namespace Actions {
+        interface Item {
+            /** Tipo (discriminador). */
+            type: string;
+            /** Caminho do arquivo. */
+            path?: string | undefined;
+            /** Consulta. */
+            query?: string | undefined;
+            /** Linha de comando. */
+            command?: string | undefined;
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `compaction`: o provedor compactou o contexto (sozinho ou pedido), com tokens antes/depois e o resumo. A tela mostra um divisor "contexto resumido".
+ */
+export interface EventsItemCompaction {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemCompaction.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;
+    /** auto (o provedor compactou sozinho) ou manual. */
+    trigger?: EventsItemCompaction.Trigger | undefined;
+    /** Tokens antes. */
+    beforeTokens?: number | undefined;
+    /** Tokens depois. */
+    afterTokens?: number | undefined;
+    /** Resumo. */
+    summary?: string | undefined;
+    /** Duração em milissegundos. */
+    durationMs?: number | undefined;
+}
+export declare namespace EventsItemCompaction {
+    /** 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];
+    /** auto (o provedor compactou sozinho) ou manual. */
+    const Trigger: {
+        readonly Auto: "auto";
+        readonly Manual: "manual";
+    };
+    type Trigger = (typeof Trigger)[keyof typeof Trigger];
+}

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

@@ -0,0 +1,40 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `error`: um erro que fica registrado NA timeline, no ponto em que aconteceu (código de erro e mensagem pronta). A tela mostra o erro em linha; o turno pode seguir ou fechar depois.
+ */
+export interface EventsItemError {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemError.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;
+    error?: SmoothAgentApi.EventsFailure | undefined;
+}
+export declare namespace EventsItemError {
+    /** 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];
+}

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

@@ -0,0 +1,73 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `file_change`: o agente criou, editou ou apagou arquivos. A tela mostra a lista de arquivos com o diff (adições/remoções).
+ */
+export interface EventsItemFileChange {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemFileChange.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;
+    /** LISTA: um item do Codex muda vários arquivos */
+    changes?: EventsItemFileChange.Changes.Item[] | undefined;
+    /** Nome da tool. */
+    tool?: string | undefined;
+    output?: SmoothAgentApi.EventsToolOutput | undefined;
+    /** Entrada da tool como texto (JSON parcial durante o stream). */
+    inputText?: string | undefined;
+}
+export declare namespace EventsItemFileChange {
+    /** 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];
+    type Changes = Changes.Item[];
+    namespace Changes {
+        interface Item {
+            /** Caminho do arquivo. */
+            path: string;
+            /** Operação. */
+            op: Item.Op;
+            /** Caminho antigo (move). */
+            oldPath?: string | undefined;
+            /** Diff unificado. */
+            diff?: string | undefined;
+            /** Linhas adicionadas. */
+            additions?: number | undefined;
+            /** Linhas removidas. */
+            deletions?: number | undefined;
+        }
+        namespace Item {
+            /** Operação. */
+            const Op: {
+                readonly Create: "create";
+                readonly Edit: "edit";
+                readonly Delete: "delete";
+                readonly Move: "move";
+            };
+            type Op = (typeof Op)[keyof typeof Op];
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `file_search`: o agente buscou arquivos ou conteúdo (glob/grep). A tela mostra o padrão, o caminho e os resultados.
+ */
+export interface EventsItemFileSearch {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemFileSearch.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;
+    /** Nome da tool. */
+    tool?: string | undefined;
+    /** Padrão buscado. */
+    pattern?: string | undefined;
+    /** Caminho do arquivo. */
+    path?: string | undefined;
+    /** Resultados. */
+    results?: EventsItemFileSearch.Results.Item[] | undefined;
+    output?: SmoothAgentApi.EventsToolOutput | undefined;
+    /** Entrada da tool como texto (JSON parcial durante o stream). */
+    inputText?: string | undefined;
+}
+export declare namespace EventsItemFileSearch {
+    /** 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];
+    type Results = Results.Item[];
+    namespace Results {
+        interface Item {
+            /** Caminho do arquivo. */
+            path: string;
+            /** Linha. */
+            line?: number | undefined;
+            /** Trecho da linha. */
+            preview?: string | undefined;
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `handoff`: na troca de agente/provedor, registra como o contexto passou pro agente novo (estratégia, o que foi reinjetado, o resumo do que não coube). A tela mostra um divisor da passagem, com o resumo aberto pra ler.
+ */
+export interface EventsItemHandoff {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemHandoff.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;
+    from?: SmoothAgentApi.EventsAgentSelection | undefined;
+    to?: SmoothAgentApi.EventsAgentSelection | undefined;
+    /** como o contexto passou */
+    strategy?: EventsItemHandoff.Strategy | undefined;
+    injected?: SmoothAgentApi.EventsHandoffInjected | undefined;
+    /** o resumo do que não coube (registrado, nunca escondido) */
+    summary?: string | undefined;
+    /** quem escreveu o resumo (o provedor que SAIU, por padrão) */
+    summarizedBy?: SmoothAgentApi.EventsAgentSelection | undefined;
+    lost?: SmoothAgentApi.EventsHandoffLost | undefined;
+    switchId?: SmoothAgentApi.EventsSwitchId | undefined;
+    /** por que houve reinjeção: troca de agente/provedor, ou sessão nativa perdida (from = to = o próprio agente) */
+    reason?: EventsItemHandoff.Reason | undefined;
+}
+export declare namespace EventsItemHandoff {
+    /** 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];
+    /** como o contexto passou */
+    const Strategy: {
+        readonly FullHistory: "full_history";
+        readonly FullSummary: "full_summary";
+        readonly HistoryAndSummary: "history_and_summary";
+        readonly None: "none";
+    };
+    type Strategy = (typeof Strategy)[keyof typeof Strategy];
+    /** por que houve reinjeção: troca de agente/provedor, ou sessão nativa perdida (from = to = o próprio agente) */
+    const Reason: {
+        readonly Switch: "switch";
+        readonly SessionLost: "session_lost";
+    };
+    type Reason = (typeof Reason)[keyof typeof Reason];
+}

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

@@ -0,0 +1,49 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `hook`: um hook configurado rodou num evento do agente (antes/depois de tool, fim de turno…). A tela mostra o nome, o resultado e a saída, normalmente recolhido.
+ */
+export interface EventsItemHook {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemHook.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;
+    /** Nome do hook. */
+    name?: string | undefined;
+    /** Evento que disparou o hook. */
+    event?: string | undefined;
+    /** Resultado do hook. */
+    outcome?: string | undefined;
+    /** Código de saída. */
+    exitCode?: number | undefined;
+    /** Saída. */
+    output?: string | undefined;
+}
+export declare namespace EventsItemHook {
+    /** 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];
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Id de um item da timeline (`itm_…`), dado pela sessão da box.
+ */
+export type EventsItemId = string;