@smoothcodes/agent-client 0.2.3 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @smoothcodes/agent-client
 
+## 0.3.0
+
+- `watch(chatId).send()` durável: se o socket não confirmar em 2 s (`stream.sendFallbackMs`), a mensagem vai pelo REST `POST /v3/chats/{id}/messages` com o MESMO messageId (`clientMessageId` e `Idempotency-Key`); o servidor deduplica, nunca 2x. Gravada pelo REST, aparece em `local.sending` como `pending`. Antes, com o socket fechado a mensagem ficava só na memória do navegador e se perdia.
+- `close()` não deixa espera pendurada: o `send` não confirmado vai pelo REST na hora e resolve gravado; se nem isso der, rejeita com `SendNotConfirmedError` (`reason`, `messageId`, `content`, `mode`) pro app reenviar. Os outros comandos (stop/respond/reset/fila/troca) rejeitam com `CommandAbortedError` (`ref`). Mensagem continua `stream closed` (compatível).
+- `send(content, { timeoutMs })`: rejeita com `SendNotConfirmedError` `reason: 'timeout'` se nada confirmou no prazo (reenviar com o mesmo `messageId` é seguro). O `timeoutMs` só para de esperar: NÃO cancela o envio pelo socket, então a mensagem ainda pode chegar à fila depois, e a ordem dela em relação aos `send` seguintes não é garantida.
+- Os envios pelo REST saem em ordem por chat, um por vez (B nunca passa na frente de A). Com o servidor fora, a nova tentativa espera cada vez mais (5 s, dobrando, até 60 s).
+- Exporta `SendNotConfirmedError` e `CommandAbortedError`.
+
 ## 0.2.3
 
 - `files.upload` agora envia o arquivo: o tipo virou `file: Uploadable` (obrigatório; `Blob`, `File`, `Buffer`/`Uint8Array`, `ReadableStream`, `{ data, filename, contentType }` ou, no Node, `{ path }`) e a parte `file` vai no multipart. Até a 0.2.2 o campo era `file?: unknown` e só array/Set era anexado, então `files.upload({ file: blob })` saía sem o arquivo.

package/dist/{chunk-ERJ5SQDU.js → chunk-4HQLFTS2.js}

@@ -11351,6 +11351,62 @@ var serverEnv = {
   }
 };
 
+// ../core-live/src/ids.ts
+function newMessageId(nowMs = Date.now()) {
+  return "msg_" + uuidv7(nowMs);
+}
+function uuidv7(nowMs = Date.now()) {
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  let ts = BigInt(Math.floor(nowMs));
+  for (let i = 5; i >= 0; i--) {
+    bytes[i] = Number(ts & 0xffn);
+    ts >>= 8n;
+  }
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// ../../../contract/events/ts/src/gen/known.ts
+var KNOWN_ERROR_CODES = ["unauthorized", "forbidden", "not_found", "invalid_request", "provider_not_connected", "provider_auth_expired", "provider_error", "usage_limit_reached", "plan_limit", "rate_limited", "box_unavailable", "conflict", "machine_offline", "request_expired", "no_run", "queue_full", "internal"];
+
+// ../core-live/src/rest.ts
+function idempotencyHeaders() {
+  return { "Idempotency-Key": () => "idk_" + uuidv7() };
+}
+var SEND_ATTEMPTS = 6;
+function transient(e, errors) {
+  if (e instanceof errors.timeout) return true;
+  if (!(e instanceof errors.api)) return false;
+  const { statusCode, body } = e;
+  const retryable = body?.error?.retryable;
+  if (retryable === false) return false;
+  if (statusCode === 409) return retryable === true;
+  return statusCode === void 0 || statusCode === 408 || statusCode === 429 || statusCode >= 500;
+}
+function apiErrorBody(e) {
+  const err = e?.body?.error;
+  if (!err || typeof err !== "object" || typeof err.code !== "string") return void 0;
+  return { ...err, code: KNOWN_ERROR_CODES.includes(err.code) ? err.code : "internal", message: String(err.message ?? ""), retryable: err.retryable === true };
+}
+function sendBody(req) {
+  const clientMessageId = req.clientMessageId ?? newMessageId();
+  return { ...req, clientMessageId, "Idempotency-Key": req["Idempotency-Key"] ?? clientMessageId };
+}
+async function untilStored(call2, o) {
+  const attempts = o.attempts ?? SEND_ATTEMPTS;
+  for (let n = 0; ; n++) {
+    try {
+      return await call2();
+    } catch (e) {
+      if (n + 1 >= attempts || !o.isTransient(e) || o.abortSignal?.aborted) throw e;
+      await new Promise((res) => o.clock.setTimeout(res, 1e3 * 2 ** n * (0.75 + 0.5 * Math.random())));
+    }
+  }
+}
+
 // ../core-live/src/wasm/live.js
 var live_exports = {};
 __export(live_exports, {
@@ -13586,30 +13642,9 @@ var Edge = class {
   }
 };
 
-// ../core-live/src/ids.ts
-function newMessageId(nowMs = Date.now()) {
-  return "msg_" + uuidv7(nowMs);
-}
-function uuidv7(nowMs = Date.now()) {
-  const bytes = new Uint8Array(16);
-  globalThis.crypto.getRandomValues(bytes);
-  let ts = BigInt(Math.floor(nowMs));
-  for (let i = 5; i >= 0; i--) {
-    bytes[i] = Number(ts & 0xffn);
-    ts >>= 8n;
-  }
-  bytes[6] = bytes[6] & 15 | 112;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-
 // ../core-live/src/wasm/empty.ts
 var EMPTY_STATE_JSON = '{"seq":0,"chat":{"state":"idle"},"items":{},"order":[],"history":[],"tasks":{},"pending":{},"limits":{},"usage":{"chat":{}},"runs":[],"switches":[]}';
 
-// ../../../contract/events/ts/src/gen/known.ts
-var KNOWN_ERROR_CODES = ["unauthorized", "forbidden", "not_found", "invalid_request", "provider_not_connected", "provider_auth_expired", "provider_error", "usage_limit_reached", "plan_limit", "rate_limited", "box_unavailable", "conflict", "machine_offline", "request_expired", "no_run", "queue_full", "internal"];
-
 // ../core-live/src/backoff.ts
 var DEFAULT_BACKOFF = {
   baseMs: 250,
@@ -13739,6 +13774,35 @@ function toContentParts(content, attachments = []) {
 }
 
 // ../core-live/src/watch.ts
+var SendNotConfirmedError = class extends Error {
+  constructor(reason, messageId, content, mode, cause) {
+    super(reason === "closed" ? "stream closed" : reason === "timeout" ? "send: sem confirma\xE7\xE3o no prazo" : "send: n\xE3o confirmado");
+    this.reason = reason;
+    this.messageId = messageId;
+    this.content = content;
+    this.mode = mode;
+    this.cause = cause;
+  }
+  name = "SendNotConfirmedError";
+};
+var CommandAbortedError = class extends Error {
+  constructor(ref) {
+    super("stream closed");
+    this.ref = ref;
+  }
+  name = "CommandAbortedError";
+};
+var SEND_FALLBACK_MS = 2e3;
+var REST_RETRY_MS = 5e3;
+var REST_RETRY_MAX_MS = 6e4;
+function safeCause(e) {
+  const x = e ?? {};
+  const out = new Error(typeof x.message === "string" ? x.message : String(e));
+  if (typeof x.name === "string") out.name = x.name;
+  if (typeof x.status === "number") out.status = x.status;
+  if (typeof x.code === "string") out.code = x.code;
+  return out;
+}
 var EMPTY_INBOX = { version: -1, pending: [], queue: [], notDelivered: [], responses: [] };
 var EMPTY_QUEUE = { version: -1, owner: "cold", turn: "idle", items: [], notDelivered: [] };
 var LiveChat = class {
@@ -13770,6 +13834,17 @@ var LiveChat = class {
   eventTaps = /* @__PURE__ */ new Set();
   waiting = /* @__PURE__ */ new Map();
   historyWaiting = /* @__PURE__ */ new Map();
+  /** os `send` esperando, NA ORDEM em que foram mandados (o Map guarda a ordem de inserção) */
+  sends = /* @__PURE__ */ new Map();
+  /** a corrente do REST: um pedido por vez, em ordem (B nunca passa na frente de A) */
+  restBusy = false;
+  restRetry = null;
+  /** falhas de vez seguidas da corrente (a espera cresce; zera quando uma grava) */
+  restFails = 0;
+  /** gravados pelo REST e ainda em `local.sending` do núcleo (que não viu o ack): a tela mostra `pending` */
+  restStored = /* @__PURE__ */ new Map();
+  /** o `local.sending` como o núcleo mandou (antes da sobreposição do REST) */
+  coreLocal = [];
   /** itens que vieram de páginas do histórico (não estão na timeline viva) */
   pageItems = /* @__PURE__ */ new Map();
   historyIds = [];
@@ -13803,13 +13878,130 @@ var LiveChat = class {
     return this.o.chatId;
   }
   // ------------------------------------------------------------------ comandos
-  /** 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).
+   */
   async send(content, opts = {}) {
     const messageId = opts.messageId ?? newMessageId(this.d.clock.now());
-    const parts = JSON.stringify(toContentParts(content, opts.attachments));
-    const r = await this.wait(`send:${messageId}`, (c, e) => c.send(...e, messageId, parts, opts.mode ?? "auto"));
+    const parts = toContentParts(content, opts.attachments);
+    const mode = opts.mode ?? "auto";
+    if (this.closed) throw new SendNotConfirmedError("closed", messageId, parts, mode);
+    const r = await new Promise((resolve, reject) => {
+      const prev = this.sends.get(messageId);
+      if (prev && !prev.done) {
+        prev.done = true;
+        for (const t of prev.timers) this.d.clock.clearTimeout(t);
+      }
+      const ps = {
+        messageId,
+        content: parts,
+        mode,
+        timers: [],
+        rest: false,
+        done: false,
+        resolve: prev ? (x) => (prev.resolve(x), resolve(x)) : resolve,
+        reject: prev ? (e) => (prev.reject(e), reject(e)) : reject
+      };
+      this.sends.set(messageId, ps);
+      const fallback = this.o.sendFallbackMs ?? SEND_FALLBACK_MS;
+      if (this.d.postMessage && Number.isFinite(fallback)) ps.timers.push(this.d.clock.setTimeout(() => this.viaRest(ps), Math.max(0, fallback)));
+      if (opts.timeoutMs !== void 0 && Number.isFinite(opts.timeoutMs))
+        ps.timers.push(this.d.clock.setTimeout(() => this.settleSend(ps, new SendNotConfirmedError("timeout", messageId, parts, mode)), Math.max(0, opts.timeoutMs)));
+      this.waiting.set(`send:${messageId}`, {
+        resolve: (x) => this.settleSend(ps, x),
+        // o núcleo desistiu (fechou): vale o REST, se houver
+        reject: (e) => this.coreGaveUp(ps, e)
+      });
+      this.edge.run((c, e) => c.send(...e, messageId, JSON.stringify(parts), mode));
+    });
     return { ...r, messageId };
   }
+  /** Pede o caminho durável pra este send (e, pela ordem, pra todos os anteriores ainda esperando). */
+  viaRest(ps) {
+    if (ps.done || !this.d.postMessage) return;
+    ps.rest = true;
+    this.pumpRest();
+  }
+  /**
+   * 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.
+   */
+  pumpRest() {
+    if (this.restBusy || !this.d.postMessage) return;
+    const order = [...this.sends.values()].filter((x) => !x.done);
+    const head = order[0];
+    if (!head || !order.some((x) => x.rest)) return;
+    if (this.restRetry !== null) {
+      this.d.clock.clearTimeout(this.restRetry);
+      this.restRetry = null;
+    }
+    this.restBusy = true;
+    this.d.postMessage(this.o.chatId, { clientMessageId: head.messageId, content: head.content, mode: head.mode }).then(
+      (r) => {
+        this.restBusy = false;
+        this.restFails = 0;
+        if (r.status === "accepted" || r.status === "duplicate") this.markStored(head.messageId, r.version ?? r.inboxVersion);
+        this.settleSend(head, r);
+        this.pumpRest();
+      },
+      (e) => {
+        this.restBusy = false;
+        if (head.done) return this.pumpRest();
+        if (this.closed) {
+          const cause = safeCause(e);
+          this.restBusy = true;
+          for (const x of [...this.sends.values()].filter((y) => !y.done)) this.settleSend(x, new SendNotConfirmedError("failed", x.messageId, x.content, x.mode, cause));
+          this.restBusy = false;
+          return;
+        }
+        const wait = Math.min(REST_RETRY_MAX_MS, REST_RETRY_MS * 2 ** this.restFails++);
+        this.restRetry = this.d.clock.setTimeout(() => {
+          this.restRetry = null;
+          this.pumpRest();
+        }, wait);
+      }
+    );
+  }
+  coreGaveUp(ps, e) {
+    if (ps.done) return;
+    if (this.d.postMessage) this.viaRest(ps);
+    else this.settleSend(ps, new SendNotConfirmedError("closed", ps.messageId, ps.content, ps.mode, e));
+  }
+  settleSend(ps, r) {
+    if (ps.done) return;
+    ps.done = true;
+    for (const t of ps.timers) this.d.clock.clearTimeout(t);
+    if (this.sends.get(ps.messageId) === ps) this.sends.delete(ps.messageId);
+    if (r instanceof Error) ps.reject(r);
+    else ps.resolve(r);
+    if (!this.restBusy) this.pumpRest();
+  }
+  /** Gravado pelo REST: no `local.sending` passa de `sending` a `pending` (o núcleo não viu o ack). */
+  markStored(messageId, version) {
+    if (this.closed || !this.coreLocal.some((l) => l.messageId === messageId)) return;
+    this.restStored.set(messageId, version);
+    this.state = { ...this.state, local: { sending: this.overlayLocal() } };
+    for (const l of this.listeners) l(this.state);
+  }
+  overlayLocal() {
+    for (const id of [...this.restStored.keys()]) if (!this.coreLocal.some((l) => l.messageId === id)) this.restStored.delete(id);
+    if (!this.restStored.size) return this.coreLocal;
+    return this.coreLocal.map((l) => {
+      if (l.status !== "sending" || !this.restStored.has(l.messageId)) return l;
+      const v = this.restStored.get(l.messageId);
+      return { ...l, status: "pending", ...v !== void 0 ? { ackVersion: v } : {} };
+    });
+  }
   stop() {
     const stopId = uuidv7(this.d.clock.now());
     return this.command({ t: "stop", ref: `stop:${stopId}`, chatId: this.o.chatId, stopId });
@@ -13878,6 +14070,11 @@ var LiveChat = class {
   tokenRenewed(token) {
     this.edge.run((c, e) => c.token_renewed(...e, token));
   }
+  /**
+   * 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() {
     if (this.closed) return;
     this.edge.run((c, e) => c.close(...e));
@@ -13886,6 +14083,11 @@ var LiveChat = class {
     this.edge.stop();
     this.listeners.clear();
     this.eventTaps.clear();
+    const left = [...this.waiting];
+    this.waiting.clear();
+    for (const [ref, w] of left) w.reject(new CommandAbortedError(ref));
+    for (const ps of [...this.sends.values()]) this.coreGaveUp(ps, new Error("stream closed"));
+    this.pumpRest();
   }
   // ------------------------------------------------------------------ histórico (§4.9)
   history = {
@@ -13950,7 +14152,7 @@ var LiveChat = class {
       case "reject": {
         const w = this.waiting.get(f.ref);
         this.waiting.delete(f.ref);
-        return w?.reject(new Error(String(f.v)));
+        return w?.reject(String(f.v) === "stream closed" ? new CommandAbortedError(f.ref) : new Error(String(f.v)));
       }
     }
   }
@@ -13983,7 +14185,7 @@ var LiveChat = class {
       inbox: p.inbox ?? prev.inbox,
       needsProvider: p.needsProvider !== void 0 ? p.needsProvider : prev.needsProvider,
       box: p.box !== void 0 ? p.box : prev.box,
-      local: p.local ? { sending: p.local } : prev.local,
+      local: p.local ? { sending: (this.coreLocal = p.local, this.overlayLocal()) } : prev.local,
       history,
       sync: p.sync ?? prev.sync
     };
@@ -14206,6 +14408,10 @@ var ChatListLive = class {
 };
 
 // ../core-live/src/client.ts
+function restTransient(e) {
+  const st = e?.status;
+  return st === void 0 || st === 408 || st === 429 || st >= 500;
+}
 var LiveClient = class {
   constructor(o) {
     this.o = o;
@@ -14374,9 +14580,32 @@ var LiveClient = class {
         if (res.status === 403 || res.status === 404) return "forbidden";
         return "ok";
       },
-      history: async (id, q) => fromControlPage(id, await this.json(`/chats/${encodeURIComponent(id)}/history?${historyQs(q)}`))
+      history: async (id, q) => fromControlPage(id, await this.json(`/chats/${encodeURIComponent(id)}/history?${historyQs(q)}`)),
+      postMessage: (id, m) => this.postMessage(id, m)
     };
   }
+  /**
+   * 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.
+   */
+  async postMessage(id, m) {
+    const call2 = () => this.json(`/chats/${encodeURIComponent(id)}/messages`, {
+      method: "POST",
+      body: JSON.stringify(m),
+      headers: { "Content-Type": "application/json", "Idempotency-Key": m.clientMessageId }
+    });
+    try {
+      const r = await untilStored(call2, { clock: this.clock, isTransient: (e) => restTransient(e) });
+      const v = r.inboxVersion ?? 0;
+      return r.status === "duplicate" ? { status: "duplicate", messageId: m.clientMessageId, inboxVersion: v } : { status: "accepted", messageId: m.clientMessageId, inboxVersion: v };
+    } catch (e) {
+      if (restTransient(e)) throw e;
+      const err = e;
+      const code = KNOWN_ERROR_CODES.includes(err.code ?? "") ? err.code : "internal";
+      return { status: "rejected", code, message: err.message ?? code };
+    }
+  }
   async json(path, init) {
     const res = await this.fetch(`${this.api}${path}`, { ...init, headers: { Accept: "application/json", ...init?.headers ?? {} } });
     if (!res.ok) {
@@ -14438,41 +14667,6 @@ function browserEnv() {
   };
 }
 
-// ../core-live/src/rest.ts
-function idempotencyHeaders() {
-  return { "Idempotency-Key": () => "idk_" + uuidv7() };
-}
-var SEND_ATTEMPTS = 6;
-function transient(e, errors) {
-  if (e instanceof errors.timeout) return true;
-  if (!(e instanceof errors.api)) return false;
-  const { statusCode, body } = e;
-  const retryable = body?.error?.retryable;
-  if (retryable === false) return false;
-  if (statusCode === 409) return retryable === true;
-  return statusCode === void 0 || statusCode === 408 || statusCode === 429 || statusCode >= 500;
-}
-function apiErrorBody(e) {
-  const err = e?.body?.error;
-  if (!err || typeof err !== "object" || typeof err.code !== "string") return void 0;
-  return { ...err, code: KNOWN_ERROR_CODES.includes(err.code) ? err.code : "internal", message: String(err.message ?? ""), retryable: err.retryable === true };
-}
-function sendBody(req) {
-  const clientMessageId = req.clientMessageId ?? newMessageId();
-  return { ...req, clientMessageId, "Idempotency-Key": req["Idempotency-Key"] ?? clientMessageId };
-}
-async function untilStored(call2, o) {
-  const attempts = o.attempts ?? SEND_ATTEMPTS;
-  for (let n = 0; ; n++) {
-    try {
-      return await call2();
-    } catch (e) {
-      if (n + 1 >= attempts || !o.isTransient(e) || o.abortSignal?.aborted) throw e;
-      await new Promise((res) => o.clock.setTimeout(res, 1e3 * 2 ** n * (0.75 + 0.5 * Math.random())));
-    }
-  }
-}
-
 // ../core-live/src/providers.ts
 var TERMINAL = /* @__PURE__ */ new Set(["connected", "expired", "failed", "cancelled"]);
 var PROVIDER_POLL_MS = 2e3;
@@ -14845,9 +15039,11 @@ export {
   SmoothAgentApiError,
   SmoothAgentApiTimeoutError,
   apiErrorBody,
+  SendNotConfirmedError,
+  CommandAbortedError,
   sortProviders,
   ProviderSet,
   DEFAULT_BASE_URL,
   SmoothAgent
 };
-//# sourceMappingURL=chunk-ERJ5SQDU.js.map
+//# sourceMappingURL=chunk-4HQLFTS2.js.map