dewee-webchat 0.4.1 → 0.5.0-beta.1

package/dist/{handler-DunrbnSD.d.ts → handler-B-c6tDr7.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,10 @@ 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[];
     /**
      * 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 +339,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 +349,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 {
@@ -39,6 +39,10 @@ type ActionConfirmHook = (action: PageActionInfo & {
 }, args: Record<string, unknown>) => boolean | Promise<boolean>;
 type ActionCallStatus = "pending" | "awaiting-confirmation" | "running" | "done" | "denied" | "error";
 
+declare const DOM_ACTION_NAMES: readonly ["page.snapshot", "page.scroll", "page.click", "page.fill"];
+/** Where the agent may act: a selector, an element, or (default) the whole document body. */
+type DomActionsRoot = string | Element;
+
 /** The only launch data allowed to reach the browser. Never an identity session. */
 interface JobAccessLaunch {
     bootstrap_url: string;
@@ -79,6 +83,8 @@ declare class ApiClient {
     private session;
     private config;
     private sessionPromise;
+    private supersededSessions;
+    private sessionGeneration;
     constructor(o: ApiClientOptions);
     private url;
     private get storageKey();
@@ -92,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.
      */
@@ -110,6 +119,8 @@ declare class ApiClient {
     private scheduleRefresh;
     /** The stored anonymous visitor session, if any. Signed-in sessions are never stored. */
     private stored;
+    /** The visitor of the session in use, or null before one is held. Backend conversations are keyed by it. */
+    visitorId(): string | null;
     /** Returns a valid visitor session, creating or refreshing it when needed. */
     ensureSession(): Promise<SessionResponse>;
     private loadSession;
@@ -154,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). */
@@ -188,6 +207,13 @@ interface DeweeChatConfig {
     maxActionRounds?: number;
     /** Per-handler timeout. Default 30000 ms. */
     actionTimeoutMs?: number;
+    /**
+     * Built-in page actions that read and operate the page DOM (page.snapshot, page.scroll, page.click,
+     * page.fill). Off by default. Host actions with the same name win. click/fill always ask the visitor.
+     */
+    domActions?: boolean;
+    /** Limits the built-in DOM actions to this element or selector. Default: document.body. */
+    domActionsRoot?: DomActionsRoot;
     /**
      * Extra headers for every request to `endpoint` (e.g. a CSRF token). A function is called before
      * each request. Cannot override content-type, authorization or the gateway credential headers.
@@ -225,17 +251,24 @@ 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;
     private propActionNames;
     private hooks;
+    /** Built-in DOM actions, created on first use when `domActions` is on (keeps the snapshot refs). */
+    private dom;
     private acks;
     /** Pause after a RATE_LIMITED refusal; send stays disabled until it ends. */
     private cooldown;
@@ -255,8 +288,10 @@ declare class DeweeChatElement extends ElementBase {
     /** Custom fetch for widget requests (property only; same as `configure({ fetch })`). */
     get fetch(): typeof fetch | undefined;
     set fetch(v: typeof fetch | undefined);
-    /** Names of the currently registered page actions. */
+    /** Names of the page actions offered to the agent (host actions, then enabled built-ins). */
     get actionNames(): string[];
+    /** Host actions plus the enabled built-in DOM actions whose names the host did not take. */
+    private actionRegistry;
     private setPropActions;
     open(): void;
     close(): void;
@@ -268,6 +303,10 @@ declare class DeweeChatElement extends ElementBase {
     private chatBody;
     /** Host snapshot, dropped (with a warning) when it fails or exceeds the backend cap. */
     private pageContext;
+    /**
+     * The backend keys a conversation by visitor as well as by id, so a sign-in, a sign-out or another
+     * user starts a conversation that has not seen the manifest, even with the same conversation id.
+     */
     private ackKey;
     private getAck;
     private setAck;
@@ -309,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;
@@ -346,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;
@@ -358,4 +407,4 @@ declare global {
     }
 }
 
-export { type ActionCallStatus, type ActionCallView, type ActionConfirmHook, type ActionEventDetail, type ActionResult, type ActionResultStatus, ActionSensitivity, ApiClient, type ApiClientOptions, ApiError, ChatRequestBody, ChatStreamEvent, type DeweeChatConfig, DeweeChatElement, HistoryMessage, type JsonSchema, LinkResponse, type PageAction, type PageActionContext, type PageActionInfo, PublicConfig, RESERVED_HEADERS, Remediation, type RequestHeadersOption, SessionResponse, defineDeweeChat, mount, renderMarkdown };
+export { type ActionCallStatus, type ActionCallView, type ActionConfirmHook, type ActionEventDetail, type ActionResult, type ActionResultStatus, ActionSensitivity, ApiClient, type ApiClientOptions, ApiError, ChatRequestBody, ChatStreamEvent, DOM_ACTION_NAMES, type DeweeChatConfig, DeweeChatElement, type DomActionsRoot, HistoryMessage, type JsonSchema, LinkResponse, type PageAction, type PageActionContext, type PageActionInfo, PublicConfig, RESERVED_HEADERS, Remediation, type RequestHeadersOption, SessionResponse, defineDeweeChat, mount, renderMarkdown };

package/dist/index.js

@@ -1,16 +1,18 @@
 import {
   ApiClient,
   ApiError,
+  DOM_ACTION_NAMES,
   DeweeChatElement,
   RESERVED_HEADERS,
   defineDeweeChat,
   mount,
   renderMarkdown
-} from "./chunk-VU2M42GA.js";
-import "./chunk-EVZ5K7BN.js";
+} from "./chunk-M6J3IXEI.js";
+import "./chunk-WHHQ6FKK.js";
 export {
   ApiClient,
   ApiError,
+  DOM_ACTION_NAMES,
   DeweeChatElement,
   RESERVED_HEADERS,
   defineDeweeChat,

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

@@ -1,8 +1,8 @@
 import * as react from 'react';
 import { CSSProperties } from 'react';
 import { DeweeChatConfig, ActionEventDetail, DeweeChatElement } from './index.js';
-export { ActionConfirmHook, PageAction, PageActionContext, RequestHeadersOption } from './index.js';
-import './protocol-CLbGE9Ns.js';
+export { ActionConfirmHook, DomActionsRoot, PageAction, PageActionContext, RequestHeadersOption } from './index.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-VU2M42GA.js";
-import "./chunk-EVZ5K7BN.js";
+} from "./chunk-M6J3IXEI.js";
+import "./chunk-WHHQ6FKK.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, ...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 });
+    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-B-c6tDr7.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-B-c6tDr7.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;
 }