@assistant-ui/core 0.3.18 → 0.3.20

package/dist/utils/silent-runtime-action.d.ts

@@ -1,6 +1,5 @@
 //#region src/utils/silent-runtime-action.d.ts
-declare const SILENT_RUNTIME_ACTION: unique symbol;
-declare const isSilentRuntimeAction: (error: unknown) => boolean;
+export declare const SILENT_RUNTIME_ACTION: unique symbol;
+export declare const isSilentRuntimeAction: (error: unknown) => boolean;
 //#endregion
-export { SILENT_RUNTIME_ACTION, isSilentRuntimeAction };
 //# sourceMappingURL=silent-runtime-action.d.ts.map

package/dist/utils/silent-runtime-action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"silent-runtime-action.d.ts","names":[],"sources":["../../src/utils/silent-runtime-action.ts"],"mappings":";cAAa;cAIA,wBAAyB"}
+{"version":3,"file":"silent-runtime-action.d.ts","names":[],"sources":["../../src/utils/silent-runtime-action.ts"],"mappings":";qBAAa;qBAIA,wBAAyB"}

package/dist/utils/text.d.ts

@@ -1,6 +1,5 @@
 import { AppendMessage, ThreadMessage } from "../types/message.js";
 //#region src/utils/text.d.ts
-declare const getThreadMessageText: (message: ThreadMessage | AppendMessage) => string;
+export declare const getThreadMessageText: (message: ThreadMessage | AppendMessage) => string;
 //#endregion
-export { getThreadMessageText };
 //# sourceMappingURL=text.d.ts.map

package/dist/utils/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","names":[],"sources":["../../src/utils/text.ts"],"mappings":";;cAGa,uBACX,SAAS,gBAAgB"}
+{"version":3,"file":"text.d.ts","names":[],"sources":["../../src/utils/text.ts"],"mappings":";;qBAGa,uBACX,SAAS,gBAAgB"}

package/dist/utils/wire-media.d.ts

@@ -8,7 +8,7 @@
  * for a url source and whenever inline bytes fail to sniff, so it fails exactly
  * where a fallback is needed.
  */
-declare function resolveImageMediaType(image: string, contentType?: string | undefined): string;
+export declare function resolveImageMediaType(image: string, contentType?: string | undefined): string;
 /**
  * The media type to declare for a `FileMessagePart`: its own `mimeType`, then
  * the payload's data URL declaration, then `application/octet-stream`.
@@ -16,7 +16,7 @@ declare function resolveImageMediaType(image: string, contentType?: string | und
  * `mimeType` is a plain string, and an adapter reading `file.type` on a file
  * the OS cannot type yields `""`, so the declared value is not always present.
  */
-declare function resolveFileMediaType(data: string, mimeType?: string | undefined): string;
+export declare function resolveFileMediaType(data: string, mimeType?: string | undefined): string;
 /**
  * A payload placed into a wire field that is contractually a url.
  *
@@ -29,7 +29,6 @@ declare function resolveFileMediaType(data: string, mimeType?: string | undefine
  * cannot be corrected without transcoding the payload and is authoritative for
  * the bytes it carries anyway.
  */
-declare function toMediaWireUrl(payload: string, mediaType: string): string;
+export declare function toMediaWireUrl(payload: string, mediaType: string): string;
 //#endregion
-export { resolveFileMediaType, resolveImageMediaType, toMediaWireUrl };
 //# sourceMappingURL=wire-media.d.ts.map

package/dist/utils/wire-media.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wire-media.d.ts","names":[],"sources":["../../src/utils/wire-media.ts"],"mappings":";;;;;;;;;;iBAYgB,sBACd,eACA;;;;;;;;iBA2Bc,qBACd,cACA;;;;;;;;;;;;;iBAiBc,eAAe,iBAAiB"}
+{"version":3,"file":"wire-media.d.ts","names":[],"sources":["../../src/utils/wire-media.ts"],"mappings":";;;;;;;;;;wBAYgB,sBACd,eACA;;;;;;;;wBA+Bc,qBACd,cACA;;;;;;;;;;;;;wBAiBc,eAAe,iBAAiB"}

package/dist/utils/wire-media.js

@@ -11,9 +11,9 @@ import { detectImageMediaType } from "./image-media-type.js";
 * where a fallback is needed.
 */
 function resolveImageMediaType(image, contentType) {
-	if (contentType?.startsWith("image/")) return contentType;
+	if (contentType?.startsWith("image/") && !contentType.includes("*")) return contentType;
 	const declared = dataUrlMediaType(image);
-	if (declared?.startsWith("image/")) return declared;
+	if (declared?.startsWith("image/") && !declared.includes("*")) return declared;
 	const payload = parseDataUrl(image)?.data ?? (isParsableUrl(image) ? void 0 : image);
 	if (payload !== void 0) {
 		const sniffed = detectImageMediaType(payload);

package/dist/utils/wire-media.js.map

@@ -1 +1 @@
-{"version":3,"file":"wire-media.js","names":["dataUrlMediaType","isParsableUrl","parseDataUrl","detectImageMediaType","resolveImageMediaType","image","contentType","startsWith","declared","parsed","payload","data","undefined","sniffed","resolveFileMediaType","mimeType","toMediaWireUrl","mediaType"],"sources":["../../src/utils/wire-media.ts"],"sourcesContent":["import { dataUrlMediaType, isParsableUrl, parseDataUrl } from \"./data-url\";\nimport { detectImageMediaType } from \"./image-media-type\";\n\n/**\n * The media type to declare for an `ImageMessagePart`, which carries none of\n * its own: an attachment's content type, then the payload's data URL\n * declaration, then its leading bytes, then `image/png`.\n *\n * The floor cannot be a wildcard. `image/*` is rejected outright by the AI SDK\n * for a url source and whenever inline bytes fail to sniff, so it fails exactly\n * where a fallback is needed.\n */\nexport function resolveImageMediaType(\n  image: string,\n  contentType?: string | undefined,\n): string {\n  if (contentType?.startsWith(\"image/\")) return contentType;\n\n  const declared = dataUrlMediaType(image);\n  if (declared?.startsWith(\"image/\")) return declared;\n\n  // Read through a data URL envelope too, so a generic one such as\n  // `application/octet-stream` does not mask the format. A url of any other\n  // scheme has no local bytes to read.\n  const parsed = parseDataUrl(image);\n  const payload = parsed?.data ?? (isParsableUrl(image) ? undefined : image);\n  if (payload !== undefined) {\n    const sniffed = detectImageMediaType(payload);\n    if (sniffed) return sniffed;\n  }\n\n  return \"image/png\";\n}\n\n/**\n * The media type to declare for a `FileMessagePart`: its own `mimeType`, then\n * the payload's data URL declaration, then `application/octet-stream`.\n *\n * `mimeType` is a plain string, and an adapter reading `file.type` on a file\n * the OS cannot type yields `\"\"`, so the declared value is not always present.\n */\nexport function resolveFileMediaType(\n  data: string,\n  mimeType?: string | undefined,\n): string {\n  return mimeType || dataUrlMediaType(data) || \"application/octet-stream\";\n}\n\n/**\n * A payload placed into a wire field that is contractually a url.\n *\n * Two hazards drive this. A consumer may hand the value to an unguarded\n * `new URL()`, so a payload that is not a url has to be wrapped; and a data\n * URL's own media type wins over a separately declared one downstream, so a\n * base64 envelope that disagrees with `mediaType` is rebuilt around the same\n * bytes. Everything else passes through byte for byte: an envelope that agrees,\n * a url of any other scheme, and a percent-encoded data URL, whose declaration\n * cannot be corrected without transcoding the payload and is authoritative for\n * the bytes it carries anyway.\n */\nexport function toMediaWireUrl(payload: string, mediaType: string): string {\n  const parsed = parseDataUrl(payload);\n  if (parsed) {\n    return parsed.mimeType === mediaType\n      ? payload\n      : `data:${mediaType};base64,${parsed.data}`;\n  }\n  if (isParsableUrl(payload)) return payload;\n  return `data:${mediaType};base64,${payload}`;\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgBI,sBACdC,OACAC,aACQ;CACR,IAAIA,aAAaC,WAAW,QAAQ,GAAG,OAAOD;CAE9C,MAAME,WAAWR,iBAAiBK,KAAK;CACvC,IAAIG,UAAUD,WAAW,QAAQ,GAAG,OAAOC;CAM3C,MAAME,UADSR,aAAaG,KACZI,CAAM,EAAEE,SAASV,cAAcI,KAAK,IAAIO,KAAAA,IAAYP;CACpE,IAAIK,YAAYE,KAAAA,GAAW;EACzB,MAAMC,UAAUV,qBAAqBO,OAAO;EAC5C,IAAIG,SAAS,OAAOA;CACtB;CAEA,OAAO;AACT;;;;;;;;AASA,SAAgBC,qBACdH,MACAI,UACQ;CACR,OAAOA,YAAYf,iBAAiBW,IAAI,KAAK;AAC/C;;;;;;;;;;;;;AAcA,SAAgBK,eAAeN,SAAiBO,WAA2B;CACzE,MAAMR,SAASP,aAAaQ,OAAO;CACnC,IAAID,QACF,OAAOA,OAAOM,aAAaE,YACvBP,UACA,QAAQO,UAAS,UAAWR,OAAOE;CAEzC,IAAIV,cAAcS,OAAO,GAAG,OAAOA;CACnC,OAAO,QAAQO,UAAS,UAAWP;AACrC"}
+{"version":3,"file":"wire-media.js","names":["dataUrlMediaType","isParsableUrl","parseDataUrl","detectImageMediaType","resolveImageMediaType","image","contentType","startsWith","includes","declared","parsed","payload","data","undefined","sniffed","resolveFileMediaType","mimeType","toMediaWireUrl","mediaType"],"sources":["../../src/utils/wire-media.ts"],"sourcesContent":["import { dataUrlMediaType, isParsableUrl, parseDataUrl } from \"./data-url\";\nimport { detectImageMediaType } from \"./image-media-type\";\n\n/**\n * The media type to declare for an `ImageMessagePart`, which carries none of\n * its own: an attachment's content type, then the payload's data URL\n * declaration, then its leading bytes, then `image/png`.\n *\n * The floor cannot be a wildcard. `image/*` is rejected outright by the AI SDK\n * for a url source and whenever inline bytes fail to sniff, so it fails exactly\n * where a fallback is needed.\n */\nexport function resolveImageMediaType(\n  image: string,\n  contentType?: string | undefined,\n): string {\n  if (contentType?.startsWith(\"image/\") && !contentType.includes(\"*\")) {\n    return contentType;\n  }\n\n  const declared = dataUrlMediaType(image);\n  if (declared?.startsWith(\"image/\") && !declared.includes(\"*\")) {\n    return declared;\n  }\n\n  // Read through a data URL envelope too, so a generic one such as\n  // `application/octet-stream` does not mask the format. A url of any other\n  // scheme has no local bytes to read.\n  const parsed = parseDataUrl(image);\n  const payload = parsed?.data ?? (isParsableUrl(image) ? undefined : image);\n  if (payload !== undefined) {\n    const sniffed = detectImageMediaType(payload);\n    if (sniffed) return sniffed;\n  }\n\n  return \"image/png\";\n}\n\n/**\n * The media type to declare for a `FileMessagePart`: its own `mimeType`, then\n * the payload's data URL declaration, then `application/octet-stream`.\n *\n * `mimeType` is a plain string, and an adapter reading `file.type` on a file\n * the OS cannot type yields `\"\"`, so the declared value is not always present.\n */\nexport function resolveFileMediaType(\n  data: string,\n  mimeType?: string | undefined,\n): string {\n  return mimeType || dataUrlMediaType(data) || \"application/octet-stream\";\n}\n\n/**\n * A payload placed into a wire field that is contractually a url.\n *\n * Two hazards drive this. A consumer may hand the value to an unguarded\n * `new URL()`, so a payload that is not a url has to be wrapped; and a data\n * URL's own media type wins over a separately declared one downstream, so a\n * base64 envelope that disagrees with `mediaType` is rebuilt around the same\n * bytes. Everything else passes through byte for byte: an envelope that agrees,\n * a url of any other scheme, and a percent-encoded data URL, whose declaration\n * cannot be corrected without transcoding the payload and is authoritative for\n * the bytes it carries anyway.\n */\nexport function toMediaWireUrl(payload: string, mediaType: string): string {\n  const parsed = parseDataUrl(payload);\n  if (parsed) {\n    return parsed.mimeType === mediaType\n      ? payload\n      : `data:${mediaType};base64,${parsed.data}`;\n  }\n  if (isParsableUrl(payload)) return payload;\n  return `data:${mediaType};base64,${payload}`;\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgBI,sBACdC,OACAC,aACQ;CACR,IAAIA,aAAaC,WAAW,QAAQ,KAAK,CAACD,YAAYE,SAAS,GAAG,GAChE,OAAOF;CAGT,MAAMG,WAAWT,iBAAiBK,KAAK;CACvC,IAAII,UAAUF,WAAW,QAAQ,KAAK,CAACE,SAASD,SAAS,GAAG,GAC1D,OAAOC;CAOT,MAAME,UADST,aAAaG,KACZK,CAAM,EAAEE,SAASX,cAAcI,KAAK,IAAIQ,KAAAA,IAAYR;CACpE,IAAIM,YAAYE,KAAAA,GAAW;EACzB,MAAMC,UAAUX,qBAAqBQ,OAAO;EAC5C,IAAIG,SAAS,OAAOA;CACtB;CAEA,OAAO;AACT;;;;;;;;AASA,SAAgBC,qBACdH,MACAI,UACQ;CACR,OAAOA,YAAYhB,iBAAiBY,IAAI,KAAK;AAC/C;;;;;;;;;;;;;AAcA,SAAgBK,eAAeN,SAAiBO,WAA2B;CACzE,MAAMR,SAASR,aAAaS,OAAO;CACnC,IAAID,QACF,OAAOA,OAAOM,aAAaE,YACvBP,UACA,QAAQO,UAAS,UAAWR,OAAOE;CAEzC,IAAIX,cAAcU,OAAO,GAAG,OAAOA;CACnC,OAAO,QAAQO,UAAS,UAAWP;AACrC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/core",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "description": "Framework-agnostic core runtime for assistant-ui",
   "keywords": [
     "assistant",
@@ -59,18 +59,18 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.42",
+    "assistant-stream": "^0.3.44",
     "nanoid": "^6.0.1"
   },
   "optionalDevDependencies": {
     "@assistant-ui/x-generative-compiler": ">=0.0.3"
   },
   "peerDependencies": {
-    "@assistant-ui/store": "^0.3.13",
-    "@assistant-ui/tap": "^0.9.17",
+    "@assistant-ui/store": "^0.3.14",
+    "@assistant-ui/tap": "^0.9.18",
     "@types/react": "*",
     "react": "^18 || ^19",
-    "assistant-cloud": "^0.2.0"
+    "assistant-cloud": "^0.2.1"
   },
   "peerDependenciesMeta": {
     "@types/react": {
@@ -84,17 +84,17 @@
     }
   },
   "devDependencies": {
-    "@assistant-ui/store": "0.3.13",
-    "@assistant-ui/tap": "0.9.17",
-    "@assistant-ui/vite": "0.0.17",
-    "@assistant-ui/x-buildutils": "0.0.26",
+    "@assistant-ui/store": "0.3.14",
+    "@assistant-ui/tap": "0.9.18",
+    "@assistant-ui/vite": "0.0.18",
+    "@assistant-ui/x-buildutils": "0.0.28",
     "@testing-library/react": "^16.3.3",
-    "@types/react": "^19.2.18",
-    "assistant-cloud": "0.2.0",
+    "@types/react": "^19.3.0",
+    "assistant-cloud": "0.2.2",
     "jsdom": "^30.0.1",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "vitest": "^4.1.11"
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "vitest": "^5.0.1"
   },
   "publishConfig": {
     "access": "public",
@@ -112,6 +112,7 @@
   "scripts": {
     "build": "aui-build",
     "test": "vitest run",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
     "test:react-compiler": "vitest run --config vitest.react-compiler.config.ts",
     "test:watch": "vitest"
   }

package/src/adapters/attachment.ts

@@ -83,6 +83,13 @@ export const getFileDataURL = async (file: File): Promise<string> => {
   });
 };
 
+const escapeAttachmentName = (name: string) =>
+  name
+    .replaceAll("&", "&amp;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+
 export class SimpleTextAttachmentAdapter implements AttachmentAdapter {
   public accept =
     "text/plain,text/html,text/markdown,text/csv,text/xml,text/json,application/json,text/css";
@@ -107,7 +114,7 @@ export class SimpleTextAttachmentAdapter implements AttachmentAdapter {
       content: [
         {
           type: "text",
-          text: `<attachment name=${attachment.name}>\n${await getFileText(attachment.file)}\n</attachment>`,
+          text: `<attachment name="${escapeAttachmentName(attachment.name)}">\n${await getFileText(attachment.file)}\n</attachment>`,
         },
       ],
     };

package/src/adapters/feedback.ts

@@ -3,6 +3,7 @@ import type { ThreadMessage } from "../types/message";
 type FeedbackAdapterFeedback = {
   message: ThreadMessage;
   type: "positive" | "negative";
+  comment?: string;
 };
 
 export type FeedbackAdapter = {

package/src/adapters/speech.test.ts

@@ -7,6 +7,62 @@ afterEach(() => {
 });
 
 describe("WebSpeechSynthesisAdapter", () => {
+  const stubSpeechSynthesis = () => {
+    const utterances: EventTarget[] = [];
+    class MockSpeechSynthesisUtterance extends EventTarget {
+      constructor() {
+        super();
+        utterances.push(this);
+      }
+    }
+    const cancel = vi.fn();
+    vi.stubGlobal("SpeechSynthesisUtterance", MockSpeechSynthesisUtterance);
+    vi.stubGlobal("window", { speechSynthesis: { speak: vi.fn(), cancel } });
+    return { utterances, cancel };
+  };
+
+  it.each(["end", "error"])(
+    "does not cancel newer playback through a handle that received %s",
+    (event) => {
+      const { utterances, cancel } = stubSpeechSynthesis();
+      const adapter = new WebSpeechSynthesisAdapter();
+      const old = adapter.speak("old");
+      utterances[0]!.dispatchEvent(new Event(event));
+      const endedStatus = old.status;
+      const current = adapter.speak("current");
+
+      old.cancel();
+      old.cancel();
+
+      expect(cancel).not.toHaveBeenCalled();
+      expect(old.status).toBe(endedStatus);
+      expect(current.status).toEqual({ type: "running" });
+    },
+  );
+
+  it("cancels active playback once and leaves later playback alone", () => {
+    const { cancel } = stubSpeechSynthesis();
+    const adapter = new WebSpeechSynthesisAdapter();
+    const old = adapter.speak("old");
+    const onChange = vi.fn();
+    old.subscribe(onChange);
+
+    old.cancel();
+
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(old.status).toMatchObject({ type: "ended", reason: "cancelled" });
+    expect(onChange).toHaveBeenCalledOnce();
+
+    const current = adapter.speak("current");
+    old.cancel();
+
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(onChange).toHaveBeenCalledOnce();
+    expect(current.status).toEqual({ type: "running" });
+    current.cancel();
+    expect(cancel).toHaveBeenCalledTimes(2);
+  });
+
   it("isolates a late subscriber that throws after the utterance ended", async () => {
     const listeners = new Map<string, EventListener>();
     class MockSpeechSynthesisUtterance {
@@ -109,6 +165,186 @@ describe("WebSpeechDictationAdapter", () => {
     return listeners;
   };
 
+  const emitResults = (
+    listeners: Map<string, EventListener>,
+    results: [transcript: string, isFinal: boolean][],
+    resultIndex = 0,
+  ) => {
+    listeners.get("result")!({
+      resultIndex,
+      results: results.map(([transcript, isFinal]) => ({
+        0: { transcript },
+        isFinal,
+      })),
+    } as unknown as Event);
+  };
+
+  it("publishes the entire interim suffix when only its last result changes", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    session.onSpeech(onSpeech);
+
+    emitResults(listeners, [
+      ["hello ", false],
+      ["world", false],
+    ]);
+    emitResults(
+      listeners,
+      [
+        ["hello ", false],
+        ["there", false],
+      ],
+      1,
+    );
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello world", isFinal: false }],
+      [{ transcript: "hello there", isFinal: false }],
+    ]);
+  });
+
+  it("publishes partial and complete retractions with no changed results", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    session.onSpeech(onSpeech);
+
+    emitResults(listeners, [
+      ["hello ", false],
+      ["world", false],
+    ]);
+    emitResults(listeners, [["hello ", false]], 1);
+    emitResults(listeners, []);
+    emitResults(listeners, []);
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello world", isFinal: false }],
+      [{ transcript: "hello ", isFinal: false }],
+      [{ transcript: "", isFinal: false }],
+    ]);
+  });
+
+  it("delivers changed final results once before the remaining interim suffix", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    const onEnd = vi.fn();
+    session.onSpeech(onSpeech);
+    session.onSpeechEnd(onEnd);
+
+    emitResults(listeners, [
+      ["hello ", true],
+      ["wor", false],
+      ["ld", false],
+    ]);
+    emitResults(
+      listeners,
+      [
+        ["hello ", true],
+        ["world", true],
+      ],
+      1,
+    );
+    listeners.get("end")!(new Event("end"));
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello ", isFinal: true }],
+      [{ transcript: "world", isFinal: false }],
+      [{ transcript: "world", isFinal: true }],
+    ]);
+    expect(onEnd).toHaveBeenCalledExactlyOnceWith({
+      transcript: "hello world",
+    });
+  });
+
+  it("clears an interim suffix while retaining earlier final results", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    session.onSpeech(onSpeech);
+
+    emitResults(listeners, [
+      ["hello ", true],
+      ["world", false],
+    ]);
+    emitResults(listeners, [["hello ", true]], 1);
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello ", isFinal: true }],
+      [{ transcript: "world", isFinal: false }],
+      [{ transcript: "", isFinal: false }],
+    ]);
+  });
+
+  it("keeps final-only delivery free of empty interim updates", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    session.onSpeech(onSpeech);
+
+    emitResults(listeners, [["hello", true]]);
+    emitResults(listeners, [["hello", true]], 1);
+
+    expect(onSpeech).toHaveBeenCalledExactlyOnceWith({
+      transcript: "hello",
+      isFinal: true,
+    });
+  });
+
+  it("does not drop an unconsumed final when resultIndex skips it", () => {
+    const listeners = stubSpeechRecognition();
+    const session = new WebSpeechDictationAdapter().listen();
+    const onSpeech = vi.fn();
+    const onEnd = vi.fn();
+    session.onSpeech(onSpeech);
+    session.onSpeechEnd(onEnd);
+
+    emitResults(listeners, [["hello ", false]]);
+    emitResults(
+      listeners,
+      [
+        ["hello ", true],
+        ["world", false],
+      ],
+      1,
+    );
+    listeners.get("end")!(new Event("end"));
+
+    expect(onSpeech.mock.calls).toEqual([
+      [{ transcript: "hello ", isFinal: false }],
+      [{ transcript: "hello ", isFinal: true }],
+      [{ transcript: "world", isFinal: false }],
+    ]);
+    expect(onEnd).toHaveBeenCalledExactlyOnceWith({ transcript: "hello " });
+  });
+
+  it("does not reread historical finalized results during interim updates", () => {
+    const listeners = stubSpeechRecognition();
+    new WebSpeechDictationAdapter().listen();
+    const readFinal = vi.fn(() => ({ transcript: "word " }));
+    const finals = Array.from({ length: 1_000 }, () => ({
+      get 0() {
+        return readFinal();
+      },
+      isFinal: true,
+    }));
+    listeners.get("result")!({
+      resultIndex: 0,
+      results: finals,
+    } as unknown as Event);
+    expect(readFinal).toHaveBeenCalledTimes(1_000);
+
+    for (const transcript of ["hel", "hello", "hello world"]) {
+      listeners.get("result")!({
+        resultIndex: finals.length,
+        results: [...finals, { 0: { transcript }, isFinal: false }],
+      } as unknown as Event);
+    }
+
+    expect(readFinal).toHaveBeenCalledTimes(1_000);
+  });
+
   it("continues notifying dictation listeners when one throws", () => {
     const listeners = stubSpeechRecognition();
     const listenerError = new Error("listener failed");

package/src/adapters/speech.ts

@@ -76,6 +76,7 @@ export class WebSpeechSynthesisAdapter implements SpeechSynthesisAdapter {
     const res: SpeechSynthesisAdapter.Utterance = {
       status: { type: "running" },
       cancel: () => {
+        if (res.status.type === "ended") return;
         window.speechSynthesis.cancel();
         handleEnd("cancelled");
       },
@@ -205,6 +206,8 @@ export class WebSpeechDictationAdapter implements DictationAdapter {
     >();
 
     let finalTranscript = "";
+    let hasInterimTranscript = false;
+    let firstInterimIndex = 0;
 
     const session: DictationAdapter.Session = {
       status: { type: "starting" },
@@ -267,32 +270,36 @@ export class WebSpeechDictationAdapter implements DictationAdapter {
 
     recognition.addEventListener("result", (event) => {
       const speechEvent = event as unknown as SpeechRecognitionEvent;
+      let interimTranscript = "";
 
-      for (
-        let i = speechEvent.resultIndex;
-        i < speechEvent.results.length;
-        i++
-      ) {
+      for (let i = firstInterimIndex; i < speechEvent.results.length; i++) {
         const result = speechEvent.results[i];
         if (!result) continue;
 
         const transcript = result[0]?.transcript ?? "";
 
         if (result.isFinal) {
+          firstInterimIndex = i + 1;
           finalTranscript += transcript;
+          hasInterimTranscript = false;
           notifyEventListeners(
             speechCallbacks,
             () => ({ transcript, isFinal: true }),
             "Dictation",
           );
         } else {
-          notifyEventListeners(
-            speechCallbacks,
-            () => ({ transcript, isFinal: false }),
-            "Dictation",
-          );
+          interimTranscript += transcript;
         }
       }
+
+      if (interimTranscript || hasInterimTranscript) {
+        hasInterimTranscript = interimTranscript.length > 0;
+        notifyEventListeners(
+          speechCallbacks,
+          () => ({ transcript: interimTranscript, isFinal: false }),
+          "Dictation",
+        );
+      }
     });
 
     recognition.addEventListener("speechend", () => {

package/src/adapters/thread-history.ts

@@ -7,6 +7,7 @@ import type {
   ExportedMessageRepositoryItem,
 } from "../runtime/utils/message-repository";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import type { ThreadMessage } from "../types";
 
 export interface MessageStorageEntry<TPayload> {
   id: string;
@@ -52,6 +53,8 @@ export type GenericThreadHistoryAdapter<TMessage> = {
     options?: {
       durationMs?: number;
       stepTimestamps?: { start_ms: number; end_ms: number }[];
+      /** The thread message the items were persisted from; its status and timing complete a report the stored format cannot carry. */
+      message?: ThreadMessage;
     },
   ): void;
 };

package/src/index.ts

@@ -40,6 +40,7 @@ export type {
   MessageStatus,
   // Thread messages
   MessageTiming,
+  MessageModality,
   ThreadStep,
   ThreadSystemMessage,
   ThreadUserMessage,