dewee-webchat 0.4.2 → 0.5.0-beta.2

package/dist/{handler-DunrbnSD.d.ts → handler-SsDyK0TG.d.ts}

@@ -1,4 +1,4 @@
-import { A as AgentInfo } from './protocol-CLbGE9Ns.js';
+import { A as AgentInfo } from './protocol-BbjGSfZa.js';
 
 interface VisitorClaims {
     /** Visitor id (random, 22 chars; derived from the principal for a signed-in user). */
@@ -89,6 +89,42 @@ declare class CcpError extends Error {
     } | undefined);
 }
 
+/** A cached identity session. The sessionToken is a bearer credential and must be protected. */
+interface StoredIdentitySession {
+    sessionToken: string;
+    visitorId: string;
+    deadline: number;
+    margin: number;
+    origin?: string;
+}
+/**
+ * Storage shared by handler instances. Subject keys are HMAC digests scoped to the integration.
+ * Implementations must protect session tokens and expire entries by deadline. Revisions must be
+ * unique and never reused after expiry or eviction. Every method must be atomic across instances:
+ * read creates a revision even for an absent subject; commit compares and advances it; takeSubject
+ * advances it even when empty; deleteToken compares tokens within the supplied namespace and advances
+ * each affected revision. This fences an in-flight exchange against logout and concurrent exchanges.
+ */
+interface IdentitySessionStore {
+    read(subjectKey: string, agent: string): Promise<{
+        revision: string;
+        session: StoredIdentitySession | null;
+    }>;
+    /** Atomically verify that no subject mutation has occurred since read. */
+    check(subjectKey: string, revision: string): Promise<boolean>;
+    /** Atomically compare and advance the subject revision when committing a session. */
+    commit(subjectKey: string, agent: string, revision: string, session: StoredIdentitySession): Promise<boolean>;
+    /** Remove only entries whose current token equals this token, not a newer replacement. */
+    deleteToken(namespace: string, token: string): Promise<void>;
+    /** Atomically advance the revision and remove and return all entries, even when none exist. */
+    takeSubject(subjectKey: string): Promise<Array<{
+        agent: string;
+        session: StoredIdentitySession;
+    }>>;
+}
+/** Bounded per-handler default; a shared adapter can be provided for multi-instance hosts. */
+declare function memoryIdentitySessionStore(limit?: number): IdentitySessionStore;
+
 /**
  * A signed-in user of the host app, as `identity.authenticate` reports it. Scopes are not part of
  * the session exchange: report scope changes with `lifecycle({ event: "scopes_changed" })` from
@@ -170,6 +206,8 @@ interface DeweeIdentitySdk {
  * to one agent, and the gateway derives the user from it.
  */
 interface DeweeIdentityOptions {
+    /** Optional protected shared store for identity-session reuse across handler instances. */
+    sessionStore?: IdentitySessionStore;
     /** `deweeIdentitySdk` from `dewee-webchat/server/identity`. */
     sdk: DeweeIdentitySdk;
     /**
@@ -237,8 +275,10 @@ interface DeweeHandlerOptions {
     token?: string;
     /** Legacy gateway transport. */
     tenantId?: string;
-    /** HMAC secret for visitor tokens (>= 32 random chars). */
+    /** HMAC secret for visitor tokens (at least 32 random UTF-8 bytes). */
     secret?: string;
+    /** Legacy gateway only: permit a process-local secret for development. Sessions reset on restart. */
+    allowEphemeralSecret?: boolean;
     /** Legacy gateway transport: agents visitors may talk to. The first is the default. `"*"` = every active agent. */
     agents?: Array<string | AgentInfo> | "*";
     defaultAgent?: string;
@@ -246,6 +286,17 @@ interface DeweeHandlerOptions {
     allowAgentSwitch?: boolean;
     /** Cross-origin sites allowed to call this backend. Same-origin is always allowed. */
     allowedOrigins?: string[] | "*";
+    /** Additional header names allowed in cross-origin requests. */
+    allowedHeaders?: string[];
+    /** HTTPS directory prefixes from which the backend may proxy images; disabled when unset. */
+    imageSources?: string[];
+    /** Explicitly public directories in this Worker's Assets binding. Bypasses site middleware. */
+    cloudflarePublicImageAssets?: {
+        binding: {
+            fetch(request: Request): Promise<Response>;
+        };
+        prefixes: string[];
+    };
     /**
      * Legacy gateway transport: let visitors bring their own gateway URL + token (sent per request, never stored).
      * Meant for playgrounds. `allowedHosts` restricts which gateways may be targeted.
@@ -295,8 +346,9 @@ interface DeweeHandler {
      * and IP (without it, the origin of the request the session was issued for is used). `token` is the
      * widget's reuse hint (`reuseHint()`) or visitor token, sent along by your logout page: its identity
      * session is revoked too when it belongs to `subject`, so a host that keeps no memory between
-     * requests still ends the exact session. Best effort: never throws. Other sessions held only by
-     * other instances end at their expiry (`sessionTtlSeconds`). Without `identity` it does nothing.
+     * requests still ends the exact session. Best effort: never throws; a store failure is logged and
+     * the exact supplied token is still attempted. Without a shared store, other instances' sessions
+     * end at expiry (`sessionTtlSeconds`). Without `identity` it does nothing.
      */
     revoke(subject: string, request?: Request, token?: string): Promise<void>;
 }
@@ -304,4 +356,4 @@ declare function createDeweeHandler(options: DeweeHandlerOptions): DeweeHandler;
 /** Reads options from environment variables (process.env, Workers env, import.meta.env…). */
 declare function optionsFromEnv(env: Record<string, string | undefined>, overrides?: Partial<DeweeHandlerOptions>): DeweeHandlerOptions;
 
-export { type AuthenticatedUser as A, CcpError as C, type DeweeIdentitySdk as D, type IdentityPrivateJwk as I, type MemoryRateLimits as M, type RateLimitBucket as R, type VisitorClaims as V, type CcpOptions as a, type DeweeHandler as b, type DeweeHandlerOptions as c, type DeweeIdentityOptions as d, type DeweeTransport as e, type IdentitySigner as f, type RateLimiter as g, createDeweeHandler as h, memoryRateLimiter as m, optionsFromEnv as o, signVisitorToken as s, verifyVisitorToken as v };
+export { type AuthenticatedUser as A, CcpError as C, type DeweeIdentitySdk as D, type IdentityPrivateJwk as I, type MemoryRateLimits as M, type RateLimitBucket as R, type StoredIdentitySession as S, type VisitorClaims as V, type CcpOptions as a, type DeweeHandler as b, type DeweeHandlerOptions as c, type DeweeIdentityOptions as d, type DeweeTransport as e, type IdentitySessionStore as f, type IdentitySigner as g, type RateLimiter as h, createDeweeHandler as i, memoryRateLimiter as j, memoryIdentitySessionStore as m, optionsFromEnv as o, signVisitorToken as s, verifyVisitorToken as v };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { d as ActionSensitivity, P as PublicConfig, S as SessionResponse, L as LinkResponse, H as HistoryMessage, e as ChatRequestBody, C as ChatStreamEvent, R as Remediation } from './protocol-CLbGE9Ns.js';
-export { a as ActionManifestEntry, b as AdmissionErrorCode, A as AgentInfo, I as IdentityErrorCode, f as LinkTarget, T as ToolCallView } from './protocol-CLbGE9Ns.js';
+import { d as ActionSensitivity, P as PublicConfig, S as SessionResponse, L as LinkResponse, H as HistoryMessage, e as ChatRequestBody, C as ChatStreamEvent, R as Remediation, g as PageContextAttachment } from './protocol-BbjGSfZa.js';
+export { a as ActionManifestEntry, b as AdmissionErrorCode, A as AgentInfo, I as IdentityErrorCode, f as LinkTarget, T as ToolCallView } from './protocol-BbjGSfZa.js';
 
 type ActionResultStatus = "ok" | "denied" | "error";
 interface ActionResult {
@@ -83,6 +83,8 @@ declare class ApiClient {
     private session;
     private config;
     private sessionPromise;
+    private supersededSessions;
+    private sessionGeneration;
     constructor(o: ApiClientOptions);
     private url;
     private get storageKey();
@@ -96,12 +98,15 @@ declare class ApiClient {
     private request;
     private headers;
     private parse;
-    getConfig(force?: boolean): Promise<PublicConfig>;
+    /** Obtain a short-lived, URL-bound image capability without exposing the visitor bearer in src. */
+    imageUrl(source: string, signal?: AbortSignal): Promise<string>;
+    getConfig(force?: boolean, probePageContext?: boolean): Promise<PublicConfig>;
     /** When each signed-in session should be refreshed, on this browser's clock. */
     private refreshAt;
     /**
      * Session reuse. A signed-in session follows its schedule (see `scheduleRefresh`). An anonymous
-     * token is refreshed once less than 10% of its lifetime (at most 24 h, at least 30 s) remains; a
+     * token is refreshed once less than 10% of its lifetime (at most 24 h, at least 30 s, and no more
+     * than half the lifetime) remains; a
      * stored token from before `obtainedAt` existed uses the 24 h margin. When the backend reports the
      * lifetime (`expiresIn`), it is counted from receipt, so a skewed browser clock does not matter.
      */
@@ -160,6 +165,14 @@ interface DeweeChatConfig {
     suggestions?: string[];
     /** Image URL used for the header avatar (and launcher when `launcherAvatar`). */
     avatar?: string;
+    /** HTTPS origins from which Markdown images may load, in addition to the page's own origin. */
+    imageOrigins?: string[];
+    /** Explicit host opt-in; the visitor must also choose to share the current page. */
+    pageContext?: "off" | "metadata" | "content";
+    contextSelector?: string;
+    excludeSelectors?: string[];
+    /** Supplies host-filtered content. Visitors still preview and opt in on each message. */
+    contextProvider?: () => Promise<Partial<PageContextAttachment>>;
     launcherAvatar?: boolean;
     position?: "bottom-right" | "bottom-left";
     /** "floating" (launcher + popup) or "inline" (fills its container). */
@@ -238,12 +251,17 @@ declare class DeweeChatElement extends ElementBase {
     private api;
     private apiKey;
     private server;
+    private sharedPage?;
+    private preparingPage;
+    private pagePending;
+    private pageGeneration;
     private agentId;
     private conversationId;
     private messages;
     private running;
     private jobAccessLaunch;
     private activated;
+    private probedPage;
     private strings;
     private mql;
     private registry;
@@ -330,6 +348,11 @@ declare class DeweeChatElement extends ElementBase {
     private applyConfig;
     private renderShell;
     private autosize;
+    private updatePageChoice;
+    private captureCurrentPage;
+    private pageFingerprint;
+    private renderPagePreview;
+    private choosePage;
     private updateSendButton;
     /** Disables sending for `ms` and announces it; the visible countdown is not read out every second. */
     private startCooldown;
@@ -367,7 +390,12 @@ declare class DeweeChatElement extends ElementBase {
 }
 
 type Doc = Document;
-declare function renderMarkdown(doc: Doc, src: string): DocumentFragment;
+interface MarkdownOptions {
+    imageOrigins?: string[];
+    imageProxy?: (source: string, signal: AbortSignal) => Promise<string>;
+    deferImages?: boolean;
+}
+declare function renderMarkdown(doc: Doc, src: string, options?: MarkdownOptions): DocumentFragment;
 
 /** Registers the `<dewee-chat>` custom element (idempotent, SSR-safe). */
 declare function defineDeweeChat(tag?: string): void;

package/dist/index.js

@@ -7,8 +7,8 @@ import {
   defineDeweeChat,
   mount,
   renderMarkdown
-} from "./chunk-UGHJZAKL.js";
-import "./chunk-SAUDVPFH.js";
+} from "./chunk-XCO4TCKF.js";
+import "./chunk-KXW4EWXA.js";
 export {
   ApiClient,
   ApiError,

package/dist/page-context-H3ZROFAV.js

@@ -0,0 +1,137 @@
+// src/widget/page-context.ts
+var BLOCKED = "script,style,noscript,template,svg,canvas,iframe,form,input,textarea,select,option,button,[contenteditable]:not([contenteditable='false']),[hidden],[aria-hidden='true'],[inert],dewee-chat";
+var MAX_CONTENT = 12e3;
+function safePageUrl(href) {
+  try {
+    const url = new URL(href);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return void 0;
+    url.username = "";
+    url.password = "";
+    url.hash = "";
+    for (const key of [...url.searchParams.keys()]) {
+      const words = key.replace(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, "$1 $2").replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, "$1 $2").replace(/(\p{L})(\p{N})/gu, "$1 $2").replace(/(\p{N})(\p{L})/gu, "$1 $2").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+      const joined = words.join("");
+      const qualifiers = ["api", "access", "auth", "oauth", "secret", "private", "client", "session", "signing", "verification", "reset", "recovery", "activation", "confirmation", "invite", "license", "encryption"];
+      const secret = words.some((word, index) => ["token", "secret", "password", "passwd", "pwd", "auth", "authorization", "cookie", "apikey", "session", "sid", "sig", "signature", "otp", "jwt", "credential", "credentials", "nonce", "bearer", "ticket"].includes(word) || ["code", "key", "state"].includes(word) && (words.length === 1 || index > 0 && qualifiers.includes(words[index - 1]))) || /token|secret|passw|apikey|credential|sessid|session|authorization|samlresponse/.test(joined);
+      if (secret) url.searchParams.set(key, "[REDACTED]");
+    }
+    return new TextEncoder().encode(url.href).length <= 2048 ? url.href : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function clip(text, length) {
+  return Array.from(text).slice(0, length).join("");
+}
+function limitBytes(context) {
+  if (context.content && new TextEncoder().encode(JSON.stringify(context)).length > 65536) {
+    const points = Array.from(context.content.text);
+    let low = 0, high = points.length;
+    while (low < high) {
+      const mid = Math.ceil((low + high) / 2);
+      context.content.text = points.slice(0, mid).join("");
+      context.content.truncated = true;
+      if (new TextEncoder().encode(JSON.stringify(context)).length <= 65536) low = mid;
+      else high = mid - 1;
+    }
+    context.content.text = points.slice(0, low).join("");
+    context.content.truncated = true;
+  }
+  return context;
+}
+function providedPageContext(raw, base, mode) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new TypeError("Invalid page context");
+  const value = raw;
+  const result = { version: 1, url: base.url, captured_at: base.captured_at };
+  for (const [key, max] of [["title", 300], ["description", 1e3]]) {
+    if (typeof value[key] === "string") result[key] = clip(value[key].replace(/\s+/g, " ").trim(), max);
+  }
+  if (mode === "content") {
+    if (typeof value.selection === "string") result.selection = clip(value.selection, 2e3);
+    if (value.content && typeof value.content === "object" && !Array.isArray(value.content)) {
+      const content = value.content;
+      if (typeof content.text !== "string" || content.format !== "text" && content.format !== "markdown") throw new TypeError("Invalid page content");
+      const text = clip(content.text, MAX_CONTENT);
+      result.content = { format: content.format, text, truncated: content.truncated === true || Array.from(content.text).length > MAX_CONTENT };
+    }
+  }
+  return limitBytes(result);
+}
+function visible(el, excludes) {
+  for (let node = el; node; node = node.parentElement) {
+    if (node.matches(BLOCKED) || excludes.some((selector) => node.matches(selector))) return false;
+    if (node instanceof HTMLDialogElement && !node.open) return false;
+    if (node instanceof HTMLDetailsElement && !node.open) {
+      const summary = [...node.children].find((child) => child.tagName === "SUMMARY");
+      if (!summary || !el || summary !== el && !summary.contains(el)) return false;
+    }
+    if (node.hasAttribute("popover")) {
+      try {
+        if (!node.matches(":popover-open")) return false;
+      } catch {
+        return false;
+      }
+    }
+    const style = getComputedStyle(node);
+    if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse" || style.opacity === "0" || style.contentVisibility === "hidden") return false;
+  }
+  if (el && typeof el.checkVisibility === "function" && !el.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true })) return false;
+  return true;
+}
+function capturePageContext(doc, options) {
+  const url = safePageUrl(doc.location.href);
+  if (!url) return void 0;
+  const excludes = options.excludeSelectors ?? [];
+  for (const selector of excludes) doc.documentElement.matches(selector);
+  const root = doc.querySelector(options.selector || "main, article, [role='main']");
+  const context = { version: 1, url, captured_at: (/* @__PURE__ */ new Date()).toISOString() };
+  const title = clip(doc.title.replace(/\s+/g, " ").trim(), 300);
+  const description = clip((doc.querySelector('meta[name="description" i]')?.getAttribute("content") ?? "").replace(/\s+/g, " ").trim(), 1e3);
+  if (title) context.title = title;
+  if (description) context.description = description;
+  if (options.mode !== "content" || !root || !visible(root, excludes)) return context;
+  const walker = doc.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  const chunks = [];
+  let size = 0;
+  let visited = 0;
+  let truncated = false;
+  while (walker.nextNode()) {
+    if (++visited > 5e3) {
+      truncated = true;
+      break;
+    }
+    const node = walker.currentNode;
+    if (!visible(node.parentElement, excludes)) continue;
+    const text2 = (node.textContent ?? "").replace(/\s+/g, " ").trim();
+    if (!text2) continue;
+    const remaining = MAX_CONTENT - size;
+    const part = clip(text2, remaining);
+    chunks.push(part);
+    size += Array.from(part).length + 1;
+    if (Array.from(text2).length > remaining || size >= MAX_CONTENT) {
+      truncated = true;
+      break;
+    }
+  }
+  const text = clip(chunks.join("\n"), MAX_CONTENT);
+  if (text) context.content = { format: "text", text, truncated };
+  const selection = doc.getSelection();
+  if (selection && !selection.isCollapsed && selection.rangeCount) {
+    const range = selection.getRangeAt(0);
+    const ancestor = range.commonAncestorContainer;
+    const element = ancestor.nodeType === Node.ELEMENT_NODE ? ancestor : ancestor.parentElement;
+    if (element && root.contains(element) && visible(element, excludes)) {
+      const nodes = root.querySelectorAll("*");
+      if (nodes.length <= 5e3 && ![...nodes].some((el) => range.intersectsNode(el) && !visible(el, excludes))) {
+        const selected = clip(selection.toString().trim(), 2e3);
+        if (selected) context.selection = selected;
+      }
+    }
+  }
+  return limitBytes(context);
+}
+export {
+  capturePageContext,
+  providedPageContext,
+  safePageUrl
+};

package/dist/{protocol-CLbGE9Ns.d.ts → protocol-BbjGSfZa.d.ts}

@@ -1,3 +1,18 @@
+/** A transient, untrusted attachment for one chat turn. Never stored in browser history. */
+interface PageContextAttachment {
+    version: 1;
+    url: string;
+    title?: string;
+    description?: string;
+    captured_at?: string;
+    selection?: string;
+    content?: {
+        format: "text" | "markdown";
+        text: string;
+        truncated: boolean;
+    };
+}
+
 /** Server-Sent Events emitted by `POST {basePath}/chat`. */
 type ChatStreamEvent = {
     type: "start";
@@ -76,6 +91,8 @@ interface PublicConfig {
     turnstileSiteKey?: string;
     maxMessageLength: number;
     version: string;
+    /** Attachment versions advertised by the connected runtime. */
+    pageContextVersions?: number[];
     /** Present (true) when the backend signs users in through Dewee: the widget then asks `/session` on every page load. */
     identity?: boolean;
     /**
@@ -108,7 +125,7 @@ interface SessionResponse {
      */
     reuseHint?: string;
     /**
-     * Verified sessions, and every session of the ccp transport: milliseconds until `expiresAt`, counted
+     * Milliseconds until `expiresAt`, counted
      * from when the response is received. The widget refreshes from this rather than `expiresAt`, so a
      * skewed browser clock does not matter.
      */
@@ -165,6 +182,8 @@ interface ChatRequestBody {
     /** Hash from the `start` event of the last completed turn; the manifest is re-sent to the agent only when it differs. */
     actionsHash?: string;
     pageContext?: unknown;
+    /** Ephemeral, untrusted content for this turn; distinct from the legacy page-action context. */
+    page_context?: PageContextAttachment;
 }
 
-export { type AgentInfo as A, type ChatStreamEvent as C, type ErrorBody as E, type HistoryMessage as H, type IdentityErrorCode as I, type LinkResponse as L, type PublicConfig as P, type Remediation as R, type SessionResponse as S, type ToolCallView as T, type ActionManifestEntry as a, type AdmissionErrorCode as b, ADMISSION_ERROR_CODES as c, type ActionSensitivity as d, type ChatRequestBody as e, type LinkTarget as f, isAdmissionErrorCode as i };
+export { type AgentInfo as A, type ChatStreamEvent as C, type ErrorBody as E, type HistoryMessage as H, type IdentityErrorCode as I, type LinkResponse as L, type PublicConfig as P, type Remediation as R, type SessionResponse as S, type ToolCallView as T, type ActionManifestEntry as a, type AdmissionErrorCode as b, ADMISSION_ERROR_CODES as c, type ActionSensitivity as d, type ChatRequestBody as e, type LinkTarget as f, type PageContextAttachment as g, isAdmissionErrorCode as i };

package/dist/react.d.ts

@@ -2,7 +2,7 @@ import * as react from 'react';
 import { CSSProperties } from 'react';
 import { DeweeChatConfig, ActionEventDetail, DeweeChatElement } from './index.js';
 export { ActionConfirmHook, DomActionsRoot, PageAction, PageActionContext, RequestHeadersOption } from './index.js';
-import './protocol-CLbGE9Ns.js';
+import './protocol-BbjGSfZa.js';
 
 interface DeweeChatProps extends Partial<DeweeChatConfig> {
     className?: string;
@@ -15,6 +15,8 @@ interface DeweeChatProps extends Partial<DeweeChatConfig> {
     onClose?: (e: CustomEvent) => void;
     /** Page action telemetry (`dewee:action`, detail: ActionEventDetail). */
     onAction?: (e: CustomEvent<ActionEventDetail>) => void;
+    onContextReady?: (e: CustomEvent) => void;
+    onContextError?: (e: CustomEvent) => void;
 }
 declare const DeweeChat: react.ForwardRefExoticComponent<DeweeChatProps & react.RefAttributes<DeweeChatElement | null>>;
 

package/dist/react.js

@@ -1,7 +1,7 @@
 import {
   defineDeweeChat
-} from "./chunk-UGHJZAKL.js";
-import "./chunk-SAUDVPFH.js";
+} from "./chunk-XCO4TCKF.js";
+import "./chunk-KXW4EWXA.js";
 
 // src/react.ts
 import { createElement, forwardRef, useEffect, useImperativeHandle, useRef } from "react";
@@ -12,23 +12,25 @@ var EVENTS = {
   onError: "dewee:error",
   onOpen: "dewee:open",
   onClose: "dewee:close",
-  onAction: "dewee:action"
+  onAction: "dewee:action",
+  onContextReady: "dewee:context-ready",
+  onContextError: "dewee:context-error"
 };
 var DeweeChat = forwardRef(function DeweeChat2(props, ref) {
   const el = useRef(null);
-  const { className, style, onReady, onSend, onReply, onError, onOpen, onClose, onAction, actions, confirm, getPageContext, headers, fetch, domActionsRoot, ...config } = props;
-  const handlers = { onReady, onSend, onReply, onError, onOpen, onClose, onAction };
+  const { className, style, onReady, onSend, onReply, onError, onOpen, onClose, onAction, onContextReady, onContextError, actions, confirm, getPageContext, headers, fetch, domActionsRoot, contextProvider, imageOrigins, ...config } = props;
+  const handlers = { onReady, onSend, onReply, onError, onOpen, onClose, onAction, onContextReady, onContextError };
   const handlersRef = useRef(handlers);
   handlersRef.current = handlers;
   useImperativeHandle(ref, () => el.current, []);
-  const configKey = JSON.stringify(config);
+  const configKey = JSON.stringify({ ...config, imageOrigins: imageOrigins ?? [] });
   useEffect(() => {
     defineDeweeChat();
     el.current?.configure(JSON.parse(configKey));
   }, [configKey]);
   useEffect(() => {
     defineDeweeChat();
-    el.current?.configure({ actions, confirm, getPageContext, headers, fetch, domActionsRoot });
+    el.current?.configure({ actions, confirm, getPageContext, headers, fetch, domActionsRoot, contextProvider });
   });
   useEffect(() => {
     const node = el.current;

package/dist/server-identity.d.ts

@@ -1,5 +1,5 @@
-import { D as DeweeIdentitySdk } from './handler-DunrbnSD.js';
-import './protocol-CLbGE9Ns.js';
+import { D as DeweeIdentitySdk } from './handler-SsDyK0TG.js';
+import './protocol-BbjGSfZa.js';
 
 declare const deweeIdentitySdk: DeweeIdentitySdk;
 

package/dist/server.d.ts

@@ -1,7 +1,7 @@
-export { A as AuthenticatedUser, C as CcpError, a as CcpOptions, b as DeweeHandler, c as DeweeHandlerOptions, d as DeweeIdentityOptions, D as DeweeIdentitySdk, e as DeweeTransport, I as IdentityPrivateJwk, f as IdentitySigner, M as MemoryRateLimits, R as RateLimitBucket, g as RateLimiter, V as VisitorClaims, h as createDeweeHandler, m as memoryRateLimiter, o as optionsFromEnv, s as signVisitorToken, v as verifyVisitorToken } from './handler-DunrbnSD.js';
+export { A as AuthenticatedUser, C as CcpError, a as CcpOptions, b as DeweeHandler, c as DeweeHandlerOptions, d as DeweeIdentityOptions, D as DeweeIdentitySdk, e as DeweeTransport, I as IdentityPrivateJwk, f as IdentitySessionStore, g as IdentitySigner, M as MemoryRateLimits, R as RateLimitBucket, h as RateLimiter, S as StoredIdentitySession, V as VisitorClaims, i as createDeweeHandler, m as memoryIdentitySessionStore, j as memoryRateLimiter, o as optionsFromEnv, s as signVisitorToken, v as verifyVisitorToken } from './handler-SsDyK0TG.js';
 import { IncomingMessage, ServerResponse } from 'node:http';
-import { R as Remediation, H as HistoryMessage, A as AgentInfo, C as ChatStreamEvent, a as ActionManifestEntry, b as AdmissionErrorCode } from './protocol-CLbGE9Ns.js';
-export { c as ADMISSION_ERROR_CODES, d as ActionSensitivity, e as ChatRequestBody, E as ErrorBody, I as IdentityErrorCode, L as LinkResponse, f as LinkTarget, P as PublicConfig, S as SessionResponse, i as isAdmissionErrorCode } from './protocol-CLbGE9Ns.js';
+import { R as Remediation, H as HistoryMessage, A as AgentInfo, C as ChatStreamEvent, a as ActionManifestEntry, b as AdmissionErrorCode } from './protocol-BbjGSfZa.js';
+export { c as ADMISSION_ERROR_CODES, d as ActionSensitivity, e as ChatRequestBody, E as ErrorBody, I as IdentityErrorCode, L as LinkResponse, f as LinkTarget, P as PublicConfig, S as SessionResponse, i as isAdmissionErrorCode } from './protocol-BbjGSfZa.js';
 
 type FetchHandler = (request: Request) => Promise<Response>;
 /** Wraps a fetch-style handler for `http.createServer`, Express (`app.all("/api/dewee/*", ...)`), etc. */
@@ -29,8 +29,9 @@ declare class GatewayError extends Error {
     code?: string | undefined;
     remediation?: Remediation | undefined;
     retryAfterMs?: unknown | undefined;
+    reason?: unknown | undefined;
     /** `retryAfterMs` is the gateway's raw value for retryable refusals (`RATE_LIMITED`), unvalidated. */
-    constructor(message: string, code?: string | undefined, remediation?: Remediation | undefined, retryAfterMs?: unknown | undefined);
+    constructor(message: string, code?: string | undefined, remediation?: Remediation | undefined, retryAfterMs?: unknown | undefined, reason?: unknown | undefined);
 }
 /** One authenticated gateway connection. Short-lived: one per chat turn or lookup. */
 declare class GatewayConnection {
@@ -39,6 +40,7 @@ declare class GatewayConnection {
     private pending;
     private listeners;
     private closed;
+    pageContextVersions: number[];
     private constructor();
     static connect(creds: GatewayCredentials, actor: GatewayActor, timeoutMs?: number): Promise<GatewayConnection>;
     call<T = any>(method: string, params: unknown, timeoutMs?: number): Promise<T>;
@@ -59,6 +61,7 @@ interface StreamChatOptions {
     agent: string;
     sessionKey: string;
     message: string;
+    pageContext?: unknown;
     signal?: AbortSignal;
     timeoutMs?: number;
 }