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

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

@@ -0,0 +1,126 @@
+export declare const LogLevel: {
+    readonly Debug: "debug";
+    readonly Info: "info";
+    readonly Warn: "warn";
+    readonly Error: "error";
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+export interface ILogger {
+    /**
+     * Logs a debug message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an info message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Logs a warning message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an error message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Configuration for logger initialization.
+ */
+export interface LogConfig {
+    /**
+     * Minimum log level to output.
+     * @default LogLevel.Info
+     */
+    level?: LogLevel;
+    /**
+     * Logger implementation to use.
+     * @default new ConsoleLogger()
+     */
+    logger?: ILogger;
+    /**
+     * Whether logging should be silenced.
+     * @default true
+     */
+    silent?: boolean;
+}
+/**
+ * Default console-based logger implementation.
+ */
+export declare class ConsoleLogger implements ILogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Logger class that provides level-based logging functionality.
+ */
+export declare class Logger {
+    private readonly level;
+    private readonly logger;
+    private readonly silent;
+    /**
+     * Creates a new logger instance.
+     * @param config - Logger configuration
+     */
+    constructor(config: Required<LogConfig>);
+    /**
+     * Checks if a log level should be output based on configuration.
+     * @param level - The log level to check
+     * @returns True if the level should be logged
+     */
+    shouldLog(level: LogLevel): boolean;
+    /**
+     * Checks if debug logging is enabled.
+     * @returns True if debug logs should be output
+     */
+    isDebug(): boolean;
+    /**
+     * Logs a debug message if debug logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if info logging is enabled.
+     * @returns True if info logs should be output
+     */
+    isInfo(): boolean;
+    /**
+     * Logs an info message if info logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if warning logging is enabled.
+     * @returns True if warning logs should be output
+     */
+    isWarn(): boolean;
+    /**
+     * Logs a warning message if warning logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if error logging is enabled.
+     * @returns True if error logs should be output
+     */
+    isError(): boolean;
+    /**
+     * Logs an error message if error logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+export declare function createLogger(config?: LogConfig | Logger): Logger;

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

@@ -0,0 +1,33 @@
+import type { HttpResponsePromise, RawResponse } from "../fetcher/index.js";
+/**
+ * A page of results from a paginated API.
+ *
+ * @template T The type of the items in the page.
+ * @template R The type of the API response.
+ */
+export declare class Page<T, R = unknown> implements AsyncIterable<T> {
+    data: T[];
+    rawResponse: RawResponse;
+    response: R;
+    private _hasNextPage;
+    private getItems;
+    private loadNextPage;
+    constructor({ response, rawResponse, hasNextPage, getItems, loadPage, }: {
+        response: R;
+        rawResponse: RawResponse;
+        hasNextPage: (response: R) => boolean;
+        getItems: (response: R) => T[];
+        loadPage: (response: R) => HttpResponsePromise<R>;
+    });
+    /**
+     * Retrieves the next page
+     * @returns this
+     */
+    getNextPage(): Promise<this>;
+    /**
+     * @returns whether there is a next page to load
+     */
+    hasNextPage(): boolean;
+    private iterMessages;
+    [Symbol.asyncIterator](): AsyncIterator<T, void, unknown>;
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * Spreads caller-supplied `additionalBodyParameters` (from `requestOptions.additionalBodyParameters`)
+ * on top of the request body. Caller-supplied properties win over the endpoint body. When no
+ * additional body parameters are provided, the original body is returned unchanged so serialization
+ * is unaffected.
+ *
+ * The merge only applies to plain-object (JSON object) bodies. When the body is `null`/`undefined`
+ * the additional parameters become the body; when the body is an array or a primitive JSON value it
+ * is returned unchanged, since object properties cannot be spread into it. This mirrors the Python
+ * SDK, which only merges additional body parameters into mapping bodies.
+ */
+export declare function mergeAdditionalBodyParameters(body: unknown, additionalBodyParameters: Record<string, unknown> | undefined): unknown;

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

@@ -0,0 +1 @@
+export { getUserAgent, RUNTIME } from "./runtime.js";

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://smoothagent-v3-api.uaibuilder.workers.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,85 @@
+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;
+};
+/** A base de produção = o `servers` do contrato (sem o `/v3`); white-label passa `baseUrl`. */
+export declare const DEFAULT_BASE_URL: string;
+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;
+        metadata?: Record<string, 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';
+/** O `send` sem confirmação (close sem caminho durável, timeoutMs, ou socket e REST falharam): traz a mensagem pra reenviar. */
+export { SendNotConfirmedError, CommandAbortedError } 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;