@runtypelabs/persona 4.32.1 → 4.32.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/persona",
-  "version": "4.32.1",
+  "version": "4.32.2",
   "description": "Themeable, pluggable streaming agent widget for websites, in plain JS with support for voice input and reasoning / tool output.",
   "type": "module",
   "main": "dist/index.cjs",

package/src/index-global.ts

@@ -37,12 +37,13 @@ export type { StreamAnimationPlugin, StreamAnimationContext } from "./types";
 // ---------------------------------------------------------------------------
 
 import { setWebMcpPolyfillLoader } from "./webmcp-bridge";
+import { pinCdnRelease } from "./utils/cdn-release";
 
 // Capture at module-evaluation time: `document.currentScript` is null once
 // execution leaves the script's initial synchronous run.
 const widgetScriptSrc: string | null =
   typeof document !== "undefined"
-    ? ((document.currentScript as HTMLScriptElement | null)?.src ?? null)
+    ? pinCdnRelease((document.currentScript as HTMLScriptElement | null)?.src ?? "") || null
     : null;
 
 /**

package/src/install.test.ts

@@ -10,6 +10,7 @@
 // `vi.runAllTimersAsync()` to drive it forward deterministically.
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { version } from "../package.json";
 
 const PERSONA_EVENTS = [
   "persona:script-load",
@@ -464,11 +465,11 @@ describe("install.ts: CDN base derivation", () => {
     return { cssHref: css?.href ?? null, scripts };
   }
 
-  it("derives asset URLs from the installer's own script directory (first-party CDN)", async () => {
+  it("pins first-party latest installer assets to the embedded release", async () => {
     setCurrentScript("https://cdn.runtype.com/persona/latest/install.global.js");
     const { cssHref, scripts } = await installedUrls({});
-    expect(cssHref).toBe("https://cdn.runtype.com/persona/latest/widget.css");
-    expect(scripts).toContain("https://cdn.runtype.com/persona/latest/launcher.global.js");
+    expect(cssHref).toBe(`https://cdn.runtype.com/persona/${version}/widget.css`);
+    expect(scripts).toContain(`https://cdn.runtype.com/persona/${version}/launcher.global.js`);
   });
 
   it("keeps npm-CDN siblings on the installer's own pinned range (no @latest skew)", async () => {
@@ -478,13 +479,13 @@ describe("install.ts: CDN base derivation", () => {
     expect(scripts).toContain("https://cdn.jsdelivr.net/npm/@runtypelabs/persona@4/dist/launcher.global.js");
   });
 
-  it("the full bundle URL follows the installer directory on the eager path", async () => {
+  it("pins the full bundle on the eager first-party latest path", async () => {
     setCurrentScript("https://cdn.runtype.com/persona/latest/install.global.js");
     markCssLoaded();
     await install({ config: { apiUrl: "/api", launcher: { enabled: false } } });
     await flush();
     const scripts = Array.from(document.head.querySelectorAll("script")).map((s) => s.src);
-    expect(scripts).toContain("https://cdn.runtype.com/persona/latest/index.global.js");
+    expect(scripts).toContain(`https://cdn.runtype.com/persona/${version}/index.global.js`);
   });
 
   it("falls back to jsDelivr@latest when currentScript is unavailable", async () => {

package/src/install.ts

@@ -4,7 +4,7 @@
  * if configuration is provided via window.siteAgentConfig
  */
 
-export {};
+import { pinCdnRelease } from "./utils/cdn-release";
 
 import type { BrandConfig } from "./types/theme";
 import { delayInstallLoading } from "./utils/install-loading";
@@ -201,7 +201,7 @@ declare global {
   const getInstallerBase = (): string | null => {
     if (!installerSrc) return null;
     try {
-      const url = new URL(installerSrc, document.baseURI);
+      const url = new URL(pinCdnRelease(installerSrc), document.baseURI);
       if (url.protocol !== "http:" && url.protocol !== "https:") return null;
       return url.origin + url.pathname.slice(0, url.pathname.lastIndexOf("/"));
     } catch {

package/src/launcher-global.ts

@@ -24,6 +24,7 @@ import { createLauncherSurface } from "./components/launcher";
 import { applyLauncherThemeVariables } from "./utils/theme";
 import { DEFAULT_LAUNCHER_CONFIG, DEFAULT_LAUNCHER_V5 } from "./defaults";
 import { setIconsExtraLoader } from "./icons-extra-loader";
+import { pinCdnRelease } from "./utils/cdn-release";
 import type { AgentWidgetConfig } from "./types";
 
 // ---------------------------------------------------------------------------
@@ -33,7 +34,7 @@ import type { AgentWidgetConfig } from "./types";
 // ---------------------------------------------------------------------------
 const launcherScriptSrc: string | null =
   typeof document !== "undefined"
-    ? ((document.currentScript as HTMLScriptElement | null)?.src ?? null)
+    ? pinCdnRelease((document.currentScript as HTMLScriptElement | null)?.src ?? "") || null
     : null;
 
 setIconsExtraLoader(() => {

package/src/session.test.ts

@@ -1070,6 +1070,47 @@ describe('AgentWidgetSession - dispatch error fallback', () => {
     expect(session.getStatus()).toBe('idle');
   });
 
+  it('does not blame the backend for an internal stream TypeError after a successful response', async () => {
+    const response = new Response('data: {}\n\n', { headers: { 'Content-Type': 'text/event-stream' } });
+    const fault = new TypeError('t.streamGeneration is not a function');
+    vi.spyOn(response.body!, 'getReader').mockImplementation(() => { throw fault; });
+    global.fetch = vi.fn().mockResolvedValue(response);
+    const errors: Error[] = [];
+    const session = new AgentWidgetSession({ apiUrl: 'http://example.invalid/chat' }, {
+      onMessagesChanged: () => {}, onStatusChanged: () => {}, onStreamingChanged: () => {},
+      onError: error => errors.push(error),
+    });
+    await session.sendMessage('Hello');
+    const content = lastAssistantMessage(session)?.content;
+    expect(content).toContain('the chat encountered an unexpected error');
+    expect(content).toContain('t.streamGeneration is not a function');
+    expect(content).not.toContain('backend');
+    expect(content).not.toContain("couldn't reach");
+    expect(errors).toContain(fault);
+    expect(session.isStreaming()).toBe(false);
+  });
+
+  it.each(['Failed to fetch', 'Load failed', 'NetworkError when attempting to fetch resource.', 'fetch failed'])(
+    'recognizes the browser fetch TypeError: %s', async (message) => {
+      failFetchWith(new TypeError(message));
+      const session = new AgentWidgetSession({ apiUrl: 'http://example.invalid/chat' }, {
+        onMessagesChanged: () => {}, onStatusChanged: () => {}, onStreamingChanged: () => {},
+      });
+      await session.sendMessage('Hello');
+      expect(lastAssistantMessage(session)?.content).toContain("I couldn't reach the assistant");
+    },
+  );
+
+  it('describes a server rejection without claiming the server was unreachable', async () => {
+    global.fetch = vi.fn().mockResolvedValue(new Response('unavailable', { status: 503 }));
+    const session = new AgentWidgetSession({ apiUrl: 'http://example.invalid/chat' }, {
+      onMessagesChanged: () => {}, onStatusChanged: () => {}, onStreamingChanged: () => {},
+    });
+    await session.sendMessage('Hello');
+    expect(lastAssistantMessage(session)?.content).toContain("chat service couldn't complete the request");
+    expect(lastAssistantMessage(session)?.content).toContain('_Details: Chat backend request failed: 503_');
+  });
+
   it('uses a static errorMessage override verbatim', async () => {
     failFetchWith(new Error('boom'));
     const session = new AgentWidgetSession(

package/src/session.ts

@@ -265,10 +265,9 @@ export class SessionHistoryError extends Error {
 }
 
 /**
- * Build the user-facing detail shown when a dispatch fails. This fires on real network/server errors
- * (connection refused, CORS, 4xx/5xx, malformed stream): not just an
- * un-wired proxy, so the copy stays honest about the failure and surfaces the
- * underlying reason to help with debugging.
+ * Dispatch can fail in transport, stream parsing, lazy modules or application
+ * callbacks. Only recognized fetch failures should suggest connectivity;
+ * unknown/internal failures must not send users to debug a healthy backend.
  *
  * Callers can override the copy via `config.errorMessage` (a static string or
  * a function of the error). An override that returns an empty string yields ""
@@ -283,9 +282,17 @@ function buildDispatchErrorContent(
   if (typeof override === "string") return override;
   if (typeof override === "function") return override(err);
 
-  const base =
-    "Sorry: I couldn't reach the assistant. The chat service didn't respond. Please check that your proxy or backend is running and reachable, then try again.";
-  return err.message ? `${base}\n\n_Details: ${err.message}_` : base;
+  // Fetch rejects with TypeError too, so the error class cannot distinguish
+  // an offline browser from an internal fault such as a missing function.
+  const detail = err.message.trim();
+  const networkFailure = /^(Failed to fetch|fetch failed|Load failed|NetworkError when attempting to fetch resource\.?)$/i.test(detail);
+  const backendFailure = /^(Chat backend|Agent execution) request failed: \d{3}\b/.test(detail);
+  const base = networkFailure
+    ? "Sorry: I couldn't reach the assistant. Please check your connection and try again."
+    : backendFailure
+      ? "Sorry: the chat service couldn't complete the request. Please try again."
+      : "Sorry: the chat encountered an unexpected error. Please reload the page and try again.";
+  return detail ? `${base}\n\n_Details: ${detail}_` : base;
 }
 
 /**

package/src/utils/cdn-release.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { version } from "../../package.json";
+import { pinCdnRelease } from "./cdn-release";
+
+describe("pinCdnRelease", () => {
+  it.each(["install", "index", "launcher"])("pins the %s entry's dependencies to its embedded release", (entry) => {
+    expect(pinCdnRelease(`https://cdn.runtype.com/persona/latest/${entry}.global.js?embed=1`))
+      .toBe(`https://cdn.runtype.com/persona/${version}/${entry}.global.js?embed=1`);
+  });
+
+  it.each([
+    "https://cdn.runtype.com/persona/4.0.0/index.global.js",
+    "https://cdn.example.com/persona/latest/index.global.js",
+    "https://cdn.jsdelivr.net/npm/@runtypelabs/persona@4/dist/index.global.js",
+    "https://cdn.runtype.com/other/latest/index.global.js",
+    "",
+  ])("preserves explicit versions and other hosting layouts: %s", (src) => {
+    expect(pinCdnRelease(src)).toBe(src);
+  });
+});

package/src/utils/cdn-release.ts

@@ -0,0 +1,14 @@
+import { version } from "../../package.json";
+
+/**
+ * A cached /latest/ entry must keep using its own release, even after another
+ * release replaces latest. Only rewrite our published CDN layout; custom hosts
+ * and explicitly versioned URLs retain their existing sibling resolution.
+ * The bundler embeds this package version in each script-tag entry.
+ */
+export function pinCdnRelease(src: string): string {
+  return src.replace(
+    /^https:\/\/cdn\.runtype\.com\/persona\/latest\//,
+    `https://cdn.runtype.com/persona/${version}/`,
+  );
+}

package/dist/chunk-BkOYJ11B.js

@@ -1 +0,0 @@
-const e=`4.32.1`;export{e as t};