@anuma/sdk 10.5.4 → 10.6.1

package/dist/react/index.cjs

@@ -7605,6 +7605,7 @@ function count(value) {
 
 // src/lib/chat/resumeStream.ts
 init_clientConfig();
+init_redactor();
 
 // src/lib/chat/toolLoop.ts
 init_clientConfig();
@@ -12076,16 +12077,34 @@ async function resumeStream(options) {
     onData,
     onThinking,
     onFinish,
-    onError
+    onError,
+    piiRedactor
   } = options;
   const strategy = getStrategy(handle.apiType);
   const accumulator = createStreamAccumulator(handle.model || void 0);
+  const contentDeAnon = piiRedactor && onData ? createStreamingDeAnonymizer(piiRedactor, onData) : null;
+  const thinkingDeAnon = piiRedactor && onThinking ? createStreamingDeAnonymizer(piiRedactor, onThinking) : null;
   const contentSmoother = new StreamSmoother((text16) => {
-    if (onData) onData(text16);
+    if (contentDeAnon) contentDeAnon.push(text16);
+    else if (onData) onData(text16);
   }, smoothing);
   const thinkingSmoother = new StreamSmoother((text16) => {
-    if (onThinking) onThinking(text16);
+    if (thinkingDeAnon) thinkingDeAnon.push(text16);
+    else if (onThinking) onThinking(text16);
   }, smoothing);
+  const flushOutput = () => {
+    contentSmoother.flush();
+    thinkingSmoother.flush();
+    contentDeAnon?.flush();
+    thinkingDeAnon?.flush();
+  };
+  const buildFinal = () => strategy.buildFinalResponse(
+    piiRedactor ? {
+      ...accumulator,
+      content: piiRedactor.deAnonymize(accumulator.content),
+      thinking: piiRedactor.deAnonymize(accumulator.thinking)
+    } : accumulator
+  );
   const idleController = new AbortController();
   let watchdog;
   let idleFired = false;
@@ -12130,9 +12149,8 @@ async function resumeStream(options) {
     if (signal) signal.removeEventListener("abort", onCallerAbort);
   };
   const buildInterrupted = (message) => {
-    contentSmoother.flush();
-    thinkingSmoother.flush();
-    const data = accumulator.toolCalls.size > 0 ? stripToolCalls(strategy.buildFinalResponse(accumulator)) : strategy.buildFinalResponse(accumulator);
+    flushOutput();
+    const data = accumulator.toolCalls.size > 0 ? stripToolCalls(buildFinal()) : buildFinal();
     return { data, error: message, interrupted: true };
   };
   if (combinedSignal.aborted) {
@@ -12180,18 +12198,16 @@ async function resumeStream(options) {
     const err = replayErr instanceof Error ? replayErr : new Error(String(replayErr));
     const statusCode = parseSseStatusCode(err);
     if (statusCode === 410) {
-      contentSmoother.flush();
-      thinkingSmoother.flush();
+      flushOutput();
       throw new StreamExpiredError(handle.inferenceId);
     }
     if (err.name === "AbortError" || combinedSignal.aborted) {
       return buildInterrupted(abortMessage());
     }
-    contentSmoother.flush();
-    thinkingSmoother.flush();
+    flushOutput();
     if (onError) onError(err);
     return {
-      data: strategy.buildFinalResponse(accumulator),
+      data: buildFinal(),
       error: err.message,
       interrupted: false,
       statusCode
@@ -12207,7 +12223,9 @@ async function resumeStream(options) {
     draining = true;
     await Promise.all([contentSmoother.drain(), thinkingSmoother.drain()]);
     if (playbackAborted) return buildInterrupted(abortMessage());
-    const response = strategy.buildFinalResponse(accumulator);
+    contentDeAnon?.flush();
+    thinkingDeAnon?.flush();
+    const response = buildFinal();
     const deliveredOutput = emittedOutput || (accumulator.toolCallEvents?.length ?? 0) > 0;
     if (onFinish && deliveredOutput) onFinish(response);
     return { data: response, error: null, interrupted: false, empty: !deliveredOutput };
@@ -20356,6 +20374,52 @@ async function getDecayCandidatesRawOp(ctx) {
     trustTier: raw.trust_tier ?? null
   }));
 }
+async function applyDecayTransitionsOp(ctx, candidates, opts) {
+  assertVaultScopeForSweep(ctx);
+  const byId = new Map(candidates.map((candidate) => [candidate.uniqueId, candidate]));
+  const ids = Array.from(byId.keys());
+  const changed = /* @__PURE__ */ new Set();
+  const CHUNK = 500;
+  for (let i = 0; i < ids.length; i += CHUNK) {
+    let applied = [];
+    try {
+      await ctx.database.write(async () => {
+        await assertCanWrite2(ctx);
+        const records = await ctx.vaultMemoryCollection.query(
+          import_watermelondb24.Q.where("id", import_watermelondb24.Q.oneOf(ids.slice(i, i + CHUNK))),
+          ...ctx.userId !== void 0 ? [import_watermelondb24.Q.where("user_id", ctx.userId)] : []
+        ).fetch();
+        const eligible = records.filter((record2) => {
+          if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+          if (opts.transition === "delete") {
+            return record2.archivedAt !== null && opts.now - record2.archivedAt > opts.hardDeleteWindowMs;
+          }
+          const candidate = byId.get(record2.id);
+          return record2.archivedAt === null && record2.updatedAt.getTime() === candidate.updatedAt && (record2.lastObservedAt ?? null) === (candidate.lastObservedAt ?? null);
+        });
+        const prepared = eligible.map(
+          (record2) => record2.prepareUpdate((row) => {
+            if (opts.transition === "archive") row._setRaw("archived_at", opts.now);
+            else row._setRaw("is_deleted", true);
+          })
+        );
+        if (prepared.length > 0) await ctx.database.batch(prepared);
+        applied = eligible.map((record2) => record2.id);
+      });
+    } catch {
+      continue;
+    }
+    for (const id2 of applied) changed.add(id2);
+    if (opts.transition === "delete" && ctx.entityCtx) {
+      try {
+        await unlinkMemoryEntitiesOp(ctx.entityCtx, applied);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return changed;
+}
 async function archiveVaultMemoryOp(ctx, id2, opts) {
   try {
     const record2 = await ctx.vaultMemoryCollection.find(id2);
@@ -25426,25 +25490,8 @@ function isBorderline(input) {
 function vaultDecayBackend(vaultCtx) {
   return {
     candidates: () => getDecayCandidatesRawOp(vaultCtx),
-    archive: async (rows, now) => {
-      const archived = /* @__PURE__ */ new Set();
-      for (const c of rows) {
-        const ok = await archiveVaultMemoryOp(vaultCtx, c.uniqueId, {
-          now,
-          expectedUpdatedAt: c.updatedAt,
-          expectedLastObservedAt: c.lastObservedAt ?? null
-        });
-        if (ok) archived.add(c.uniqueId);
-      }
-      return archived;
-    },
-    hardDelete: async (rows, deleteOptions) => {
-      const deleted = /* @__PURE__ */ new Set();
-      for (const c of rows) {
-        if (await hardDeleteDecayedOp(vaultCtx, c.uniqueId, deleteOptions)) deleted.add(c.uniqueId);
-      }
-      return deleted;
-    }
+    archive: (rows, now) => applyDecayTransitionsOp(vaultCtx, rows, { transition: "archive", now }),
+    hardDelete: (rows, deleteOptions) => applyDecayTransitionsOp(vaultCtx, rows, { transition: "delete", ...deleteOptions })
   };
 }
 function createDecaySweeper(options) {
@@ -27472,6 +27519,7 @@ function createLocalMemoryStore(options) {
     "trust_tier",
     "superseded_by",
     "visibility",
+    "twin_opt_in",
     "published_at",
     "geohash",
     "topics",
@@ -28663,6 +28711,7 @@ function subscriptionState({ memory, version }) {
         memory.event_time_kind,
         memory.trust_tier,
         memory.visibility,
+        memory.twin_opt_in,
         memory.published_at,
         memory.geohash,
         memory.topics,
@@ -36366,6 +36415,7 @@ function useChat(options) {
     onToolCallArgumentsDelta,
     onStepFinish,
     resumable,
+    background = false,
     onStreamMeta,
     apiType: defaultApiType = "auto",
     smoothing,
@@ -36374,12 +36424,12 @@ function useChat(options) {
     piiRedaction,
     onPiiRedacted
   } = options || {};
+  const keepAlive = resumable === true && background;
   const [isLoading, setIsLoading] = (0, import_react4.useState)(false);
   const abortControllerRef = (0, import_react4.useRef)(null);
   const requestIdRef = (0, import_react4.useRef)(0);
-  const pendingInferenceRef = (0, import_react4.useRef)(
-    null
-  );
+  const detachControllerRef = (0, import_react4.useRef)(null);
+  const pendingInferenceRef = (0, import_react4.useRef)(null);
   const cancelInference = (0, import_react4.useCallback)(
     (inferenceId, requestToken) => {
       void (async () => {
@@ -36407,7 +36457,95 @@ function useChat(options) {
       abortControllerRef.current = null;
     }
   }, []);
-  (0, import_react4.useEffect)(() => stop, [stop]);
+  const keepAliveRef = (0, import_react4.useRef)(keepAlive);
+  keepAliveRef.current = keepAlive;
+  (0, import_react4.useEffect)(
+    () => () => {
+      if (keepAliveRef.current) {
+        if (detachControllerRef.current) {
+          detachControllerRef.current.abort();
+          return;
+        }
+        pendingInferenceRef.current = null;
+        abortControllerRef.current?.abort();
+        abortControllerRef.current = null;
+        return;
+      }
+      stop();
+    },
+    [stop]
+  );
+  const resumeStream2 = (0, import_react4.useCallback)(
+    async (handle, opts) => {
+      const getterValidation = validateTokenGetter(getToken);
+      if (!getterValidation.valid) {
+        return { data: null, error: getterValidation.message, interrupted: false };
+      }
+      const { headless, ...resumeOpts } = opts ?? {};
+      if (!headless && abortControllerRef.current) {
+        return { data: null, error: "A request is already in progress", interrupted: false };
+      }
+      const abortController = new AbortController();
+      const requestId = headless ? null : ++requestIdRef.current;
+      if (!headless) {
+        abortControllerRef.current = abortController;
+        pendingInferenceRef.current = {
+          id: handle.inferenceId,
+          round: -1,
+          cancel: () => cancelInference(handle.inferenceId),
+          handle
+        };
+        setIsLoading(true);
+      }
+      const ownsForeground = () => requestId !== null && requestIdRef.current === requestId;
+      try {
+        let token;
+        try {
+          token = await getToken();
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          if (!headless) onError?.(error);
+          return { data: null, error: error.message, interrupted: false };
+        }
+        const tokenValidation = validateToken(token);
+        if (!tokenValidation.valid) {
+          return { data: null, error: tokenValidation.message, interrupted: false };
+        }
+        return await resumeStream({
+          handle,
+          token,
+          baseUrl,
+          smoothing,
+          signal: abortController.signal,
+          piiRedactor: typeof resolvedPiiRedaction === "object" ? resolvedPiiRedaction : void 0,
+          ...headless ? {} : {
+            onData: (chunk) => globalOnData?.(chunk),
+            onThinking: (chunk) => globalOnThinking?.(chunk),
+            onFinish,
+            onError
+          },
+          ...resumeOpts
+        });
+      } finally {
+        if (ownsForeground()) {
+          setIsLoading(false);
+          if (abortControllerRef.current === abortController) abortControllerRef.current = null;
+          if (pendingInferenceRef.current?.round === -1) pendingInferenceRef.current = null;
+        }
+      }
+    },
+    [
+      getToken,
+      baseUrl,
+      smoothing,
+      cancelInference,
+      resolvedPiiRedaction,
+      globalOnData,
+      globalOnThinking,
+      onFinish,
+      onError
+    ]
+  );
   const sendMessage = (0, import_react4.useCallback)(
     async ({
       messages,
@@ -36435,9 +36573,12 @@ function useChat(options) {
       stop();
       const abortController = new AbortController();
       abortControllerRef.current = abortController;
+      const detachController = keepAlive ? new AbortController() : null;
+      detachControllerRef.current = detachController;
       const requestId = ++requestIdRef.current;
       setIsLoading(true);
-      let succeeded = false;
+      let keepServerStream = false;
+      const deferredErrors = [];
       try {
         const tokenGetterValidation = validateTokenGetter(getToken);
         if (!tokenGetterValidation.valid) {
@@ -36501,6 +36642,7 @@ function useChat(options) {
           apiType: requestApiType ?? defaultApiType,
           endpointOverride,
           resumable,
+          detachSignal: detachController?.signal,
           onStreamMeta: resumable || onStreamMeta ? (meta) => {
             if (requestId !== requestIdRef.current || abortController.signal.aborted) {
               if (resumable) cancelInference(meta.inferenceId, token);
@@ -36509,12 +36651,19 @@ function useChat(options) {
             const previous = pendingInferenceRef.current;
             if (previous && previous.round === meta.round && previous.id !== meta.inferenceId)
               previous.cancel();
+            const handle2 = {
+              inferenceId: meta.inferenceId,
+              apiType: resolveApiType(requestApiType ?? defaultApiType, model),
+              model,
+              conversationId
+            };
             pendingInferenceRef.current = {
               id: meta.inferenceId,
               round: meta.round,
-              cancel: resumable ? () => cancelInference(meta.inferenceId, token) : () => void 0
+              cancel: resumable ? () => cancelInference(meta.inferenceId, token) : () => void 0,
+              handle: handle2
             };
-            onStreamMeta?.(meta);
+            onStreamMeta?.({ ...handle2, round: meta.round });
           } : void 0,
           temperature,
           maxOutputTokens,
@@ -36536,17 +36685,44 @@ function useChat(options) {
             if (globalOnThinking) globalOnThinking(chunk);
           },
           onFinish,
-          onError,
+          onError: keepAlive ? (error) => deferredErrors.push(error) : onError,
           onToolCall,
           onServerToolCall,
           onToolCallArgumentsDelta,
-          onStepFinish,
+          onStepFinish: keepAlive || onStepFinish ? (event) => {
+            const pending2 = pendingInferenceRef.current;
+            if (keepAlive && pending2 && requestIdRef.current === requestId) {
+              pendingInferenceRef.current = { ...pending2, settled: true };
+            }
+            onStepFinish?.(event);
+          } : void 0,
           preProcessors,
           hooks,
           piiRedaction: requestPiiRedaction ?? resolvedPiiRedaction,
           onPiiRedacted
         });
-        succeeded = result.error === null;
+        const pending = pendingInferenceRef.current;
+        const handle = pending && !pending.settled ? pending.handle : null;
+        const detach = result.error !== null && keepAlive && handle && result.error !== "Request aborted";
+        if (!detach) deferredErrors.forEach((error) => onError?.(error));
+        if (result.error === null) {
+          keepServerStream = true;
+          return result;
+        }
+        if (detach) {
+          keepServerStream = true;
+          return {
+            data: result.data,
+            error: "Request detached",
+            detached: true,
+            resume: handle,
+            toolsChecksum: result.toolsChecksum
+          };
+        }
+        if ("detached" in result && result.detached) {
+          keepServerStream = true;
+          return { ...result, resume: null };
+        }
         return result;
       } catch (err) {
         return createErrorResult(
@@ -36557,7 +36733,8 @@ function useChat(options) {
         if (requestIdRef.current === requestId) {
           setIsLoading(false);
           abortControllerRef.current = null;
-          if (!succeeded) pendingInferenceRef.current?.cancel();
+          if (detachControllerRef.current === detachController) detachControllerRef.current = null;
+          if (!keepServerStream) pendingInferenceRef.current?.cancel();
           pendingInferenceRef.current = null;
         }
       }
@@ -36576,6 +36753,7 @@ function useChat(options) {
       onToolCallArgumentsDelta,
       onStepFinish,
       resumable,
+      keepAlive,
       onStreamMeta,
       defaultApiType,
       smoothing,
@@ -36588,7 +36766,8 @@ function useChat(options) {
   return {
     isLoading,
     sendMessage,
-    stop
+    stop,
+    resumeStream: resumeStream2
   };
 }
 

package/dist/react/index.d.mts

@@ -2890,6 +2890,8 @@ interface ResumeStreamOptions {
     onData?: (chunk: string) => void;
     /** Thinking/reasoning deltas as they replay. */
     onThinking?: (chunk: string) => void;
+    /** Restores the placeholders this redactor assigned when the original request was sent. */
+    piiRedactor?: PiiRedactor;
     /** Called once on a clean completion. Never called for 410 nor interrupted terminals. */
     onFinish?: (response: ApiResponse) => void;
     /** Called on a transient/unexpected failure. Never called for 410 (throws) nor interrupted terminals. */
@@ -14633,6 +14635,10 @@ type SendMessageResult = {
     error: string;
     /** Checksum of tools used to generate this response */
     toolsChecksum?: string;
+    /** True when a background stream was left running; `error` is "Request detached". */
+    detached?: true;
+    /** Pass to `resumeStream`; null when no inference id was issued before the detach. */
+    resume?: StreamResumeHandle | null;
 };
 /**
  * @inline
@@ -14640,11 +14646,13 @@ type SendMessageResult = {
 interface UseChatOptions extends BaseUseChatOptions {
     /** Buffer streamed rounds so a service can verify their canonical output. */
     resumable?: boolean;
-    /** Inference identifier for each HTTP round, including client-tool continuations. */
-    onStreamMeta?: (meta: {
-        inferenceId: string;
-        round: number;
-    }) => void;
+    /**
+     * Keep a resumable generation running server-side when the request fails or
+     * the hook unmounts; only `stop()` cancels it. Replay it with `resumeStream`.
+     */
+    background?: boolean;
+    /** Stream handle for each HTTP round, including client-tool continuations. */
+    onStreamMeta?: (meta: StreamMeta) => void;
     /**
      * Which API endpoint to use. Default: "auto"
      * - "auto": automatically selects the best API based on model support
@@ -14653,8 +14661,19 @@ interface UseChatOptions extends BaseUseChatOptions {
      */
     apiType?: ApiType;
 }
+/**
+ * A resumable stream handle plus the tool-loop round that issued it.
+ * @inline
+ */
+type StreamMeta = StreamResumeHandle & {
+    round: number;
+};
 type UseChatResult = BaseUseChatResult & {
     sendMessage: (args: SendMessageArgs) => Promise<SendMessageResult>;
+    /** Replay a resumable stream from the portal buffer, from its first frame. */
+    resumeStream: (handle: StreamResumeHandle, opts?: Pick<ResumeStreamOptions, "idleTimeoutMs" | "smoothing"> & {
+        headless?: boolean;
+    }) => Promise<ResumeStreamResult>;
 };
 /**
  * A React hook for managing chat completions with authentication.

package/dist/react/index.d.ts

@@ -2890,6 +2890,8 @@ interface ResumeStreamOptions {
     onData?: (chunk: string) => void;
     /** Thinking/reasoning deltas as they replay. */
     onThinking?: (chunk: string) => void;
+    /** Restores the placeholders this redactor assigned when the original request was sent. */
+    piiRedactor?: PiiRedactor;
     /** Called once on a clean completion. Never called for 410 nor interrupted terminals. */
     onFinish?: (response: ApiResponse) => void;
     /** Called on a transient/unexpected failure. Never called for 410 (throws) nor interrupted terminals. */
@@ -14633,6 +14635,10 @@ type SendMessageResult = {
     error: string;
     /** Checksum of tools used to generate this response */
     toolsChecksum?: string;
+    /** True when a background stream was left running; `error` is "Request detached". */
+    detached?: true;
+    /** Pass to `resumeStream`; null when no inference id was issued before the detach. */
+    resume?: StreamResumeHandle | null;
 };
 /**
  * @inline
@@ -14640,11 +14646,13 @@ type SendMessageResult = {
 interface UseChatOptions extends BaseUseChatOptions {
     /** Buffer streamed rounds so a service can verify their canonical output. */
     resumable?: boolean;
-    /** Inference identifier for each HTTP round, including client-tool continuations. */
-    onStreamMeta?: (meta: {
-        inferenceId: string;
-        round: number;
-    }) => void;
+    /**
+     * Keep a resumable generation running server-side when the request fails or
+     * the hook unmounts; only `stop()` cancels it. Replay it with `resumeStream`.
+     */
+    background?: boolean;
+    /** Stream handle for each HTTP round, including client-tool continuations. */
+    onStreamMeta?: (meta: StreamMeta) => void;
     /**
      * Which API endpoint to use. Default: "auto"
      * - "auto": automatically selects the best API based on model support
@@ -14653,8 +14661,19 @@ interface UseChatOptions extends BaseUseChatOptions {
      */
     apiType?: ApiType;
 }
+/**
+ * A resumable stream handle plus the tool-loop round that issued it.
+ * @inline
+ */
+type StreamMeta = StreamResumeHandle & {
+    round: number;
+};
 type UseChatResult = BaseUseChatResult & {
     sendMessage: (args: SendMessageArgs) => Promise<SendMessageResult>;
+    /** Replay a resumable stream from the portal buffer, from its first frame. */
+    resumeStream: (handle: StreamResumeHandle, opts?: Pick<ResumeStreamOptions, "idleTimeoutMs" | "smoothing"> & {
+        headless?: boolean;
+    }) => Promise<ResumeStreamResult>;
 };
 /**
  * A React hook for managing chat completions with authentication.