@smoothcodes/agent-client 0.2.3 → 0.3.0

package/dist/index.js

@@ -1,16 +1,20 @@
 import {
+  CommandAbortedError,
   DEFAULT_BASE_URL,
   ProviderSet,
+  SendNotConfirmedError,
   SmoothAgent,
   SmoothAgentApiError,
   SmoothAgentApiTimeoutError,
   apiErrorBody,
   sortProviders
-} from "./chunk-ERJ5SQDU.js";
+} from "./chunk-4HQLFTS2.js";
 import "./chunk-PZ5AY32C.js";
 export {
+  CommandAbortedError,
   DEFAULT_BASE_URL,
   ProviderSet,
+  SendNotConfirmedError,
   SmoothAgent,
   SmoothAgentApiError,
   SmoothAgentApiTimeoutError,

package/dist/testing.js

@@ -1,6 +1,6 @@
 import {
   SmoothAgent
-} from "./chunk-ERJ5SQDU.js";
+} from "./chunk-4HQLFTS2.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/testing.ts

package/dist/types/contract/events/ts/src/gen/events.d.ts

@@ -4496,6 +4496,14 @@ export interface BLCredentialsFetch {
      * geração que a box já tem
      */
     have?: number;
+    /**
+     * o credentialRef que a box tem agora (sem ele, o control devolve sempre a credencial completa)
+     */
+    haveRef?: string;
+    /**
+     * a família da credencial que a box tem — ref ou família diferente da atual = devolve a completa, qualquer que seja a geração
+     */
+    haveFamily?: string;
     agentId?: AgentId;
 }
 /**
@@ -4618,6 +4626,20 @@ export interface LBWelcome {
      * revisão da config do agente que vale agora (a box compara antes de cada turno)
      */
     agentRevision?: number;
+    /**
+     * A versão ATUAL da credencial deste chat por provedor, no momento do welcome (o corpo do wake + o que o control empurrou depois; fecha a janela do wake assinado com a geração anterior). Antes de subir/usar um provedor no 1º run, a box compara com a dela: geração MENOR ou OUTRO credentialRef = busca SÍNCRONA (credentialsFetch) e grava; a busca falhou OU voltou com geração menor que a do welcome ou outro credentialRef = falha, NÃO roda o turno (falha fechada, nunca um refresh com a credencial velha). Lista PRESENTE sem um provedor = a credencial dele foi revogada/não existe: a box solta a que tem e não roda com ela. `[]` = sabe que não há nenhuma. AUSENTE = não se sabe (realtime antigo, aviso de invalidação perdido, wake sem versões): a box segue a versão do wake, como antes. ⚠️ No Rust gerado (Vec com skip_serializing_if is_empty) `[]` e ausente são indistinguíveis: consumidor Rust trata `[]` como AUSENTE; o Go (ponteiro) e o TS distinguem
+     */
+    credentialVersions?: {
+        provider: Provider;
+        /**
+         * `pcr_…`: o id da credencial no cofre
+         */
+        credentialRef: string;
+        /**
+         * a geração (sobe a cada aceite)
+         */
+        generation: number;
+    }[];
     /**
      * H8: o run que o log ainda vê aberto (a box retoma ou fecha)
      */

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

@@ -80,3 +80,5 @@ 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/core-live/src/client.d.ts

@@ -72,6 +72,12 @@ export declare class LiveClient<S, I = unknown> {
     private release;
     private watchOptions;
     private deps;
+    /**
+     * O caminho durável do `send` (REST `SendMessage`): a mesma fila fria do ChatLog, deduplicada pelo
+     * `clientMessageId` (= o messageId do socket) e pela Idempotency-Key (a mesma). Falha passageira: repete com
+     * espera (`untilStored`) e, esgotado, rejeita; recusa do servidor = `rejected` com o código do §6.
+     */
+    private postMessage;
     private json;
 }
 /**

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

@@ -1,5 +1,5 @@
 export { LiveClient, type LiveClientOptions } from './client.js';
-export { LiveChat, newMessageId, uuidv7, type HistoryPage, type HistoryQuery, type HistoryWindow, type LocalSend, type Reducer, type WatchDeps, type SwitchTo, type WatchOptions, type WatchState } from './watch.js';
+export { LiveChat, SendNotConfirmedError, CommandAbortedError, SEND_FALLBACK_MS, newMessageId, uuidv7, type HistoryPage, type HistoryQuery, type HistoryWindow, type LocalSend, type Reducer, type WatchDeps, type SwitchTo, type WatchOptions, type WatchState } from './watch.js';
 export { RunHandle, PromptRejectedError, type RunEvent, type RunOutcome, type RunResult } from './prompt.js';
 export { ChatStream, ERROR_CODES, ERROR_CODE_HTTP, errorCode, type ErrorCode, type DebugEvent, type LiveStatus, type StreamListener, type StreamOptions, type Via, type Violation } from './stream.js';
 export { TokenSource, authedFetch, jwtExpiresAt, SmoothAgentAuthError, type AuthErrorReason } from './auth.js';

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

@@ -58,7 +58,39 @@ export type HistoryQuery = {
 });
 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;
+    }): 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[];
@@ -119,6 +151,11 @@ export interface WatchOptions<S, I> extends Omit<StreamOptions, 'chatId'> {
     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> {
@@ -130,6 +167,17 @@ export declare class LiveChat<S, I = unknown> {
     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;
@@ -144,14 +192,39 @@ export declare class LiveChat<S, I = unknown> {
     /** 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. */
+    /**
+     * 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).
+     */
     send(content: string | ContentPart[], opts?: {
         mode?: SendMode;
         attachments?: string[];
         messageId?: string;
+        timeoutMs?: number;
     }): 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. */
@@ -189,6 +262,11 @@ export declare class LiveChat<S, I = unknown> {
     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. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smoothcodes/agent-client",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "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",