basalt-ui 1.11.0 → 1.12.0

package/dist/agent/adapter.js

@@ -0,0 +1,473 @@
+import { useEffect, useSyncExternalStore } from "react";
+import { mintThreadId } from "./id.js";
+function createAdapterThreadsStore(adapter, opts) {
+  const revalidateOnFocus = opts?.revalidateOnFocus ?? false;
+  const EMPTY = [];
+  const SERVER_SNAPSHOT = {
+    threads: EMPTY,
+    activeId: null,
+    hydrated: false,
+    error: void 0
+  };
+  let base = EMPTY;
+  let baseSeq = 0;
+  let activeId = null;
+  let hydrated = false;
+  let error;
+  let errorToken = 0;
+  let errorFromWrite = false;
+  const pending = [];
+  let snapshot = SERVER_SNAPSHOT;
+  const listeners = /* @__PURE__ */ new Set();
+  function recompute() {
+    let threads = base;
+    let active = activeId;
+    for (const patch of pending) {
+      threads = patch.apply(threads);
+      if (patch.applyActive !== void 0) active = patch.applyActive(active);
+    }
+    snapshot = { threads, activeId: active, hydrated, error };
+    for (const listener of listeners) listener();
+  }
+  function memoizeApply(apply) {
+    let lastIn;
+    let lastOut;
+    return (threads) => {
+      if (lastOut !== void 0 && threads === lastIn) return lastOut;
+      lastIn = threads;
+      lastOut = apply(threads);
+      return lastOut;
+    };
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  function getSnapshot() {
+    return snapshot;
+  }
+  function getServerSnapshot() {
+    return SERVER_SNAPSHOT;
+  }
+  let loadController = null;
+  let loadSeq = 0;
+  let queuedSeq = null;
+  function prune() {
+    const kept = [];
+    for (const patch of pending) {
+      if (patch.confirmSeq !== null && patch.confirmSeq <= baseSeq) {
+        if (patch.applyActive !== void 0) activeId = patch.applyActive(activeId);
+        continue;
+      }
+      kept.push(patch);
+    }
+    if (kept.length !== pending.length) pending.splice(0, pending.length, ...kept);
+  }
+  function startLoad(seq) {
+    const controller = new AbortController();
+    loadController = controller;
+    void (async () => {
+      try {
+        const next = await adapter.listThreads(controller.signal);
+        if (loadController !== controller) return;
+        base = [...next];
+        baseSeq = seq;
+        hydrated = true;
+        if (!errorFromWrite) error = void 0;
+        prune();
+        recompute();
+      } catch (cause) {
+        if (controller.signal.aborted || loadController !== controller) return;
+        error = cause;
+        errorToken += 1;
+        errorFromWrite = false;
+        recompute();
+      } finally {
+        if (loadController === controller) {
+          loadController = null;
+          if (queuedSeq !== null) {
+            const next = queuedSeq;
+            queuedSeq = null;
+            startLoad(next);
+          }
+        }
+      }
+    })();
+  }
+  function revalidate() {
+    if (loadController !== null) {
+      queuedSeq ??= ++loadSeq;
+      return queuedSeq;
+    }
+    const seq = ++loadSeq;
+    startLoad(seq);
+    return seq;
+  }
+  function forceRevalidate() {
+    loadController?.abort();
+    queuedSeq = null;
+    const seq = ++loadSeq;
+    startLoad(seq);
+    return seq;
+  }
+  const chains = /* @__PURE__ */ new Map();
+  function enqueue(threadIds, task) {
+    const ids = [...new Set(threadIds)];
+    const prior = ids.map((id) => chains.get(id)).filter((p) => p !== void 0);
+    const after = prior.length === 0 ? Promise.resolve() : Promise.all(prior).then(() => void 0);
+    const run = after.then(task);
+    for (const id of ids) chains.set(id, run);
+    void run.finally(() => {
+      for (const id of ids) if (chains.get(id) === run) chains.delete(id);
+    });
+  }
+  function drop(patch) {
+    const index = pending.indexOf(patch);
+    if (index !== -1) pending.splice(index, 1);
+  }
+  function mutate(i) {
+    const patch = {
+      apply: memoizeApply(i.apply),
+      ...i.applyActive !== void 0 ? { applyActive: i.applyActive } : {},
+      confirmSeq: null
+    };
+    pending.push(patch);
+    const tokenAtIssue = errorToken;
+    recompute();
+    enqueue(i.threadIds, async () => {
+      try {
+        await i.commit();
+      } catch (cause) {
+        drop(patch);
+        error = cause;
+        errorToken += 1;
+        errorFromWrite = true;
+        recompute();
+        revalidate();
+        return;
+      }
+      if (errorFromWrite && errorToken === tokenAtIssue) {
+        error = void 0;
+        errorFromWrite = false;
+        recompute();
+      }
+      patch.confirmSeq = revalidate();
+    });
+  }
+  function patchThread(id, update) {
+    return (threads) => threads.map((thread) => thread.id === id ? update(thread) : thread);
+  }
+  let mounted = 0;
+  function onFocus() {
+    forceRevalidate();
+  }
+  function retain() {
+    mounted += 1;
+    if (mounted !== 1) return;
+    revalidate();
+    if (revalidateOnFocus && typeof window !== "undefined") {
+      window.addEventListener("focus", onFocus);
+    }
+  }
+  function release() {
+    mounted -= 1;
+    if (mounted !== 0) return;
+    loadController?.abort();
+    loadController = null;
+    queuedSeq = null;
+    if (revalidateOnFocus && typeof window !== "undefined") {
+      window.removeEventListener("focus", onFocus);
+    }
+  }
+  function select(id) {
+    activeId = id;
+    recompute();
+  }
+  function create(createOpts) {
+    const id = mintThreadId();
+    const now = Date.now();
+    const thread = {
+      id,
+      messages: [],
+      outcome: null,
+      status: "pending",
+      read: false,
+      createdAt: now,
+      updatedAt: now,
+      ...createOpts?.meta !== void 0 ? { meta: createOpts.meta } : {}
+    };
+    mutate({
+      threadIds: [id],
+      apply: (threads) => threads.some((t) => t.id === id) ? [...threads] : [thread, ...threads],
+      commit: () => adapter.createThread({
+        id,
+        ...createOpts?.meta !== void 0 ? { meta: createOpts.meta } : {}
+      })
+    });
+    return id;
+  }
+  function appendMessage(id, message2) {
+    const now = Date.now();
+    mutate({
+      threadIds: [id],
+      apply: patchThread(
+        id,
+        (thread) => thread.messages.some((m) => m.id === message2.id) ? thread : { ...thread, messages: [...thread.messages, message2], updatedAt: now }
+      ),
+      commit: () => adapter.appendMessage({ threadId: id, message: message2 })
+    });
+  }
+  function setOutcome(id, outcome) {
+    const now = Date.now();
+    mutate({
+      threadIds: [id],
+      apply: patchThread(id, (thread) => ({ ...thread, outcome, updatedAt: now })),
+      commit: () => adapter.setOutcome({ threadId: id, outcome })
+    });
+  }
+  function setStatus(id, status) {
+    const now = Date.now();
+    mutate({
+      threadIds: [id],
+      apply: patchThread(id, (thread) => ({ ...thread, status, updatedAt: now })),
+      commit: () => adapter.setStatus({ threadId: id, status })
+    });
+  }
+  function setResumeToken(id, token) {
+    const now = Date.now();
+    mutate({
+      threadIds: [id],
+      apply: patchThread(id, (thread) => {
+        const { resumeToken: _resumeToken, ...rest } = thread;
+        return {
+          ...rest,
+          ...token !== void 0 ? { resumeToken: token } : {},
+          updatedAt: now
+        };
+      }),
+      commit: () => adapter.setResumeToken({ threadId: id, token })
+    });
+  }
+  function markRead(id) {
+    mutate({
+      threadIds: [id],
+      // Identity-preserving when the server already agrees — markRead does not bump updatedAt.
+      apply: patchThread(id, (thread) => thread.read ? thread : { ...thread, read: true }),
+      commit: () => adapter.markRead(id)
+    });
+  }
+  function remove(id) {
+    mutate({
+      threadIds: [id],
+      apply: (threads) => threads.filter((thread) => thread.id !== id),
+      // Inside the patch, so a rejected delete restores the SELECTION along with the row. Written
+      // as a conditional clear rather than a flat `null` so a `select()` issued while the delete
+      // is in flight survives the patch being re-applied on top of it.
+      applyActive: (active) => active === id ? null : active,
+      commit: () => adapter.removeThread(id)
+    });
+  }
+  function clear() {
+    const ids = snapshot.threads.map((thread) => thread.id);
+    const clearedIds = new Set(ids);
+    mutate({
+      threadIds: ids,
+      apply: () => [],
+      // Same idiom as remove(): only null a selection pointing at one of the threads THIS clear
+      // captured, so a select() issued while the clear is in flight — e.g. into a thread created
+      // concurrently by create() — survives the patch being re-applied on top of it.
+      applyActive: (active) => active !== null && clearedIds.has(active) ? null : active,
+      commit: async () => {
+        const results = await Promise.allSettled(ids.map((id) => adapter.removeThread(id)));
+        const failures = results.filter((r) => r.status === "rejected");
+        if (failures.length === 0) return;
+        throw new AggregateError(
+          failures.map((f) => f.reason),
+          `removeThread rejected for ${failures.length} of ${ids.length} threads`
+        );
+      }
+    });
+  }
+  return function useAdapterThreadsStore() {
+    const current = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    useEffect(() => {
+      retain();
+      return () => {
+        release();
+      };
+    }, []);
+    return {
+      threads: current.threads,
+      activeId: current.activeId,
+      hydrated: current.hydrated,
+      error: current.error,
+      select,
+      create,
+      appendMessage,
+      setOutcome,
+      setStatus,
+      setResumeToken,
+      markRead,
+      remove,
+      clear
+    };
+  };
+}
+function assert(condition, message2) {
+  if (!condition) throw new Error(`ThreadsStoreAdapter contract: ${message2}`);
+}
+function message(id) {
+  return { id, role: "user", parts: [], createdAt: Date.now() };
+}
+function threadsStoreAdapterContract(makeAdapter) {
+  function define(name, run) {
+    return {
+      name,
+      run: async () => {
+        await run(await makeAdapter());
+      }
+    };
+  }
+  async function loadOrThrow(adapter, id) {
+    const thread = await adapter.loadThread(id);
+    assert(thread !== null, `loadThread('${id}') returned null for a thread that was created`);
+    return thread;
+  }
+  return [
+    define("createThread then listThreads returns the thread with empty defaults", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      const threads = await a.listThreads();
+      const found = threads.filter((t) => t.id === id);
+      assert(found.length === 1, `listThreads returned ${found.length} threads for one create`);
+      const thread = found[0];
+      assert(thread !== void 0, "listThreads entry was undefined");
+      assert(thread.messages.length === 0, "a new thread must start with no messages");
+      assert(thread.outcome === null, "a new thread's outcome must be null");
+      assert(thread.status === "pending", `a new thread's status must be 'pending'`);
+      assert(thread.read === false, "a new thread must be unread");
+      assert(typeof thread.createdAt === "number", "createdAt must be a number");
+      assert(typeof thread.updatedAt === "number", "updatedAt must be a number");
+    }),
+    define("createThread persists meta", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id, meta: { source: "contract" } });
+      const thread = await loadOrThrow(a, id);
+      assert(thread.meta?.["source"] === "contract", "meta did not round-trip");
+    }),
+    define("loadThread returns null for an unknown id", async (a) => {
+      const thread = await a.loadThread(crypto.randomUUID());
+      assert(thread === null, "loadThread must return null (not throw, not undefined) when absent");
+    }),
+    define("appendMessage is idempotent on message.id", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      const msg = message("contract-msg-1");
+      await a.appendMessage({ threadId: id, message: msg });
+      await a.appendMessage({ threadId: id, message: msg });
+      const thread = await loadOrThrow(a, id);
+      assert(
+        thread.messages.length === 1,
+        `appending the same message.id twice produced ${thread.messages.length} rows \u2014 the id is the only idempotency key`
+      );
+      assert(thread.messages[0]?.id === "contract-msg-1", "the retained message has the wrong id");
+    }),
+    define("appendMessage preserves order for distinct ids", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.appendMessage({ threadId: id, message: message("contract-msg-1") });
+      await a.appendMessage({ threadId: id, message: message("contract-msg-2") });
+      const thread = await loadOrThrow(a, id);
+      assert(
+        thread.messages.map((m) => m.id).join(",") === "contract-msg-1,contract-msg-2",
+        "messages must read back oldest-first in append order"
+      );
+    }),
+    define("setStatus round-trips", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.setStatus({ threadId: id, status: "streaming" });
+      assert((await loadOrThrow(a, id)).status === "streaming", "status did not become 'streaming'");
+      await a.setStatus({ threadId: id, status: "error" });
+      assert((await loadOrThrow(a, id)).status === "error", "status did not become 'error'");
+    }),
+    define("setOutcome round-trips", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      const outcome = { title: "Title", summary: "Summary", status: "done" };
+      await a.setOutcome({ threadId: id, outcome });
+      const thread = await loadOrThrow(a, id);
+      assert(thread.outcome?.title === "Title", "outcome.title did not round-trip");
+      assert(thread.outcome?.summary === "Summary", "outcome.summary did not round-trip");
+      assert(thread.outcome?.status === "done", "outcome.status did not round-trip");
+    }),
+    define("setResumeToken round-trips and clears with undefined", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.setResumeToken({ threadId: id, token: "tok-1" });
+      assert((await loadOrThrow(a, id)).resumeToken === "tok-1", "resumeToken did not round-trip");
+      await a.setResumeToken({ threadId: id, token: void 0 });
+      assert(
+        (await loadOrThrow(a, id)).resumeToken === void 0,
+        "setResumeToken(undefined) must CLEAR the token"
+      );
+    }),
+    define("markRead marks the thread read", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      assert((await loadOrThrow(a, id)).read === false, "a new thread must start unread");
+      await a.markRead(id);
+      assert((await loadOrThrow(a, id)).read === true, "markRead did not set read");
+    }),
+    define("listThreads reflects a write that has already resolved", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.appendMessage({ threadId: id, message: message("contract-msg-raw") });
+      await a.setStatus({ threadId: id, status: "streaming" });
+      const found = (await a.listThreads()).find((t) => t.id === id);
+      assert(found !== void 0, "listThreads omitted a thread created before the call");
+      assert(
+        found.status === "streaming",
+        "listThreads returned a STALE status \u2014 a list started after a write resolves must reflect it"
+      );
+      assert(
+        found.messages.length === 1,
+        `listThreads returned a STALE message list (${found.messages.length} rows) \u2014 a list started after a write resolves must reflect it`
+      );
+    }),
+    define(
+      "dependent writes issued straight after createThread resolves are honoured",
+      async (a) => {
+        const id = crypto.randomUUID();
+        await a.createThread({ id });
+        await a.markRead(id);
+        await a.appendMessage({ threadId: id, message: message("contract-msg-dep") });
+        await a.setStatus({ threadId: id, status: "streaming" });
+        const thread = await loadOrThrow(a, id);
+        assert(thread.read === true, "markRead did not apply to a just-created thread");
+        assert(
+          thread.messages.length === 1,
+          `appendMessage did not apply to a just-created thread (${thread.messages.length} rows)`
+        );
+        assert(thread.status === "streaming", "setStatus did not apply to a just-created thread");
+      }
+    ),
+    define("removeThread removes the thread", async (a) => {
+      const id = crypto.randomUUID();
+      await a.createThread({ id });
+      await a.removeThread(id);
+      assert(await a.loadThread(id).then((t) => t === null), "loadThread must be null after remove");
+      const threads = await a.listThreads();
+      assert(!threads.some((t) => t.id === id), "listThreads still contains the removed thread");
+    }),
+    define("removeThread of an unknown id does not throw", async (a) => {
+      await a.removeThread(crypto.randomUUID());
+    })
+  ];
+}
+export {
+  createAdapterThreadsStore,
+  threadsStoreAdapterContract
+};

package/dist/agent/adapter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adapter.test.d.ts.map

package/dist/agent/adapter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.test.d.ts","sourceRoot":"","sources":["../../src/agent/adapter.test.ts"],"names":[],"mappings":""}

package/dist/agent/ai-sdk-transport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ai-sdk-transport.test.d.ts.map

package/dist/agent/ai-sdk-transport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-sdk-transport.test.d.ts","sourceRoot":"","sources":["../../src/agent/ai-sdk-transport.test.ts"],"names":[],"mappings":""}

package/dist/agent/coalesce.d.ts

@@ -12,10 +12,26 @@
  * wire, the SDK re-supplies `input` by reading it back off the stored invocation, and a merge that
  * replaces wholesale rather than accumulating would lose it outright.
  *
- * `approval`-bearing responses can arrive without a usable `toolCallId` (the SDK resolves them by
- * reverse lookup on `approval.id` instead) — this maintains an `approvalId -> toolCallId` side
- * index while folding and routes such a part through it. A part resolvable by neither key is kept
- * as-is rather than dropped; never silently discard a part.
+ * A settled tool part can arrive without a `toolCallId` at all — `approval-responded` plus the
+ * three terminal states all carry it as optional (see `MaybeIdentified` in `parts.ts`).
+ * `approval-responded` is where the WIRE itself omits it: the SDK's `tool-approval-response` chunk
+ * carries no `toolCallId`, only `approval.id`, so it is resolved by reverse lookup on `approval.id`
+ * instead — this maintains an `approvalId -> toolCallId` side index while folding and routes such a
+ * part through it. A part resolvable by neither key is kept as-is rather than dropped; never
+ * silently discard a part.
+ *
+ * The fold is strictly LEFT-TO-RIGHT with no backtracking: the side index only holds ids seen so
+ * far, so an unidentified `approval-responded` arriving BEFORE its `approval-requested` stays its
+ * own block and the later request opens a second one. That is deliberate, not an oversight —
+ * reconciling backwards would let the request (the later arrival) win under the "later state wins"
+ * rule and render an already-answered call as still pending, which is worse than two blocks in an
+ * ordering the wire never produces.
+ *
+ * **This function never throws.** It is public, it runs on the render path, and it folds data that
+ * came off a wire — so every anomaly (an unrecognized tool state, an unresolvable id) degrades to
+ * "keep the part as it arrived", announced in dev, rather than aborting the render. A throw here
+ * would turn one malformed chunk into a permanently dead transcript. Exhaustiveness over the tool
+ * states is still enforced, but at COMPILE time only (see `mergeToolPart`'s default branch).
  *
  * @example
  * import { coalesceParts } from 'basalt-ui/agent'

package/dist/agent/coalesce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coalesce.d.ts","sourceRoot":"","sources":["../../src/agent/coalesce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAyC,MAAM,SAAS,CAAA;AA+C/E,wBAAgB,aAAa,CAAC,KAAK,SAAS,SAAS,EAAE,KAAK,EAAE,SAAS,KAAK,EAAE,GAAG,KAAK,EAAE,CA+CvF"}
+{"version":3,"file":"coalesce.d.ts","sourceRoot":"","sources":["../../src/agent/coalesce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,EAAE,SAAS,EAAyC,MAAM,SAAS,CAAA;AA8I/E,wBAAgB,aAAa,CAAC,KAAK,SAAS,SAAS,EAAE,KAAK,EAAE,SAAS,KAAK,EAAE,GAAG,KAAK,EAAE,CA+CvF"}

package/dist/agent/coalesce.js

@@ -2,27 +2,95 @@ function isTextLikeType(type) {
   return type === "text" || type === "reasoning";
 }
 function resolveToolCallId(part, toolCallIdByApprovalId) {
-  if (typeof part.toolCallId === "string" && part.toolCallId.length > 0) return part.toolCallId;
+  if (part.toolCallId !== void 0) return part.toolCallId;
   const approval = "approval" in part ? part.approval : void 0;
   return approval !== void 0 ? toolCallIdByApprovalId.get(approval.id) : void 0;
 }
 function registerApprovalIndex(part, toolCallIdByApprovalId) {
   const approval = "approval" in part ? part.approval : void 0;
   if (approval === void 0) return;
-  if (typeof part.toolCallId !== "string" || part.toolCallId.length === 0) return;
+  if (part.toolCallId === void 0) return;
   toolCallIdByApprovalId.set(approval.id, part.toolCallId);
 }
 function mergeToolPart(existing, next) {
   const existingInput = "input" in existing ? existing.input : void 0;
   const nextInput = "input" in next ? next.input : void 0;
   const input = nextInput !== void 0 ? nextInput : existingInput;
-  const toolName = next.toolName.length > 0 ? next.toolName : existing.toolName;
-  return {
-    ...existing,
-    ...next,
-    toolName,
-    ...input !== void 0 ? { input } : {}
+  const durationMs = next.durationMs ?? existing.durationMs;
+  const providerExecuted = next.providerExecuted ?? existing.providerExecuted;
+  const settledToolCallId = next.toolCallId ?? existing.toolCallId;
+  const common = {
+    id: next.id,
+    type: "tool",
+    toolName: next.toolName.length > 0 ? next.toolName : existing.toolName,
+    ...durationMs !== void 0 ? { durationMs } : {},
+    ...providerExecuted !== void 0 ? { providerExecuted } : {}
   };
+  switch (next.state) {
+    case "input-streaming":
+      return {
+        ...common,
+        toolCallId: next.toolCallId,
+        state: "input-streaming",
+        ...input !== void 0 ? { input } : {}
+      };
+    case "input-available":
+      return { ...common, toolCallId: next.toolCallId, state: "input-available", input };
+    case "approval-requested":
+      return {
+        ...common,
+        toolCallId: next.toolCallId,
+        state: "approval-requested",
+        input,
+        approval: next.approval
+      };
+    case "approval-responded":
+      return {
+        ...common,
+        ...settledToolCallId !== void 0 ? { toolCallId: settledToolCallId } : {},
+        state: "approval-responded",
+        input,
+        approval: next.approval
+      };
+    case "output-available":
+      return {
+        ...common,
+        ...settledToolCallId !== void 0 ? { toolCallId: settledToolCallId } : {},
+        state: "output-available",
+        input,
+        output: next.output,
+        ...next.preliminary !== void 0 ? { preliminary: next.preliminary } : {},
+        ...next.approval !== void 0 ? { approval: next.approval } : {}
+      };
+    case "output-error":
+      return {
+        ...common,
+        ...settledToolCallId !== void 0 ? { toolCallId: settledToolCallId } : {},
+        state: "output-error",
+        errorText: next.errorText,
+        ...input !== void 0 ? { input } : {},
+        ...next.rawInput !== void 0 ? { rawInput: next.rawInput } : {},
+        ...next.approval !== void 0 ? { approval: next.approval } : {}
+      };
+    case "output-denied":
+      return {
+        ...common,
+        ...settledToolCallId !== void 0 ? { toolCallId: settledToolCallId } : {},
+        state: "output-denied",
+        input,
+        approval: next.approval
+      };
+    default: {
+      const unhandled = next;
+      const fallback = unhandled;
+      if (process.env["NODE_ENV"] !== "production") {
+        console.warn(
+          `[basalt] coalesceParts: unrecognized tool state ${JSON.stringify(fallback.state)} \u2014 kept, merged best-effort`
+        );
+      }
+      return { ...fallback, ...common };
+    }
+  }
 }
 function coalesceParts(parts) {
   const out = [];

package/dist/agent/coalesce.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=coalesce.test.d.ts.map

package/dist/agent/coalesce.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coalesce.test.d.ts","sourceRoot":"","sources":["../../src/agent/coalesce.test.ts"],"names":[],"mappings":""}

package/dist/agent/foreign.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=foreign.test.d.ts.map

package/dist/agent/foreign.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign.test.d.ts","sourceRoot":"","sources":["../../src/agent/foreign.test.ts"],"names":[],"mappings":""}

package/dist/agent/id.d.ts

@@ -1,3 +1,33 @@
+/**
+ * Id-minting helpers shared by the thread stores: `mintThreadId` (a client-side thread id, used by
+ * both `./thread`'s `createThreadsStore` and `./adapter`'s `createAdapterThreadsStore`) and
+ * `withPartIds` (stamps sequence ids onto streamed parts). Related in theme — both mint an id a
+ * store needs — unrelated in mechanism; grouped here because they're the two id-minting leaves the
+ * two thread stores both sit above.
+ */
+/**
+ * Mints a client-side thread id. `crypto.randomUUID()` exists only in SECURE CONTEXTS (HTTPS or
+ * localhost) — a consumer served over plain HTTP on a LAN hostname (a homelab dashboard on a bare
+ * IP, a staging box) would otherwise have `create()`, about the most basic user action a thread
+ * store has, throw a plain TypeError. A store used from a browser must not throw on a user gesture
+ * — the same principle already applied twice this release (`spliceText` clamps rather than throws,
+ * `coalesceParts` degrades rather than throws).
+ *
+ * Fallback chain, each rung reached only when the one above it is unavailable:
+ *   1. `crypto.randomUUID()` — cryptographically random, RFC 4122 UUID. The normal path.
+ *   2. `crypto.getRandomValues()` — still cryptographically random; hand-assembled into a UUIDv4
+ *      (the version/variant bits are set per RFC 4122, since this rung hands back raw bytes, not a
+ *      formatted UUID).
+ *   3. No usable `crypto` at all (missing entirely, or missing both methods above — an old WebView,
+ *      an SSR shim). NOT cryptographically random and NOT collision-resistant in general. This rung
+ *      exists solely so `create()` never throws on such a host. It is acceptable ONLY because this
+ *      id is minted a handful of times per client session and is not the idempotency key any write
+ *      here depends on — `ThreadsStoreAdapter.appendMessage`'s idempotency key is the MESSAGE id,
+ *      not this thread id, so a collision on this rung costs a locally merged/duplicated thread, not
+ *      silent data loss on the append path. Do not reuse this rung for anything with a higher
+ *      collision cost than that.
+ */
+export declare function mintThreadId(): string;
 /**
  * withPartIds — stamps a stable id onto every draft part arriving without one.
  *