@smoothcodes/agent-client 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,32 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Uma tarefa viva ou recente do chat: subagente ou processo de fundo do agente.
+ */
+export interface ChatTask {
+    id: string;
+    kind: ChatTask.Kind;
+    /** O que o agente disse que é (descrição do subagente, a linha de comando…). */
+    title: string;
+    status: ChatTask.Status;
+    /** O item do log que abriu a tarefa (pular pra ela no histórico). */
+    itemId?: string | undefined;
+    startedAt: SmoothAgentApi.Timestamp;
+    endedAt?: SmoothAgentApi.Timestamp | undefined;
+    exitCode?: number | undefined;
+}
+export declare namespace ChatTask {
+    const Kind: {
+        readonly Subagent: "subagent";
+        readonly Command: "command";
+        readonly Monitor: "monitor";
+        readonly Terminal: "terminal";
+    };
+    type Kind = (typeof Kind)[keyof typeof Kind];
+    const Status: {
+        readonly Running: "running";
+        readonly Completed: "completed";
+        readonly Failed: "failed";
+        readonly Stopped: "stopped";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+}

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

@@ -0,0 +1,9 @@
+export interface ChatTaskOutput {
+    taskId: string;
+    /** Texto a partir de `after` (offset em bytes da saída inteira). */
+    text: string;
+    /** Offset pra pedir o resto (`after`). */
+    next: number;
+    /** A tarefa terminou e não vem mais nada. */
+    done: boolean;
+}

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

@@ -0,0 +1,19 @@
+import type * as SmoothAgentApi from "../index.js";
+export interface ChatUsage {
+    /** Soma de todos os runs do chat (inclui os de outros provedores, separados em `byProvider`). */
+    total: SmoothAgentApi.EventsUsage;
+    byProvider: ChatUsage.ByProvider.Item[];
+    /** O run ativo ou o último. */
+    lastRun: SmoothAgentApi.RunSummary | null;
+}
+export declare namespace ChatUsage {
+    type ByProvider = ByProvider.Item[];
+    namespace ByProvider {
+        interface Item {
+            provider: SmoothAgentApi.EventsProvider;
+            model: string | null;
+            runs: number;
+            usage: SmoothAgentApi.EventsUsage;
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+export interface Deleted {
+    id: string;
+    deleted: boolean;
+}

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

@@ -0,0 +1,11 @@
+import type * as SmoothAgentApi from "../index.js";
+/**
+ * Assinatura ChatGPT: o CLI oficial roda `codex login --device-auth` numa box descartável (o WAF
+ * barra o nosso servidor) e devolve URL + código; o usuário autoriza no navegador DELE.
+ */
+export interface DeviceFlow {
+    loginId: string;
+    url: string;
+    userCode: string;
+    expiresAt: SmoothAgentApi.Timestamp;
+}

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

@@ -0,0 +1,12 @@
+import type * 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-client/api/types/Error_.d.ts

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

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

@@ -0,0 +1,15 @@
+import type * 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-client/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-client/api/types/EventsAgentSelection.d.ts

@@ -0,0 +1,14 @@
+import type * 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-client/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-client/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-client/api/types/EventsChatId.d.ts

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

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

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

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

@@ -0,0 +1,11 @@
+import type * 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-client/api/types/EventsContentPart.d.ts

@@ -0,0 +1,19 @@
+import type * 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-client/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-client/api/types/EventsContentText.d.ts

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

package/dist/types/sdk/generated/ts-client/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-client/api/types/EventsEAgentSwitchFailed.d.ts

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

@@ -0,0 +1,9 @@
+import type * 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-client/api/types/EventsEAgentSwitched.d.ts

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

@@ -0,0 +1,12 @@
+import type * 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-client/api/types/EventsEChatState.d.ts

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

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

@@ -0,0 +1,20 @@
+import type * 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-client/api/types/EventsEError.d.ts

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

@@ -0,0 +1,13 @@
+import type * 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-client/api/types/EventsEItemCompleted.d.ts

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

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