dewee-webchat 0.2.0 → 0.4.1-beta.1

package/dist/server.js

@@ -1,24 +1,72 @@
 import {
   ACTION_LIMITS,
+  ADMISSION_ERROR_CODES,
   ActionInputError,
   HEADER_GATEWAY_TOKEN,
   HEADER_GATEWAY_URL,
   VERSION,
   buildPageBlock,
   hashManifest,
+  isAdmissionErrorCode,
+  isIdentityErrorCode,
   normalizeManifest,
+  parseJobAccessLaunch,
   serializePageContext,
   stripPageBlock
-} from "./chunk-JX6AH37X.js";
+} from "./chunk-USXVB3AC.js";
+
+// src/server/admission-errors.ts
+var MESSAGES = {
+  POLICY_DENIED: "This message can't be sent.",
+  RATE_LIMITED: "Too many messages, please wait a moment.",
+  // Reserved for the gateway challenge protocol: no challenge context is defined or forwarded yet.
+  CHALLENGE_REQUIRED: "Verification is required to continue."
+};
+var STATUS = { POLICY_DENIED: 403, RATE_LIMITED: 429, CHALLENGE_REQUIRED: 403 };
+var DEFAULT_RETRY_AFTER_MS = 5e3;
+var MAX_RETRY_AFTER_MS = 6e5;
+var DECIMAL_RE = /^\s*[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?\s*$/;
+function normalizeRetryAfterMs(raw) {
+  const n = typeof raw === "number" ? raw : typeof raw === "string" && DECIMAL_RE.test(raw) ? Number(raw) : NaN;
+  if (!Number.isFinite(n) || n <= 0) return DEFAULT_RETRY_AFTER_MS;
+  return Math.min(Math.ceil(n), MAX_RETRY_AFTER_MS);
+}
+var gatewayReasons = /* @__PURE__ */ new WeakMap();
+function gatewayReasonOf(event) {
+  return gatewayReasons.get(event);
+}
+function admissionErrorEvent(code, retryAfterMs, gatewayReason) {
+  const event = code === "RATE_LIMITED" ? { type: "error", message: MESSAGES[code], code, retryAfterMs: normalizeRetryAfterMs(retryAfterMs) } : { type: "error", message: MESSAGES[code], code };
+  if (gatewayReason) gatewayReasons.set(event, gatewayReason);
+  return event;
+}
+function admissionErrorResponse(code, retryAfterMs) {
+  const { type: _type, ...error } = admissionErrorEvent(code, retryAfterMs);
+  const headers = error.retryAfterMs ? { "retry-after": String(Math.ceil(error.retryAfterMs / 1e3)) } : {};
+  return { status: STATUS[code], body: { error }, headers };
+}
 
 // src/server/gateway-client.ts
 var GatewayError = class extends Error {
-  constructor(message, code) {
+  /** `retryAfterMs` is the gateway's raw value for retryable refusals (`RATE_LIMITED`), unvalidated. */
+  constructor(message, code, remediation, retryAfterMs) {
     super(message);
     this.code = code;
+    this.remediation = remediation;
+    this.retryAfterMs = retryAfterMs;
   }
   code;
+  remediation;
+  retryAfterMs;
 };
+function parseRemediation(raw) {
+  if (raw === null || typeof raw !== "object") return void 0;
+  const { action, audience } = raw;
+  return typeof action === "string" && typeof audience === "string" ? { action, audience } : void 0;
+}
+function isIdentityUser(userId) {
+  return typeof userId === "string" && userId.startsWith("tuc:") && userId.length > 4;
+}
 function wsUrl(base) {
   const u = new URL(base);
   u.protocol = u.protocol === "http:" ? "ws:" : "wss:";
@@ -62,12 +110,15 @@ var GatewayConnection = class _GatewayConnection {
   pending = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   closed = false;
-  static async connect(creds, userId, timeoutMs = 15e3) {
+  static async connect(creds, actor, timeoutMs = 15e3) {
     const conn = new _GatewayConnection(await openSocket(creds.url, timeoutMs));
-    const params = { token: creds.token, user_id: userId };
+    const params = typeof actor === "string" ? { token: creds.token, user_id: actor } : { token: creds.token, identity_session: actor.identitySession };
     if (creds.tenantId) params.tenant_id = creds.tenantId;
     try {
-      await conn.call("connect", params, timeoutMs);
+      const res = await conn.call("connect", params, timeoutMs);
+      if (typeof actor !== "string" && !isIdentityUser(res?.user_id)) {
+        throw new GatewayError("Gateway did not apply the identity session", "SOURCE_UNAVAILABLE", { action: "retry_later", audience: "operator" });
+      }
     } catch (e) {
       conn.close();
       throw e;
@@ -120,7 +171,10 @@ var GatewayConnection = class _GatewayConnection {
       const p = this.pending.get(frame.id);
       this.pending.delete(frame.id);
       if (frame.ok) p.resolve(frame.payload);
-      else p.reject(new GatewayError(frame.error?.message || "Gateway request failed", frame.error?.code));
+      else {
+        const e = frame.error;
+        p.reject(new GatewayError(e?.message || "Gateway request failed", e?.code, parseRemediation(e?.details?.remediation), e?.retryAfterMs));
+      }
     } else if (frame.type === "event" && frame.event) {
       for (const cb of this.listeners) cb(frame.event, frame.payload);
     }
@@ -134,8 +188,13 @@ var GatewayConnection = class _GatewayConnection {
 function buildSessionKey(agent, conversationId) {
   return `agent:${agent}:ws:direct:${conversationId}`;
 }
+function actorOf(opts) {
+  if (opts.identitySession) return { identitySession: opts.identitySession };
+  if (opts.userId) return opts.userId;
+  throw new GatewayError("A user id or an identity session is required", "invalid_actor");
+}
 async function* streamChat(opts) {
-  const conn = await GatewayConnection.connect(opts.creds, opts.userId);
+  const conn = opts.connection ?? await GatewayConnection.connect(opts.creds, actorOf(opts));
   const queue = [];
   let wake = null;
   let finished = false;
@@ -188,7 +247,8 @@ async function* streamChat(opts) {
     push({ type: "done", content: res?.content ?? "", usage: res?.usage });
     end();
   }).catch((err) => {
-    if (!finished) push({ type: "error", message: err.message, code: err.code });
+    if (!finished && isAdmissionErrorCode(err.code)) push(admissionErrorEvent(err.code, err.retryAfterMs, err.message));
+    else if (!finished) push(err.remediation ? { type: "error", message: err.message, code: err.code, remediation: err.remediation } : { type: "error", message: err.message, code: err.code });
     end();
   });
   try {
@@ -212,8 +272,8 @@ function clip(v, max = 4e3) {
   const s = typeof v === "string" ? v : JSON.stringify(v);
   return s.length > max ? s.slice(0, max) + "\u2026" : s;
 }
-async function fetchHistory(creds, userId, agent, sessionKey) {
-  const conn = await GatewayConnection.connect(creds, userId);
+async function fetchHistory(creds, actor, agent, sessionKey) {
+  const conn = await GatewayConnection.connect(creds, actor);
   try {
     const res = await conn.call("chat.history", { agentId: agent, sessionKey }, 15e3);
     return foldHistory(res?.messages ?? []);
@@ -270,6 +330,9 @@ function b64url(bytes) {
   for (const b of bytes) s += String.fromCharCode(b);
   return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
+async function sha256B64url(s) {
+  return b64url(new Uint8Array(await crypto.subtle.digest("SHA-256", enc.encode(s))));
+}
 function fromB64url(s) {
   const bin = atob(s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4));
   return Uint8Array.from(bin, (c) => c.charCodeAt(0));
@@ -283,32 +346,162 @@ function hmacKey(secret) {
   }
   return k;
 }
-async function signVisitorToken(secret, claims) {
-  const body = b64url(enc.encode(JSON.stringify(claims)));
+var MAX_IDENTITY_SESSION_LENGTH = 512;
+var MAX_SEALED_PLAINTEXT = '{"t":"","h":""}'.length + 6 * MAX_IDENTITY_SESSION_LENGTH + 43;
+var MAX_SEALED_LENGTH = Math.ceil((12 + MAX_SEALED_PLAINTEXT + 16) * 4 / 3);
+var AGENT_CLAIM_RE = /^[A-Za-z0-9_.:-]{1,64}$/;
+var MAX_EDGE_SESSION_LENGTH = 1024;
+var MAX_SEALED_EDGE_LENGTH = Math.ceil((12 + '{"t":""}'.length + 6 * MAX_EDGE_SESSION_LENGTH + 16) * 4 / 3);
+var IDENTITY_SEAL_INFO = "dewee-webchat:identity-session:aes-256-gcm:v1";
+var EDGE_SEAL_INFO = "dewee-webchat:edge-session:aes-256-gcm:v1";
+var sealKeyCache = /* @__PURE__ */ new Map();
+function sealKey(secret, info = IDENTITY_SEAL_INFO) {
+  const id = `${info}
+${secret}`;
+  let k = sealKeyCache.get(id);
+  if (!k) {
+    k = crypto.subtle.importKey("raw", enc.encode(secret), "HKDF", false, ["deriveKey"]).then(
+      (base) => crypto.subtle.deriveKey(
+        { name: "HKDF", hash: "SHA-256", salt: enc.encode("dewee-webchat"), info: enc.encode(info) },
+        base,
+        { name: "AES-GCM", length: 256 },
+        false,
+        ["encrypt", "decrypt"]
+      )
+    );
+    sealKeyCache.set(id, k);
+  }
+  return k;
+}
+var edgeAad = (v) => enc.encode(`dewee-webchat:es:${v}`);
+async function sealEdgeSession(secret, v, token) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const ct = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData: edgeAad(v) }, await sealKey(secret, EDGE_SEAL_INFO), enc.encode(JSON.stringify({ t: token }))));
+  const out = new Uint8Array(iv.length + ct.length);
+  out.set(iv);
+  out.set(ct, iv.length);
+  return b64url(out);
+}
+async function openEdgeSession(secret, v, sealed) {
+  const raw = fromB64url(sealed);
+  if (raw.length <= 12 + 16) return null;
+  try {
+    const pt = await crypto.subtle.decrypt({ name: "AES-GCM", iv: raw.slice(0, 12), additionalData: edgeAad(v) }, await sealKey(secret, EDGE_SEAL_INFO), raw.slice(12));
+    const parsed = JSON.parse(new TextDecoder().decode(pt));
+    return typeof parsed?.t === "string" && parsed.t !== "" && parsed.t.length <= MAX_EDGE_SESSION_LENGTH ? parsed.t : null;
+  } catch {
+    return null;
+  }
+}
+var sealAad = (v, agent) => enc.encode(`dewee-webchat:ids:${v}:${agent}`);
+async function sealIdentitySession(secret, v, agent, sealed) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const ct = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData: sealAad(v, agent) }, await sealKey(secret), enc.encode(JSON.stringify(sealed))));
+  const out = new Uint8Array(iv.length + ct.length);
+  out.set(iv);
+  out.set(ct, iv.length);
+  return b64url(out);
+}
+async function openIdentitySession(secret, v, agent, sealed) {
+  const raw = fromB64url(sealed);
+  if (raw.length <= 12 + 16) return null;
+  try {
+    const pt = await crypto.subtle.decrypt({ name: "AES-GCM", iv: raw.slice(0, 12), additionalData: sealAad(v, agent) }, await sealKey(secret), raw.slice(12));
+    const parsed = JSON.parse(new TextDecoder().decode(pt));
+    if (typeof parsed?.t !== "string" || parsed.t === "" || parsed.t.length > MAX_IDENTITY_SESSION_LENGTH) return null;
+    if (parsed.h !== void 0 && typeof parsed.h !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function subjectDigest(secret, subject) {
+  const mac = new Uint8Array(await crypto.subtle.sign("HMAC", await hmacKey(secret), enc.encode(`dewee-webchat:subject:${subject}`)));
+  return b64url(mac);
+}
+function constantTimeEqual(a, b) {
+  const x = enc.encode(a);
+  const y = enc.encode(b);
+  let diff = x.length ^ y.length;
+  for (let i = 0; i < Math.max(x.length, y.length); i++) diff |= (x[i] ?? 0) ^ (y[i] ?? 0);
+  return diff === 0;
+}
+var REUSE_HINT_PURPOSE = "reuse";
+function signVisitorToken(secret, claims) {
+  return signClaims(secret, claims);
+}
+function signReuseHint(secret, claims) {
+  if (!claims.ids || !claims.ida || !claims.sub) throw new Error("a reuse hint needs a signed-in session with its subject digest");
+  return signClaims(secret, claims, REUSE_HINT_PURPOSE);
+}
+function verifyVisitorToken(secret, token) {
+  return verifyClaims(secret, token);
+}
+async function verifyReuseHint(secret, token) {
+  const claims = await verifyClaims(secret, token, REUSE_HINT_PURPOSE);
+  return claims?.ids && claims.sub ? claims : null;
+}
+async function signClaims(secret, claims, purpose) {
+  let wire = claims;
+  if (claims.ids !== void 0 && claims.ida !== void 0) {
+    const { sub, ...rest } = claims;
+    wire = { ...rest, ids: await sealIdentitySession(secret, claims.v, claims.ida, sub ? { t: claims.ids, h: sub } : { t: claims.ids }) };
+  }
+  if (claims.es !== void 0) {
+    if (typeof claims.es !== "string" || claims.es === "" || claims.es.length > MAX_EDGE_SESSION_LENGTH) throw new Error("edge session token is empty or too long");
+    if (typeof claims.ese !== "number" || !Number.isFinite(claims.ese)) throw new Error("edge session expiry is required");
+    wire = { ...wire, es: await sealEdgeSession(secret, claims.v, claims.es) };
+  }
+  if (purpose) wire = { ...wire, p: purpose };
+  const body = b64url(enc.encode(JSON.stringify(wire)));
   const sig = new Uint8Array(await crypto.subtle.sign("HMAC", await hmacKey(secret), enc.encode(body)));
   return `${body}.${b64url(sig)}`;
 }
-async function verifyVisitorToken(secret, token) {
+async function verifyClaims(secret, token, purpose) {
+  if (typeof token !== "string") return null;
   const [body, sig] = token.split(".");
   if (!body || !sig) return null;
   try {
     const ok = await crypto.subtle.verify("HMAC", await hmacKey(secret), fromB64url(sig), enc.encode(body));
     if (!ok) return null;
     const claims = JSON.parse(new TextDecoder().decode(fromB64url(body)));
+    if (claims.p !== purpose) return null;
     if (typeof claims.v !== "string" || !/^[A-Za-z0-9_-]{8,64}$/.test(claims.v)) return null;
     if (typeof claims.exp !== "number" || claims.exp < Date.now()) return null;
-    return claims;
+    let edge = {};
+    if (claims.es !== void 0 || claims.ese !== void 0) {
+      if (typeof claims.es !== "string" || claims.es === "" || claims.es.length > MAX_SEALED_EDGE_LENGTH) return null;
+      if (typeof claims.ese !== "number" || !Number.isFinite(claims.ese)) return null;
+      const es = await openEdgeSession(secret, claims.v, claims.es);
+      if (!es) return null;
+      edge = { es, ese: claims.ese };
+    }
+    if (claims.ids !== void 0 || claims.ida !== void 0) {
+      if (typeof claims.ids !== "string" || claims.ids === "" || claims.ids.length > MAX_SEALED_LENGTH) return null;
+      if (typeof claims.ida !== "string" || !AGENT_CLAIM_RE.test(claims.ida)) return null;
+      if (claims.sub !== void 0) return null;
+      const opened = await openIdentitySession(secret, claims.v, claims.ida, claims.ids);
+      if (!opened) return null;
+      return opened.h ? { v: claims.v, exp: claims.exp, ids: opened.t, ida: claims.ida, sub: opened.h, ...edge } : { v: claims.v, exp: claims.exp, ids: opened.t, ida: claims.ida, ...edge };
+    }
+    if (purpose !== void 0) return { v: claims.v, exp: claims.exp, ...edge };
+    return claims.es !== void 0 ? { v: claims.v, exp: claims.exp, ...edge } : claims;
   } catch {
     return null;
   }
 }
+async function deriveVisitorId(secret, label) {
+  const mac = new Uint8Array(await crypto.subtle.sign("HMAC", await hmacKey(secret), enc.encode(`dewee-webchat:visitor:${label}`)));
+  return b64url(mac.slice(0, 16));
+}
 function randomId(bytes = 16) {
   return b64url(crypto.getRandomValues(new Uint8Array(bytes)));
 }
+var DEFAULT_PREAUTH_LIMIT = [120, 6e4];
 function memoryRateLimiter(limits) {
   const windows = /* @__PURE__ */ new Map();
   return (key, bucket) => {
-    const [max, windowMs] = limits[bucket];
+    const [max, windowMs] = limits[bucket] ?? (bucket === "preauth" ? DEFAULT_PREAUTH_LIMIT : limits.session);
     const id = `${bucket}:${key}`;
     const now = Date.now();
     const w = windows.get(id);
@@ -333,9 +526,676 @@ async function verifyTurnstile(secret, response, ip) {
   return data.success === true;
 }
 
+// src/server/identity-errors.ts
+var IDENTITY_ERRORS = {
+  IDENTITY_REQUIRED: { status: 401, message: "Sign in to continue.", action: "reauthenticate" },
+  LINK_EXPIRED: { status: 401, message: "Your session expired.", action: "reauthenticate" },
+  LINK_REVOKED: { status: 401, message: "Your access was revoked.", action: "reauthenticate" },
+  IDENTITY_LINK_REQUIRED: { status: 403, message: "Link your account to continue.", action: "send_connect_link" },
+  PERMISSION_DENIED: { status: 403, message: "You are not allowed to do this.", action: "contact_admin" },
+  IDENTITY_CONFLICT: { status: 409, message: "This account is linked to another user.", action: "contact_admin" },
+  SOURCE_UNAVAILABLE: { status: 503, message: "Your sign-in could not be checked. Try again later.", action: "retry_later" }
+};
+var DEAD_SESSION_CODES = /* @__PURE__ */ new Set(["IDENTITY_REQUIRED", "LINK_EXPIRED", "LINK_REVOKED"]);
+
+// src/server/ccp-client.ts
+var INTEGRATION_ID_RE = /^wci_[a-z2-7]{26}$/;
+var SECRET_RE = /^dwc_[A-Za-z0-9_-]{16,256}$/;
+var INGRESS_PATH_RE = /\/api\/public\/webchat\/v1\/(wci_[a-z2-7]{26})$/;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+var CODE_RE = /^[A-Za-z0-9_.-]{1,64}$/;
+var CCP_JSON_TIMEOUT_MS = 15e3;
+var REMEDIATION_ACTIONS = /* @__PURE__ */ new Set(["send_connect_link", "ask_user_to_dm", "retry_later", "contact_admin", "reauthenticate"]);
+var REMEDIATION_AUDIENCES = /* @__PURE__ */ new Set(["end_user", "operator", "integrator"]);
+function knownRemediation(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const { action, audience } = raw;
+  return typeof action === "string" && typeof audience === "string" && REMEDIATION_ACTIONS.has(action) && REMEDIATION_AUDIENCES.has(audience) ? { action, audience } : void 0;
+}
+function withDeadline(signal, ms) {
+  const ctl = new AbortController();
+  let fired = false;
+  const timer = setTimeout(() => {
+    fired = true;
+    ctl.abort(new DOMException("CCP request timed out", "TimeoutError"));
+  }, ms);
+  const onAbort = () => ctl.abort(signal?.reason);
+  if (signal?.aborted) ctl.abort(signal.reason);
+  else signal?.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: ctl.signal,
+    timedOut: () => fired && !signal?.aborted,
+    dispose() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+function parseCcpOptions(raw) {
+  const refuse = (why) => {
+    throw new Error(`[dewee-webchat] ccp: ${why}`);
+  };
+  if (!raw || typeof raw !== "object") return refuse("options are required (chatUrl, integrationId, integrationSecret)");
+  const { chatUrl, integrationId, integrationSecret } = raw;
+  if (typeof chatUrl !== "string" || chatUrl.trim() === "") refuse("chatUrl (DEWEE_CCP_CHAT_URL) is required");
+  if (typeof integrationId !== "string" || integrationId === "") refuse("integrationId (DEWEE_WEBCHAT_INTEGRATION_ID) is required");
+  if (typeof integrationSecret !== "string" || integrationSecret === "") refuse("integrationSecret (DEWEE_WEBCHAT_INTEGRATION_SECRET) is required");
+  let u;
+  try {
+    u = new URL(chatUrl.trim());
+  } catch {
+    return refuse("chatUrl is not a valid URL");
+  }
+  if (u.username || u.password) refuse("chatUrl must not contain credentials");
+  if (u.search || u.hash) refuse("chatUrl must not contain a query or fragment");
+  const loopback = LOOPBACK_HOSTS.has(u.hostname.toLowerCase());
+  if (u.protocol !== "https:" && !(u.protocol === "http:" && loopback)) refuse("chatUrl must use https (plain http is allowed for localhost only)");
+  const path = u.pathname.replace(/\/+$/, "");
+  const m = INGRESS_PATH_RE.exec(path);
+  if (!m) refuse("chatUrl must end with /api/public/webchat/v1/<integration id> (copy it from the CCP Website chat page)");
+  if (!INTEGRATION_ID_RE.test(integrationId)) refuse("integrationId must look like wci_ followed by 26 characters");
+  if (m[1] !== integrationId) refuse("integrationId does not match the id in chatUrl");
+  if (!SECRET_RE.test(integrationSecret)) refuse("integrationSecret must be the dwc_ secret the CCP Website chat page shows (not a CCP or gateway API key)");
+  if (raw.fetch !== void 0 && typeof raw.fetch !== "function") refuse("fetch must be a function");
+  return { chatUrl: `${u.origin}${path}`, integrationId, integrationSecret, fetch: raw.fetch, origin: u.origin };
+}
+var CcpError = class extends Error {
+  constructor(status, code, message, retryAfterSeconds, remediation) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.retryAfterSeconds = retryAfterSeconds;
+    this.remediation = remediation;
+    this.name = "CcpError";
+  }
+  status;
+  code;
+  retryAfterSeconds;
+  remediation;
+};
+var VISITOR_IP_RE = /^[0-9A-Fa-f:.]{2,64}$/;
+var CcpClient = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.fetchImpl = cfg.fetch ?? ((input, init) => fetch(input, init));
+  }
+  cfg;
+  fetchImpl;
+  get integrationId() {
+    return this.cfg.integrationId;
+  }
+  /** Sends one request and returns the response when it is a 2xx; throws {@link CcpError} otherwise. */
+  async send(route, req = {}) {
+    const url = `${this.cfg.chatUrl}/${route}`;
+    const headers = {
+      authorization: `Bearer ${this.cfg.integrationSecret}`,
+      accept: req.accept ?? "application/json"
+    };
+    if (req.body !== void 0) headers["content-type"] = "application/json";
+    if (req.session) headers["x-dewee-webchat-session"] = req.session;
+    if (req.visitorOrigin) headers["x-dewee-visitor-origin"] = req.visitorOrigin;
+    if (req.visitorIp && VISITOR_IP_RE.test(req.visitorIp)) headers["x-dewee-visitor-ip"] = req.visitorIp;
+    if (req.requestId) headers["x-request-id"] = req.requestId;
+    if (req.idempotencyKey) headers["idempotency-key"] = req.idempotencyKey;
+    let res;
+    try {
+      res = await this.fetchImpl(url, {
+        method: req.method ?? (req.body !== void 0 ? "POST" : "GET"),
+        headers,
+        body: req.body !== void 0 ? JSON.stringify(req.body) : void 0,
+        redirect: "manual",
+        signal: req.signal
+      });
+    } catch (e) {
+      if (req.signal?.aborted) throw e;
+      throw new CcpError(0, "ccp_unreachable", `CCP request failed: ${e?.name ?? "error"}`);
+    }
+    if (res.type === "opaqueredirect" || res.status >= 300 && res.status < 400) {
+      await res.body?.cancel().catch(() => {
+      });
+      throw new CcpError(res.status, "ccp_redirect", `CCP answered ${res.status} with a redirect; redirects are never followed`);
+    }
+    if (res.ok) return res;
+    throw await errorFrom(res);
+  }
+  /**
+   * {@link send} and parse a JSON object body, within {@link CCP_JSON_TIMEOUT_MS} (headers and body)
+   * on top of the caller's own signal. A deadline that passes is `ccp_timeout`; a caller that aborts
+   * gets its own abort error.
+   */
+  async json(route, req = {}) {
+    const deadline = withDeadline(req.signal, CCP_JSON_TIMEOUT_MS);
+    const timeout = () => new CcpError(0, "ccp_timeout", `CCP ${route} did not answer within ${CCP_JSON_TIMEOUT_MS} ms`);
+    try {
+      const res = await this.send(route, { ...req, signal: deadline.signal });
+      const data = await res.json().catch(() => null);
+      if (deadline.timedOut()) throw timeout();
+      if (data === null || typeof data !== "object" || Array.isArray(data)) throw new CcpError(res.status, "ccp_bad_response", `CCP ${route} returned a body that is not a JSON object`);
+      return data;
+    } catch (e) {
+      if (deadline.timedOut() && !(e instanceof CcpError && e.code === "ccp_timeout")) throw timeout();
+      throw e;
+    } finally {
+      deadline.dispose();
+    }
+  }
+};
+async function errorFrom(res) {
+  const data = await res.json().catch(() => null);
+  const e = data?.error;
+  const code = typeof e?.code === "string" && CODE_RE.test(e.code) ? e.code : `http_${res.status}`;
+  const message = typeof e?.message === "string" ? e.message.slice(0, 500) : `HTTP ${res.status}`;
+  const header = Number(res.headers.get("retry-after"));
+  const retry = Number.isFinite(e?.retry_after_seconds) && e.retry_after_seconds > 0 ? Number(e.retry_after_seconds) : header > 0 ? header : void 0;
+  return new CcpError(res.status, code, message, retry, knownRemediation(e?.remediation));
+}
+async function* readSseJson(body, maxFrameBytes = 1048576) {
+  const reader = body.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  let heldCr = false;
+  const frameData = (frame) => frame.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).replace(/^ /, "")).join("\n");
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      let text = done ? dec.decode() : dec.decode(value, { stream: true });
+      if (heldCr) text = `\r${text}`;
+      heldCr = !done && text.endsWith("\r");
+      if (heldCr) text = text.slice(0, -1);
+      buf += text.replace(/\r\n?/g, "\n");
+      let idx;
+      while ((idx = buf.indexOf("\n\n")) >= 0) {
+        const data2 = frameData(buf.slice(0, idx));
+        buf = buf.slice(idx + 2);
+        if (!data2) continue;
+        try {
+          yield JSON.parse(data2);
+        } catch {
+        }
+      }
+      if (buf.length > maxFrameBytes) throw new CcpError(502, "ccp_bad_response", "CCP stream frame too large");
+      if (done) break;
+    }
+    const data = frameData(buf);
+    if (data) {
+      try {
+        yield JSON.parse(data);
+      } catch {
+      }
+    }
+  } finally {
+    reader.cancel().catch(() => {
+    });
+  }
+}
+
+// src/server/transport-selection.ts
+var legacyWarned = false;
+function resolveTransport(o) {
+  const refuse = (why) => {
+    throw new Error(`[dewee-webchat] ${why}`);
+  };
+  if (o.transport !== void 0 && o.transport !== "ccp" && o.transport !== "legacy-gateway") refuse(`transport must be "ccp" or "legacy-gateway"`);
+  const hasCcp = o.ccp !== void 0 && o.ccp !== null && Object.values(o.ccp).some((v) => v !== void 0 && v !== "");
+  const gatewayOptions = ["gatewayUrl", "token", "tenantId"].filter((k) => o[k] !== void 0 && o[k] !== "");
+  const transport = o.transport ?? (hasCcp ? "ccp" : "legacy-gateway");
+  if (transport === "ccp") {
+    if (!hasCcp) refuse('transport "ccp" needs ccp options (DEWEE_CCP_CHAT_URL, DEWEE_WEBCHAT_INTEGRATION_ID, DEWEE_WEBCHAT_INTEGRATION_SECRET)');
+    if (gatewayOptions.length) {
+      refuse(`both CCP and gateway options are set (${gatewayOptions.join(", ")}); remove the gateway ones (DEWEE_GATEWAY_URL, DEWEE_GATEWAY_TOKEN, DEWEE_TENANT_ID), or set transport "legacy-gateway" and remove the CCP ones`);
+    }
+    if (o.allowClientCredentials) refuse("allowClientCredentials does not apply to the ccp transport");
+    if (o.agents !== void 0 && !(Array.isArray(o.agents) && o.agents.length === 0)) refuse("agents does not apply to the ccp transport: choose the agents on the CCP Website chat page");
+    if (o.defaultAgent) refuse("defaultAgent does not apply to the ccp transport: choose the default agent on the CCP Website chat page");
+    if (!o.secret || new TextEncoder().encode(o.secret).length < 32) refuse("the ccp transport needs secret (DEWEE_WEBCHAT_SECRET), at least 32 bytes");
+    return transport;
+  }
+  if (hasCcp) refuse('transport "legacy-gateway" is set together with ccp options; remove one of them');
+  if (!legacyWarned) {
+    legacyWarned = true;
+    console.warn(
+      '[dewee-webchat] transport "legacy-gateway" (a direct Gateway URL and token) is deprecated. Create a Website chat integration in CCP and switch to transport "ccp": https://github.com/nextlevelbuilder/dewee-webchat/blob/main/docs/migrating-to-ccp-transport.md'
+    );
+  }
+  return transport;
+}
+
+// src/server/job-access.ts
+var JobAccessRefusal = class extends Error {
+  constructor(code) {
+    super("Job access was refused");
+    this.code = code;
+  }
+  code;
+};
+async function mintJobAccess(gatewayUrl, identitySession, launchOrigin) {
+  const gateway = new URL(gatewayUrl);
+  if (gateway.protocol !== "https:" || gateway.username || gateway.password || gateway.search || gateway.hash || gateway.pathname !== "/") {
+    throw new Error("Job access is unavailable");
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const response = await fetch(new URL("/v1/identity/job-access/launch", gateway), {
+      method: "POST",
+      redirect: "error",
+      signal: controller.signal,
+      headers: { "Content-Type": "application/json", "X-Dewee-Identity-Session": identitySession },
+      body: JSON.stringify({ launch_origin: launchOrigin })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      const code = data?.error?.code;
+      if (isIdentityErrorCode(code)) throw new JobAccessRefusal(code);
+      throw new Error("Job access is unavailable");
+    }
+    const launch = parseJobAccessLaunch(data);
+    if (new URL(launch.bootstrap_url).origin !== gateway.origin || launch.launch_token === identitySession) {
+      throw new Error("Job access is unavailable");
+    }
+    return launch;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// src/server/ccp-transport.ts
+var CCP_AGENT_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,99}$/;
+async function ccpIdempotencyKey(key) {
+  return sha256B64url(key);
+}
+var CCP_ID_RE = /^[A-Za-z0-9_-]{8,64}$/;
+var EDGE_TOKEN_RE = /^dws1\.[A-Za-z0-9_.-]{1,1019}$/;
+var MAX_IDENTITY_SESSION_LENGTH2 = 512;
+var CONFIG_TTL_MS = 6e4;
+var EDGE_MARGIN_MS = 3e4;
+var EDGE_RESEAL_MS = 15 * 6e4;
+var CHANNEL_RE = /^[A-Za-z0-9_.-]{1,64}$/;
+var EDGE_REFRESH_WINDOW_MS = 24 * 36e5;
+var MAX_CACHED_EDGES = 5e3;
+var GENERIC_UNAVAILABLE = { status: 502, code: "gateway_error", message: "Dewee is unavailable, try again later" };
+function browserErrorFor(e, route) {
+  if (!(e instanceof CcpError)) {
+    console.error(`[dewee-webchat] ccp ${route} failed:`, e?.name ?? "error");
+    return GENERIC_UNAVAILABLE;
+  }
+  const log = (level, hint) => console[level](`[dewee-webchat] ccp ${route}: ${e.code} (HTTP ${e.status}) ${hint}`);
+  if (isIdentityErrorCode(e.code)) return { status: IDENTITY_ERRORS[e.code].status, code: e.code, message: IDENTITY_ERRORS[e.code].message, identity: e.code, remediation: e.remediation };
+  const retryAfterMs = e.retryAfterSeconds ? e.retryAfterSeconds * 1e3 : void 0;
+  if (route === "chat") {
+    if (isAdmissionErrorCode(e.code)) return { status: e.code === "RATE_LIMITED" ? 429 : 403, code: e.code, message: "", admission: e.code, retryAfterMs };
+    if (e.code === "rate_limited" || e.code === "concurrency_limited" || e.status === 429) return { status: 429, code: "RATE_LIMITED", message: "", admission: "RATE_LIMITED", retryAfterMs };
+  }
+  switch (e.code) {
+    case "invalid_request":
+      log("error", "- the ingress refused the request shape; check the dewee-webchat version");
+      return { status: 400, code: "bad_request", message: "Invalid request" };
+    case "integration_unauthorized":
+      log("error", "- check DEWEE_WEBCHAT_INTEGRATION_SECRET (wrong, rotated past its overlap, or revoked) and DEWEE_CCP_CHAT_URL");
+      return { status: 500, code: "not_configured", message: "Chat is not configured on this server" };
+    case "integration_disabled":
+    case "workspace_unavailable":
+    case "agent_unavailable":
+      log("error", "- the integration, its workspace or its agent is not active (see the CCP Website chat page)");
+      return { status: 503, code: "unavailable", message: "Chat is unavailable right now, try again later" };
+    case "agent_not_allowed":
+      return { status: 403, code: "agent_not_allowed", message: "Agent not allowed" };
+    case "origin_not_allowed":
+      log("warn", "- the visitor origin is not in the integration's allowed sites");
+      return { status: 403, code: "forbidden_origin", message: "Origin not allowed" };
+    case "not_found":
+      return { status: 404, code: "not_found", message: "Not found" };
+    case "run_in_progress":
+      return { status: 409, code: "run_in_progress", message: "Still answering the previous message" };
+    case "message_too_large":
+      return { status: 413, code: "too_long", message: "Message is too long" };
+    case "rate_limited":
+    case "concurrency_limited":
+      return { status: 429, code: "rate_limited", message: "Too many messages, please wait a moment", retryAfterSeconds: e.retryAfterSeconds };
+    case "idempotency_key_reused":
+      return { status: 409, code: "idempotency_key_reused", message: "This idempotency key was already used for a different link request" };
+    case "link_in_progress":
+      return { status: 409, code: "link_in_progress", message: "A link is already in progress. Use its code or wait until it expires." };
+    case "linking_unavailable":
+      return { status: 503, code: "linking_unavailable", message: "Linking is not available right now" };
+    case "ccp_redirect":
+      log("error", "- refused to follow a redirect; DEWEE_CCP_CHAT_URL must be the final ingress URL");
+      return GENERIC_UNAVAILABLE;
+    case "ccp_timeout":
+      log("error", "- CCP did not answer in time");
+      return GENERIC_UNAVAILABLE;
+    default:
+      if (e.status === 429) return { status: 429, code: "rate_limited", message: "Too many messages, please wait a moment", retryAfterSeconds: e.retryAfterSeconds };
+      log("error", "");
+      return GENERIC_UNAVAILABLE;
+  }
+}
+function streamError(code, remediation, retryAfterMs) {
+  if (isIdentityErrorCode(code)) {
+    const valid = knownRemediation(remediation);
+    return { type: "error", code, message: IDENTITY_ERRORS[code].message, ...valid ? { remediation: valid } : {} };
+  }
+  if (code === "cancelled") return { type: "error", code: "cancelled", message: "Cancelled" };
+  if (code === "rate_limited" || code === "concurrency_limited") return admissionErrorEvent("RATE_LIMITED", retryAfterMs);
+  if (isAdmissionErrorCode(code)) return admissionErrorEvent(code, retryAfterMs);
+  if (code === "run_failed") return { type: "error", code: "run_failed", message: "The agent could not answer, please try again" };
+  return { type: "error", code: "gateway_error", message: "Dewee is unavailable, try again later" };
+}
+var str = (v, max) => typeof v === "string" ? v.slice(0, max) : void 0;
+function parseConfig(data) {
+  const bad = (why) => {
+    throw new CcpError(200, "ccp_bad_response", `CCP config: ${why}`);
+  };
+  const rawAgents = Array.isArray(data.agents) ? data.agents : [];
+  const agents = [];
+  for (const a of rawAgents.slice(0, 50)) {
+    const key = a?.key;
+    if (typeof key !== "string" || !CCP_AGENT_RE.test(key) || agents.some((x) => x.id === key)) continue;
+    const name = str(a.name, 200);
+    const description = str(a.description, 1e3);
+    agents.push({ id: key, ...name ? { name } : {}, ...description ? { description } : {} });
+  }
+  if (!agents.length) bad("no agent");
+  const def = typeof data.default_agent_key === "string" && agents.some((a) => a.id === data.default_agent_key) ? data.default_agent_key : agents[0].id;
+  const mode = data.mode === "signed_in_optional" || data.mode === "signed_in_required" ? data.mode : "anonymous";
+  const max = Number(data.max_message_chars);
+  return {
+    agents,
+    defaultAgent: def,
+    // Without the flag, switching follows the number of agents.
+    allowAgentSwitch: typeof data.allow_agent_switch === "boolean" ? data.allow_agent_switch && agents.length > 1 : agents.length > 1,
+    mode,
+    identityEnabled: data.identity_enabled === true,
+    // Reasoning and tool activity stay hidden unless the integration turns them on explicitly.
+    showThinking: data.show_thinking === true,
+    showToolActivity: data.show_tool_activity === true,
+    maxMessageChars: Number.isInteger(max) && max > 0 ? max : Number.POSITIVE_INFINITY
+  };
+}
+function numericUsage(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(raw).slice(0, 32)) if (typeof v === "number" && Number.isFinite(v) && /^[a-z0-9_]{1,64}$/i.test(k)) out[k] = v;
+  return Object.keys(out).length ? out : void 0;
+}
+function createCcpTransport(client, identity) {
+  let config;
+  let pendingConfig;
+  const edges = /* @__PURE__ */ new Map();
+  async function getConfig() {
+    if (config && Date.now() - config.at < CONFIG_TTL_MS) return config.value;
+    pendingConfig ??= client.json("config").then((data) => {
+      const value = parseConfig(data);
+      config = { value, at: Date.now() };
+      return value;
+    }).finally(() => {
+      pendingConfig = void 0;
+    });
+    return pendingConfig;
+  }
+  function remember(visitorId, edge) {
+    edges.delete(visitorId);
+    edges.set(visitorId, edge);
+    if (edges.size > MAX_CACHED_EDGES) {
+      const now = Date.now();
+      for (const [k, v] of edges) if (now - v.expiresAt > EDGE_REFRESH_WINDOW_MS) edges.delete(k);
+      for (const k of edges.keys()) {
+        if (edges.size <= MAX_CACHED_EDGES) break;
+        edges.delete(k);
+      }
+    }
+    return edge;
+  }
+  const base = (ctx) => ({ visitorOrigin: ctx.visitorOrigin, visitorIp: ctx.visitorIp, requestId: ctx.requestId });
+  async function openEdge(ctx, visitorId, previous) {
+    const data = await client.json("session", { ...base(ctx), body: previous ? {} : { visitor_id: visitorId }, session: previous });
+    const token = data.session;
+    if (typeof token !== "string" || !EDGE_TOKEN_RE.test(token)) throw new CcpError(200, "ccp_bad_response", "CCP session: no edge session token");
+    if (data.visitor_id !== void 0 && data.visitor_id !== visitorId) throw new CcpError(200, "ccp_bad_response", "CCP session: visitor mismatch");
+    const seconds = Number(data.expires_in);
+    const lifetime = Number.isFinite(seconds) && seconds > 0 ? Math.min(seconds * 1e3, EDGE_REFRESH_WINDOW_MS) : 36e5;
+    return remember(visitorId, { token, expiresAt: Date.now() + lifetime });
+  }
+  async function edgeFor(ctx, visitorId, sealed, force, minRemainingMs = EDGE_MARGIN_MS) {
+    const now = Date.now();
+    const cached = edges.get(visitorId);
+    const known = [cached, sealed].filter((e) => !!e).sort((a, b) => b.expiresAt - a.expiresAt)[0];
+    if (!force && known && known.expiresAt - now > minRemainingMs) return known;
+    if (force !== "create" && known && now - known.expiresAt < EDGE_REFRESH_WINDOW_MS - EDGE_MARGIN_MS) {
+      try {
+        return await openEdge(ctx, visitorId, known.token);
+      } catch (e) {
+        if (!(e instanceof CcpError && (e.code === "ingress_session_invalid" || e.code === "ingress_session_expired"))) throw e;
+      }
+    }
+    return openEdge(ctx, visitorId);
+  }
+  async function withEdge(ctx, visitorId, sealed, call) {
+    const edge = await edgeFor(ctx, visitorId, sealed);
+    try {
+      return await call(edge);
+    } catch (e) {
+      if (!(e instanceof CcpError)) throw e;
+      if (e.code === "ingress_session_expired") return call(await edgeFor(ctx, visitorId, edge, "refresh"));
+      if (e.code === "ingress_session_invalid") {
+        edges.delete(visitorId);
+        return call(await edgeFor(ctx, visitorId, void 0, "create"));
+      }
+      throw e;
+    }
+  }
+  const withAgent = (agent) => agent ? { agent } : {};
+  return {
+    config: getConfig,
+    edgeFor,
+    /** Starts a turn. Resolves once CCP accepted it (2xx, SSE); refusals reject with {@link CcpError}. */
+    async startChat(ctx, visitorId, sealed, input) {
+      const body = {
+        message: input.message,
+        conversation_id: input.conversationId,
+        ...withAgent(input.agent),
+        ...input.identitySession ? { identity_session: input.identitySession } : {}
+      };
+      return withEdge(ctx, visitorId, sealed, (edge) => client.send("chat", { ...base(ctx), body, session: edge.token, accept: "text/event-stream", signal: input.signal }));
+    },
+    /**
+     * Browser events of an accepted turn: exactly one `start` first and exactly one terminal event
+     * (`done` or `error`) last. Reasoning and tool frames pass only when the integration shows them,
+     * tool arguments and results never; unknown frames are dropped.
+     */
+    async *chatEvents(res, cfg, conversationId, requestedAgent) {
+      let started = false;
+      const start = (f) => {
+        started = true;
+        const agent = typeof f?.agent === "string" && CCP_AGENT_RE.test(f.agent) ? f.agent : requestedAgent;
+        const runId = typeof f?.runId === "string" && f.runId.length <= 128 ? f.runId : void 0;
+        return { type: "start", conversationId, agent, ...runId ? { runId } : {} };
+      };
+      if (!res.body) {
+        yield start();
+        yield streamError("gateway_error", void 0);
+        return;
+      }
+      for await (const f of readSseJson(res.body)) {
+        if (!f || typeof f !== "object") continue;
+        if (f.type === "start") {
+          if (!started) yield start(f);
+          continue;
+        }
+        if (!started) yield start();
+        switch (f.type) {
+          case "delta":
+            if (typeof f.text === "string") yield { type: "delta", text: f.text };
+            break;
+          case "thinking":
+            if (cfg.showThinking && typeof f.text === "string") yield { type: "thinking", text: f.text };
+            break;
+          case "tool_call":
+            if (cfg.showToolActivity && typeof f.id === "string" && typeof f.name === "string") yield { type: "tool_call", id: f.id.slice(0, 128), name: f.name.slice(0, 128) };
+            break;
+          case "tool_result":
+            if (cfg.showToolActivity && typeof f.id === "string" && typeof f.name === "string") yield { type: "tool_result", id: f.id.slice(0, 128), name: f.name.slice(0, 128), isError: f.isError === true };
+            break;
+          case "done": {
+            const usage = numericUsage(f.usage);
+            yield { type: "done", content: typeof f.content === "string" ? f.content : "", ...usage ? { usage } : {} };
+            return;
+          }
+          case "error":
+            yield streamError(f.code, f.remediation, f.retryAfterMs ?? (typeof f.retry_after_seconds === "number" ? f.retry_after_seconds * 1e3 : void 0));
+            return;
+          default:
+            break;
+        }
+      }
+      if (!started) yield start();
+      yield streamError("gateway_error", void 0);
+    },
+    /** Best-effort `POST abort` after the browser went away mid-turn. Never throws. */
+    async abort(ctx, visitorId, sealed, input) {
+      const body = {
+        conversation_id: input.conversationId,
+        ...input.runId ? { run_id: input.runId } : {},
+        ...withAgent(input.agent),
+        ...input.identitySession ? { identity_session: input.identitySession } : {}
+      };
+      await withEdge(ctx, visitorId, sealed, (edge) => client.json("abort", { ...base(ctx), body, session: edge.token, signal: AbortSignal.timeout(5e3) })).catch(() => {
+      });
+    },
+    /** The visitor's own conversation, folded for the widget. An unknown or foreign conversation is empty. */
+    async history(ctx, visitorId, sealed, input) {
+      const cfg = await getConfig();
+      const body = {
+        conversation_id: input.conversationId,
+        limit: 50,
+        ...withAgent(input.agent),
+        ...input.identitySession ? { identity_session: input.identitySession } : {}
+      };
+      let data;
+      try {
+        data = await withEdge(ctx, visitorId, sealed, (edge) => client.json("history", { ...base(ctx), body, session: edge.token }));
+      } catch (e) {
+        if (e instanceof CcpError && e.code === "not_found") return [];
+        throw e;
+      }
+      const out = [];
+      for (const m of Array.isArray(data.messages) ? data.messages.slice(0, 200) : []) {
+        if (m?.role !== "user" && m?.role !== "assistant") continue;
+        const content = typeof m.content === "string" ? m.role === "user" ? stripPageBlock(m.content) : m.content : "";
+        const msg = { role: m.role, content };
+        if (cfg.showThinking && typeof m.thinking === "string" && m.thinking) msg.thinking = m.thinking;
+        if (cfg.showToolActivity && Array.isArray(m.tool_calls)) {
+          const calls = [];
+          for (const t of m.tool_calls.slice(0, 64)) {
+            if (typeof t?.id !== "string" || typeof t?.name !== "string") continue;
+            const status = t.status === "running" || t.status === "error" ? t.status : "done";
+            calls.push({ id: t.id.slice(0, 128), name: t.name.slice(0, 128), status, isError: t.is_error === true });
+          }
+          if (calls.length) msg.toolCalls = calls;
+        }
+        if (typeof m.created_at === "string") msg.createdAt = m.created_at.slice(0, 64);
+        if (!msg.content && !msg.thinking && !msg.toolCalls) continue;
+        out.push(msg);
+      }
+      return out;
+    },
+    /**
+     * Signs a partner assertion for `subject` and exchanges it at CCP for an identity session. `sealed`
+     * is the user's edge session from an earlier token, refreshed rather than replaced when stale.
+     */
+    async exchange(ctx, visitorId, subject, agent, sealed) {
+      if (!identity) throw new Error("identity is not configured");
+      const assertion = await identity.createAssertion({ ...identity.signer(), purpose: "session", subject });
+      const body = { assertion, ...identity.ttlSeconds ? { ttl_seconds: identity.ttlSeconds } : {}, ...withAgent(agent) };
+      const data = await withEdge(ctx, visitorId, sealed, (edge) => client.json("identity/exchange", { ...base(ctx), body, session: edge.token }));
+      const token = data.identity_session;
+      const principal = data.principal_ref;
+      const expiresAt = new Date(String(data.expires_at));
+      if (typeof token !== "string" || token === "" || token.length > MAX_IDENTITY_SESSION_LENGTH2) throw new CcpError(201, "ccp_bad_response", "CCP identity exchange: no usable identity session");
+      if (typeof principal !== "string" || principal === "") throw new CcpError(201, "ccp_bad_response", "CCP identity exchange: no principal");
+      return { sessionToken: token, principalRef: principal, expiresAt };
+    },
+    /** Best-effort `POST identity/revoke` (the user signed out or switched). Never throws. */
+    async revoke(ctx, visitorId, sealed, identitySession, agent) {
+      await withEdge(ctx, visitorId, sealed, (edge) => client.json("identity/revoke", { ...base(ctx), body: { identity_session: identitySession, ...withAgent(agent) }, session: edge.token, signal: AbortSignal.timeout(5e3) })).catch((e) => {
+        if (e instanceof CcpError && DEAD_SESSION_CODES.has(e.code)) return;
+        console.warn("[dewee-webchat] ccp identity/revoke failed:", e instanceof CcpError ? e.code : e?.name);
+      });
+    },
+    /** One-time hosted-page launch, with the original session kept server-side. */
+    async jobAccess(ctx, visitorId, sealed, input) {
+      const data = await withEdge(ctx, visitorId, sealed, (edge) => client.json("job-access", {
+        ...base(ctx),
+        session: edge.token,
+        body: { identity_session: input.identitySession, agent: input.agent }
+      }));
+      try {
+        const launch = parseJobAccessLaunch(data);
+        if (launch.launch_token === input.identitySession) throw new Error("Invalid launch ticket");
+        return launch;
+      } catch {
+        throw new CcpError(502, "ccp_bad_response", "Job access is unavailable");
+      }
+    },
+    /** Web-first link for a signed-in visitor. */
+    async link(ctx, visitorId, sealed, input) {
+      const body = { identity_session: input.identitySession, ...withAgent(input.agent) };
+      const idempotencyKey = input.idempotencyKey === void 0 ? void 0 : await ccpIdempotencyKey(input.idempotencyKey);
+      const data = await withEdge(ctx, visitorId, sealed, (edge) => client.json("link", { ...base(ctx), body, session: edge.token, idempotencyKey }));
+      if (typeof data.proof_code !== "string" || data.proof_code === "") throw new CcpError(201, "ccp_bad_response", "CCP link: no proof code");
+      const expires = Date.parse(String(data.expires_at));
+      const deepLinks = (Array.isArray(data.deep_links) ? data.deep_links.slice(0, 20) : []).map((t) => typeof t?.channel === "string" && CHANNEL_RE.test(t.channel) ? { channelType: t.channel, channelInstanceId: "", name: t.channel } : null).filter((t) => t !== null);
+      return { proofCode: data.proof_code.slice(0, 64), expiresAt: Number.isFinite(expires) ? expires : Date.now() + 6e5, deepLinks };
+    },
+    /** Drops a cached identity session's dependents when CCP reports it dead. */
+    isDeadSessionCode: (code) => typeof code === "string" && DEAD_SESSION_CODES.has(code)
+  };
+}
+
 // src/server/handler.ts
 var ID_RE = /^[A-Za-z0-9_-]{6,64}$/;
 var AGENT_RE = /^[A-Za-z0-9_.:-]{1,64}$/;
+var IDEMPOTENCY_KEY_RE = /^[\x21-\x7E]{1,255}$/;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var DEFAULT_IDENTITY_TTL_MS = 36e5;
+var MAX_IDENTITY_TTL_MS = 432e5;
+var MAX_CACHED_SESSIONS = 1e3;
+var ANON_REUSE_MS = 864e5;
+var VERIFIED_REUSE_MIN_MS = 12e4;
+function checkIdentityOptions(o, staticAgents, transport) {
+  const idn = o.identity;
+  const refuse = (why) => {
+    throw new Error(`[dewee-webchat] identity: ${why}`);
+  };
+  if (o.allowClientCredentials) refuse("cannot be combined with allowClientCredentials (a visitor-chosen gateway must never receive a user's session)");
+  const sdkHint = 'import { deweeIdentitySdk } from "dewee-webchat/server/identity" (needs the @dewee/identity package)';
+  if (transport === "ccp") {
+    if (!idn.sdk || typeof idn.sdk.createAssertion !== "function") refuse(`sdk with createAssertion is required: ${sdkHint}`);
+    if (idn.allowInsecureHttp) refuse("allowInsecureHttp does not apply to the ccp transport");
+  } else {
+    if (!o.gatewayUrl || !o.token) refuse("needs the server's own gatewayUrl and token");
+    if (!idn.sdk || typeof idn.sdk.exchangeSession !== "function" || typeof idn.sdk.startLink !== "function") refuse(`sdk is required: ${sdkHint}`);
+  }
+  if (typeof idn.authenticate !== "function") refuse("authenticate(req) is required");
+  if (typeof idn.appId !== "string" || !UUID_RE.test(idn.appId)) refuse("appId must be the Dewee application id (a UUID)");
+  if (typeof idn.issuer !== "string" || idn.issuer.trim() === "") refuse("issuer is required");
+  if (idn.audience !== void 0 && String(idn.audience).toLowerCase() !== `dewee:${idn.appId.toLowerCase()}`) refuse("audience must be dewee:<appId>");
+  const hasSecret = idn.assertionSecret !== void 0 && idn.assertionSecret !== "";
+  const hasJwk = idn.privateKeyJwk !== void 0;
+  if (hasSecret === hasJwk) refuse("set exactly one of assertionSecret or privateKeyJwk");
+  if (hasSecret && new TextEncoder().encode(idn.assertionSecret).length < 32) refuse("assertionSecret is too short (at least 32 bytes)");
+  if (hasJwk && (typeof idn.privateKeyJwk.d !== "string" || typeof idn.privateKeyJwk.kid !== "string")) refuse("privateKeyJwk must be a private JWK with a kid");
+  const ttl = idn.sessionTtlSeconds;
+  if (ttl !== void 0 && (!Number.isInteger(ttl) || ttl < 60 || ttl > 43200)) refuse("sessionTtlSeconds must be an integer from 60 to 43200");
+  if (transport === "ccp") {
+    if (idn.agent !== void 0 && (typeof idn.agent !== "string" || !CCP_AGENT_RE.test(idn.agent))) refuse("agent must be an agent key");
+    return idn.agent ?? "";
+  }
+  const agent = idn.agent || o.defaultAgent || staticAgents[0]?.id;
+  if (!agent || !AGENT_RE.test(agent)) refuse("no agent to bind sessions to: set identity.agent, defaultAgent or agents");
+  if (staticAgents.length && !staticAgents.some((a) => a.id === agent)) refuse(`agent "${agent}" is not in agents`);
+  return agent;
+}
 function createDeweeHandler(options) {
   const o = {
     maxMessageLength: 4e3,
@@ -344,15 +1204,39 @@ function createDeweeHandler(options) {
     timeoutMs: 18e4,
     ...options
   };
+  const transport = resolveTransport(o);
   let secret = o.secret;
   if (!secret) {
     secret = randomId(32);
     console.warn("[dewee-webchat] No secret configured: using an ephemeral one. Visitor sessions reset on restart.");
   }
-  const limiter = o.rateLimit === false ? null : o.rateLimit ?? memoryRateLimiter({ chat: [20, 6e4], session: [10, 6e5] });
+  const limiter = o.rateLimit === false ? null : o.rateLimit ?? memoryRateLimiter({ chat: [20, 6e4], session: [10, 6e5], preauth: [120, 6e4], verified: [30, 6e5], link: [5, 6e5] });
   const staticAgents = o.agents === "*" ? [] : (o.agents ?? []).map((a) => typeof a === "string" ? { id: a } : a);
   const wildcardAgents = o.agents === "*";
   const byo = o.allowClientCredentials ? o.allowClientCredentials === true ? {} : o.allowClientCredentials : null;
+  const idn = o.identity;
+  const identityAgent = idn ? checkIdentityOptions(o, staticAgents, transport) : "";
+  const ccp = transport === "ccp" ? createCcpTransport(
+    new CcpClient(parseCcpOptions(o.ccp)),
+    idn ? { createAssertion: (a) => idn.sdk.createAssertion(a), signer: () => identitySigner(), ttlSeconds: idn.sessionTtlSeconds } : void 0
+  ) : null;
+  function visitorContext(req) {
+    const ip = clientIp(req);
+    let visitorOrigin = req.headers.get("origin") || void 0;
+    if (!visitorOrigin) {
+      try {
+        visitorOrigin = new URL(req.headers.get("referer") || req.url).origin;
+      } catch {
+        visitorOrigin = void 0;
+      }
+    }
+    return { visitorOrigin: visitorOrigin === "null" ? void 0 : visitorOrigin, visitorIp: ip === "unknown" ? void 0 : ip, requestId: `dwc-${randomId(12)}` };
+  }
+  const sealedEdge = (claims) => claims?.es && typeof claims.ese === "number" ? { token: claims.es, expiresAt: claims.ese } : void 0;
+  const ccpSessionTimes = (exp, edge, now = Date.now()) => {
+    const expiresAt = Math.min(exp, edge.expiresAt);
+    return { expiresAt, expiresIn: Math.max(0, expiresAt - now) };
+  };
   function serverCreds() {
     return o.gatewayUrl && o.token ? { url: o.gatewayUrl, token: o.token, tenantId: o.tenantId } : null;
   }
@@ -406,17 +1290,233 @@ function createDeweeHandler(options) {
     if (!origin || origin === new URL(req.url).origin) return true;
     return o.allowedOrigins === "*" || (o.allowedOrigins ?? []).includes(origin);
   }
-  const json = (req, body, status = 200) => new Response(JSON.stringify(body), {
+  const json = (req, body, status = 200, extraHeaders = {}) => new Response(JSON.stringify(body), {
     status,
-    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", ...corsHeaders(req) }
+    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", ...extraHeaders, ...corsHeaders(req) }
   });
   const fail = (req, status, message, code = "bad_request") => json(req, { error: { message, code } }, status);
+  const identityFail = (req, code, remediation) => {
+    const e = IDENTITY_ERRORS[code];
+    return json(req, { error: { message: e.message, code, remediation: remediation ?? { action: e.action, audience: "end_user" } } }, e.status);
+  };
+  const misconfigured = (req) => fail(req, 500, "Signed-in chat is misconfigured on this server", "identity_misconfigured");
+  function ccpFail(req, e, route, sessionToken) {
+    const b = browserErrorFor(e, route);
+    if (b.admission) {
+      const r = admissionErrorResponse(b.admission, b.retryAfterMs);
+      return json(req, r.body, r.status, r.headers);
+    }
+    if (b.identity) {
+      if (sessionToken && DEAD_SESSION_CODES.has(b.identity)) forgetCachedSession(sessionToken);
+      return identityFail(req, b.identity, b.remediation);
+    }
+    const res = fail(req, b.status, b.message, b.code);
+    if (b.retryAfterSeconds) res.headers.set("retry-after", String(Math.ceil(b.retryAfterSeconds)));
+    return res;
+  }
+  const gatewayFail = (req, e, sessionToken) => {
+    if (e instanceof GatewayError && isAdmissionErrorCode(e.code)) {
+      const r = admissionErrorResponse(e.code, e.retryAfterMs);
+      return json(req, r.body, r.status, r.headers);
+    }
+    if (!(e instanceof GatewayError && isIdentityErrorCode(e.code))) return fail(req, 502, e.message, "gateway_error");
+    if (sessionToken && DEAD_SESSION_CODES.has(e.code)) forgetCachedSession(sessionToken);
+    if (e.remediation?.audience === "operator") console.error(`[dewee-webchat] identity: ${e.message} (${e.code})`);
+    return identityFail(req, e.code, e.remediation);
+  };
+  const sdkFail = (req, e, what) => {
+    const code = e?.code;
+    if (isIdentityErrorCode(code)) {
+      console.warn(`[dewee-webchat] identity ${what} refused: ${code}`);
+      return identityFail(req, code, e.remediation);
+    }
+    console.warn(`[dewee-webchat] identity ${what} failed:`, code ?? e);
+    if (code === "RESOURCE_EXHAUSTED") return fail(req, 429, "Too many sign-ins, slow down", "rate_limited");
+    if (code === "INVALID_ARGUMENT" || code === "SERVER_ONLY") return misconfigured(req);
+    return fail(req, 502, "Dewee is unavailable, try again later", "gateway_error");
+  };
+  const exchangeFail = (req, e) => {
+    const { code, remediation } = e ?? {};
+    if (isIdentityErrorCode(code) && remediation && remediation.audience !== "end_user" || code === "NOT_FOUND") {
+      console.error(`[dewee-webchat] identity session exchange refused: ${String(code)} (remediation for ${remediation?.audience ?? "operator"}: ${remediation?.action ?? "check the gateway"})`);
+      return misconfigured(req);
+    }
+    return sdkFail(req, e, "session exchange");
+  };
+  const ccpExchangeFail = (req, e) => {
+    const { code, remediation } = e ?? {};
+    if (isIdentityErrorCode(code) && remediation && remediation.audience !== "end_user") {
+      console.error(`[dewee-webchat] identity session exchange refused: ${code} (remediation for ${remediation.audience}: ${remediation.action})`);
+      return misconfigured(req);
+    }
+    if (typeof e?.code !== "string") {
+      console.warn("[dewee-webchat] identity session exchange failed:", e?.name ?? e);
+    }
+    return ccpFail(req, e, "identity/exchange");
+  };
+  const linkFail = (req, e, sessionToken) => {
+    const code = e?.code;
+    if (code === "IDEMPOTENCY_KEY_REUSED") return fail(req, 409, "This idempotency key was already used for a different link request", "idempotency_key_reused");
+    if (code === "FAILED_PRECONDITION") return fail(req, 409, "A link is already in progress. Use its code or wait until it expires.", "link_in_progress");
+    if (code === "NOT_FOUND") {
+      console.error("[dewee-webchat] identity link start: the gateway has identity exchange switched off");
+      return fail(req, 503, "Linking is not available right now", "linking_unavailable");
+    }
+    if (typeof code === "string" && DEAD_SESSION_CODES.has(code)) forgetCachedSession(sessionToken);
+    return sdkFail(req, e, "link start");
+  };
   const clientIp = (req) => req.headers.get("cf-connecting-ip") || req.headers.get("x-real-ip") || req.headers.get("x-forwarded-for")?.split(",")[0].trim() || "unknown";
   async function visitorFrom(req) {
     const auth = req.headers.get("authorization") || "";
     const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
     const claims = token ? await verifyVisitorToken(secret, token) : null;
-    return claims?.v ?? null;
+    if (claims?.ids && !idn) return null;
+    return claims;
+  }
+  async function agentFor(claims, requested, creds, isByo) {
+    if (claims.ids) {
+      const bound = claims.ida;
+      if (requested && requested !== bound) return null;
+      return wildcardAgents || staticAgents.some((a) => a.id === bound) ? bound : null;
+    }
+    return pickAgent(requested, creds, isByo);
+  }
+  async function rebindRefusal(req, claims, required = false) {
+    if (!idn || !required && !idn.rebindEachRequest || !claims.ids) return null;
+    const throttled = await preauthRefusal(req);
+    if (throttled) return throttled;
+    let user;
+    try {
+      user = await idn.authenticate(req);
+    } catch (e) {
+      console.warn("[dewee-webchat] identity.authenticate failed:", e instanceof Error ? e.name : "unknown");
+      return identityFail(req, "SOURCE_UNAVAILABLE", { action: "retry_later", audience: "end_user" });
+    }
+    const current = !!user && typeof user.subject === "string" && user.subject !== "" ? await subjectDigest(secret, user.subject) : null;
+    if (current && claims.sub && constantTimeEqual(current, claims.sub)) return null;
+    if (ccp && current && claims.sub) {
+      forgetCachedSession(claims.ids);
+      await ccp.revoke(visitorContext(req), claims.v, sealedEdge(claims), claims.ids, claims.ida);
+    }
+    return identityFail(req, "IDENTITY_REQUIRED");
+  }
+  async function preauthRefusal(req) {
+    if (!limiter || await limiter(clientIp(req), "preauth")) return null;
+    return fail(req, 429, "Too many requests, slow down", "rate_limited");
+  }
+  const actorOf2 = (claims) => claims.ids ? { identitySession: claims.ids } : o.userIdPrefix + claims.v;
+  function identitySigner() {
+    if (idn.assertionSecret) return { applicationId: idn.appId, issuer: idn.issuer, secret: idn.assertionSecret };
+    return { applicationId: idn.appId, issuer: idn.issuer, privateKeyJwk: idn.privateKeyJwk, algorithm: idn.algorithm };
+  }
+  const sessionCache = /* @__PURE__ */ new Map();
+  const exchanges = /* @__PURE__ */ new Map();
+  function forgetCachedSession(sessionToken) {
+    for (const [k, c] of sessionCache) if (c.sessionToken === sessionToken) sessionCache.delete(k);
+  }
+  function rememberSession(key, c) {
+    sessionCache.delete(key);
+    sessionCache.set(key, c);
+    if (sessionCache.size <= MAX_CACHED_SESSIONS) return;
+    const now = Date.now();
+    for (const [k, v] of sessionCache) if (v.deadline - now <= v.margin) sessionCache.delete(k);
+    for (const k of sessionCache.keys()) {
+      if (sessionCache.size <= MAX_CACHED_SESSIONS) break;
+      sessionCache.delete(k);
+    }
+  }
+  async function exchangeFor(subject, req, sealed) {
+    if (ccp) return ccpExchangeFor(subject, req, sealed);
+    const session = await idn.sdk.exchangeSession({
+      gatewayUrl: o.gatewayUrl,
+      allowInsecureHttp: idn.allowInsecureHttp,
+      signer: identitySigner(),
+      subject,
+      agent: identityAgent,
+      ttlSeconds: idn.sessionTtlSeconds
+    });
+    const receivedAt = Date.now();
+    const bound = idn.sessionTtlSeconds ? idn.sessionTtlSeconds * 1e3 : MAX_IDENTITY_TTL_MS;
+    let lifetime = session.expiresAt.getTime() - receivedAt;
+    if (!(lifetime > 0 && lifetime <= bound)) {
+      console.warn("[dewee-webchat] identity session expiry does not match this server's clock; using the requested lifetime");
+      lifetime = idn.sessionTtlSeconds ? idn.sessionTtlSeconds * 1e3 : DEFAULT_IDENTITY_TTL_MS;
+    }
+    const visitorId = await deriveVisitorId(secret, `principal:${session.principalId}`);
+    return { sessionToken: session.sessionToken, visitorId, deadline: receivedAt + lifetime, margin: Math.min(6e4, lifetime / 2) };
+  }
+  function identityLifetime(expiresAt, receivedAt) {
+    const bound = idn.sessionTtlSeconds ? idn.sessionTtlSeconds * 1e3 : MAX_IDENTITY_TTL_MS;
+    const lifetime = expiresAt.getTime() - receivedAt;
+    if (lifetime > 0 && lifetime <= bound) return lifetime;
+    console.warn("[dewee-webchat] identity session expiry does not match this server's clock; using the requested lifetime");
+    return idn.sessionTtlSeconds ? idn.sessionTtlSeconds * 1e3 : DEFAULT_IDENTITY_TTL_MS;
+  }
+  async function ccpExchangeFor(subject, req, sealed) {
+    const visitorId = await deriveVisitorId(secret, `subject:${subject}`);
+    const ctx = visitorContext(req);
+    const session = await ccp.exchange(ctx, visitorId, subject, await boundAgent(), sealed);
+    const receivedAt = Date.now();
+    const lifetime = identityLifetime(session.expiresAt, receivedAt);
+    return { sessionToken: session.sessionToken, visitorId, deadline: receivedAt + lifetime, margin: Math.min(6e4, lifetime / 2), origin: ctx.visitorOrigin };
+  }
+  async function boundAgent() {
+    if (!ccp || identityAgent) return identityAgent;
+    return (await ccp.config()).defaultAgent;
+  }
+  async function verifiedReuse(req, hint, subject, agent, userVisitor) {
+    if (!ccp || !hint?.ids || hint.ida !== agent || !hint.sub || hint.v !== userVisitor) return null;
+    if (hint.exp - Date.now() <= VERIFIED_REUSE_MIN_MS) return null;
+    if (!constantTimeEqual(await subjectDigest(secret, subject), hint.sub)) return null;
+    return { sessionToken: hint.ids, visitorId: hint.v, deadline: hint.exp, margin: Math.min(6e4, VERIFIED_REUSE_MIN_MS / 2), origin: req.headers.get("origin") || void 0 };
+  }
+  async function issueIdentitySession(req, subject, hint = null) {
+    let agent;
+    try {
+      agent = await boundAgent();
+    } catch (e) {
+      return ccpFail(req, e, "config");
+    }
+    const key = `${agent}
+${subject}`;
+    let s = sessionCache.get(key);
+    const userVisitor = ccp ? await deriveVisitorId(secret, `subject:${subject}`) : void 0;
+    const sealed = hint && hint.ids && hint.v === userVisitor ? sealedEdge(hint) : void 0;
+    if (!s || s.deadline - Date.now() <= s.margin) {
+      const reused = await verifiedReuse(req, hint, subject, agent, userVisitor);
+      if (reused) {
+        s = reused;
+      } else {
+        let pending = exchanges.get(key);
+        if (!pending) {
+          pending = exchangeFor(subject, req, sealed).finally(() => exchanges.delete(key));
+          exchanges.set(key, pending);
+        }
+        try {
+          s = await pending;
+        } catch (e) {
+          return ccp ? ccpExchangeFail(req, e) : exchangeFail(req, e);
+        }
+      }
+      rememberSession(key, s);
+    }
+    const now = Date.now();
+    const expiresAt = Math.min(s.deadline, now + o.sessionTtlMs);
+    const sub = await subjectDigest(secret, subject);
+    let edge;
+    if (ccp) {
+      try {
+        edge = await ccp.edgeFor(visitorContext(req), s.visitorId, sealed, void 0, EDGE_RESEAL_MS);
+      } catch (e) {
+        return ccpFail(req, e, "session");
+      }
+    }
+    const claims = { v: s.visitorId, exp: expiresAt, ids: s.sessionToken, ida: agent, sub, ...edge ? { es: edge.token, ese: edge.expiresAt } : {} };
+    const token = await signVisitorToken(secret, claims);
+    const times = edge ? ccpSessionTimes(expiresAt, edge) : { expiresAt, expiresIn: expiresAt - now };
+    const body = { visitorId: s.visitorId, token, expiresAt: times.expiresAt, verified: true, expiresIn: times.expiresIn };
+    if (ccp) body.reuseHint = await signReuseHint(secret, claims);
+    return json(req, body);
   }
   async function pickAgent(requested, creds, isByo) {
     if (isByo || wildcardAgents) {
@@ -428,6 +1528,7 @@ function createDeweeHandler(options) {
     return staticAgents.some((a) => a.id === requested) ? requested : null;
   }
   async function handleConfig(req) {
+    if (ccp) return handleCcpConfig(req);
     const { creds, byo: isByo, error } = resolveCreds(req);
     if (error) return fail(req, 400, error, "bad_credentials");
     let agents = [];
@@ -445,36 +1546,135 @@ function createDeweeHandler(options) {
       maxMessageLength: o.maxMessageLength,
       version: VERSION
     };
+    if (idn) {
+      body.defaultAgent = identityAgent;
+      body.allowAgentSwitch = false;
+      body.identity = true;
+    }
+    return json(req, body);
+  }
+  async function handleCcpConfig(req) {
+    const { error } = resolveCreds(req);
+    if (error) return fail(req, 400, error, "bad_credentials");
+    let cfg;
+    try {
+      cfg = await ccp.config();
+    } catch (e) {
+      return ccpFail(req, e, "config");
+    }
+    const body = {
+      agents: cfg.agents,
+      defaultAgent: cfg.defaultAgent,
+      allowAgentSwitch: o.allowAgentSwitch === false ? false : cfg.allowAgentSwitch,
+      allowClientCredentials: false,
+      turnstileSiteKey: o.turnstile?.siteKey,
+      ...o.turnstile ? { refreshWithoutTurnstile: true } : {},
+      maxMessageLength: Math.min(o.maxMessageLength, cfg.maxMessageChars),
+      version: VERSION
+    };
+    if (idn) {
+      body.defaultAgent = identityAgent || cfg.defaultAgent;
+      body.allowAgentSwitch = false;
+      body.identity = true;
+    }
     return json(req, body);
   }
+  async function turnstilePassed(body, ip) {
+    if (!o.turnstile) return true;
+    return !!body?.turnstileToken && await verifyTurnstile(o.turnstile.secretKey, String(body.turnstileToken), ip);
+  }
   async function handleSession(req) {
+    if (idn) return handleIdentitySession(req);
     const ip = clientIp(req);
+    if (ccp) {
+      const body2 = await req.json().catch(() => ({}));
+      const previous = await anonymousPrevious(body2);
+      if (limiter && !await limiter(previous ? `visitor:${previous.v}` : ip, "session")) return fail(req, 429, "Too many sessions, slow down", "rate_limited");
+      return issueAnonymousSession(req, body2, ip, previous);
+    }
     if (limiter && !await limiter(ip, "session")) return fail(req, 429, "Too many sessions, slow down", "rate_limited");
     const body = await req.json().catch(() => ({}));
-    if (o.turnstile) {
-      if (!body?.turnstileToken || !await verifyTurnstile(o.turnstile.secretKey, String(body.turnstileToken), ip)) {
-        return fail(req, 403, "Verification failed", "turnstile_failed");
-      }
-    }
+    return issueAnonymousSession(req, body, ip);
+  }
+  async function anonymousPrevious(body) {
     const previous = typeof body?.token === "string" ? await verifyVisitorToken(secret, body.token) : null;
+    return previous && !previous.ids ? previous : null;
+  }
+  async function issueAnonymousSession(req, body, ip, known) {
+    const previous = known === void 0 ? await anonymousPrevious(body) : known;
+    if (!(ccp && previous) && !await turnstilePassed(body, ip)) return fail(req, 403, "Verification failed", "turnstile_failed");
     const visitorId = previous?.v ?? randomId(16);
     const expiresAt = Date.now() + o.sessionTtlMs;
-    return json(req, { visitorId, token: await signVisitorToken(secret, { v: visitorId, exp: expiresAt }), expiresAt });
+    if (!ccp) return json(req, { visitorId, token: await signVisitorToken(secret, { v: visitorId, exp: expiresAt }), expiresAt });
+    let edge;
+    try {
+      edge = await ccp.edgeFor(visitorContext(req), visitorId, sealedEdge(previous), void 0, EDGE_RESEAL_MS);
+    } catch (e) {
+      return ccpFail(req, e, "session");
+    }
+    const token = await signVisitorToken(secret, { v: visitorId, exp: expiresAt, es: edge.token, ese: edge.expiresAt });
+    const body2 = { visitorId, token, ...ccpSessionTimes(expiresAt, edge) };
+    return json(req, body2);
+  }
+  async function handleIdentitySession(req) {
+    const ip = clientIp(req);
+    const body = await req.json().catch(() => ({}));
+    const throttled = await preauthRefusal(req);
+    if (throttled) return throttled;
+    let user;
+    try {
+      user = await idn.authenticate(req);
+    } catch (e) {
+      console.warn("[dewee-webchat] identity.authenticate failed:", e);
+      return identityFail(req, "SOURCE_UNAVAILABLE", { action: "retry_later", audience: "end_user" });
+    }
+    if (user != null) {
+      if (typeof user !== "object" || typeof user.subject !== "string" || user.subject.trim() === "") {
+        console.error("[dewee-webchat] identity.authenticate must return { subject } or null");
+        return misconfigured(req);
+      }
+      if (limiter && !await limiter(`subject:${user.subject}`, "verified")) return fail(req, 429, "Too many sessions, slow down", "rate_limited");
+      if (!await turnstilePassed(body, ip)) return fail(req, 403, "Verification failed", "turnstile_failed");
+      const hint = ccp && typeof body?.reuseHint === "string" ? await verifyReuseHint(secret, body.reuseHint) : null;
+      return issueIdentitySession(req, user.subject, hint);
+    }
+    if (idn.required) return identityFail(req, "IDENTITY_REQUIRED");
+    const previous = await anonymousPrevious(body);
+    if (previous && previous.exp - Date.now() > ANON_REUSE_MS) {
+      if (!ccp) {
+        const reused = { visitorId: previous.v, token: body.token, expiresAt: previous.exp };
+        return json(req, reused);
+      }
+      const edge = sealedEdge(previous);
+      if (edge && edge.expiresAt - Date.now() > EDGE_RESEAL_MS) {
+        const reused = { visitorId: previous.v, token: body.token, ...ccpSessionTimes(previous.exp, edge) };
+        return json(req, reused);
+      }
+    }
+    const key = ccp && previous ? `visitor:${previous.v}` : ip;
+    if (limiter && !await limiter(key, "session")) return fail(req, 429, "Too many sessions, slow down", "rate_limited");
+    return issueAnonymousSession(req, body, ip, previous);
   }
   async function handleChat(req) {
-    const visitorId = await visitorFrom(req);
-    if (!visitorId) return fail(req, 401, "Missing or expired visitor session", "unauthorized");
+    const claims = await visitorFrom(req);
+    if (!claims) return fail(req, 401, "Missing or expired visitor session", "unauthorized");
+    if (idn?.required && !claims.ids) return identityFail(req, "IDENTITY_REQUIRED");
+    const refused = await rebindRefusal(req, claims);
+    if (refused) return refused;
+    const visitorId = claims.v;
     if (limiter && !await limiter(`${visitorId}|${clientIp(req)}`, "chat")) return fail(req, 429, "Too many messages, please wait a moment", "rate_limited");
     const { creds, byo: isByo, error } = resolveCreds(req);
     if (error) return fail(req, 400, error, "bad_credentials");
-    if (!creds) return fail(req, 500, "Gateway is not configured", "not_configured");
+    if (!creds && !ccp) return fail(req, 500, "Gateway is not configured", "not_configured");
     const body = await req.json().catch(() => null);
     const message = typeof body?.message === "string" ? body.message.trim() : "";
     if (!message) return fail(req, 400, "Message is required");
     if (message.length > o.maxMessageLength) return fail(req, 413, `Message exceeds ${o.maxMessageLength} characters`, "too_long");
-    const conversationId = typeof body?.conversationId === "string" && ID_RE.test(body.conversationId) ? body.conversationId : randomId(9);
-    const agent = await pickAgent(body?.agent, creds, isByo);
-    if (!agent) return fail(req, 403, "Agent not allowed", "agent_not_allowed");
+    const idRe = ccp ? CCP_ID_RE : ID_RE;
+    const conversationId = typeof body?.conversationId === "string" && idRe.test(body.conversationId) ? body.conversationId : randomId(9);
+    const agent = ccp ? ccpAgentFor(req, claims, body?.agent) : await agentFor(claims, body?.agent, creds, isByo);
+    if (agent instanceof Response) return agent;
+    if (agent === null) return fail(req, 403, "Agent not allowed", "agent_not_allowed");
     let pageBlock = "";
     let actionsHash;
     try {
@@ -486,6 +1686,16 @@ function createDeweeHandler(options) {
       if (e instanceof ActionInputError) return fail(req, e.status, e.message, e.code);
       throw e;
     }
+    if (ccp) return ccpChat(req, claims, { message: pageBlock + message, rawMessage: message, conversationId, agent, actionsHash });
+    if (!creds) return fail(req, 500, "Gateway is not configured", "not_configured");
+    let connection;
+    if (claims.ids) {
+      try {
+        connection = await GatewayConnection.connect(creds, { identitySession: claims.ids });
+      } catch (e) {
+        return gatewayFail(req, e, claims.ids);
+      }
+    }
     const sessionKey = buildSessionKey(agent, `webchat-${visitorId}-${conversationId}`);
     const abort = new AbortController();
     req.signal?.addEventListener("abort", () => abort.abort(), { once: true });
@@ -501,17 +1711,23 @@ function createDeweeHandler(options) {
       let errMsg;
       try {
         await send(actionsHash ? { type: "start", conversationId, agent, actionsHash } : { type: "start", conversationId, agent });
-        for await (const ev of streamChat({ creds, userId: o.userIdPrefix + visitorId, agent, sessionKey, message: pageBlock + message, signal: abort.signal, timeoutMs: o.timeoutMs })) {
+        const who = connection ? { connection } : { userId: o.userIdPrefix + visitorId };
+        for await (const ev of streamChat({ creds, ...who, agent, sessionKey, message: pageBlock + message, signal: abort.signal, timeoutMs: o.timeoutMs })) {
           if (ev.type === "start") continue;
           if (ev.type === "done") reply = ev.content;
-          if (ev.type === "error") errMsg = ev.message;
+          if (ev.type === "error") {
+            errMsg = gatewayReasonOf(ev) ?? ev.message;
+            if (claims.ids && ev.code && DEAD_SESSION_CODES.has(ev.code)) forgetCachedSession(claims.ids);
+          }
           await send(ev);
           if (abort.signal.aborted) break;
         }
       } catch (e) {
+        const admission = e instanceof GatewayError && isAdmissionErrorCode(e.code) ? admissionErrorEvent(e.code, e.retryAfterMs) : null;
         errMsg = e.message;
-        await send({ type: "error", message: errMsg, code: "gateway_error" });
+        await send(admission ?? { type: "error", message: errMsg, code: "gateway_error" });
       } finally {
+        connection?.close();
         clearInterval(keepAlive);
         try {
           o.onChat?.({ visitorId, agent, message, reply, error: errMsg });
@@ -530,26 +1746,255 @@ function createDeweeHandler(options) {
       }
     });
   }
+  function ccpAgentFor(req, claims, requested) {
+    if (requested !== void 0 && requested !== null && requested !== "" && (typeof requested !== "string" || !CCP_AGENT_RE.test(requested))) {
+      return fail(req, 400, "Invalid agent");
+    }
+    const asked = requested || "";
+    if (claims.ids && asked && asked !== claims.ida) return fail(req, 403, "Agent not allowed", "agent_not_allowed");
+    return claims.ids ? claims.ida : asked;
+  }
+  async function ccpChat(req, claims, turn) {
+    const ctx = visitorContext(req);
+    const visitorId = claims.v;
+    const abort = new AbortController();
+    const onAbort = () => abort.abort();
+    req.signal?.addEventListener("abort", onAbort, { once: true });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      abort.abort();
+    }, o.timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      req.signal?.removeEventListener("abort", onAbort);
+    };
+    let cfg;
+    let upstream;
+    try {
+      cfg = await ccp.config();
+      if (turn.rawMessage.length > cfg.maxMessageChars) {
+        cleanup();
+        return fail(req, 413, `Message exceeds ${cfg.maxMessageChars} characters`, "too_long");
+      }
+      upstream = await ccp.startChat(ctx, visitorId, sealedEdge(claims), {
+        message: turn.message,
+        conversationId: turn.conversationId,
+        agent: turn.agent || void 0,
+        identitySession: claims.ids,
+        signal: abort.signal
+      });
+    } catch (e) {
+      cleanup();
+      if (timedOut) return fail(req, 504, "The agent took too long to answer", "timeout");
+      if (abort.signal.aborted && !(e instanceof CcpError)) return fail(req, 499, "Request cancelled", "cancelled");
+      return ccpFail(req, e, "chat", claims.ids);
+    }
+    const { readable, writable } = new TransformStream();
+    const writer = writable.getWriter();
+    const enc2 = new TextEncoder();
+    const send = (e) => writer.write(enc2.encode(typeof e === "string" ? e : `data: ${JSON.stringify(e)}
+
+`)).catch(() => abort.abort());
+    let runId;
+    let finished = false;
+    abort.signal.addEventListener(
+      "abort",
+      () => {
+        if (finished) return;
+        void ccp.abort(ctx, visitorId, sealedEdge(claims), { conversationId: turn.conversationId, runId, agent: turn.agent || void 0, identitySession: claims.ids });
+        if (!timedOut) writer.abort().catch(() => {
+        });
+      },
+      { once: true }
+    );
+    (async () => {
+      const keepAlive = setInterval(() => send(": ping\n\n"), 15e3);
+      let reply = "";
+      let errMsg;
+      let agent = turn.agent || cfg.defaultAgent;
+      try {
+        for await (const ev of ccp.chatEvents(upstream, cfg, turn.conversationId, agent)) {
+          if (ev.type === "start") {
+            runId = ev.runId;
+            agent = ev.agent;
+            await send(turn.actionsHash ? { ...ev, actionsHash: turn.actionsHash } : ev);
+            continue;
+          }
+          if (ev.type === "done") {
+            reply = ev.content;
+            finished = true;
+          }
+          if (ev.type === "error") {
+            errMsg = ev.message;
+            finished = true;
+            if (claims.ids && ev.code && DEAD_SESSION_CODES.has(ev.code)) forgetCachedSession(claims.ids);
+          }
+          await send(ev);
+          if (abort.signal.aborted) break;
+        }
+      } catch (e) {
+        if (timedOut) {
+          errMsg = "The agent took too long to answer";
+          await send({ type: "error", message: errMsg, code: "timeout" });
+        } else if (!abort.signal.aborted) {
+          console.error("[dewee-webchat] ccp chat stream failed:", e?.name ?? "error");
+          errMsg = "Dewee is unavailable, try again later";
+          await send({ type: "error", message: errMsg, code: "gateway_error" });
+          finished = true;
+        }
+      } finally {
+        clearInterval(keepAlive);
+        cleanup();
+        if (!finished && abort.signal.aborted) errMsg ??= "cancelled";
+        finished = true;
+        try {
+          o.onChat?.({ visitorId, agent, message: turn.rawMessage, reply, error: errMsg });
+        } catch {
+        }
+        writer.close().catch(() => {
+        });
+      }
+    })();
+    return new Response(readable, {
+      headers: {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        "x-accel-buffering": "no",
+        ...corsHeaders(req)
+      }
+    });
+  }
+  async function ccpHistory(req, claims) {
+    const url = new URL(req.url);
+    const conversationId = url.searchParams.get("conversationId") || "";
+    if (!ID_RE.test(conversationId)) return fail(req, 400, "Invalid conversationId");
+    const agent = ccpAgentFor(req, claims, url.searchParams.get("agent"));
+    if (agent instanceof Response) return agent;
+    if (!CCP_ID_RE.test(conversationId)) return json(req, { messages: [] });
+    try {
+      const messages = await ccp.history(visitorContext(req), claims.v, sealedEdge(claims), { conversationId, agent: agent || void 0, identitySession: claims.ids });
+      return json(req, { messages });
+    } catch (e) {
+      return ccpFail(req, e, "history", claims.ids);
+    }
+  }
   async function handleHistory(req) {
-    const visitorId = await visitorFrom(req);
-    if (!visitorId) return fail(req, 401, "Missing or expired visitor session", "unauthorized");
+    const claims = await visitorFrom(req);
+    if (!claims) return fail(req, 401, "Missing or expired visitor session", "unauthorized");
+    if (idn?.required && !claims.ids) return identityFail(req, "IDENTITY_REQUIRED");
+    const refused = await rebindRefusal(req, claims);
+    if (refused) return refused;
+    const visitorId = claims.v;
     const { creds, byo: isByo, error } = resolveCreds(req);
     if (error) return fail(req, 400, error, "bad_credentials");
+    if (ccp) return ccpHistory(req, claims);
     if (!creds) return fail(req, 500, "Gateway is not configured", "not_configured");
     const url = new URL(req.url);
     const conversationId = url.searchParams.get("conversationId") || "";
     if (!ID_RE.test(conversationId)) return fail(req, 400, "Invalid conversationId");
-    const agent = await pickAgent(url.searchParams.get("agent"), creds, isByo);
+    const agent = await agentFor(claims, url.searchParams.get("agent"), creds, isByo);
     if (!agent) return fail(req, 403, "Agent not allowed", "agent_not_allowed");
     try {
-      const messages = await fetchHistory(creds, o.userIdPrefix + visitorId, agent, buildSessionKey(agent, `webchat-${visitorId}-${conversationId}`));
+      const messages = await fetchHistory(creds, actorOf2(claims), agent, buildSessionKey(agent, `webchat-${visitorId}-${conversationId}`));
       return json(req, { messages });
     } catch (e) {
       if (e.code === "NOT_FOUND") return json(req, { messages: [] });
-      return fail(req, 502, e.message, "gateway_error");
+      return gatewayFail(req, e, claims.ids);
     }
   }
-  return async function deweeHandler(req) {
+  async function handleJobAccess(req) {
+    const origin = req.headers.get("origin");
+    try {
+      const parsed = new URL(origin ?? "");
+      if (parsed.protocol !== "https:" || parsed.origin !== origin) return fail(req, 403, "Open job access from your signed-in chat", "forbidden_origin");
+    } catch {
+      return fail(req, 403, "Open job access from your signed-in chat", "forbidden_origin");
+    }
+    const claims = await visitorFrom(req);
+    if (!claims?.ids || !claims.ida) return identityFail(req, "IDENTITY_REQUIRED");
+    const refused = await rebindRefusal(req, claims, true);
+    if (refused) return refused;
+    const agent = ccp ? ccpAgentFor(req, claims, claims.ida) : await agentFor(claims, claims.ida, serverCreds(), false);
+    if (agent instanceof Response) return agent;
+    if (!agent) return fail(req, 403, "Agent not allowed", "agent_not_allowed");
+    if (limiter && !await limiter(`visitor:${claims.v}`, "link")) return fail(req, 429, "Too many requests, try again later", "rate_limited");
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      return fail(req, 400, "Invalid request", "invalid_request");
+    }
+    if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).length) return fail(req, 400, "Invalid request", "invalid_request");
+    try {
+      const launch = ccp ? await ccp.jobAccess(visitorContext(req), claims.v, sealedEdge(claims), { identitySession: claims.ids, agent }) : await mintJobAccess(o.gatewayUrl, claims.ids, origin);
+      return json(req, launch);
+    } catch (error) {
+      if (error instanceof JobAccessRefusal) return identityFail(req, error.code);
+      if (error instanceof CcpError) return ccpFail(req, error, "job-access", claims.ids);
+      return fail(req, 502, "Job access is unavailable. Try again later.", "job_access_unavailable");
+    }
+  }
+  async function handleLink(req) {
+    const claims = await visitorFrom(req);
+    if (!claims?.ids) return identityFail(req, "IDENTITY_REQUIRED");
+    const refused = await rebindRefusal(req, claims);
+    if (refused) return refused;
+    if (limiter && !await limiter(`visitor:${claims.v}`, "link")) return fail(req, 429, "Too many link requests, slow down", "rate_limited");
+    const body = await req.json().catch(() => ({}));
+    const idempotencyKey = body?.idempotencyKey;
+    if (idempotencyKey !== void 0 && (typeof idempotencyKey !== "string" || !IDEMPOTENCY_KEY_RE.test(idempotencyKey))) {
+      return fail(req, 400, "idempotencyKey must be 1 to 255 printable ASCII characters without spaces");
+    }
+    if (ccp) {
+      try {
+        const res = await ccp.link(visitorContext(req), claims.v, sealedEdge(claims), { identitySession: claims.ids, agent: claims.ida, idempotencyKey });
+        return json(req, res);
+      } catch (e) {
+        return ccpFail(req, e, "link", claims.ids);
+      }
+    }
+    try {
+      const link = await idn.sdk.startLink({ gatewayUrl: o.gatewayUrl, allowInsecureHttp: idn.allowInsecureHttp, sessionToken: claims.ids, idempotencyKey });
+      const res = {
+        proofCode: link.proofCode,
+        expiresAt: link.expiresAt.getTime(),
+        deepLinks: link.deepLinks.map((t) => ({ channelType: t.channelType, channelInstanceId: t.channelInstanceId, name: t.name, ...t.displayName ? { displayName: t.displayName } : {} }))
+      };
+      return json(req, res);
+    } catch (e) {
+      return linkFail(req, e, claims.ids);
+    }
+  }
+  async function revoke(subject, request, token) {
+    if (!idn || typeof subject !== "string" || subject === "") return;
+    try {
+      const held = [];
+      for (const [k, c] of sessionCache) {
+        const cut = k.indexOf("\n");
+        if (k.slice(cut + 1) === subject) held.push({ agent: k.slice(0, cut), session: c });
+      }
+      if (ccp && typeof token === "string" && token !== "") {
+        const c = await verifyReuseHint(secret, token) ?? await verifyVisitorToken(secret, token);
+        if (c?.ids && c.ida && c.sub && constantTimeEqual(await subjectDigest(secret, subject), c.sub) && !held.some((h) => h.session.sessionToken === c.ids)) {
+          held.push({ agent: c.ida, session: { sessionToken: c.ids, visitorId: c.v, deadline: c.exp, margin: 0 }, edge: sealedEdge(c) });
+        }
+      }
+      for (const { session } of held) forgetCachedSession(session.sessionToken);
+      if (!ccp) return;
+      const fromRequest = request ? visitorContext(request) : null;
+      await Promise.all(
+        held.map(({ agent, session, edge }) => {
+          const ctx = fromRequest ?? { visitorOrigin: session.origin, requestId: `dwc-${randomId(12)}` };
+          return ccp.revoke(ctx, session.visitorId, edge, session.sessionToken, agent || void 0).catch(() => {
+          });
+        })
+      );
+    } catch (e) {
+      console.warn("[dewee-webchat] revoke failed:", e instanceof CcpError ? e.code : "unexpected error");
+    }
+  }
+  const deweeHandler = async function deweeHandler2(req) {
     if (req.method === "OPTIONS") return new Response(null, { status: 204, headers: corsHeaders(req) });
     if (!originAllowed(req)) return fail(req, 403, "Origin not allowed", "forbidden_origin");
     const action = new URL(req.url).pathname.replace(/\/+$/, "").split("/").pop();
@@ -558,18 +2003,33 @@ function createDeweeHandler(options) {
       if (req.method === "POST" && action === "session") return await handleSession(req);
       if (req.method === "POST" && action === "chat") return await handleChat(req);
       if (req.method === "GET" && action === "history") return await handleHistory(req);
+      if (req.method === "POST" && action === "link" && idn) return await handleLink(req);
+      if (req.method === "POST" && action === "job-access" && idn) return await handleJobAccess(req);
       return fail(req, 404, "Not found", "not_found");
     } catch (e) {
-      return fail(req, 500, e.message || "Internal error", "internal");
+      if (!ccp) return fail(req, 500, e.message || "Internal error", "internal");
+      console.error("[dewee-webchat] internal error:", e instanceof CcpError ? e.code : e);
+      return fail(req, 500, "Internal error", "internal");
     }
   };
+  return Object.assign(deweeHandler, { revoke });
 }
 function optionsFromEnv(env, overrides = {}) {
   const list = (v) => v?.split(",").map((s) => s.trim()).filter(Boolean);
   const agents = env.DEWEE_AGENTS?.trim() === "*" ? "*" : list(env.DEWEE_AGENTS);
   const origins = env.DEWEE_ALLOWED_ORIGINS?.trim() === "*" ? "*" : list(env.DEWEE_ALLOWED_ORIGINS);
   const byoHosts = list(env.DEWEE_CLIENT_CREDENTIAL_HOSTS);
+  const ccpEnv = {
+    chatUrl: env.DEWEE_CCP_CHAT_URL?.trim() || void 0,
+    integrationId: env.DEWEE_WEBCHAT_INTEGRATION_ID?.trim() || void 0,
+    integrationSecret: env.DEWEE_WEBCHAT_INTEGRATION_SECRET?.trim() || void 0
+  };
+  const transport = env.DEWEE_WEBCHAT_TRANSPORT?.trim() || void 0;
   return {
+    // Validated by createDeweeHandler, which refuses unknown values.
+    transport,
+    // Partial CCP settings are kept so createDeweeHandler can name the missing variable.
+    ccp: ccpEnv.chatUrl || ccpEnv.integrationId || ccpEnv.integrationSecret ? ccpEnv : void 0,
     gatewayUrl: env.DEWEE_GATEWAY_URL || env.GOCLAW_GATEWAY_URL,
     token: env.DEWEE_GATEWAY_TOKEN || env.GOCLAW_GATEWAY_TOKEN,
     tenantId: env.DEWEE_TENANT_ID,
@@ -635,14 +2095,20 @@ function toNodeHandler(handler) {
 }
 export {
   ACTION_LIMITS,
+  ADMISSION_ERROR_CODES,
+  CcpError,
+  DEFAULT_RETRY_AFTER_MS,
   GatewayConnection,
   GatewayError,
+  MAX_RETRY_AFTER_MS,
+  admissionErrorEvent,
   buildPageBlock,
   buildSessionKey,
   createDeweeHandler,
   fetchHistory,
   foldHistory,
   hashManifest,
+  isAdmissionErrorCode,
   listAgents,
   memoryRateLimiter,
   normalizeManifest,