@smoothcodes/agent-client 0.0.0-stage → 0.1.0

package/dist/types/sdk/generated/ts-client/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-client/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;

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

@@ -0,0 +1,65 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `notification`: uma notificação entrou no chat sem ser do usuário (tarefa em background terminou, agendamento disparou, outro agente, sistema). A tela mostra como linha de sistema com a origem.
+ */
+export interface EventsItemNotification {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemNotification.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;
+    /** Origem. */
+    source?: EventsItemNotification.Source | undefined;
+    /** Texto. */
+    text?: string | undefined;
+}
+export declare namespace EventsItemNotification {
+    /** 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];
+    /**
+     * Origem.
+     */
+    interface Source {
+        /** Tipo (discriminador). */
+        kind: Source.Kind;
+        taskId?: SmoothAgentApi.EventsTaskId | undefined;
+        /** O agendamento. */
+        scheduleId?: string | undefined;
+        /** Nome. */
+        name?: string | undefined;
+    }
+    namespace Source {
+        /** Tipo (discriminador). */
+        const Kind: {
+            readonly Task: "task";
+            readonly Schedule: "schedule";
+            readonly Peer: "peer";
+            readonly System: "system";
+        };
+        type Kind = (typeof Kind)[keyof typeof Kind];
+    }
+}

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

@@ -0,0 +1,65 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `plan`: a lista de passos (to-do) que o agente mantém durante o trabalho; atualiza enquanto ele avança. A tela mostra os passos com o estado de cada um.
+ */
+export interface EventsItemPlan {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemPlan.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;
+    /** Passos do plano, em ordem. */
+    steps?: EventsItemPlan.Steps.Item[] | undefined;
+    /** Explicação. */
+    explanation?: string | undefined;
+    /** Entrada da tool como texto (JSON parcial durante o stream). */
+    inputText?: string | undefined;
+}
+export declare namespace EventsItemPlan {
+    /** 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 Steps = Steps.Item[];
+    namespace Steps {
+        interface Item {
+            /** Texto. */
+            text: string;
+            /** Texto do passo em andamento. */
+            activeText?: string | undefined;
+            /** Estado. */
+            status: Item.Status;
+        }
+        namespace Item {
+            /** Estado. */
+            const Status: {
+                readonly Pending: "pending";
+                readonly InProgress: "in_progress";
+                readonly Completed: "completed";
+            };
+            type Status = (typeof Status)[keyof typeof Status];
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `proposed_plan`: um plano que o agente PROPÕE antes de executar (modo plano). A tela mostra o plano pra o usuário ler e decidir o que mandar em seguida.
+ */
+export interface EventsItemProposedPlan {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemProposedPlan.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;
+    /** Texto. */
+    text?: string | undefined;
+    /** Entrada da tool como texto (JSON parcial durante o stream). */
+    inputText?: string | undefined;
+}
+export declare namespace EventsItemProposedPlan {
+    /** 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-client/api/types/EventsItemQuestion.d.ts

@@ -0,0 +1,81 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `question`: o agente faz uma ou mais perguntas ao usuário e o turno para em run.waiting. A tela mostra o formulário; a resposta vai por `respond` com o requestId, e o item fecha com as respostas.
+ */
+export interface EventsItemQuestion {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemQuestion.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;
+    /** As perguntas, em ordem. */
+    questions?: EventsItemQuestion.Questions.Item[] | undefined;
+    /** Respostas por id de pergunta. */
+    answers?: Record<string, string[]> | undefined;
+    answeredBy?: SmoothAgentApi.EventsOrigin | undefined;
+    /** Ainda dá pra responder (false = pedido morreu num acordar cold). */
+    respondable?: boolean | undefined;
+    /** Resolve sozinho depois disso (ms). */
+    autoResolveMs?: number | undefined;
+    /** O turno espera a resposta. */
+    blocking?: boolean | undefined;
+}
+export declare namespace EventsItemQuestion {
+    /** 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 Questions = Questions.Item[];
+    namespace Questions {
+        interface Item {
+            /** Id. */
+            id: string;
+            /** Título curto da pergunta. */
+            header?: string | undefined;
+            /** Texto. */
+            text: string;
+            /** Opções. */
+            options?: Item.Options.Item[] | undefined;
+            /** Aceita várias opções. */
+            multiSelect?: boolean | undefined;
+            /** Aceita resposta livre. */
+            allowOther?: boolean | undefined;
+            /** Resposta é segredo (não mostrar nem logar). */
+            secret?: boolean | undefined;
+        }
+        namespace Item {
+            type Options = Options.Item[];
+            namespace Options {
+                interface Item {
+                    /** Rótulo. */
+                    label: string;
+                    /** Descrição. */
+                    description?: string | undefined;
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `reasoning`: o raciocínio do modelo, quando o provedor expõe (texto ou só resumo; pode vir escondido). A tela mostra recolhido ("pensando…") e deixa abrir.
+ */
+export interface EventsItemReasoning {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemReasoning.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;
+    /** Texto. */
+    text?: string | undefined;
+    /** Resumo. */
+    summary?: string[] | undefined;
+    /** O provedor escondeu o conteúdo. */
+    redacted?: boolean | undefined;
+    /** Tokens estimados. */
+    estimatedTokens?: number | undefined;
+}
+export declare namespace EventsItemReasoning {
+    /** 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-client/api/types/EventsItemSubagent.d.ts

@@ -0,0 +1,56 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `subagent`: o agente abriu um subagente com uma tarefa; os itens do subagente vêm com parentItemId apontando pra cá e o progresso por task.updated. A tela mostra um bloco aninhado com a tarefa, o progresso e o resultado.
+ */
+export interface EventsItemSubagent {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemSubagent.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;
+    /** Tipo de subagente. */
+    agentType?: string | undefined;
+    /** Descrição. */
+    description?: string | undefined;
+    /** o prompt dado ao subagente */
+    task?: string | undefined;
+    /** Modelo. */
+    model?: string | undefined;
+    /** Esforço de raciocínio (low, medium, high…). */
+    effort?: string | undefined;
+    /** Resultado. */
+    result?: string | undefined;
+    progress?: SmoothAgentApi.EventsTaskProgress | undefined;
+    /** Id da thread nativa do subagente. */
+    nativeThreadId?: string | undefined;
+    /** Entrada da tool como texto (JSON parcial durante o stream). */
+    inputText?: string | undefined;
+}
+export declare namespace EventsItemSubagent {
+    /** 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-client/api/types/EventsItemText.d.ts

@@ -0,0 +1,49 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `text`: a resposta em texto do agente; abre quando ele começa a escrever e cresce por item.delta. A tela renderiza o texto (markdown) e substitui pelo final no item.completed.
+ */
+export interface EventsItemText {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemText.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;
+    /** Texto. */
+    text?: string | undefined;
+    /** Codex final_answer × commentary */
+    phase?: EventsItemText.Phase | undefined;
+}
+export declare namespace EventsItemText {
+    /** 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];
+    /** Codex final_answer × commentary */
+    const Phase: {
+        readonly Commentary: "commentary";
+        readonly Final: "final";
+    };
+    type Phase = (typeof Phase)[keyof typeof Phase];
+}

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

@@ -0,0 +1,46 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `timer`: o agente agendou continuar depois (wakeAt, opcionalmente recorrente). A tela mostra "volto às HH:MM"; o chat pode dormir até lá.
+ */
+export interface EventsItemTimer {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemTimer.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;
+    wakeAt?: SmoothAgentApi.EventsTimestamp | undefined;
+    /** Motivo. */
+    reason?: string | undefined;
+    /** O agendamento. */
+    scheduleId?: string | undefined;
+    /** Recorrência. */
+    recurrence?: string | undefined;
+}
+export declare namespace EventsItemTimer {
+    /** 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-client/api/types/EventsItemToolCall.d.ts

@@ -0,0 +1,76 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `tool_call`: o agente chamou uma ferramenta (MCP ou nativa); abre com a entrada (em stream enquanto o modelo monta) e fecha com a saída. A tela mostra nome, entrada e saída, com o status.
+ */
+export interface EventsItemToolCall {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemToolCall.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. */
+    name?: string | undefined;
+    /** servidor MCP */
+    server?: string | undefined;
+    /** vocabulário do ACP */
+    toolKind?: EventsItemToolCall.ToolKind | undefined;
+    /** Entrada (JSON). */
+    input?: unknown | undefined;
+    /** JSON parcial em stream */
+    inputText?: string | undefined;
+    output?: SmoothAgentApi.EventsToolOutput | undefined;
+    /** Arquivos/linhas que a tool tocou. */
+    locations?: EventsItemToolCall.Locations.Item[] | undefined;
+}
+export declare namespace EventsItemToolCall {
+    /** 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];
+    /** vocabulário do ACP */
+    const ToolKind: {
+        readonly Read: "read";
+        readonly Edit: "edit";
+        readonly Delete: "delete";
+        readonly Move: "move";
+        readonly Search: "search";
+        readonly Execute: "execute";
+        readonly Think: "think";
+        readonly Fetch: "fetch";
+        readonly Task: "task";
+        readonly Message: "message";
+        readonly Other: "other";
+    };
+    type ToolKind = (typeof ToolKind)[keyof typeof ToolKind];
+    type Locations = Locations.Item[];
+    namespace Locations {
+        interface Item {
+            /** Caminho do arquivo. */
+            path: string;
+            /** Linha. */
+            line?: number | undefined;
+        }
+    }
+}

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

@@ -0,0 +1,65 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Item `user_message`: aparece quando o PROVEDOR leu uma mensagem do usuário (começo do turno, steer ou prompt de subagente). A tela tira a mensagem da fila/inbox e a mostra como balão do usuário na timeline, pelo messageId.
+ */
+export interface EventsItemUserMessage {
+    id: SmoothAgentApi.EventsItemId;
+    /** Estado. */
+    status: EventsItemUserMessage.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;
+    /** ausente só em subagent_prompt */
+    messageId?: SmoothAgentApi.EventsMessageId | undefined;
+    /** Id do lado do cliente (idempotência). */
+    clientMessageId?: string | undefined;
+    /** Conteúdo da mensagem. */
+    content?: SmoothAgentApi.EventsContentPart[] | undefined;
+    /** Como a mensagem entrou: turn_start, steer, steer_restart ou subagent_prompt. */
+    via?: EventsItemUserMessage.Via | undefined;
+    /** evidência do ponto de consumo */
+    consumption?: EventsItemUserMessage.Consumption | undefined;
+}
+export declare namespace EventsItemUserMessage {
+    /** 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 a mensagem entrou: turn_start, steer, steer_restart ou subagent_prompt. */
+    const Via: {
+        readonly TurnStart: "turn_start";
+        readonly Steer: "steer";
+        readonly SteerRestart: "steer_restart";
+        readonly SubagentPrompt: "subagent_prompt";
+    };
+    type Via = (typeof Via)[keyof typeof Via];
+    /** evidência do ponto de consumo */
+    const Consumption: {
+        readonly Echo: "echo";
+        readonly Item: "item";
+        readonly Order: "order";
+        readonly Result: "result";
+    };
+    type Consumption = (typeof Consumption)[keyof typeof Consumption];
+}