@smoothcodes/agent-client 0.0.0-stage → 0.1.1

package/dist/types/sdk/generated/ts-client/core/runtime/runtime.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A constant that indicates which environment and version the SDK is running in.
+ */
+export declare const RUNTIME: Runtime;
+export interface Runtime {
+    type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown" | "workerd" | "edge-runtime";
+    version?: string;
+    parsedVersion?: number;
+    /**
+     * The operating system the SDK is running on, when it can be determined
+     * (e.g. "linux", "darwin", "win32" on server runtimes). Undefined in
+     * environments where the OS is not observable (e.g. browsers).
+     */
+    os?: string;
+    /**
+     * The CPU architecture the SDK is running on, when it can be determined
+     * (e.g. "x64", "arm64" on server runtimes). Undefined in environments where
+     * the architecture is not observable (e.g. browsers).
+     */
+    arch?: string;
+}
+/**
+ * Builds a structured User-Agent string of the form
+ *   `{sdkName}/{sdkVersion} ({os}; {arch}) {runtime}/{runtimeVersion}`
+ * where the platform group and runtime segment are omitted gracefully when the
+ * underlying values cannot be determined (e.g. in a browser).
+ */
+export declare function getUserAgent(sdkName: string, sdkVersion: string): string;

package/dist/types/sdk/generated/ts-client/core/stream/Stream.d.ts

@@ -0,0 +1,103 @@
+export declare namespace Stream {
+    interface Args {
+        /**
+         * The HTTP response stream to read from.
+         */
+        stream: ReadableStream;
+        /**
+         * The event shape to use for parsing the stream data.
+         */
+        eventShape: JsonEvent | SseEvent;
+        /**
+         * An abort signal to stop the stream.
+         */
+        signal?: AbortSignal;
+        /**
+         * Whether transparent mid-stream reconnection is enabled on resumable
+         * SSE endpoints. Defaults to true. Has no effect on non-resumable endpoints.
+         */
+        reconnectionEnabled?: boolean;
+        /**
+         * Maximum number of consecutive failed reconnect attempts on resumable SSE
+         * endpoints before giving up. The counter resets to zero each time a
+         * reconnected stream successfully yields at least one event (i.e. makes
+         * progress). Has no effect on non-resumable endpoints.
+         */
+        maxReconnectionAttempts?: number;
+        /**
+         * A function that re-issues the HTTP request with the Last-Event-ID header
+         * and returns the new response body stream. Required for reconnection to work.
+         */
+        reconnect?: (lastEventId: string) => Promise<ReadableStream>;
+    }
+    interface JsonEvent {
+        type: "json";
+        messageTerminator: string;
+    }
+    interface SseEvent {
+        type: "sse";
+        streamTerminator?: string;
+        eventDiscriminator?: string;
+        /** Event names whose union variant wraps the `data:` payload as `{ <eventDiscriminator>, data }`. */
+        envelopeEvents?: string[];
+        resumable?: boolean;
+    }
+}
+export interface ServerSentEvent<T> {
+    data: T;
+    id?: string;
+    retry?: number;
+    event?: string;
+}
+export declare class Stream<T> implements AsyncIterable<T> {
+    private stream;
+    private parse;
+    /**
+     * The prefix to use for each message. For example,
+     * for SSE, the prefix is "data: ".
+     */
+    private prefix;
+    private messageTerminator;
+    private streamTerminator;
+    private eventDiscriminator;
+    private envelopeEvents;
+    private resumable;
+    private reconnectionEnabled;
+    private maxReconnectionAttempts;
+    private reconnect;
+    private controller;
+    private decoder;
+    private externalSignal;
+    private onExternalAbort;
+    constructor({ stream, parse, eventShape, signal, reconnectionEnabled, maxReconnectionAttempts, reconnect, }: Stream.Args & {
+        parse: (val: unknown) => Promise<T>;
+    });
+    private iterMessages;
+    private iterDataMessages;
+    private iterSseEvents;
+    /**
+     * Parses and returns a single SSE event, or returns null if the event is a stream terminator.
+     */
+    private dispatchSseEvent;
+    /**
+     * Determines whether a reconnection attempt should be made.
+     */
+    private shouldReconnect;
+    /**
+     * Delays before reconnecting, using a server-sent retry directive if provided
+     * (clamped to MAX_RECONNECT_DELAY_MS), otherwise falling back to
+     * DEFAULT_RECONNECT_DELAY_MS. The delay is abortable: if the stream's abort
+     * signal fires during the wait, the promise resolves immediately.
+     */
+    private delayReconnect;
+    private createEmptyStream;
+    private removeAbortListener;
+    withMetadata(): AsyncIterable<ServerSentEvent<T>>;
+    private injectDiscriminator;
+    [Symbol.asyncIterator](): AsyncIterator<T, void, unknown>;
+    private decodeChunk;
+}
+/**
+ * Browser polyfill for ReadableStream
+ */
+export declare function readableStreamAsyncIterable<T>(stream: any): AsyncIterableIterator<T>;

package/dist/types/sdk/generated/ts-client/core/stream/index.d.ts

@@ -0,0 +1,2 @@
+export type { ServerSentEvent } from "./Stream.js";
+export { Stream } from "./Stream.js";

package/dist/types/sdk/generated/ts-client/core/url/QueryStringBuilder.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Creates a fluent builder for constructing URL query strings.
+ *
+ * Each `.add()` call serializes its value immediately (like C#'s builder),
+ * so no format tracking is needed — the style is applied at add-time.
+ *
+ * Usage (generated code):
+ *
+ *     const qs = core.url.queryBuilder()
+ *         .add("limit", limit)
+ *         .add("tags", tags, { style: "comma" })   // explode: false
+ *         .mergeAdditional(requestOptions?.queryParams)
+ *         .build();
+ */
+export declare function queryBuilder(): QueryStringBuilder;
+declare class QueryStringBuilder {
+    private parts;
+    /**
+     * Adds a query parameter, serializing it immediately.
+     *
+     * By default arrays use "repeat" format (`key=a&key=b`).
+     * Pass `{ style: "comma" }` for OpenAPI `explode: false` parameters
+     * to get comma-separated values (`key=a,b,c`).
+     *
+     * Null / undefined values are silently skipped.
+     */
+    add(key: string, value: unknown, options?: {
+        style?: "comma";
+    }): this;
+    /**
+     * Adds multiple query parameters at once from a record.
+     * All parameters use the default "repeat" array format.
+     * Null / undefined values are silently skipped.
+     */
+    addMany(params: Record<string, unknown>): this;
+    /**
+     * Merges additional query parameters supplied at call-time via
+     * `requestOptions.queryParams`. Overrides existing keys (last-write-wins).
+     */
+    mergeAdditional(additionalParams?: Record<string, unknown>): this;
+    /**
+     * Returns the assembled query string (without the leading `?`).
+     * Returns an empty string when no parameters were added.
+     */
+    build(): string;
+}
+export {};

package/dist/types/sdk/generated/ts-client/core/url/encodePathParam.d.ts

@@ -0,0 +1,3 @@
+export declare function encodePathParam(param: unknown, InvalidPathParameterError?: new (args: {
+    message: string;
+}) => Error): string;

package/dist/types/sdk/generated/ts-client/core/url/index.d.ts

@@ -0,0 +1,4 @@
+export { encodePathParam } from "./encodePathParam.js";
+export { join } from "./join.js";
+export { queryBuilder } from "./QueryStringBuilder.js";
+export { toQueryString } from "./qs.js";

package/dist/types/sdk/generated/ts-client/core/url/join.d.ts

@@ -0,0 +1 @@
+export declare function join(base: string, ...segments: string[]): string;

package/dist/types/sdk/generated/ts-client/core/url/qs.d.ts

@@ -0,0 +1,7 @@
+type ArrayFormat = "indices" | "repeat" | "comma";
+interface QueryStringOptions {
+    arrayFormat?: ArrayFormat;
+    encode?: boolean;
+}
+export declare function toQueryString(obj: unknown, options?: QueryStringOptions): string;
+export {};

package/dist/types/sdk/generated/ts-client/core/utils/index.d.ts

@@ -0,0 +1 @@
+export { setObjectProperty } from "./setObjectProperty.js";

package/dist/types/sdk/generated/ts-client/core/utils/setObjectProperty.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns a copy of object with the value at path set. If a portion of path doesn’t exist it’s created.
+ * Each object along path is shallow-copied, so the original object (and any nested objects it
+ * shares with the copy) is never modified. This is inspired by Lodash's set function, but is
+ * simplified to accommodate our use case. For more details, see https://lodash.com/docs/4.17.15#set.
+ *
+ * @param object The object to copy.
+ * @param path The path of the property to set.
+ * @param value The value to set.
+ * @return Returns the updated copy of object.
+ */
+export declare function setObjectProperty<T extends object>(object: T, path: string, value: any): T;

package/dist/types/sdk/generated/ts-client/environments.d.ts

@@ -0,0 +1,4 @@
+export declare const SmoothAgentApiEnvironment: {
+    readonly Default: "https://api.smoothagent.dev/v3";
+};
+export type SmoothAgentApiEnvironment = typeof SmoothAgentApiEnvironment.Default;

package/dist/types/sdk/generated/ts-client/errors/SmoothAgentApiError.d.ts

@@ -0,0 +1,15 @@
+import type * as core from "../core/index.js";
+export declare class SmoothAgentApiError extends Error {
+    readonly statusCode?: number;
+    readonly body?: unknown;
+    readonly rawResponse?: core.RawResponse;
+    readonly cause?: unknown;
+    constructor({ message, statusCode, body, rawResponse, cause, }: {
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
+        rawResponse?: core.RawResponse;
+        cause?: unknown;
+    });
+    get requestId(): string | undefined;
+}

package/dist/types/sdk/generated/ts-client/errors/SmoothAgentApiTimeoutError.d.ts

@@ -0,0 +1,6 @@
+import * as errors from "./index.js";
+export declare class SmoothAgentApiTimeoutError extends errors.SmoothAgentApiError {
+    constructor(message: string, opts?: {
+        cause?: unknown;
+    });
+}

package/dist/types/sdk/generated/ts-client/errors/handleNonStatusCodeError.d.ts

@@ -0,0 +1,2 @@
+import type * as core from "../core/index.js";
+export declare function handleNonStatusCodeError(error: core.Fetcher.Error, rawResponse: core.RawResponse, method: string, path: string): never;

package/dist/types/sdk/generated/ts-client/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { SmoothAgentApiError } from "./SmoothAgentApiError.js";
+export { SmoothAgentApiTimeoutError } from "./SmoothAgentApiTimeoutError.js";

package/dist/types/sdk/generated/ts-client/exports.d.ts

@@ -0,0 +1 @@
+export * from "./core/exports.js";

package/dist/types/sdk/generated/ts-client/index.d.ts

@@ -0,0 +1,6 @@
+export * as SmoothAgentApi from "./api/index.js";
+export type { BaseClientOptions, BaseRequestOptions } from "./BaseClient.js";
+export { SmoothAgentApiClient } from "./Client.js";
+export { SmoothAgentApiEnvironment } from "./environments.js";
+export { SmoothAgentApiError, SmoothAgentApiTimeoutError } from "./errors/index.js";
+export * from "./exports.js";

package/dist/types/sdk/ts/client/src/index.d.ts

@@ -0,0 +1,81 @@
+import { SmoothAgentApiClient, SmoothAgentApiError, SmoothAgentApiTimeoutError } from '../../../generated/ts-client/index.js';
+import { LiveClient, type Clock, type DebugEvent, type ChatListLive, type LiveChat, type LiveEnv, type RunHandle, type SendMode, type SocketLike, type Violation } from '../../core-live/src/index.js';
+import type { ContractChatState, ContractItem } from '../../core-live/src/reducers/contract.js';
+import { ProviderSet } from '../../core-live/src/providers.js';
+export interface SmoothAgentOptions {
+    /** Token do usuário (um por dispositivo). Passe este ou `getToken`. */
+    token?: string;
+    /** Renovação: chamado no início, perto do `exp` e no 401 `expired` (o backend do dev emite outro). */
+    getToken?: () => Promise<string>;
+    /** White-label: só isto muda. Padrão: produção. */
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    WebSocket?: new (url: string, protocols: string[]) => SocketLike;
+    /** Avisado uma vez quando o token foi revogado (o app volta pro login dele). */
+    onAuthRevoked?(): void;
+    onDebug?(chatId: string, e: DebugEvent): void;
+    /** Modo estrito (testes): buraco que não fecha vira violação (`onViolation`, `sync.violations`) em vez de resync. */
+    strict?: boolean;
+    onViolation?(chatId: string, v: Violation): void;
+    /** Testes e ambientes sem navegador. */
+    clock?: Clock;
+    env?: LiveEnv;
+}
+export type ChatLive = LiveChat<ContractChatState, ContractItem> & {
+    release(): void;
+};
+export declare const DEFAULT_BASE_URL = "https://api.smoothagent.dev";
+type GeneratedChats = SmoothAgentApiClient['chats'];
+export interface ChatsLive {
+    /** O estado pronto da tela (snapshot + eventos aplicados + fila + box + histórico paginado). */
+    watch(chatId: string): ChatLive;
+    /** Eventos crus, já sem duplicado/buraco e com a troca box↔conector. */
+    events(chatId: string, opts?: {
+        after?: number;
+        includeRaw?: boolean;
+        onSnapshot?(seq: number): void;
+    }): AsyncGenerator<import('../../core-live/src/index.js').Envelope, void, undefined>;
+    /** Manda e acompanha só esse run; `result` nunca rejeita por queda. */
+    prompt(chatId: string, content: string, opts?: {
+        mode?: SendMode;
+        attachments?: string[];
+        messageId?: string;
+    }): RunHandle;
+    /** A lista lateral ao vivo (estado, esperando o quê, não lidas), opcionalmente de um agente só. */
+    watchList(filter?: {
+        agentId?: string;
+    }): ChatListLive;
+    /** Marca como lido até o evento `seq` (todos os dispositivos). */
+    markRead(chatId: string, seq: number): Promise<void>;
+}
+type GeneratedProviders = SmoothAgentApiClient['providers'];
+export interface ProvidersLive {
+    /**
+     * Os provedores DO USUÁRIO prontos pra tela (`/me/providers`): lista ordenada (`needed` primeiro), conectar
+     * (OAuth/device, com o poll dentro da SDK), chave e desconectar; recarrega sozinho. `release()` ao desmontar.
+     */
+    watch(opts?: {
+        primary?: readonly string[];
+    }): ProviderSet;
+}
+export declare class SmoothAgent {
+    /** O cliente REST gerado (todas as rotas da audience `client`). */
+    readonly api: SmoothAgentApiClient;
+    readonly live: LiveClient<ContractChatState, ContractItem>;
+    readonly chats: GeneratedChats & ChatsLive;
+    readonly providers: GeneratedProviders & ProvidersLive;
+    constructor(o: SmoothAgentOptions);
+    get agents(): import("../../../generated/ts-client/api/resources/agents/client/Client.js").AgentsClient;
+    get files(): import("../../../generated/ts-client/api/resources/files/client/Client.js").FilesClient;
+    get machines(): import("../../../generated/ts-client/api/resources/machines/client/Client.js").MachinesClient;
+    get me(): import("../../../generated/ts-client/api/resources/identity/client/Client.js").IdentityClient;
+    /** Fecha todos os sockets. */
+    close(): void;
+}
+/** O erro tipado do REST: `apiErrorBody(e)?.code` (um `ErrorCode` do §6) diz o que tratar na tela. */
+export { SmoothAgentApiError, SmoothAgentApiTimeoutError };
+export { apiErrorBody, type ApiErrorBody } from '../../core-live/src/rest.js';
+export type { ErrorCode } from '../../core-live/src/types.js';
+export type { ContractChatState, ContractItem };
+export { ProviderSet, sortProviders, type ConnectFlow, type ConnectState, type ConnectStatus, type ProviderEntry, type ProviderGroup, type ProviderRow, type ProvidersState } from '../../core-live/src/providers.js';
+export type { DebugEvent, LiveStatus, RunResult, RunEvent, WatchState, HistoryWindow, NeedsProvider, Violation } from '../../core-live/src/index.js';

package/dist/types/sdk/ts/client/src/testing.d.ts

@@ -0,0 +1,71 @@
+import type { Clock, DebugEvent, LiveEnv, SocketLike, Violation } from '../../core-live/src/index.js';
+import { SmoothAgent, type ChatLive } from './index.js';
+export interface HarnessOptions {
+    n: number;
+    baseUrl: string;
+    chatId: string;
+    /** Um token pra todas, ou um por interface (dispositivos diferentes do mesmo usuário ou usuários diferentes). */
+    token?: string;
+    tokens?: string[];
+    /** Padrão: true (buraco vira violação, nada é escondido). */
+    strict?: boolean;
+    WebSocket?: new (url: string, protocols: string[]) => SocketLike;
+    fetch?: typeof fetch;
+    clock?: Clock;
+    env?: LiveEnv;
+}
+export interface Iface {
+    index: number;
+    sa: SmoothAgent;
+    live: ChatLive;
+    debug: Array<DebugEvent & {
+        at: number;
+    }>;
+    /** Seqs aplicados, na ordem em que a tela os recebeu. */
+    applied: number[];
+    violations: Violation[];
+    /** Sockets abertos por esta interface (pro caos). */
+    sockets: Array<{
+        url: string;
+        socket: SocketLike;
+    }>;
+}
+export interface DiffEntry {
+    field: 'cursor' | 'inbox' | 'timeline' | 'history';
+    ifaceA: number;
+    ifaceB: number;
+    a: unknown;
+    b: unknown;
+}
+export interface OrderProblem {
+    iface: number;
+    kind: 'not_increasing' | 'skipped';
+    prev: number;
+    next: number;
+}
+export type CompareMode = 'full' | 'core';
+export declare class Harness {
+    readonly ifaces: Iface[];
+    private readonly clock;
+    constructor(ifaces: Iface[], clock: Clock);
+    /** Diferenças entre as interfaces (vazio = todas iguais). `core` = cursor + inbox + ids do histórico; `full` = + a timeline inteira. */
+    diff(mode?: CompareMode): DiffEntry[];
+    /** Espera todas convergirem (diff vazio e nenhuma sincronizando). Rejeita com o último diff no prazo. */
+    converged(o?: {
+        timeoutMs?: number;
+        mode?: CompareMode;
+        everyMs?: number;
+    }): Promise<void>;
+    /**
+     * Por interface: aplicados estritamente crescentes e sem pular — pular só vale onde a SDK declarou
+     * (trecho compactado pelo log, ou o snapshot que reposicionou o cursor).
+     */
+    checkOrder(): OrderProblem[];
+    violations(): Array<Violation & {
+        iface: number;
+    }>;
+    /** Caos: derruba os sockets daquela interface (a SDK religa sozinha). `box` = qualquer socket que não é o conector. */
+    disconnect(i: number, which?: 'connector' | 'box' | 'all'): number;
+    close(): Promise<void>;
+}
+export declare function createInterfaces(o: HarnessOptions): Harness;

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

@@ -0,0 +1,40 @@
+import type { Clock } from './deps.js';
+export type AuthErrorReason = 'missing' | 'invalid' | 'expired' | 'revoked';
+export declare class SmoothAgentAuthError extends Error {
+    readonly reason: AuthErrorReason;
+    constructor(reason: AuthErrorReason, message?: string);
+}
+export interface TokenSourceOptions {
+    token?: string;
+    getToken?: () => Promise<string>;
+    clock: Clock;
+    /** Renova quando falta menos que isto pro `exp` (padrão 60 s). */
+    skewMs?: number;
+}
+/** `exp` (ms) de um JWT, ou null se não for JWT (chave de API) ou não tiver `exp`. */
+export declare function jwtExpiresAt(token: string): number | null;
+export declare class TokenSource {
+    private readonly o;
+    private current;
+    private inflight;
+    private stale;
+    private revoked;
+    private readonly listeners;
+    private readonly skewMs;
+    constructor(o: TokenSourceOptions);
+    /** Token válido agora (renova se precisar). Rejeita com SmoothAgentAuthError('revoked') depois de revogado. */
+    get(): Promise<string>;
+    /** O servidor disse `expired`: a próxima `get()` renova. */
+    invalidate(): void;
+    /** O servidor disse `revoked`: nada de renovar. */
+    markRevoked(): void;
+    get isRevoked(): boolean;
+    onRenew(cb: (token: string) => void): () => void;
+    private nearExpiry;
+    private refresh;
+}
+/**
+ * `fetch` com o Authorization do TokenSource e a regra do 401: `expired` → renova e repete UMA vez;
+ * `revoked` → marca e devolve a resposta (quem chamou mostra o erro). Vai como `fetch` da SDK gerada.
+ */
+export declare function authedFetch(source: TokenSource, base?: typeof fetch): typeof fetch;

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

@@ -0,0 +1,9 @@
+export interface BackoffPolicy {
+    baseMs: number;
+    factor: number;
+    capVisibleMs: number;
+    capHiddenMs: number;
+    /** Só zera o contador depois de ficar de pé este tempo. */
+    stableMs: number;
+}
+export declare const DEFAULT_BACKOFF: BackoffPolicy;

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

@@ -0,0 +1,82 @@
+import { TokenSource } from './auth.js';
+import { type Clock, type LiveEnv, type SocketLike } from './deps.js';
+import type { DebugEvent, Violation } from './stream.js';
+import type { ContentPart, Envelope, SendMode } from './types.js';
+import { LiveChat, type HistoryPage, type Reducer, type WatchOptions } from './watch.js';
+import { RunHandle } from './prompt.js';
+import type { HistoryPage as ControlHistoryPage } from '../../../generated/ts-client/api/types/HistoryPage.js';
+import { ChatListLive } from './feed.js';
+export interface LiveClientOptions<S, I> {
+    /** `https://api.smoothagent.dev` (white-label: só isto muda). */
+    baseUrl: string;
+    token?: string;
+    getToken?: () => Promise<string>;
+    /** Ignorado: o reducer é o do contrato, no núcleo Rust (mantido pra compatibilidade). */
+    reducer?: Reducer<S, I>;
+    fetch?: typeof fetch;
+    WebSocket?: new (url: string, protocols: string[]) => SocketLike;
+    clock?: Clock;
+    env?: LiveEnv;
+    keepAliveMs?: number;
+    onDebug?(chatId: string, e: DebugEvent): void;
+    /** Modo estrito (testes): buraco vira violação em vez de resync. */
+    strict?: boolean;
+    onViolation?(chatId: string, v: Violation): void;
+    /** Revogado: a sessão acabou (o app volta pro login dele). */
+    onAuthRevoked?(): void;
+    /** Opções repassadas a cada stream (testes e ajuste fino). */
+    stream?: Partial<Omit<WatchOptions<S, I>, 'chatId' | 'reducer'>>;
+}
+export declare class LiveClient<S, I = unknown> {
+    private readonly o;
+    readonly tokens: TokenSource;
+    /** `fetch` com o token e a regra do 401 (a SDK gerada usa o mesmo). */
+    readonly fetch: typeof fetch;
+    private readonly clock;
+    private readonly entries;
+    private readonly lists;
+    private readonly api;
+    constructor(o: LiveClientOptions<S, I>);
+    /** O estado ao vivo do chat. Chame `close()` no handle quando a tela desmontar. */
+    watch(chatId: string): LiveChat<S, I> & {
+        release(): void;
+    };
+    /**
+     * Eventos crus, já sem duplicado/buraco e com a troca de transporte. Termina no `return()`/break.
+     * - `after`: começa DEPOIS deste seq (retomar de onde parou: todo evento de `after+1` em diante, sem snapshot);
+     *   sem `after`, começa no estado atual (o snapshot do servidor; `onSnapshot(seq)` diz até onde ele cobre).
+     * - `onSnapshot(seq)`: o servidor mandou um snapshot em vez dos eventos — os anteriores a `seq` NÃO vêm
+     *   (início sem `after`, ou resync depois de um buraco que não fechou). Nunca pula em silêncio (M46).
+     * - `includeRaw`: os eventos trazem o `raw` do provedor.
+     * Um socket próprio (não o do `watch()`), pra o cursor ser só dele.
+     */
+    events(chatId: string, o?: {
+        after?: number;
+        includeRaw?: boolean;
+        onSnapshot?(seq: number): void;
+    }): AsyncGenerator<Envelope, void, undefined>;
+    /** Manda e acompanha só esse run. `result` nunca rejeita por transporte. */
+    prompt(chatId: string, content: string | ContentPart[], opts?: {
+        mode?: SendMode;
+        attachments?: string[];
+        messageId?: string;
+    }): RunHandle;
+    /** A lista lateral ao vivo (UserFeed): título, estado, esperando o quê, não lidas. Filtro por agente aqui. */
+    watchList(filter?: {
+        agentId?: string;
+    }): ChatListLive;
+    /** Marca como lido até `seq` (vale pra todos os dispositivos do usuário; o feed atualiza o unreadCount). */
+    markRead(chatId: string, seq: number): Promise<void>;
+    /** Fecha tudo agora. */
+    close(): void;
+    private release;
+    private watchOptions;
+    private deps;
+    private json;
+}
+/**
+ * A página do `GET /v3/chats/{id}/history` do contrato (tipo GERADO): cada entrada é o EVENTO que fechou
+ * um item (`entry.event`, um Events.Event) + o `seq` dele. Vira envelope do log e passa pelo reducer do
+ * contrato como qualquer evento (`item.completed` traz o item em `data.item`). Ids de evento vêm em string.
+ */
+export declare function fromControlPage(_chatId: string, p: ControlHistoryPage): HistoryPage;

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

@@ -0,0 +1,63 @@
+import type { ChatSnapshot, Envelope } from './types.js';
+/** O mínimo de um WebSocket (browser, React Native, Node ≥ 22, Bun, Deno ou um falso de teste). */
+export interface SocketLike {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    onopen: ((ev?: unknown) => void) | null;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((ev: {
+        code: number;
+        reason: string;
+    }) => void) | null;
+    onerror: ((ev?: unknown) => void) | null;
+}
+export type OpenSocket = (url: string, protocols: string[]) => SocketLike;
+export interface Clock {
+    now(): number;
+    setTimeout(fn: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+export interface LiveEnv {
+    /** false = sabemos que não há rede (navigator.onLine). */
+    online(): boolean;
+    /** Primeiro plano? (visibilitychange / AppState). Muda o teto do backoff. */
+    visible(): boolean;
+    /** Rede voltou, aba voltou pro primeiro plano, foco: acorda o retry na hora. Devolve o "desligar". */
+    onWake(cb: (why: 'online' | 'visible' | 'focus' | 'manual', awayMs?: number) => void): () => void;
+}
+export interface LiveDeps {
+    /** URL do conector (o WebSocket do ChatLog): `wss://…/v3/chats/:id/live`. */
+    connectorUrl(chatId: string): string;
+    openSocket: OpenSocket;
+    /** Token do usuário (ou chave), já com a renovação single-flight (auth.ts). */
+    token(): Promise<string>;
+    /** O servidor disse que o token venceu: a próxima `token()` tem que trazer um novo. */
+    invalidateToken?(): void;
+    /** Pedaço do log por REST, quando não há socket que responda o `fetch`. */
+    eventsRange?(chatId: string, from: number, to: number): Promise<{
+        events: Envelope[];
+        range: {
+            from: number;
+            to: number;
+        };
+    }>;
+    /**
+     * O WebSocket não mostra o HTTP de um upgrade recusado (o navegador só dá 1006). Quando o conector nem
+     * chega a abrir, a SDK pergunta aqui (REST `GET /chats/{id}`) se é falta de acesso, pra não religar pra sempre.
+     */
+    probeAccess?(chatId: string): Promise<'ok' | 'unauthorized' | 'forbidden'>;
+    /** Snapshot por REST (resync sem socket). */
+    snapshot?(chatId: string): Promise<ChatSnapshot>;
+    clock: Clock;
+    env: LiveEnv;
+}
+export declare const PROTOCOL = "smoothagent.v3";
+/** A auto-resposta hibernável do DO compara a STRING EXATA (realtime: PING/PONG). Qualquer outra forma acorda o DO. */
+export declare const PING = "{\"t\":\"ping\"}";
+export declare const PONG = "{\"t\":\"pong\"}";
+export declare const systemClock: Clock;
+/** Ambiente neutro (Node/servidor): sempre online e visível, sem eventos de wakeup. */
+export declare const serverEnv: LiveEnv;