@smoothcodes/agent-client 0.0.0-stage → 0.1.1

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;
+  /**
+   * `config_json`: { url, agentId?, backoff? }
+   */
+  constructor(config_json: string);
+  start(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;
+  tick(now: number, online: boolean, visible: boolean, rand: number): string;
+  on_open(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_message(now: number, online: boolean, visible: boolean, rand: number, conn: number, text: string): string;
+  on_error(_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_open_failed(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_token(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, token: string): 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_snapshot(_n: number, _o: boolean, _v: boolean, _r: number, _req: number, _ok: boolean, _s: string): string;
+  status(): string;
+  next_deadline(): number;
+}
+/**
+ * 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;
+  /**
+   * `config_json`: { chatId, connectorUrl, resumeCursor?, resumeInboxVersion?, includeRaw?, strict?,
+   * pingEveryMs?, pongTimeoutMs?, switchGraceMs?, syncTimeoutMs?, gapTimeoutMs?,
+   * longAwayMs?, backoff?{…}, has:{probeAccess,eventsRange,snapshot} }
+   */
+  constructor(config_json: string);
+  start(now: number, online: boolean, visible: boolean, rand: number): string;
+  command(now: number, online: boolean, visible: boolean, rand: number, frame_json: string): string;
+  token_renewed(now: number, online: boolean, visible: boolean, rand: number, token: string): 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;
+  tick(now: number, online: boolean, visible: boolean, rand: number): string;
+  on_open(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_message(now: number, online: boolean, visible: boolean, rand: number, conn: number, text: string): string;
+  on_error(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_open_failed(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  /**
+   * `ok=false` = o getToken falhou.
+   */
+  on_token(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, token: string): 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;
+  on_snapshot(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, snapshot_json: string): string;
+  status(): string;
+  cursor(): number;
+  /**
+   * "connector" | "box" | "" (nenhum)
+   */
+  via(): string;
+  /**
+   * JSON da presença da box ou "".
+   */
+  box_presence(): string;
+  /**
+   * Próximo prazo (ms) ou -1.
+   */
+  next_deadline(): number;
+}
+/**
+ * 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;
+  /**
+   * A mesma configuração da `LiveSession` + `pageSize?`, `maxWindow?`, `has.history`.
+   */
+  constructor(config_json: string);
+  start(now: number, online: boolean, visible: boolean, rand: number): 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;
+  token_renewed(now: number, online: boolean, visible: boolean, rand: number, token: string): string;
+  on_open(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_message(now: number, online: boolean, visible: boolean, rand: number, conn: number, text: string): string;
+  on_error(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_open_failed(now: number, online: boolean, visible: boolean, rand: number, conn: number): string;
+  on_token(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, token: string): 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_snapshot(now: number, online: boolean, visible: boolean, rand: number, req: number, ok: boolean, snapshot_json: string): string;
+  /**
+   * `content_json` = ContentPart[] (a borda converte texto/anexos).
+   */
+  send(now: number, online: boolean, visible: boolean, rand: number, message_id: string, content_json: string, mode: 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;
+  /**
+   * O ref que o próximo `queue_op` vai usar (a borda espera o `resolve` dele).
+   */
+  next_queue_ref(): string;
+  queue_op(now: number, online: boolean, visible: boolean, rand: number, op_json: string): string;
+  /**
+   * Comando cru com `ref` (stop/respond/resend/reset).
+   */
+  command(now: number, online: boolean, visible: boolean, rand: number, frame_json: string): string;
+  load_older(): string;
+  load_newer(): string;
+  /**
+   * `anchor_json` = {"messageId": "msg_…"} | {"eventId": N}
+   */
+  jump_to(anchor_json: string): string;
+  jump_to_end(): 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;
+  status(): string;
+  cursor(): number;
+  via(): string;
+  next_deadline(): number;
+}
+/**
+ * O reducer do contrato, em Rust (o mesmo que os nativos usam).
+ */
+export class Reducer {
+  free(): void;
+  constructor();
+  apply(event_json: string): void;
+  state_json(): string;
+  /**
+   * Parte de um estado (o snapshot) em vez do vazio.
+   */
+  load_state(state_json: string): void;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_livesession_free: (a: number, b: number) => void;
+  readonly livesession_new: (a: number, b: number, c: number) => void;
+  readonly livesession_start: (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_token_renewed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: 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 livesession_close: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livesession_tick: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livesession_on_open: (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_error: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  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_open_failed: (a: number, b: number, c: number, d: number, e: number, f: number, g: 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_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_status: (a: number, b: number) => void;
+  readonly livesession_cursor: (a: number) => number;
+  readonly livesession_via: (a: number, b: number) => void;
+  readonly livesession_box_presence: (a: number, b: number) => void;
+  readonly livesession_next_deadline: (a: number) => number;
+  readonly __wbg_reducer_free: (a: number, b: number) => void;
+  readonly reducer_new: () => number;
+  readonly reducer_apply: (a: number, b: number, c: number, d: number) => void;
+  readonly reducer_state_json: (a: number, b: number) => void;
+  readonly reducer_load_state: (a: number, b: number, c: number, d: number) => void;
+  readonly to_ms: (a: number, b: number) => number;
+  readonly error_code: (a: number, b: number, c: number) => void;
+  readonly error_codes: (a: number) => void;
+  readonly __wbg_livefeed_free: (a: number, b: number) => void;
+  readonly livefeed_new: (a: number, b: number, c: number) => void;
+  readonly livefeed_start: (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 livefeed_close: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livefeed_tick: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livefeed_on_open: (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_error: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  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_open_failed: (a: number, b: number, c: number, d: number, e: number, f: number, g: 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_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_status: (a: number, b: number) => void;
+  readonly livefeed_next_deadline: (a: number) => number;
+  readonly __wbg_livewatch_free: (a: number, b: number) => void;
+  readonly livewatch_new: (a: number, b: number, c: number) => void;
+  readonly livewatch_start: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livewatch_tick: (a: number, b: number, c: number, d: number, e: number, f: 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 livewatch_close: (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_on_open: (a: number, b: number, c: number, d: number, e: number, f: number, g: 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_error: (a: number, b: number, c: number, d: number, e: number, f: number, g: 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_open_failed: (a: number, b: number, c: number, d: number, e: number, f: number, g: 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_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_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) => 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_cancel_switch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly livewatch_next_queue_ref: (a: number, b: 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_command: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly livewatch_load_older: (a: number, b: number) => void;
+  readonly livewatch_load_newer: (a: number, b: number) => void;
+  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_on_history: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly livewatch_status: (a: number, b: number) => void;
+  readonly livewatch_cursor: (a: number) => number;
+  readonly livewatch_via: (a: number, b: number) => void;
+  readonly livewatch_next_deadline: (a: number) => number;
+  readonly needs_provider: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  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,211 @@
+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 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>;
+}
+export interface LocalSend {
+    messageId: string;
+    content: ContentPart[];
+    mode: SendMode;
+    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;
+    /**
+     * 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;
+}
+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;
+    /** 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. */
+    send(content: string | ContentPart[], opts?: {
+        mode?: SendMode;
+        attachments?: string[];
+        messageId?: string;
+    }): Promise<SubmitResult & {
+        messageId: string;
+    }>;
+    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;
+    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/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@smoothcodes/agent-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "description": "SmoothAgent SDK do usuário (token do usuário): REST gerada do contrato + a camada ao vivo (watch, events, prompt, lista de chats). Roda no navegador e no Node.",
+  "license": "UNLICENSED",
+  "keywords": [
+    "smoothagent",
+    "agents",
+    "sdk",
+    "realtime"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/types/sdk/ts/client/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/sdk/ts/client/src/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/types/sdk/ts/client/src/testing.d.ts",
+      "import": "./dist/testing.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/bytes-*.js.map",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "build": "node build.mjs",
+    "prepack": "node build.mjs",
+    "pack:next": "node build.mjs && npm pack --pack-destination ../../.packs",
+    "prepublishOnly": "node build.mjs && vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "esbuild": "^0.24.2",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
+  },
+  "homepage": "https://smoothagent-v3-api.uaibuilder.workers.dev/v3/docs"
+}