basalt-ui 1.10.0 → 1.12.0

package/dist/agent/ai-sdk-transport.js

@@ -1,3 +1,5 @@
+import { assertNever } from "../register.js";
+import { TERMINAL_TOOL_STATES } from "./parts.js";
 function createAiSdkResolver(options) {
   let resolved;
   return function resolveAiSdk() {
@@ -15,55 +17,133 @@ function createAiSdkResolver(options) {
     return resolved;
   };
 }
-function diffPart(prevPart, currPart) {
+function diffPart(chatId, index, prevPart, currPart, toolStartTimes) {
   switch (currPart.type) {
     case "text": {
       const prevText = prevPart?.type === "text" ? prevPart.text : "";
       const delta = currPart.text.slice(prevText.length);
-      return delta.length === 0 ? [] : [{ type: "text", text: delta }];
+      return delta.length === 0 ? [] : [{ id: `${chatId}#${index}`, type: "text", text: delta, offset: prevText.length }];
     }
     case "reasoning": {
       const prevText = prevPart?.type === "reasoning" ? prevPart.text : "";
       const delta = currPart.text.slice(prevText.length);
-      return delta.length === 0 ? [] : [{ type: "reasoning", text: delta }];
+      return delta.length === 0 ? [] : [{ id: `${chatId}#${index}`, type: "reasoning", text: delta, offset: prevText.length }];
     }
     case "source-url": {
       if (prevPart !== void 0) return [];
-      const source = { type: "source", url: currPart.url };
+      const source = { id: `${chatId}#${index}`, type: "source", url: currPart.url };
       return [currPart.title !== void 0 ? { ...source, title: currPart.title } : source];
     }
     default:
-      return currPart.type.startsWith("tool-") ? diffToolPart(prevPart, currPart) : [];
+      return isToolLikePart(currPart) ? diffToolPart(prevPart, currPart, toolStartTimes) : [];
   }
 }
-function diffToolPart(prevPart, currPart) {
-  const curr = currPart;
-  if (curr.state === "input-streaming") return [];
-  const prev = prevPart !== void 0 && prevPart.type === currPart.type ? prevPart : void 0;
-  if (prev?.state === curr.state) return [];
-  const toolName = curr.type.slice("tool-".length);
+function isToolLikePart(part) {
+  return part.type === "dynamic-tool" || part.type.startsWith("tool-");
+}
+function deriveToolName(part) {
+  return part.type === "dynamic-tool" ? part.toolName : part.type.split("-").slice(1).join("-");
+}
+function outputSnapshot(part) {
+  return part.state === "output-available" ? { output: part.output, preliminary: part.preliminary } : void 0;
+}
+function isSameToolState(prev, curr) {
+  if (prev.state !== curr.state) return false;
+  const prevOutput = outputSnapshot(prev);
+  const currOutput = outputSnapshot(curr);
+  if (prevOutput === void 0 || currOutput === void 0) return true;
+  return JSON.stringify(prevOutput.output) === JSON.stringify(currOutput.output) && prevOutput.preliminary === currOutput.preliminary;
+}
+function diffToolPart(prevPart, currPart, toolStartTimes) {
+  if (!toolStartTimes.has(currPart.toolCallId)) {
+    toolStartTimes.set(currPart.toolCallId, Date.now());
+  }
+  const prev = prevPart !== void 0 && isToolLikePart(prevPart) ? prevPart : void 0;
+  if (prev !== void 0 && isSameToolState(prev, currPart)) return [];
+  const settled = TERMINAL_TOOL_STATES.includes(currPart.state);
+  const durationMs = settled ? Date.now() - (toolStartTimes.get(currPart.toolCallId) ?? Date.now()) : void 0;
   const base = {
+    id: `tool#${currPart.toolCallId}`,
     type: "tool",
-    toolName,
-    toolCallId: curr.toolCallId,
-    input: curr.input
+    toolCallId: currPart.toolCallId,
+    toolName: deriveToolName(currPart),
+    ...currPart.providerExecuted !== void 0 ? { providerExecuted: currPart.providerExecuted } : {},
+    ...durationMs !== void 0 ? { durationMs } : {}
   };
-  if (curr.state === "output-available") return [{ ...base, output: curr.output }];
-  if (curr.state === "output-error") return [{ ...base, output: { error: curr.errorText } }];
-  return [base];
+  switch (currPart.state) {
+    case "input-streaming":
+      return [
+        {
+          ...base,
+          state: "input-streaming",
+          ...currPart.input !== void 0 ? { input: currPart.input } : {}
+        }
+      ];
+    case "input-available":
+      return [{ ...base, state: "input-available", input: currPart.input }];
+    case "approval-requested":
+      return [
+        {
+          ...base,
+          state: "approval-requested",
+          input: currPart.input,
+          approval: currPart.approval
+        }
+      ];
+    case "approval-responded":
+      return [
+        {
+          ...base,
+          state: "approval-responded",
+          input: currPart.input,
+          approval: currPart.approval
+        }
+      ];
+    case "output-available":
+      return [
+        {
+          ...base,
+          state: "output-available",
+          input: currPart.input,
+          output: currPart.output,
+          ...currPart.preliminary !== void 0 ? { preliminary: currPart.preliminary } : {},
+          ...currPart.approval !== void 0 ? { approval: currPart.approval } : {}
+        }
+      ];
+    case "output-error": {
+      const rawInput = currPart.type === "dynamic-tool" ? void 0 : currPart.rawInput;
+      return [
+        {
+          ...base,
+          state: "output-error",
+          ...currPart.input !== void 0 ? { input: currPart.input } : {},
+          errorText: currPart.errorText,
+          ...rawInput !== void 0 ? { rawInput } : {},
+          ...currPart.approval !== void 0 ? { approval: currPart.approval } : {}
+        }
+      ];
+    }
+    case "output-denied":
+      return [
+        { ...base, state: "output-denied", input: currPart.input, approval: currPart.approval }
+      ];
+    default:
+      return assertNever(currPart);
+  }
 }
-function diffMessage(prev, curr) {
+function diffMessage(chatId, prev, curr, toolStartTimes) {
   const deltas = [];
   curr.parts.forEach((part, i) => {
-    deltas.push(...diffPart(prev?.parts[i], part));
+    deltas.push(...diffPart(chatId, i, prev?.parts[i], part, toolStartTimes));
   });
   return deltas;
 }
-async function* diffChunkStream(chunkStream, readStream, signal) {
+async function* diffChunkStream(chatId, chunkStream, readStream, signal) {
   let prev;
+  const toolStartTimes = /* @__PURE__ */ new Map();
   for await (const curr of readStream({ stream: chunkStream })) {
     if (signal?.aborted) return;
-    for (const part of diffMessage(prev, curr)) {
+    for (const part of diffMessage(chatId, prev, curr, toolStartTimes)) {
       yield part;
     }
     prev = curr;
@@ -73,8 +153,12 @@ function aiSdkTransport(options) {
   const resolveAiSdk = createAiSdkResolver(options);
   function makeTransport(chatId) {
     return {
+      // Every text/reasoning delta this transport emits carries an authoritative `offset` (see
+      // diffPart), so a replayed run rewrites in place instead of duplicating — the literal
+      // condition this assertion stands for.
+      idempotentReplay: true,
       async *stream(input, signal) {
-        yield { type: "start", runId: chatId, resumeToken: chatId };
+        yield { id: `${chatId}#start`, type: "start", runId: chatId, resumeToken: chatId };
         const { httpTransport, readUIMessageStream: readStream } = await resolveAiSdk();
         const userMessage = {
           id: crypto.randomUUID(),
@@ -88,13 +172,13 @@ function aiSdkTransport(options) {
           messageId: void 0,
           abortSignal: signal
         });
-        yield* diffChunkStream(chunkStream, readStream, signal);
+        yield* diffChunkStream(chatId, chunkStream, readStream, signal);
       },
       async *resume(resumeToken, signal) {
         const { httpTransport, readUIMessageStream: readStream } = await resolveAiSdk();
         const chunkStream = await httpTransport.reconnectToStream({ chatId: resumeToken });
         if (chunkStream === null) return;
-        yield* diffChunkStream(chunkStream, readStream, signal);
+        yield* diffChunkStream(resumeToken, chunkStream, readStream, signal);
       }
     };
   }

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

@@ -0,0 +1,42 @@
+/**
+ * coalesceParts — merges a rendered-turn's parts array for display.
+ *
+ * Merges consecutive `text`+`text` and `reasoning`+`reasoning` parts (streamed answers arrive as
+ * many small fragments; this renders a streaming reply as one flowing block instead of a stack of
+ * fragments). Merges `tool` parts BY `toolCallId` regardless of adjacency — the AI SDK re-emits a
+ * tool call's `input-available` then `output-available` as two separate parts, not necessarily
+ * adjacent once other parts interleave; without this rule a UI renders two stacked tool blocks for
+ * one call. The later state always wins; the merged part keeps the position of its FIRST
+ * occurrence (stable ordering); and an `input` (or `toolName`) supplied by an earlier state
+ * survives a later state that omits it — `tool-output-available` carries only `output` on the
+ * 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.
+ *
+ * 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'
+ * <PartList parts={coalesceParts(parts)} />
+ */
+import type { AgentPart } from './parts.js';
+export declare function coalesceParts<TPart extends AgentPart>(parts: readonly TPart[]): TPart[];
+//# sourceMappingURL=coalesce.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,137 @@
+function isTextLikeType(type) {
+  return type === "text" || type === "reasoning";
+}
+function resolveToolCallId(part, toolCallIdByApprovalId) {
+  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 (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 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 = [];
+  const toolIndexByCallId = /* @__PURE__ */ new Map();
+  const toolCallIdByApprovalId = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    if (isTextLikeType(part.type)) {
+      const last = out[out.length - 1];
+      if (last !== void 0 && last.type === part.type) {
+        const merged = {
+          ...part,
+          text: last.text + part.text
+        };
+        out[out.length - 1] = merged;
+        continue;
+      }
+      out.push(part);
+      continue;
+    }
+    if (part.type === "tool") {
+      const toolPart = part;
+      registerApprovalIndex(toolPart, toolCallIdByApprovalId);
+      const resolvedCallId = resolveToolCallId(toolPart, toolCallIdByApprovalId);
+      if (resolvedCallId === void 0) {
+        out.push(part);
+        continue;
+      }
+      const existingIndex = toolIndexByCallId.get(resolvedCallId);
+      if (existingIndex === void 0) {
+        toolIndexByCallId.set(resolvedCallId, out.length);
+        out.push(part);
+        continue;
+      }
+      const existing = out[existingIndex];
+      out[existingIndex] = mergeToolPart(existing, toolPart);
+      continue;
+    }
+    out.push(part);
+  }
+  return out;
+}
+export {
+  coalesceParts
+};

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.d.ts

@@ -0,0 +1,97 @@
+/**
+ * foreign.ts — the open half of the transcript's part-rendering registry.
+ *
+ * `AgentPart` (`./parts`) is a closed, exhaustively-switched union — adding a variant without
+ * updating every consuming switch is a tsc error (`PartList`'s `assertNever` gate). A transport
+ * that streams app-specific structured data (a chart spec, a progress ping) needs a part type
+ * `AgentPart` will never carry — closing the union around it would defeat the whole point of the
+ * gate. This file is the seam: `ForeignPart` describes what basalt does NOT know, `ConsumerPart`
+ * resolves the augmented union a consumer registers via `declare module 'basalt-ui'`, and
+ * `definePartRenderers` types an exhaustive renderer map against it. See
+ * `agent-chat/thread-message.tsx`'s three-step resolution order for how this plugs into
+ * `ThreadTranscript`: a consumer renderer wins first, `narrowAgentPart` routes the built-in six to
+ * `PartList`'s own exhaustive switch second, and `fallbackRenderer` catches anything left.
+ *
+ * @example
+ * // app-side: src/features/chat/parts.ts
+ * type ChartPart = { type: 'data-chart'; id: string; spec: ChartSpec }
+ * declare module 'basalt-ui' {
+ *   interface BasaltRegister { parts: ChartPart }
+ * }
+ * export const chatRenderers = definePartRenderers({
+ *   'data-chart': ({ part, settled }) => (settled ? <Chart spec={part.spec} /> : <ChartSkeleton />),
+ * })
+ */
+import type { ReactNode } from 'react';
+import type { BasaltRegister } from '../register.js';
+import type { ChatMessage } from './history.js';
+import type { AgentPart } from './parts.js';
+/** A part basalt does not know. NOT a member of AgentPart — the built-in union stays closed. */
+export type ForeignPart = {
+    readonly type: string;
+    readonly id: string;
+    readonly [k: string]: unknown;
+};
+/** What a transcript actually holds — basalt's own six variants plus anything a consumer registers. */
+export type TranscriptPart = AgentPart | ForeignPart;
+/** The consumer's registered foreign-part union, or `never` when un-augmented. */
+export type ConsumerPart = BasaltRegister extends {
+    parts: infer P extends ForeignPart;
+} ? P : never;
+/**
+ * Un-augmented: a loose string-keyed map (any renderer, any key — there is nothing to check
+ * against). Augmented: a MISSING key is a tsc error (`definePartRenderers` requires the full
+ * registered union), and each renderer's `part` is narrowed to exactly its variant. Same
+ * bound-check mechanism as `SeriesKey` (`register.ts:26-58`), applied to a union instead of a map.
+ *
+ * NOT caught: a STALE (extra, unregistered) key. `<const T extends Constraint>` inference does
+ * not excess-property-check an object-literal argument the way a direct assignment to a fixed
+ * target type would (verified against this repo's tsc — see
+ * `apps/playground/src/demo/agent-part-registry.type-guard.ts`'s Fixture 3) — an extra key
+ * compiles as dead code rather than erroring. Catching it would need an `Exact<T, Shape>`-style
+ * wrapper that departs from the `spec: T` "canonical token-factory contract" every other `defineX`
+ * in this codebase follows verbatim; that trade was left as a documented gap rather than a one-off
+ * factory shape.
+ */
+export type PartRenderers = [ConsumerPart] extends [never] ? Readonly<Record<string, PartRenderer<ForeignPart>>> : {
+    readonly [K in ConsumerPart['type']]: PartRenderer<Extract<ConsumerPart, {
+        type: K;
+    }>>;
+};
+/** Everything a foreign-part renderer needs beyond the part itself. */
+export type PartRenderContext<TPart = ForeignPart> = {
+    readonly part: TPart;
+    readonly messageId: string;
+    readonly partId: string;
+    /** false while this part belongs to the in-flight tail of a streaming turn. */
+    readonly settled: boolean;
+    readonly role: ChatMessage['role'];
+};
+export type PartRenderer<TPart = ForeignPart> = (ctx: PartRenderContext<TPart>) => ReactNode;
+/**
+ * Canonical const-generic factory (`packages/basalt-ui/CLAUDE.md`, "Canonical token-factory
+ * contract") — identity passthrough, exact-keyed return, no builder, no config bag. Mirrors
+ * `defineSeries` (`tokens/index.ts:648-650`) and `defineNotifications`
+ * (`notifications/define-notifications.ts:112-115`).
+ *
+ * @example
+ * const chatRenderers = definePartRenderers({
+ *   'data-chart': ({ part }) => <Chart spec={part.spec} />,
+ * })
+ */
+export declare function definePartRenderers<const T extends PartRenderers>(map: T): T;
+/**
+ * Returns `part` as an `AgentPart` when its `type` is one of the six built-in variants, else
+ * `null`. Deliberately NOT routed through `parseAgentPart`: that function is a VALIDATING parser
+ * for untrusted wire data — it checks every field a variant requires (`runId`, `toolCallId`,
+ * `approval`, ...) and would reject an already-well-typed in-memory `AgentPart` on shape grounds
+ * if it doesn't happen to match the wire representation byte-for-byte. `narrowAgentPart` is the
+ * cheap complement: a plain discriminator check on a value already known to be a `TranscriptPart`,
+ * used purely to route rendering — it trusts the caller's typing rather than re-validating it.
+ *
+ * @example
+ * const agentPart = narrowAgentPart(part)
+ * if (agentPart !== null) return <PartList parts={[agentPart]} />
+ */
+export declare function narrowAgentPart(part: TranscriptPart): AgentPart | null;
+//# sourceMappingURL=foreign.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"foreign.d.ts","sourceRoot":"","sources":["../../src/agent/foreign.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAIxC,gGAAgG;AAChG,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAC9B,CAAA;AAED,uGAAuG;AACvG,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,WAAW,CAAA;AAuBpD,kFAAkF;AAClF,MAAM,MAAM,YAAY,GAAG,cAAc,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC,SAAS,WAAW,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAA;AAIpG;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,CAAC,GACtD,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,GACnD;IAAE,QAAQ,EAAE,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,YAAY,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,CAAC;CAAE,CAAA;AAE9F,uEAAuE;AACvE,MAAM,MAAM,iBAAiB,CAAC,KAAK,GAAG,WAAW,IAAI;IACnD,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,YAAY,CAAC,KAAK,GAAG,WAAW,IAAI,CAAC,GAAG,EAAE,iBAAiB,CAAC,KAAK,CAAC,KAAK,SAAS,CAAA;AAE5F;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,CAAC,CAAC,SAAS,aAAa,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAE5E;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,GAAG,IAAI,CAEtE"}

package/dist/agent/foreign.js

@@ -0,0 +1,18 @@
+function definePartRenderers(map) {
+  return map;
+}
+const AGENT_PART_TYPES = /* @__PURE__ */ new Set([
+  "start",
+  "text",
+  "reasoning",
+  "tool",
+  "source",
+  "error"
+]);
+function narrowAgentPart(part) {
+  return AGENT_PART_TYPES.has(part.type) ? part : null;
+}
+export {
+  definePartRenderers,
+  narrowAgentPart
+};

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/history.d.ts

@@ -16,6 +16,8 @@ export type ChatMessage<TPart = AgentPart> = {
     readonly role: 'user' | 'assistant';
     readonly parts: TPart[];
     readonly createdAt: number;
+    /** How the turn ended. Absent on user messages and on pre-1.11 persisted assistant messages. */
+    readonly finish?: 'complete' | 'stopped' | 'error';
 };
 export type ChatHistoryStoreOptions = {
     /** localStorage key (namespaced as `basalt:<key>`). Stable — changes key lose history. */

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

@@ -1 +1 @@
-{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/agent/history.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAIxC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,KAAK,GAAG,SAAS,IAAI;IAC3C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAA;IACnC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B,CAAA;AAID,MAAM,MAAM,uBAAuB,GAAG;IACpC,0FAA0F;IAC1F,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,wFAAwF;IACxF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAID,MAAM,MAAM,gBAAgB,CAAC,KAAK,GAAG,SAAS,IAAI;IAChD,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAA;IACvC,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC,KAAK,CAAC,KAAK,IAAI,CAAA;IACtD,0BAA0B;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;CAC3B,CAAA;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,GAAG,SAAS,EACtD,IAAI,EAAE,uBAAuB,GAC5B,MAAM,gBAAgB,CAAC,KAAK,CAAC,CAoC/B"}
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/agent/history.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAIxC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,KAAK,GAAG,SAAS,IAAI;IAC3C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAA;IACnC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,gGAAgG;IAChG,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAAA;CACnD,CAAA;AAID,MAAM,MAAM,uBAAuB,GAAG;IACpC,0FAA0F;IAC1F,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,wFAAwF;IACxF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAID,MAAM,MAAM,gBAAgB,CAAC,KAAK,GAAG,SAAS,IAAI;IAChD,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAA;IACvC,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC,KAAK,CAAC,KAAK,IAAI,CAAA;IACtD,0BAA0B;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;CAC3B,CAAA;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,GAAG,SAAS,EACtD,IAAI,EAAE,uBAAuB,GAC5B,MAAM,gBAAgB,CAAC,KAAK,CAAC,CAoC/B"}

package/dist/agent/id.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 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.
+ *
+ * A transport is allowed to yield a draft (`AgentPartDraft` — `id` optional); this wraps such a
+ * generator and normalizes it into a fully-identified stream, minting `${runId}#${n}` for any
+ * part that arrives without an `id`. A part that already carries an id passes through untouched
+ * (idempotent) and does not advance the counter.
+ *
+ * NOT a replay-convergence mechanism. The minted id is a bare per-call sequence number with no
+ * relationship to content or offset — it identifies "the nth id-less part THIS invocation saw",
+ * nothing more. Calling `withPartIds` again over a resumed/replayed stream restarts its counter at
+ * 0, so the resumed stream's first delta mints the SAME id as the original run's first delta
+ * (`${runId}#0`) regardless of whether it carries the same content — if the resumed transport
+ * re-sends the full text as one chunk while the original sent it as several deltas, mergePart's
+ * tail-splice will corrupt the accumulated text rather than converge it. A transport that needs
+ * genuine replay convergence (one asserting `ResumableAgentTransport`'s `idempotentReplay: true`)
+ * MUST mint its own content-stable ids — e.g. `aiSdkTransport`'s `${chatId}#${index}` /
+ * `tool#${toolCallId}` — and must not rely on this helper for that guarantee. Combining
+ * `withPartIds` with a transport that asserts `idempotentReplay: true` is only safe when that
+ * transport already mints stable ids itself, in which case every part already carries an `id` and
+ * `withPartIds` is a no-op passthrough (see the idempotent behavior above) — it is never the thing
+ * providing replay safety.
+ *
+ * @example
+ * const identified = withPartIds(runId, transport.stream(input, signal))
+ * for await (const part of identified) {
+ *   // part.id is always defined here
+ * }
+ */
+export declare function withPartIds<TPart extends {
+    id?: string;
+}>(runId: string, source: AsyncGenerator<TPart>): AsyncGenerator<TPart & {
+    id: string;
+}>;
+//# sourceMappingURL=id.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../src/agent/id.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAgBrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAuB,WAAW,CAAC,KAAK,SAAS;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,EAC9D,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,GAC5B,cAAc,CAAC,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAUxC"}

package/dist/agent/id.js

@@ -0,0 +1,30 @@
+function mintThreadId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    const hex = Array.from({ length: 16 }, (_, i) => {
+      const raw = bytes.at(i) ?? 0;
+      const byte = i === 6 ? raw & 15 | 64 : i === 8 ? raw & 63 | 128 : raw;
+      return byte.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)}`;
+  }
+  return `id-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+async function* withPartIds(runId, source) {
+  let n = 0;
+  for await (const part of source) {
+    if (part.id !== void 0) {
+      yield part;
+      continue;
+    }
+    yield { ...part, id: `${runId}#${n}` };
+    n += 1;
+  }
+}
+export {
+  mintThreadId,
+  withPartIds
+};

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

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

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

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