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

package/dist/types/sdk/ts/core-live/src/wasm/empty.d.ts

@@ -0,0 +1 @@
+export declare const EMPTY_STATE_JSON = "{\"seq\":0,\"chat\":{\"state\":\"idle\"},\"items\":{},\"order\":[],\"history\":[],\"tasks\":{},\"pending\":{},\"limits\":{},\"usage\":{\"chat\":{}},\"runs\":[],\"switches\":[]}";

package/dist/types/sdk/ts/core-live/src/wasm/live.d.ts

@@ -0,0 +1,278 @@
+/* tslint:disable */
+/* eslint-disable */
+export function to_ms(epoch: number, now: number): number;
+export function error_code(c: string): string;
+/**
+ * A lista fechada do contrato (§6), gerada do schema no build.
+ */
+export function error_codes(): string;
+/**
+ * `state.needsProvider` a partir do estado (o mesmo do watch; a fixture de conformidade usa).
+ */
+export function needs_provider(timeline_json: string, queue_json: string, refusal_json: string): string;
+/**
+ * A lista lateral ao vivo (UserFeed). As entradas são as mesmas da borda comum; as que não se aplicam
+ * (probe, range, snapshot) não fazem nada.
+ */
+export class LiveFeed {
+  free(): void;
+  on_message(now: number, online: boolean, visible: boolean, rand: number, conn: number, text: string): string;
+  on_snapshot(_n: number, _o: boolean, _v: boolean, _r: number, _req: number, _ok: boolean, _s: string): string;
+  next_deadline(): number;
+  on_open_failed(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  /**
+   * `config_json`: { url, agentId?, backoff? }
+   */
+  constructor(config_json: string);
+  tick(now: number, online: boolean, visible: boolean, rand: number): string;
+  wake(now: number, online: boolean, visible: boolean, rand: number, _why: string, _away_ms: number): string;
+  close(now: number, online: boolean, visible: boolean, rand: number): string;
+  start(now: number, online: boolean, visible: boolean, rand: number): string;
+  status(): string;
+  on_open(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_close(now: number, online: boolean, visible: boolean, rand: number, conn: number, code: number, reason: string): string;
+  on_error(_now: number, _online: boolean, _visible: boolean, _rand: number, _conn: number): string;
+  on_probe(_n: number, _o: boolean, _v: boolean, _r: number, _req: number, _ok: boolean, _a: string): string;
+  on_range(_n: number, _o: boolean, _v: boolean, _r: number, _req: number, _ok: boolean, _e: string, _f: number, _t: number): string;
+  on_token(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, token: string): string;
+}
+/**
+ * Uma sessão ao vivo de um chat (o `ChatStream`). Toda entrada recebe o ambiente do instante e devolve
+ * os efeitos (JSON array) que a borda executa em ordem.
+ */
+export class LiveSession {
+  free(): void;
+  on_message(now: number, online: boolean, visible: boolean, rand: number, conn: number, text: string): string;
+  on_snapshot(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, snapshot_json: string): string;
+  /**
+   * JSON da presença da box ou "".
+   */
+  box_presence(): string;
+  /**
+   * Próximo prazo (ms) ou -1.
+   */
+  next_deadline(): number;
+  token_renewed(now: number, online: boolean, visible: boolean, rand: number, token: string): string;
+  on_open_failed(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  /**
+   * `config_json`: { chatId, connectorUrl, resumeCursor?, resumeInboxVersion?, includeRaw?, strict?,
+   * pingEveryMs?, pongTimeoutMs?, switchGraceMs?, syncTimeoutMs?, gapTimeoutMs?,
+   * longAwayMs?, backoff?{…}, has:{probeAccess,eventsRange,snapshot} }
+   */
+  constructor(config_json: string);
+  /**
+   * "connector" | "box" | "" (nenhum)
+   */
+  via(): string;
+  tick(now: number, online: boolean, visible: boolean, rand: number): string;
+  wake(now: number, online: boolean, visible: boolean, rand: number, why: string, away_ms: number): string;
+  close(now: number, online: boolean, visible: boolean, rand: number): string;
+  start(now: number, online: boolean, visible: boolean, rand: number): string;
+  cursor(): number;
+  status(): string;
+  command(now: number, online: boolean, visible: boolean, rand: number, frame_json: string): string;
+  on_open(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_close(now: number, online: boolean, visible: boolean, rand: number, conn: number, code: number, reason: string): string;
+  on_error(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_probe(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, access: string): string;
+  /**
+   * `events_json` = array de envelopes.
+   */
+  on_range(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, events_json: string, from: number, to: number): string;
+  /**
+   * `ok=false` = o getToken falhou.
+   */
+  on_token(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, token: string): string;
+}
+/**
+ * O `watch()` inteiro (transporte + estado + histórico + otimista). Efeitos = os da sessão + `history`
+ * (pedir página), `patch` (o que mudou no estado) e `tap` (eventos aplicados).
+ */
+export class LiveWatch {
+  free(): void;
+  load_newer(): string;
+  load_older(): string;
+  /**
+   * `page_json` = a página no formato do log ({items: envelopes, hasBefore, hasAfter, anchorIndex?…});
+   * com `ok=false`, `page_json` é a mensagem de erro.
+   */
+  on_history(req: number, ok: boolean, page_json: string): string;
+  on_message(now: number, online: boolean, visible: boolean, rand: number, conn: number, text: string): string;
+  jump_to_end(): string;
+  on_snapshot(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, snapshot_json: string): string;
+  /**
+   * Troca de agente (§17.4) no mesmo canal ordenado dos comandos; `to_json` = `{agentId?, model?, effort?}` (o
+   * realtime completa e valida; provider/agentName que vierem são ignorados). O `resolve`
+   * sai com o ref `switch:<switch_id>`.
+   */
+  switch_agent(now: number, online: boolean, visible: boolean, rand: number, switch_id: string, to_json: string): string;
+  /**
+   * Só modelo/esforço do mesmo agente (`change_json` = `{model?, effort?}`). Ref `switch:<switch_id>`.
+   */
+  switch_model(now: number, online: boolean, visible: boolean, rand: number, switch_id: string, change_json: string): string;
+  /**
+   * Cancela a troca agendada (frame `cancelSwitch`). Ref `switch:<switch_id>`.
+   */
+  cancel_switch(now: number, online: boolean, visible: boolean, rand: number, switch_id: string): string;
+  next_deadline(): number;
+  token_renewed(now: number, online: boolean, visible: boolean, rand: number, token: string): string;
+  /**
+   * O ref que o próximo `queue_op` vai usar (a borda espera o `resolve` dele).
+   */
+  next_queue_ref(): string;
+  on_open_failed(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  /**
+   * A mesma configuração da `LiveSession` + `pageSize?`, `maxWindow?`, `has.history`.
+   */
+  constructor(config_json: string);
+  via(): string;
+  /**
+   * `content_json` = ContentPart[] (a borda converte texto/anexos); `metadata_json` = `{chave: texto}` ou `""` (sem).
+   */
+  send(now: number, online: boolean, visible: boolean, rand: number, message_id: string, content_json: string, mode: string, metadata_json: string): string;
+  tick(now: number, online: boolean, visible: boolean, rand: number): string;
+  wake(now: number, online: boolean, visible: boolean, rand: number, why: string, away_ms: number): string;
+  close(now: number, online: boolean, visible: boolean, rand: number): string;
+  start(now: number, online: boolean, visible: boolean, rand: number): string;
+  cursor(): number;
+  status(): string;
+  /**
+   * Comando cru com `ref` (stop/respond/resend/reset).
+   */
+  command(now: number, online: boolean, visible: boolean, rand: number, frame_json: string): string;
+  /**
+   * `anchor_json` = {"messageId": "msg_…"} | {"eventId": N}
+   */
+  jump_to(anchor_json: string): string;
+  on_open(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_close(now: number, online: boolean, visible: boolean, rand: number, conn: number, code: number, reason: string): string;
+  on_error(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_probe(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, access: string): string;
+  on_range(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, events_json: string, from: number, to: number): string;
+  on_token(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, token: string): string;
+  queue_op(now: number, online: boolean, visible: boolean, rand: number, op_json: string): string;
+}
+/**
+ * O reducer do contrato, em Rust (o mesmo que os nativos usam).
+ */
+export class Reducer {
+  free(): void;
+  /**
+   * Parte de um estado (o snapshot) em vez do vazio.
+   */
+  load_state(state_json: string): void;
+  state_json(): string;
+  constructor();
+  apply(event_json: string): void;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_livefeed_free: (a: number, b: number) => void;
+  readonly __wbg_livesession_free: (a: number, b: number) => void;
+  readonly __wbg_livewatch_free: (a: number, b: number) => void;
+  readonly __wbg_reducer_free: (a: number, b: number) => void;
+  readonly error_code: (a: number, b: number, c: number) => void;
+  readonly error_codes: (a: number) => void;
+  readonly livefeed_close: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livefeed_new: (a: number, b: number, c: number) => void;
+  readonly livefeed_next_deadline: (a: number) => number;
+  readonly livefeed_on_close: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livefeed_on_error: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly livefeed_on_message: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly livefeed_on_open: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly livefeed_on_open_failed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly livefeed_on_probe: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livefeed_on_range: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
+  readonly livefeed_on_token: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livefeed_start: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livefeed_status: (a: number, b: number) => void;
+  readonly livefeed_tick: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livefeed_wake: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly livesession_box_presence: (a: number, b: number) => void;
+  readonly livesession_close: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livesession_command: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly livesession_cursor: (a: number) => number;
+  readonly livesession_new: (a: number, b: number, c: number) => void;
+  readonly livesession_next_deadline: (a: number) => number;
+  readonly livesession_on_close: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livesession_on_error: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly livesession_on_message: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly livesession_on_open: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly livesession_on_open_failed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly livesession_on_probe: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livesession_on_range: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
+  readonly livesession_on_snapshot: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livesession_on_token: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livesession_start: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livesession_status: (a: number, b: number) => void;
+  readonly livesession_tick: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livesession_token_renewed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly livesession_via: (a: number, b: number) => void;
+  readonly livesession_wake: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly livewatch_cancel_switch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly livewatch_close: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livewatch_command: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly livewatch_cursor: (a: number) => number;
+  readonly livewatch_jump_to: (a: number, b: number, c: number, d: number) => void;
+  readonly livewatch_jump_to_end: (a: number, b: number) => void;
+  readonly livewatch_load_newer: (a: number, b: number) => void;
+  readonly livewatch_load_older: (a: number, b: number) => void;
+  readonly livewatch_new: (a: number, b: number, c: number) => void;
+  readonly livewatch_next_deadline: (a: number) => number;
+  readonly livewatch_next_queue_ref: (a: number, b: number) => void;
+  readonly livewatch_on_close: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livewatch_on_error: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly livewatch_on_history: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livewatch_on_message: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly livewatch_on_open: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly livewatch_on_open_failed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly livewatch_on_probe: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livewatch_on_range: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
+  readonly livewatch_on_snapshot: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livewatch_on_token: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livewatch_queue_op: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly livewatch_send: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number) => void;
+  readonly livewatch_start: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livewatch_status: (a: number, b: number) => void;
+  readonly livewatch_switch_agent: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livewatch_switch_model: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly livewatch_tick: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livewatch_token_renewed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly livewatch_via: (a: number, b: number) => void;
+  readonly livewatch_wake: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly needs_provider: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly reducer_apply: (a: number, b: number, c: number, d: number) => void;
+  readonly reducer_load_state: (a: number, b: number, c: number, d: number) => void;
+  readonly reducer_new: () => number;
+  readonly reducer_state_json: (a: number, b: number) => void;
+  readonly to_ms: (a: number, b: number) => number;
+  readonly livefeed_on_snapshot: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly __wbindgen_export_0: (a: number, b: number) => number;
+  readonly __wbindgen_export_1: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export_2: (a: number, b: number, c: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dist/types/sdk/ts/core-live/src/watch.d.ts

@@ -0,0 +1,299 @@
+import type { LiveDeps } from './deps.js';
+import { newMessageId, uuidv7 } from './ids.js';
+import { type DebugEvent, type LiveStatus, type StreamOptions, type Via, type Violation } from './stream.js';
+import { type ChatMessage, type EffectiveSelection, type QueueState, type BoxPresence, type ContentPart, type Envelope, type InboxState, type NeedsProvider, type SendMode, type SubmitResult } from './types.js';
+export { newMessageId, uuidv7 };
+/** A troca, na forma do REST (`SwitchAgent`). */
+export interface SwitchTo {
+    agentId: string;
+    /**
+     * Ausente = no MESMO agente fica o de agora; em OUTRO agente, o padrão dele. `null` = (no mesmo agente) voltar ao
+     * padrão do agente. Tem que estar em `selection.options`.
+     */
+    model?: string | null;
+    effort?: string | null;
+    /** @deprecated ignorado: o servidor resolve o provedor pelo agente */
+    provider?: string;
+    /** @deprecated ignorado: o servidor resolve o nome pelo agente */
+    agentName?: string;
+}
+/**
+ * O reducer do contrato (contract/events). Com o núcleo em Rust, o reducer que roda é SEMPRE o do contrato
+ * (o mesmo nos nativos); este tipo fica pra compatibilidade de quem já passava `contractReducer`.
+ */
+export interface Reducer<S, I = unknown> {
+    empty(): S;
+    /** Pode mutar e devolver o mesmo objeto; a camada publica um estado novo por lote. */
+    apply(state: S, ev: Envelope): S;
+    /** Itens FECHADOS, em ordem (o histórico ao vivo). */
+    history(state: S): I[];
+    /** Item de histórico a partir de uma entrada de página do REST. */
+    itemOf(entry: Envelope): I;
+    idOf(item: I): string;
+}
+export interface HistoryPage {
+    items: Envelope[];
+    firstEventId: number | null;
+    lastEventId: number | null;
+    hasBefore: boolean;
+    hasAfter: boolean;
+    anchorIndex?: number;
+    headEventId: number;
+    liveFromEventId?: number;
+}
+export type HistoryQuery = {
+    limit?: number;
+} & ({
+    before: number;
+} | {
+    after: number;
+} | {
+    around: {
+        messageId: string;
+    } | {
+        eventId: number;
+    };
+} | {
+    anchor: 'end';
+});
+export interface WatchDeps extends LiveDeps {
+    history?(chatId: string, q: HistoryQuery): Promise<HistoryPage>;
+    /**
+     * REST `POST /v3/chats/{id}/messages` com `clientMessageId` = o messageId do `send` (a MESMA fila fria durável do
+     * ChatLog, que deduplica pelo id). O caminho durável do `send` quando o socket não confirma a tempo e no `close()`.
+     * Falha passageira: rejeita (o socket segue tentando); recusa do servidor: resolve `rejected`.
+     */
+    postMessage?(chatId: string, m: {
+        clientMessageId: string;
+        content: ContentPart[];
+        mode: SendMode;
+        metadata?: Record<string, string>;
+    }): Promise<SubmitResult>;
+}
+/**
+ * Um `send` que não chegou a ser confirmado gravado: o `close()` sem caminho durável (`reason: 'closed'`), o
+ * `timeoutMs` vencido (`'timeout'`), ou socket e REST falharam (`'failed'`). Traz a mensagem pro app reenviar —
+ * reenviar com o MESMO `messageId` é seguro (o servidor deduplica: nunca 2x).
+ */
+export declare class SendNotConfirmedError extends Error {
+    readonly reason: 'closed' | 'timeout' | 'failed';
+    readonly messageId: string;
+    readonly content: ContentPart[];
+    readonly mode: SendMode;
+    readonly cause?: unknown | undefined;
+    readonly name = "SendNotConfirmedError";
+    constructor(reason: 'closed' | 'timeout' | 'failed', messageId: string, content: ContentPart[], mode: SendMode, cause?: unknown | undefined);
+}
+/** Um comando (stop/respond/reset/fila/troca) que esperava o ack quando o `close()` chegou. */
+export declare class CommandAbortedError extends Error {
+    readonly ref: string;
+    readonly name = "CommandAbortedError";
+    constructor(ref: string);
+}
+/** Espera padrão do socket antes do caminho durável (REST) no `send`. */
+export declare const SEND_FALLBACK_MS = 2000;
+export interface LocalSend {
+    messageId: string;
+    content: ContentPart[];
+    mode: SendMode;
+    /** O metadata que foi junto (chave → texto do app; o agente nunca vê). */
+    metadata?: Record<string, string>;
+    status: 'sending' | 'pending' | 'rejected';
+    error?: string;
+    /** Versão da inbox que o ack disse conter a mensagem. */
+    ackVersion?: number;
+}
+export interface HistoryWindow<I> {
+    anchor: 'end' | 'detached';
+    /** Os itens fechados que a tela mostra, em ordem. */
+    items: I[];
+    hasBefore: boolean;
+    hasAfter: boolean;
+    loadingBefore: boolean;
+    loadingAfter: boolean;
+    newWhileDetached: number;
+    /** Depois de `jumpTo`: o índice do item âncora em `items` (pra tela rolar até ele). */
+    anchorIndex?: number;
+    error?: string;
+}
+export interface WatchState<S, I = unknown> {
+    /** Sobe a cada mudança (comparar barato). */
+    version: number;
+    timeline: S;
+    messages: ChatMessage[];
+    effectiveSelection: EffectiveSelection;
+    /**
+     * A fila do chat (§17): a MESMA venha da fila fria do realtime ou da box (a maior versão vale). Uma
+     * mensagem some daqui quando o `user_message` com o mesmo messageId entra na timeline — nunca aparece 2×.
+     */
+    queue: QueueState;
+    /** @deprecated §17 (lote 2 tira): use `queue`. */
+    inbox: InboxState;
+    /** "Conecte sua conta" (ver `NeedsProvider`); null = nada a pedir. */
+    needsProvider: NeedsProvider | null;
+    box: BoxPresence | null;
+    local: {
+        sending: LocalSend[];
+    };
+    history: HistoryWindow<I>;
+    sync: {
+        status: LiveStatus;
+        cursor: number;
+        via: Via | null;
+        violations: Violation[];
+    };
+}
+export interface WatchOptions<S, I> extends Omit<StreamOptions, 'chatId'> {
+    chatId: string;
+    /** Ignorado: o reducer é o do contrato, no núcleo (mantido pra compatibilidade). */
+    reducer?: Reducer<S, I>;
+    /** Itens por página do histórico (1–200). */
+    pageSize?: number;
+    /** Teto da janela: rolar muito solta a ponta oposta (a virtualização é da tela). */
+    maxWindow?: number;
+    onDebug?(e: DebugEvent): void;
+    /** Erro de auth definitivo (revogado). */
+    onAuthFailed?(): void;
+    /** Modo estrito: cada violação (também fica em `sync.violations`). */
+    onViolation?(v: Violation): void;
+    /**
+     * Quanto o `send` espera a confirmação pelo socket antes de gravar pelo REST (`deps.postMessage`), com o mesmo
+     * messageId. Padrão 2000 ms; `Infinity` = só no `close()`.
+     */
+    sendFallbackMs?: number;
+}
+type Listener<S, I> = (s: WatchState<S, I>) => void;
+export declare class LiveChat<S, I = unknown> {
+    private readonly d;
+    private readonly o;
+    private readonly edge;
+    private state;
+    private readonly listeners;
+    private readonly eventTaps;
+    private readonly waiting;
+    private readonly historyWaiting;
+    /** os `send` esperando, NA ORDEM em que foram mandados (o Map guarda a ordem de inserção) */
+    private readonly sends;
+    /** a corrente do REST: um pedido por vez, em ordem (B nunca passa na frente de A) */
+    private restBusy;
+    private restRetry;
+    /** falhas de vez seguidas da corrente (a espera cresce; zera quando uma grava) */
+    private restFails;
+    /** gravados pelo REST e ainda em `local.sending` do núcleo (que não viu o ack): a tela mostra `pending` */
+    private readonly restStored;
+    /** o `local.sending` como o núcleo mandou (antes da sobreposição do REST) */
+    private coreLocal;
+    /** itens que vieram de páginas do histórico (não estão na timeline viva) */
+    private readonly pageItems;
+    private historyIds;
+    private closed;
+    private readonly unWake;
+    constructor(d: WatchDeps, o: WatchOptions<S, I>);
+    getState: () => WatchState<S, I>;
+    /** Compatível com `useSyncExternalStore(live.subscribe, live.getState)`. */
+    subscribe: (cb: Listener<S, I>) => (() => void);
+    /** Só chama quando o pedaço escolhido muda (a fila não re-renderiza a cada delta de texto — T3). */
+    select<T>(fn: (s: WatchState<S, I>) => T, cb: (v: T) => void, eq?: (a: T, b: T) => boolean): () => void;
+    /** Eventos aplicados, em ordem (o `prompt()` e o `events()` usam). */
+    tap(cb: (evs: Envelope[]) => void): () => void;
+    get chatId(): string;
+    /**
+     * Manda uma mensagem. Aparece na hora em `local.sending`; sai quando a inbox do log a mostra. Resolve quando
+     * gravada: pelo socket ou, se ele não confirmar em `sendFallbackMs`, pelo REST com o mesmo messageId (o servidor
+     * deduplica). `timeoutMs`: rejeita com `SendNotConfirmedError` ('timeout') se nada confirmou no prazo.
+     *
+     * O `timeoutMs` só desiste de ESPERAR: não cancela o envio pelo socket (o núcleo segue reenviando aquele frame
+     * até o ack ou o `close()`), então a mensagem ainda pode chegar à fila depois do timeout — e, chegando, a ordem
+     * relativa dela com os `send` seguintes não é garantida (o caminho do REST também não espera mais por ela).
+     * Reenviar com o mesmo `messageId` é seguro (o servidor deduplica) — com o MESMO `metadata`: outro = `conflict`.
+     *
+     * `metadata`: chave → texto do app (até 16 chaves `^[A-Za-z0-9_.:-]{1,64}$`, sem o prefixo `sa.`; valores de até
+     * 512 caracteres). Volta como `metadata` no item `user_message` e nos itens da fila; o agente/LLM NUNCA vê.
+     * Fora dos limites = `rejected` `invalid_request`. `{}` = sem metadata.
+     */
+    send(content: string | ContentPart[], opts?: {
+        mode?: SendMode;
+        attachments?: string[];
+        messageId?: string;
+        timeoutMs?: number;
+        metadata?: Record<string, string>;
+    }): Promise<SubmitResult & {
+        messageId: string;
+    }>;
+    /** Pede o caminho durável pra este send (e, pela ordem, pra todos os anteriores ainda esperando). */
+    private viaRest;
+    /**
+     * A corrente do REST, por chat: grava UM por vez, na ordem dos `send`. A cabeça é o send mais antigo ainda
+     * esperando; se algum depois dela pediu o REST, ela vai antes (a fila no servidor fica na ordem em que o usuário
+     * mandou). A cabeça confirmada (por qualquer caminho) libera a próxima. Falhou de vez: com o chat aberto a corrente
+     * para e tenta de novo com espera crescente, 5 s até 60 s (o socket também segue tentando); fechado, a cabeça e TODAS as de trás
+     * rejeitam — nenhuma pula a que não foi gravada.
+     */
+    private pumpRest;
+    private coreGaveUp;
+    private settleSend;
+    /** Gravado pelo REST: no `local.sending` passa de `sending` a `pending` (o núcleo não viu o ack). */
+    private markStored;
+    private overlayLocal;
+    stop(): Promise<SubmitResult>;
+    respond(requestId: string, answer: unknown): Promise<SubmitResult>;
+    /** Sessão nova do provedor (era o recycle); `clearHistory` também esconde o histórico até aqui. */
+    reset(opts?: {
+        clearHistory?: boolean;
+    }): Promise<SubmitResult>;
+    /**
+     * Troca de agente (§17.4): um comando da fila no MESMO canal ordenado do `send` — "troquei e mandei" chega
+     * na ordem, sem esperar nada. O dono aplica antes do próximo run; uma troca nova substitui a pendente
+     * (`queue.pendingSwitch`). A forma é a do REST (`agentId`, `model?`, `effort?`): o servidor completa o resto e
+     * valida o acesso; `provider`/`agentName` não vão (o servidor ignoraria).
+     */
+    switchAgent(to: SwitchTo): Promise<SubmitResult>;
+    /**
+     * Troca SÓ modelo/esforço do agente de agora (o que não vier fica o de agora): o mesmo comando `switch`, sem
+     * `agentId` — o servidor completa com o agente atual (a box aplica ao vivo, sem sessão nova). `null` = voltar
+     * ao padrão do agente (vai no frame como `reset`).
+     */
+    switchModel(change: {
+        model?: string | null;
+        effort?: string | null;
+    }): Promise<SubmitResult>;
+    /** Cancela a troca agendada (`queue.pendingSwitch`): o comando `cancelSwitch`, no mesmo canal ordenado. */
+    cancelSwitch(): Promise<SubmitResult>;
+    resend(messageId: string): Promise<SubmitResult>;
+    /** Fila: sempre em cima da versão que a tela está vendo; `conflict` traz (e aplica) o estado novo. */
+    readonly queue: {
+        reorder: (order: string[]) => Promise<SubmitResult>;
+        edit: (messageId: string, content: string | ContentPart[]) => Promise<SubmitResult>;
+        remove: (messageId: string) => Promise<SubmitResult>;
+        sendNow: (messageId: string) => Promise<SubmitResult>;
+    };
+    private queueOp;
+    private command;
+    private wait;
+    retry(): void;
+    tokenRenewed(token: string): void;
+    /**
+     * Fecha. Nenhuma espera fica pendurada: o `send` não confirmado vai pelo REST (mesmo messageId) e resolve quando
+     * gravado; sem REST, rejeita com `SendNotConfirmedError` ('closed', com a mensagem). Os demais comandos
+     * rejeitam com `CommandAbortedError`.
+     */
+    close(): void;
+    readonly history: {
+        /** Rola pra cima: página de itens fechados antes do primeiro da janela. */
+        loadOlder: () => Promise<void>;
+        /** Só na janela parada: página depois do último item; encontrando o ao vivo, recola no fim. */
+        loadNewer: () => Promise<void>;
+        /** Abre "em volta" de uma mensagem ou evento. O ao vivo continua aplicando por baixo. */
+        jumpTo: (anchor: {
+            messageId: string;
+        } | {
+            eventId: number;
+        }) => Promise<void>;
+        /** Volta pro fim (cola no ao vivo). */
+        jumpToEnd: () => Promise<void>;
+    };
+    /** Roda um pedido de histórico; resolve quando a página chegou e foi aplicada (ou na hora, se não pediu). */
+    private page;
+    private handle;
+    private applyPatch;
+}

package/dist/types/sdk/ts/server/src/dashboard.d.ts

@@ -0,0 +1,25 @@
+import { SmoothAgentDashboardClient } from '../../../generated/ts-dashboard/index.js';
+export { SmoothAgentDashboardClient, SmoothAgentDashboard, SmoothAgentDashboardError, SmoothAgentDashboardTimeoutError, } from '../../../generated/ts-dashboard/index.js';
+export interface DashboardAuthOptions {
+    /** A MESMA origem do `SmoothAgentServer` (sem `/v3`): no Studio, `location.origin`. */
+    baseUrl?: string;
+    /** Sessão do dashboard, se ela for por Bearer; sem isto, vai sem Authorization (login/signup/forgot/cookie). */
+    token?: string | (() => string | Promise<string>);
+    fetch?: typeof fetch;
+}
+/**
+ * Casca do login do dev com o mesmo `baseUrl` do `SmoothAgentServer` (a gerada já põe `v3/auth/…` no caminho,
+ * a do server põe `/v3` na base — aqui as duas aceitam a origem pura) e nomes curtos.
+ */
+export declare class SmoothAgentDashboardAuth {
+    /** O cliente gerado, inteiro. */
+    readonly api: SmoothAgentDashboardClient;
+    constructor(o?: DashboardAuthOptions);
+    login: (...a: Parameters<SmoothAgentDashboardClient["dashboardAuthLogin"]>) => import("../../../generated/ts-dashboard/core/index.js").HttpResponsePromise<import("../../../generated/ts-dashboard/api/index.js").SessionResponse>;
+    logout: (...a: Parameters<SmoothAgentDashboardClient["dashboardAuthLogout"]>) => import("../../../generated/ts-dashboard/core/index.js").HttpResponsePromise<import("../../../generated/ts-dashboard/api/index.js").DashboardAuthLogoutResponse>;
+    me: (...a: Parameters<SmoothAgentDashboardClient["dashboardAuthMe"]>) => import("../../../generated/ts-dashboard/core/index.js").HttpResponsePromise<import("../../../generated/ts-dashboard/api/index.js").DashboardAuthMeResponse>;
+    signup: (...a: Parameters<SmoothAgentDashboardClient["dashboardAuthSignup"]>) => import("../../../generated/ts-dashboard/core/index.js").HttpResponsePromise<import("../../../generated/ts-dashboard/api/index.js").SessionResponse>;
+    forgot: (...a: Parameters<SmoothAgentDashboardClient["dashboardAuthForgot"]>) => import("../../../generated/ts-dashboard/core/index.js").HttpResponsePromise<import("../../../generated/ts-dashboard/api/index.js").DashboardAuthForgotResponse>;
+    reset: (...a: Parameters<SmoothAgentDashboardClient["dashboardAuthReset"]>) => import("../../../generated/ts-dashboard/core/index.js").HttpResponsePromise<import("../../../generated/ts-dashboard/api/index.js").SessionResponse>;
+    changePassword: (...a: Parameters<SmoothAgentDashboardClient["dashboardAuthChangePassword"]>) => import("../../../generated/ts-dashboard/core/index.js").HttpResponsePromise<import("../../../generated/ts-dashboard/api/index.js").DashboardAuthChangePasswordResponse>;
+}