@tangle-network/agent-app 0.43.61 → 0.43.62

package/dist/chat-routes/index.js

@@ -26,7 +26,7 @@ import {
   normalizeClientTurnId,
   replayTurnEvents,
   resolveChatTurn
-} from "../chunk-VCOD5AOR.js";
+} from "../chunk-YN7QR7MJ.js";
 import {
   createInteractionAnswerRoute
 } from "../chunk-7YW6EBDX.js";
@@ -58,6 +58,7 @@ import {
 import {
   asRecord,
   asString,
+  draftAssistantParts,
   finalizeAssistantParts,
   finalizePendingInteractionParts,
   getPartKey,
@@ -65,7 +66,7 @@ import {
   normalizePersistedPart,
   normalizeToolEvent,
   terminalizeDanglingAssistantToolUpdates
-} from "../chunk-IG46XCZM.js";
+} from "../chunk-BG52UKNN.js";
 import {
   cancelStatusFor,
   interactionPartKey,
@@ -94,6 +95,192 @@ import "../chunk-7CTIUCQ4.js";
 
 // src/chat-routes/turn-routes.ts
 import { deriveExecutionId, handleChatTurn } from "@tangle-network/agent-runtime";
+
+// src/chat-routes/draft-persistence.ts
+var CONTENT_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "reasoning",
+  "tool_call",
+  "tool_result",
+  "usage",
+  "notice",
+  "error",
+  "file",
+  "interaction",
+  "interaction.cancel",
+  "plan.submitted",
+  "message.part.updated"
+]);
+var DEFAULT_INTERVAL_MS = 2e3;
+var DEFAULT_BACKOFF_BYTES = 262144;
+var DEFAULT_MAX_DRAFT_TOOL_OUTPUT_BYTES = 32768;
+function isDraftContentEvent(event) {
+  return typeof event?.type === "string" && CONTENT_EVENT_TYPES.has(event.type);
+}
+function capDraftToolOutput(part, maxBytes) {
+  if (maxBytes <= 0) return part;
+  if (String(part.type ?? "") !== "tool") return part;
+  const state = part.state;
+  if (!state || typeof state !== "object") return part;
+  const record = state;
+  const output = record.output;
+  if (output === void 0 || output === null) return part;
+  const serialized = typeof output === "string" ? output : safeStringify(output);
+  if (serialized.length <= maxBytes) return part;
+  const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
+  return {
+    ...part,
+    state: {
+      ...record,
+      output: `${serialized.slice(0, maxBytes)}\u2026[draft-truncated ${serialized.length - maxBytes} chars]`,
+      metadata: { ...metadata, draftTruncated: true }
+    }
+  };
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+function createAssistantDraftWriter(options) {
+  const log = options.log ?? (() => {
+  });
+  const baseIntervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const backoffBytes = options.backoffBytes ?? DEFAULT_BACKOFF_BYTES;
+  const maxToolOutput = options.maxDraftToolOutputBytes ?? DEFAULT_MAX_DRAFT_TOOL_OUTPUT_BYTES;
+  let dirty = false;
+  let closed = false;
+  let inFlight;
+  let lastWriteAt = 0;
+  let lastBlobBytes = 0;
+  let rowId;
+  let writes = 0;
+  function currentIntervalMs() {
+    if (lastBlobBytes >= backoffBytes * 10) return baseIntervalMs * 5;
+    if (lastBlobBytes >= backoffBytes) return Math.round(baseIntervalMs * 2.5);
+    return baseIntervalMs;
+  }
+  async function projectValues(snapshot) {
+    const transform = options.transformText;
+    const content = transform ? await transform(snapshot.content) : snapshot.content;
+    let parts;
+    if (snapshot.parts) {
+      const capped = snapshot.parts.map((part) => capDraftToolOutput(part, maxToolOutput));
+      const redacted = transform ? await Promise.all(
+        capped.map(
+          async (part) => String(part.type ?? "") === "text" ? { ...part, text: await transform(String(part.text ?? "")) } : part
+        )
+      ) : capped;
+      parts = toChatMessageParts(redacted);
+    }
+    const usage = snapshot.usage ?? {};
+    return {
+      content,
+      ...parts && parts.length > 0 ? { parts } : {},
+      ...snapshot.model ? { model: snapshot.model } : {},
+      ...usage.inputTokens !== void 0 ? { inputTokens: usage.inputTokens } : {},
+      ...usage.outputTokens !== void 0 ? { outputTokens: usage.outputTokens } : {},
+      ...usage.reasoningTokens !== void 0 ? { reasoningTokens: usage.reasoningTokens } : {},
+      ...usage.cacheReadTokens !== void 0 ? { cacheReadTokens: usage.cacheReadTokens } : {},
+      ...usage.cacheWriteTokens !== void 0 ? { cacheWriteTokens: usage.cacheWriteTokens } : {},
+      ...usage.costUsd !== void 0 ? { costUsd: usage.costUsd } : {}
+    };
+  }
+  async function adoptRow() {
+    if (rowId) return rowId;
+    const existing = (await options.store.listMessages(options.threadId)).find(
+      (message) => message.id === options.messageId
+    );
+    if (existing) rowId = existing.id;
+    return rowId;
+  }
+  async function writeOnce(values) {
+    if (await adoptRow()) {
+      await options.store.updateMessage(rowId, values);
+      writes += 1;
+      return;
+    }
+    const inserted = await options.store.appendMessage({
+      id: options.messageId,
+      threadId: options.threadId,
+      role: "assistant",
+      ...values
+    });
+    const insertedId = inserted?.id;
+    rowId = typeof insertedId === "string" && insertedId ? insertedId : options.messageId;
+    writes += 1;
+  }
+  function trigger() {
+    if (closed) return;
+    if (!dirty) return;
+    if (inFlight) return;
+    const now = Date.now();
+    if (lastWriteAt !== 0 && now - lastWriteAt < currentIntervalMs()) return;
+    const snapshot = options.snapshot();
+    if (!snapshot) return;
+    if (!snapshot.content && (!snapshot.parts || snapshot.parts.length === 0)) return;
+    dirty = false;
+    lastWriteAt = now;
+    inFlight = (async () => {
+      try {
+        const values = await projectValues(snapshot);
+        lastBlobBytes = values.parts ? safeStringify(values.parts).length : 0;
+        await writeOnce(values);
+      } catch (err) {
+        log("[chat-routes] incremental assistant persistence failed", {
+          messageId: options.messageId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      } finally {
+        inFlight = void 0;
+        if (dirty && !closed) trigger();
+      }
+    })();
+  }
+  return {
+    notify(event) {
+      if (closed) return;
+      if (isDraftContentEvent(event)) dirty = true;
+      trigger();
+    },
+    async close() {
+      closed = true;
+      if (inFlight) await inFlight;
+    },
+    async finalize(values) {
+      closed = true;
+      if (inFlight) await inFlight;
+      await writeOnce(values);
+    },
+    rowId: () => rowId,
+    async discard() {
+      closed = true;
+      if (inFlight) await inFlight;
+      if (!options.store.deleteMessage) return;
+      try {
+        if (!await adoptRow()) return;
+        await options.store.deleteMessage(rowId);
+        rowId = void 0;
+      } catch (err) {
+        log("[chat-routes] draft assistant row discard failed", {
+          messageId: options.messageId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    },
+    writeCount: () => writes
+  };
+}
+function storeSupportsDraftPersistence(store) {
+  return typeof store.updateMessage === "function";
+}
+function assistantRowIdForTurn(turnKey) {
+  return `assistant:${turnKey}`;
+}
+
+// src/chat-routes/turn-routes.ts
 function failureReasonOf(data) {
   if (!data) return void 0;
   const message = data.message ?? data.error ?? data.reason;
@@ -184,6 +371,13 @@ async function* withStreamHeartbeat(source, intervalMs, makeEvent) {
 }
 function createChatTurnRoutes(options) {
   const log = options.log ?? ((message, meta) => console.error(message, meta ?? ""));
+  const draftStore = options.store;
+  if (options.incrementalPersistence && !storeSupportsDraftPersistence(draftStore)) {
+    throw new Error(
+      "incrementalPersistence requires a store with updateMessage() \u2014 `/chat-store`'s createChatStore has it; a product store must implement it or omit the option"
+    );
+  }
+  const draftTuning = options.incrementalPersistence === false || !storeSupportsDraftPersistence(draftStore) ? null : options.incrementalPersistence ?? {};
   async function turn(request, ctx) {
     const [rawBody, badBody] = await parseJsonObjectBody(request);
     if (badBody) return badBody;
@@ -204,7 +398,18 @@ function createChatTurnRoutes(options) {
       content: m.content,
       parts: m.parts ?? null
     }));
-    const chatTurn = resolveChatTurn({ existingMessages, userContent: content, turnId });
+    let hasRunningTurn = false;
+    if (draftTuning && existingMessages.at(-1)?.role === "assistant") {
+      try {
+        hasRunningTurn = (await options.turnStore.listRunning?.(payload.threadId) ?? []).length > 0;
+      } catch (err) {
+        log("[chat-routes] listRunning probe failed; treating the thread as idle", {
+          threadId: payload.threadId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    const chatTurn = resolveChatTurn({ existingMessages, userContent: content, turnId, hasRunningTurn });
     const identity = {
       tenantId,
       sessionId: payload.threadId,
@@ -250,6 +455,7 @@ function createChatTurnRoutes(options) {
       lockHandle = acquired.handle;
     }
     let producer;
+    let draft;
     let runFailed = false;
     let lastFailureData;
     let turnStartedAtMs = 0;
@@ -318,6 +524,25 @@ function createChatTurnRoutes(options) {
       });
       const turnMarker = { type: "turn", turnId: turnStreamId };
       await tap.onEvent(turnMarker);
+      if (draftTuning) {
+        draft = createAssistantDraftWriter({
+          ...draftTuning,
+          store: draftStore,
+          threadId: payload.threadId,
+          messageId: options.draftMessageId ? options.draftMessageId({ identity, executionId, threadId: payload.threadId }) : assistantRowIdForTurn(executionId),
+          snapshot: () => {
+            if (!producer) return null;
+            return {
+              content: producer.finalText(),
+              ...producer.draftParts ? { parts: producer.draftParts() } : {},
+              ...producer.usage ? { usage: producer.usage() } : {},
+              ...producer.model ? { model: producer.model } : {}
+            };
+          },
+          ...options.transformFinalText ? { transformText: options.transformFinalText } : {},
+          log
+        });
+      }
       turnStartedAtMs = Date.now();
       turnStarted = true;
       if (options.lifecycle?.onTurnStart) {
@@ -363,6 +588,7 @@ function createChatTurnRoutes(options) {
               lastFailureData = event.data;
             }
             await tap.onEvent(event);
+            draft?.notify(event);
             if (options.onEvent) await options.onEvent(event, context);
           },
           ...options.transformFinalText ? { transformFinalText: options.transformFinalText } : {},
@@ -374,11 +600,12 @@ function createChatTurnRoutes(options) {
               )
             ) : rawParts;
             const parts = projected ? toChatMessageParts(projected) : void 0;
-            if (!finalText.trim() && (!parts || parts.length === 0)) return;
+            if (!finalText.trim() && (!parts || parts.length === 0)) {
+              await draft?.discard();
+              return;
+            }
             const usage = producer?.usage?.() ?? {};
-            await options.store.appendMessage({
-              threadId: payload.threadId,
-              role: "assistant",
+            const values = {
               content: finalText,
               ...parts && parts.length > 0 ? { parts } : {},
               ...producer?.model ? { model: producer.model } : {},
@@ -388,6 +615,15 @@ function createChatTurnRoutes(options) {
               ...usage.cacheReadTokens !== void 0 ? { cacheReadTokens: usage.cacheReadTokens } : {},
               ...usage.cacheWriteTokens !== void 0 ? { cacheWriteTokens: usage.cacheWriteTokens } : {},
               ...usage.costUsd !== void 0 ? { costUsd: usage.costUsd } : {}
+            };
+            if (draft) {
+              await draft.finalize(values);
+              return;
+            }
+            await options.store.appendMessage({
+              threadId: payload.threadId,
+              role: "assistant",
+              ...values
             });
           },
           ...options.onTurnComplete ? {
@@ -424,6 +660,7 @@ function createChatTurnRoutes(options) {
           });
         }
         const failed = runFailed || drainError !== void 0;
+        await draft?.close();
         try {
           await tap.done(failed ? "error" : "complete");
         } catch (err) {
@@ -947,6 +1184,12 @@ ${diagnostic.userMessage}` : diagnostic.userMessage;
       finalizeAssistantParts(partOrder, partMap, fullText),
       interactionOutcome
     ),
+    // Mid-stream snapshot for incremental persistence: the same accumulators,
+    // WITHOUT the two completion-time settlements (`terminalizeDanglingTool*`
+    // and `finalizePendingInteractionParts`). A running tool and an unanswered
+    // ask are the correct live state; settling them early would persist
+    // phantom failures the final write then reverses.
+    draftParts: () => draftAssistantParts(partOrder, partMap, fullText),
     usage: () => usage,
     ...options.model ? { model: options.model } : {}
   };
@@ -973,6 +1216,58 @@ function cachedResultFrom(final) {
 }
 async function runDetachedTurn(opts) {
   const { store, turnId, scopeId } = opts;
+  let producer;
+  let draft;
+  if (opts.persist) {
+    const { store: persistStore, threadId, messageId, transformText, ...tuning } = opts.persist;
+    if (!storeSupportsDraftPersistence(persistStore)) {
+      throw new Error(
+        "runDetachedTurn persist requires a store with updateMessage() \u2014 `/chat-store`'s createChatStore has it"
+      );
+    }
+    draft = createAssistantDraftWriter({
+      ...tuning,
+      store: persistStore,
+      threadId,
+      messageId: messageId ?? assistantRowIdForTurn(turnId),
+      snapshot: () => producer ? {
+        content: producer.finalText?.() ?? "",
+        ...producer.draftParts ? { parts: producer.draftParts() } : {},
+        ...producer.usage ? { usage: producer.usage() } : {},
+        ...opts.model ? { model: opts.model } : {}
+      } : null,
+      ...transformText ? { transformText } : {},
+      ...opts.log ? { log: opts.log } : {}
+    });
+  }
+  const settleRow = async (result) => {
+    if (!draft) return result;
+    const transform = opts.persist?.transformText;
+    const content = transform ? await transform(result.text) : result.text;
+    const rawParts = transform ? await Promise.all(
+      result.parts.map(
+        async (part) => String(part.type ?? "") === "text" ? { ...part, text: await transform(String(part.text ?? "")) } : part
+      )
+    ) : result.parts;
+    const parts2 = toChatMessageParts(rawParts);
+    if (!content.trim() && parts2.length === 0) {
+      await draft.discard();
+      return { ...result, messageId: null };
+    }
+    const values = {
+      content,
+      ...parts2.length > 0 ? { parts: parts2 } : {},
+      ...opts.model ? { model: opts.model } : {},
+      ...result.usage.inputTokens !== void 0 ? { inputTokens: result.usage.inputTokens } : {},
+      ...result.usage.outputTokens !== void 0 ? { outputTokens: result.usage.outputTokens } : {},
+      ...result.usage.reasoningTokens !== void 0 ? { reasoningTokens: result.usage.reasoningTokens } : {},
+      ...result.usage.cacheReadTokens !== void 0 ? { cacheReadTokens: result.usage.cacheReadTokens } : {},
+      ...result.usage.cacheWriteTokens !== void 0 ? { cacheWriteTokens: result.usage.cacheWriteTokens } : {},
+      ...result.usage.costUsd !== void 0 ? { costUsd: result.usage.costUsd } : {}
+    };
+    await draft.finalize(values);
+    return { ...result, messageId: draft.rowId() ?? null };
+  };
   const completed = async () => {
     if (!opts.completedResult) return null;
     try {
@@ -988,14 +1283,14 @@ async function runDetachedTurn(opts) {
   } catch (err) {
     opts.log?.("[chat-routes] runDetachedTurn getStatus failed; treating as no prior", { turnId, err: String(err) });
   }
-  if (prior === "complete") return cachedResultFrom(await completed());
+  if (prior === "complete") return await settleRow(cachedResultFrom(await completed()));
   if (prior === "running") {
     const final = await completed();
     if (final) {
       await store.setStatus(turnId, "complete", scopeId).catch((err) => {
         opts.log?.("[chat-routes] runDetachedTurn failed to settle a completed running turn", { turnId, err: String(err) });
       });
-      return cachedResultFrom(final);
+      return await settleRow(cachedResultFrom(final));
     }
     if (opts.resetBuffer) {
       await opts.resetBuffer(turnId).catch((err) => {
@@ -1012,7 +1307,7 @@ async function runDetachedTurn(opts) {
     coalesce: opts.coalesce ?? coalesceDeltas
   });
   await tap.onEvent({ type: "turn", turnId });
-  const producer = createSandboxChatProducer({
+  producer = createSandboxChatProducer({
     events: opts.events,
     model: opts.model,
     isRenderableInteraction: opts.isRenderableInteraction,
@@ -1026,11 +1321,14 @@ async function runDetachedTurn(opts) {
       const type = ev.type;
       if (typeof type === "string" && TERMINAL_ERROR_TYPES.has(type)) runError = errorMessageOf(ev);
       await tap.onEvent(ev);
+      draft?.notify(ev);
     }
     await tap.done(runError ? "error" : "complete");
   } catch (err) {
     await tap.done("error").catch(() => {
     });
+    await draft?.close().catch(() => {
+    });
     throw err;
   }
   const text = producer.finalText?.() ?? "";
@@ -1040,11 +1338,11 @@ async function runDetachedTurn(opts) {
     const final = await completed();
     if (final?.usage) usage = { ...usage, ...final.usage };
     if (!text && final?.text) {
-      return { state: "completed", text: final.text, parts: final.parts ?? parts, usage, cached: false };
+      return await settleRow({ state: "completed", text: final.text, parts: final.parts ?? parts, usage, cached: false });
     }
   }
-  if (runError) return { state: "failed", text, parts, usage, error: runError, cached: false };
-  return { state: "completed", text, parts, usage, cached: false };
+  if (runError) return await settleRow({ state: "failed", text, parts, usage, error: runError, cached: false });
+  return await settleRow({ state: "completed", text, parts, usage, cached: false });
 }
 
 // src/chat-routes/durable-projection.ts
@@ -1755,6 +2053,7 @@ export {
   UPLOAD_INLINE_MAX_BYTES,
   UPLOAD_MAX_FILE_BYTES,
   assertPromptPartsWithinCap,
+  assistantRowIdForTurn,
   attachmentSizeErrorMessage,
   attachmentTotalSizeErrorMessage,
   base64WireLen,
@@ -1763,6 +2062,7 @@ export {
   bytesToBase64,
   chatTurnRequestInit,
   checkAttachmentType,
+  createAssistantDraftWriter,
   createAttachmentUploadRoute,
   createChatTurnRoutes,
   createSandboxChatProducer,
@@ -1771,6 +2071,7 @@ export {
   defaultValidateAttachmentPath,
   fileMentionsToParts,
   formatBytes,
+  isDraftContentEvent,
   mediaTypeForMentionPath,
   mentionKindForPath,
   parseChatTurnParts,
@@ -1784,6 +2085,7 @@ export {
   sanitizeUploadFilename,
   sniffBinary,
   sniffMimeFromName,
+  storeSupportsDraftPersistence,
   validateSandboxMentionPath,
   withDurableChatProjection
 };