@hol-org/rb-client 0.1.180 → 0.1.182

package/dist/index.cjs

@@ -29,6 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  GUARD_CANONICAL_PATH_PREFIX: () => GUARD_CANONICAL_PATH_PREFIX,
+  GUARD_COMPAT_PATH_PREFIX: () => GUARD_COMPAT_PATH_PREFIX,
   HOL_CHAT_PROTOCOL_ID: () => HOL_CHAT_PROTOCOL_ID,
   RegistryBrokerClient: () => RegistryBrokerClient,
   RegistryBrokerError: () => RegistryBrokerError,
@@ -284,12 +286,128 @@ var sessionEncryptionSummarySchema = import_zod2.z.object({
 });
 var chatHistoryEntrySchema = import_zod2.z.object({
   messageId: import_zod2.z.string(),
-  role: import_zod2.z.enum(["user", "agent"]),
+  role: import_zod2.z.enum([
+    "user",
+    "agent",
+    "system",
+    "tool",
+    "payment",
+    "delivery",
+    "error"
+  ]),
   content: import_zod2.z.string(),
   timestamp: import_zod2.z.string(),
   cipherEnvelope: cipherEnvelopeSchema.optional(),
   metadata: import_zod2.z.record(jsonValueSchema).optional()
 });
+var chatDeliveryStateSchema = import_zod2.z.enum([
+  "draft",
+  "queued",
+  "persisted",
+  "delivered",
+  "streaming",
+  "responded",
+  "failed",
+  "timeout",
+  "cancelled"
+]);
+var chatReadinessStatusSchema = import_zod2.z.enum([
+  "responsive",
+  "delivery_only",
+  "degraded",
+  "blocked",
+  "unknown"
+]);
+var chatReplyModeSchema = import_zod2.z.enum([
+  "direct",
+  "stream",
+  "poll",
+  "delivery_only",
+  "none"
+]);
+var chatRouteTypeSchema = import_zod2.z.enum([
+  "a2a",
+  "hcs-10",
+  "mcp",
+  "openrouter",
+  "acp",
+  "xmtp",
+  "moltbook",
+  "agentverse",
+  "nanda",
+  "http",
+  "erc-8004",
+  "x402",
+  "unknown"
+]);
+var chatSessionStateSchema = import_zod2.z.enum([
+  "connecting",
+  "ready",
+  "blocked",
+  "ended",
+  "expired"
+]);
+var chatErrorCodeSchema = import_zod2.z.enum([
+  "AUTH_REQUIRED",
+  "CREDITS_REQUIRED",
+  "PAYMENT_REQUIRED",
+  "AGENT_UNRESPONSIVE",
+  "ROUTE_UNAVAILABLE",
+  "PROTOCOL_UNSUPPORTED",
+  "BROKER_NOT_EXECUTABLE",
+  "NETWORK_TIMEOUT",
+  "STREAM_STALLED",
+  "HISTORY_UNAVAILABLE",
+  "ENCRYPTION_REQUIRED",
+  "RATE_LIMITED",
+  "VALIDATION_ERROR",
+  "UNKNOWN_ERROR"
+]);
+var chatRouteSummarySchema = import_zod2.z.object({
+  type: chatRouteTypeSchema,
+  replyMode: chatReplyModeSchema,
+  transport: import_zod2.z.string(),
+  endpoint: import_zod2.z.string().optional()
+});
+var chatPaymentStateSchema = import_zod2.z.object({
+  required: import_zod2.z.boolean(),
+  provider: import_zod2.z.enum(["credits", "x402", "acp", "openrouter"]).optional(),
+  status: import_zod2.z.enum([
+    "not_required",
+    "preflight",
+    "required",
+    "approved",
+    "paid",
+    "failed"
+  ]),
+  estimatedCredits: import_zod2.z.number().nullable().optional(),
+  estimatedUsd: import_zod2.z.number().nullable().optional()
+});
+var chatReadinessResponseSchema = import_zod2.z.object({
+  status: chatReadinessStatusSchema,
+  routeType: chatRouteTypeSchema,
+  replyMode: chatReplyModeSchema,
+  transport: import_zod2.z.string(),
+  endpoint: import_zod2.z.string().optional(),
+  checkedAt: import_zod2.z.string(),
+  cachedUntil: import_zod2.z.string(),
+  latencyMs: import_zod2.z.number().nullable().optional(),
+  lastSuccessfulReplyAt: import_zod2.z.string().nullable().optional(),
+  lastDeliveryConfirmationAt: import_zod2.z.string().nullable().optional(),
+  lastFailureCode: chatErrorCodeSchema.nullable().optional(),
+  supportsStreaming: import_zod2.z.boolean(),
+  supportsHistory: import_zod2.z.boolean(),
+  supportsEncryption: import_zod2.z.boolean(),
+  supportsPayments: import_zod2.z.boolean(),
+  supportsAttachments: import_zod2.z.boolean(),
+  requiresAuth: import_zod2.z.boolean(),
+  operatorActionRequired: import_zod2.z.boolean(),
+  issue: import_zod2.z.object({
+    code: import_zod2.z.string(),
+    message: import_zod2.z.string(),
+    details: import_zod2.z.string().optional()
+  }).optional()
+});
 var metadataFacetSchema = import_zod2.z.record(
   import_zod2.z.union([
     import_zod2.z.array(jsonValueSchema),
@@ -489,7 +607,16 @@ var createSessionResponseSchema = import_zod2.z.object({
   }),
   history: import_zod2.z.array(chatHistoryEntrySchema).optional().default([]),
   historyTtlSeconds: import_zod2.z.number().nullable().optional(),
-  encryption: sessionEncryptionSummarySchema.nullable().optional()
+  encryption: sessionEncryptionSummarySchema.nullable().optional(),
+  route: chatRouteSummarySchema.optional(),
+  transport: import_zod2.z.string().optional(),
+  senderUaid: import_zod2.z.string().nullable().optional(),
+  visibility: import_zod2.z.enum(["private", "public"]).optional(),
+  payment: chatPaymentStateSchema.optional(),
+  readiness: chatReadinessResponseSchema.optional(),
+  state: chatSessionStateSchema.optional(),
+  traceId: import_zod2.z.string().optional(),
+  expiresAt: import_zod2.z.string().nullable().optional()
 });
 var sendMessageResponseSchema = import_zod2.z.object({
   sessionId: import_zod2.z.string(),
@@ -501,7 +628,20 @@ var sendMessageResponseSchema = import_zod2.z.object({
   ops: import_zod2.z.array(import_zod2.z.record(jsonValueSchema)).optional(),
   history: import_zod2.z.array(chatHistoryEntrySchema).optional(),
   historyTtlSeconds: import_zod2.z.number().nullable().optional(),
-  encrypted: import_zod2.z.boolean().optional()
+  encrypted: import_zod2.z.boolean().optional(),
+  messageId: import_zod2.z.string().optional(),
+  assistantMessageId: import_zod2.z.string().nullable().optional(),
+  deliveryState: chatDeliveryStateSchema.optional(),
+  replyMode: chatReplyModeSchema.optional(),
+  deliveryConfirmation: import_zod2.z.boolean().optional(),
+  idempotent: import_zod2.z.boolean().optional(),
+  metadata: import_zod2.z.record(jsonValueSchema).optional(),
+  errorCode: chatErrorCodeSchema.optional()
+});
+var chatSessionEndResponseSchema = import_zod2.z.object({
+  message: import_zod2.z.string(),
+  sessionId: import_zod2.z.string(),
+  state: chatSessionStateSchema.optional()
 });
 var chatHistorySnapshotResponseSchema = import_zod2.z.object({
   sessionId: import_zod2.z.string(),
@@ -2975,8 +3115,11 @@ var EncryptedChatManager = class {
 function createChatApi(client, encryptedManager) {
   return {
     start: (options) => client.startChat(options),
+    readiness: (payload) => client.checkChatReadiness(payload),
     createSession: (payload) => client.createSession(payload),
     sendMessage: (payload) => client.sendMessage(payload),
+    retryMessage: (messageId, payload) => client.retryMessage(messageId, payload),
+    cancelSession: (sessionId) => client.cancelSession(sessionId),
     endSession: (sessionId) => client.endSession(sessionId),
     getHistory: (sessionId, options) => client.fetchHistorySnapshot(sessionId, options),
     compactHistory: (payload) => client.compactHistory(payload),
@@ -2988,6 +3131,30 @@ function createChatApi(client, encryptedManager) {
     acceptEncryptedSession: (options) => encryptedManager.acceptSession(options)
   };
 }
+async function checkChatReadiness(client, payload) {
+  const body = {};
+  const uaid = "uaid" in payload ? payload.uaid?.trim() : void 0;
+  const agentUrl = "agentUrl" in payload ? payload.agentUrl?.trim() : void 0;
+  if (!uaid && !agentUrl) {
+    throw new Error("uaid or agentUrl is required to check chat readiness");
+  }
+  if (uaid) {
+    body.uaid = uaid;
+  }
+  if (agentUrl) {
+    body.agentUrl = agentUrl;
+  }
+  const raw = await client.requestJson("/chat/readiness", {
+    method: "POST",
+    body,
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    chatReadinessResponseSchema,
+    "chat readiness response"
+  );
+}
 async function createSession(client, payload, allowHistoryAutoTopUp = true) {
   const body = {};
   if ("uaid" in payload && payload.uaid) {
@@ -3008,6 +3175,9 @@ async function createSession(client, payload, allowHistoryAutoTopUp = true) {
   if (payload.senderUaid) {
     body.senderUaid = payload.senderUaid;
   }
+  if (payload.visibility) {
+    body.visibility = payload.visibility;
+  }
   try {
     const raw = await client.requestJson("/chat/session", {
       method: "POST",
@@ -3242,6 +3412,15 @@ async function sendMessage(client, payload) {
   if (payload.streaming !== void 0) {
     body.streaming = payload.streaming;
   }
+  if (payload.idempotencyKey) {
+    body.idempotencyKey = payload.idempotencyKey;
+  }
+  if (payload.senderUaid) {
+    body.senderUaid = payload.senderUaid;
+  }
+  if (payload.transport) {
+    body.transport = payload.transport;
+  }
   if (payload.auth) {
     body.auth = serialiseAuthConfig(payload.auth);
   }
@@ -3285,9 +3464,130 @@ async function sendMessage(client, payload) {
   );
 }
 async function endSession(client, sessionId) {
-  await client.request(`/chat/session/${encodeURIComponent(sessionId)}`, {
-    method: "DELETE"
-  });
+  const normalizedSessionId = sessionId?.trim();
+  if (!normalizedSessionId) {
+    throw new Error("sessionId is required to end a chat session");
+  }
+  const response = await client.request(
+    `/chat/session/${encodeURIComponent(normalizedSessionId)}`,
+    { method: "DELETE" }
+  );
+  if (response.status === 204) {
+    return {
+      message: "Session ended",
+      sessionId: normalizedSessionId,
+      state: "ended"
+    };
+  }
+  const contentType = response.headers?.get("content-type") ?? "";
+  if (!contentType.toLowerCase().includes("json")) {
+    await response.text();
+    return {
+      message: "Session ended",
+      sessionId: normalizedSessionId,
+      state: "ended"
+    };
+  }
+  const responseBody = await response.text();
+  if (responseBody.trim().length === 0) {
+    return {
+      message: "Session ended",
+      sessionId: normalizedSessionId,
+      state: "ended"
+    };
+  }
+  const raw = JSON.parse(responseBody);
+  return client.parseWithSchema(
+    raw,
+    chatSessionEndResponseSchema,
+    "chat session end response"
+  );
+}
+async function cancelSession(client, sessionId) {
+  const normalizedSessionId = sessionId?.trim();
+  if (!normalizedSessionId) {
+    throw new Error("sessionId is required to cancel a chat session");
+  }
+  const raw = await client.requestJson(
+    `/chat/session/${encodeURIComponent(normalizedSessionId)}/cancel`,
+    {
+      method: "POST"
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    chatSessionEndResponseSchema,
+    "chat session cancel response"
+  );
+}
+async function retryMessage(client, messageId, payload) {
+  const normalizedMessageId = messageId?.trim();
+  const normalizedSessionId = payload.sessionId?.trim();
+  const normalizedMessage = payload.message?.trim();
+  if (!normalizedMessageId) {
+    throw new Error("messageId is required to retry a message");
+  }
+  if (!normalizedSessionId) {
+    throw new Error("sessionId is required to retry a message");
+  }
+  if (!normalizedMessage) {
+    throw new Error("message is required to retry a message");
+  }
+  const body = {
+    sessionId: normalizedSessionId,
+    message: payload.message
+  };
+  if (payload.streaming !== void 0) {
+    body.streaming = payload.streaming;
+  }
+  if (payload.transport) {
+    body.transport = payload.transport;
+  }
+  const uaid = payload.uaid?.trim();
+  const agentUrl = payload.agentUrl?.trim();
+  const idempotencyKey = payload.idempotencyKey?.trim();
+  const senderUaid = payload.senderUaid?.trim();
+  if (uaid) {
+    body.uaid = uaid;
+  }
+  if (agentUrl) {
+    body.agentUrl = agentUrl;
+  }
+  if (idempotencyKey) {
+    body.idempotencyKey = idempotencyKey;
+  }
+  if (senderUaid) {
+    body.senderUaid = senderUaid;
+  }
+  if (payload.auth) {
+    body.auth = serialiseAuthConfig(payload.auth);
+  }
+  let cipherEnvelope = payload.cipherEnvelope ?? null;
+  if (payload.encryption) {
+    if (!payload.encryption.recipients?.length) {
+      throw new Error("recipients are required for encrypted chat payloads");
+    }
+    cipherEnvelope = client.encryption.encryptCipherEnvelope({
+      ...payload.encryption,
+      sessionId: payload.encryption.sessionId ?? normalizedSessionId
+    });
+  }
+  if (cipherEnvelope) {
+    body.cipherEnvelope = toJsonObject(cipherEnvelope);
+  }
+  const raw = await client.requestJson(
+    `/chat/message/${encodeURIComponent(normalizedMessageId)}/retry`,
+    {
+      method: "POST",
+      body,
+      headers: { "content-type": "application/json" }
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    sendMessageResponseSchema,
+    "chat retry response"
+  );
 }
 
 // ../../src/services/registry-broker/client/encryption.ts
@@ -4293,10 +4593,98 @@ async function registerOwnedMoltbookAgent(client, uaid, request) {
 }
 
 // ../../src/services/registry-broker/client/guard.ts
+function isStatusError(error) {
+  if (error instanceof RegistryBrokerError) {
+    return true;
+  }
+  if (typeof error !== "object" || error === null || !("status" in error)) {
+    return false;
+  }
+  return typeof Reflect.get(error, "status") === "number";
+}
+function toPortalCanonicalGuardPath(path) {
+  const segments = path.split("/");
+  const findPatternStart = (size, matcher) => {
+    for (let startIndex = segments.length - size; startIndex >= 0; startIndex -= 1) {
+      if (matcher(startIndex)) {
+        return startIndex;
+      }
+    }
+    return -1;
+  };
+  const replaceAt = (startIndex, consumed) => [
+    ...segments.slice(0, startIndex),
+    "api",
+    "guard",
+    ...segments.slice(startIndex + consumed)
+  ].join("/");
+  const registryStart = findPatternStart(
+    4,
+    (startIndex) => segments[startIndex] === "registry" && segments[startIndex + 1] === "api" && /^v\d+$/.test(segments[startIndex + 2] ?? "") && segments[startIndex + 3] === "guard"
+  );
+  if (registryStart >= 0) {
+    return replaceAt(registryStart, 4);
+  }
+  const apiVersionStart = findPatternStart(
+    3,
+    (startIndex) => segments[startIndex] === "api" && /^v\d+$/.test(segments[startIndex + 1] ?? "") && segments[startIndex + 2] === "guard"
+  );
+  if (apiVersionStart >= 0) {
+    return replaceAt(apiVersionStart, 3);
+  }
+  for (let index = segments.length - 1; index >= 0; index -= 1) {
+    if (segments[index] === "guard" && segments[index - 1] !== "api") {
+      return [
+        ...segments.slice(0, index),
+        "api",
+        "guard",
+        ...segments.slice(index + 1)
+      ].join("/");
+    }
+  }
+  return path;
+}
+function buildPortalCanonicalGuardUrl(baseUrl, path) {
+  const target = new URL(path, "https://guard.local");
+  const normalizedBasePath = (() => {
+    try {
+      const base = new URL(baseUrl);
+      return base.pathname.replace(/\/+$/, "");
+    } catch {
+      return baseUrl.replace(/\/+$/, "");
+    }
+  })();
+  const requestedPath = `${normalizedBasePath}${target.pathname}`;
+  const canonicalPath = toPortalCanonicalGuardPath(requestedPath);
+  const canonicalRelativePath = `${canonicalPath}${target.search}`;
+  try {
+    const base = new URL(baseUrl);
+    return `${base.origin}${canonicalRelativePath}`;
+  } catch {
+    return canonicalRelativePath;
+  }
+}
+async function requestPortalFirstJson(client, path, init) {
+  try {
+    return await client.requestJson(path, init);
+  } catch (error) {
+    if (isStatusError(error) && (error.status === 404 || error.status === 501)) {
+      return client.requestAbsoluteJson(
+        buildPortalCanonicalGuardUrl(client.baseUrl, path),
+        init
+      );
+    }
+    throw error;
+  }
+}
 async function getGuardSession(client) {
-  const raw = await client.requestJson("/guard/auth/session", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/auth/session",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardSessionResponseSchema,
@@ -4304,9 +4692,13 @@ async function getGuardSession(client) {
   );
 }
 async function getGuardEntitlements(client) {
-  const raw = await client.requestJson("/guard/entitlements", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/entitlements",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardSessionResponseSchema,
@@ -4314,9 +4706,13 @@ async function getGuardEntitlements(client) {
   );
 }
 async function getGuardBillingBalance(client) {
-  const raw = await client.requestJson("/guard/billing/balance", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/billing/balance",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardBalanceResponseSchema,
@@ -4330,9 +4726,13 @@ async function getGuardFeed(client, limit) {
   }
   const query = params.toString();
   const suffix = query ? `?${query}` : "";
-  const raw = await client.requestJson(`/guard/feed${suffix}`, {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    `/guard/feed${suffix}`,
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardFeedResponseSchema,
@@ -4340,9 +4740,13 @@ async function getGuardFeed(client, limit) {
   );
 }
 async function getGuardOverview(client) {
-  const raw = await client.requestJson("/guard/overview", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/overview",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardOverviewResponseSchema,
@@ -4354,7 +4758,8 @@ async function getGuardTrustByHash(client, sha256) {
   if (!normalizedHash) {
     throw new Error("sha256 is required");
   }
-  const raw = await client.requestJson(
+  const raw = await requestPortalFirstJson(
+    client,
     `/guard/trust/by-hash/${encodeURIComponent(normalizedHash)}`,
     { method: "GET" }
   );
@@ -4376,7 +4781,8 @@ async function resolveGuardTrust(client, query) {
     params.set("version", query.version.trim());
   }
   const suffix = params.size > 0 ? `?${params.toString()}` : "";
-  const raw = await client.requestJson(
+  const raw = await requestPortalFirstJson(
+    client,
     `/guard/trust/resolve${suffix}`,
     { method: "GET" }
   );
@@ -4387,9 +4793,13 @@ async function resolveGuardTrust(client, query) {
   );
 }
 async function getGuardRevocations(client) {
-  const raw = await client.requestJson("/guard/revocations", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/revocations",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardRevocationResponseSchema,
@@ -4397,9 +4807,13 @@ async function getGuardRevocations(client) {
   );
 }
 async function fetchGuardAdvisories(client) {
-  const raw = await client.requestJson("/guard/advisories", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/advisories",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardRevocationResponseSchema,
@@ -4407,9 +4821,13 @@ async function fetchGuardAdvisories(client) {
   );
 }
 async function fetchGuardPolicy(client) {
-  const raw = await client.requestJson("/guard/policy/fetch", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/policy/fetch",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardPolicySchema,
@@ -4417,9 +4835,13 @@ async function fetchGuardPolicy(client) {
   );
 }
 async function getGuardInventory(client) {
-  const raw = await client.requestJson("/guard/inventory", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/inventory",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardInventoryResponseSchema,
@@ -4427,9 +4849,13 @@ async function getGuardInventory(client) {
   );
 }
 async function getGuardReceiptHistory(client) {
-  const raw = await client.requestJson("/guard/history", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/history",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardReceiptHistoryResponseSchema,
@@ -4441,7 +4867,8 @@ async function getGuardArtifactTimeline(client, artifactId) {
   if (!normalizedArtifactId) {
     throw new Error("artifactId is required");
   }
-  const raw = await client.requestJson(
+  const raw = await requestPortalFirstJson(
+    client,
     `/guard/history/${encodeURIComponent(normalizedArtifactId)}`,
     { method: "GET" }
   );
@@ -4452,7 +4879,7 @@ async function getGuardArtifactTimeline(client, artifactId) {
   );
 }
 async function exportGuardAbom(client) {
-  const raw = await client.requestJson("/guard/abom", {
+  const raw = await requestPortalFirstJson(client, "/guard/abom", {
     method: "GET"
   });
   return client.parseWithSchema(
@@ -4466,7 +4893,8 @@ async function exportGuardArtifactAbom(client, artifactId) {
   if (!normalizedArtifactId) {
     throw new Error("artifactId is required");
   }
-  const raw = await client.requestJson(
+  const raw = await requestPortalFirstJson(
+    client,
     `/guard/abom/${encodeURIComponent(normalizedArtifactId)}`,
     { method: "GET" }
   );
@@ -4477,9 +4905,13 @@ async function exportGuardArtifactAbom(client, artifactId) {
   );
 }
 async function exportGuardReceipts(client) {
-  const raw = await client.requestJson("/guard/receipts/export", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/receipts/export",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardReceiptExportResponseSchema,
@@ -4487,9 +4919,13 @@ async function exportGuardReceipts(client) {
   );
 }
 async function getGuardInventoryDiff(client) {
-  const raw = await client.requestJson("/guard/inventory/diff", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/inventory/diff",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardInventoryDiffResponseSchema,
@@ -4497,9 +4933,13 @@ async function getGuardInventoryDiff(client) {
   );
 }
 async function getGuardDevices(client) {
-  const raw = await client.requestJson("/guard/devices", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/devices",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardDeviceListResponseSchema,
@@ -4507,9 +4947,13 @@ async function getGuardDevices(client) {
   );
 }
 async function getGuardAlertPreferences(client) {
-  const raw = await client.requestJson("/guard/alerts/preferences", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/alerts/preferences",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardAlertPreferencesSchema,
@@ -4517,10 +4961,14 @@ async function getGuardAlertPreferences(client) {
   );
 }
 async function updateGuardAlertPreferences(client, payload) {
-  const raw = await client.requestJson("/guard/alerts/preferences", {
-    method: "PUT",
-    body: payload
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/alerts/preferences",
+    {
+      method: "PUT",
+      body: payload
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardAlertPreferencesSchema,
@@ -4528,9 +4976,13 @@ async function updateGuardAlertPreferences(client, payload) {
   );
 }
 async function getGuardExceptions(client) {
-  const raw = await client.requestJson("/guard/exceptions", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/exceptions",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardExceptionListResponseSchema,
@@ -4538,9 +4990,13 @@ async function getGuardExceptions(client) {
   );
 }
 async function getGuardWatchlist(client) {
-  const raw = await client.requestJson("/guard/watchlist", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/watchlist",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardWatchlistResponseSchema,
@@ -4548,10 +5004,14 @@ async function getGuardWatchlist(client) {
   );
 }
 async function lookupGuardWatchlist(client, payload) {
-  const raw = await client.requestJson("/guard/watchlist/lookup", {
-    method: "POST",
-    body: payload
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/watchlist/lookup",
+    {
+      method: "POST",
+      body: payload
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardWatchlistLookupResponseSchema,
@@ -4559,9 +5019,13 @@ async function lookupGuardWatchlist(client, payload) {
   );
 }
 async function getGuardPainSignals(client) {
-  const raw = await client.requestJson("/guard/signals/pain", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/signals/pain",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardPainSignalListResponseSchema,
@@ -4569,7 +5033,8 @@ async function getGuardPainSignals(client) {
   );
 }
 async function getGuardAggregatedPainSignals(client) {
-  const raw = await client.requestJson(
+  const raw = await requestPortalFirstJson(
+    client,
     "/guard/signals/pain/aggregate",
     {
       method: "GET"
@@ -4582,7 +5047,7 @@ async function getGuardAggregatedPainSignals(client) {
   );
 }
 async function getGuardPreflightVerdict(client, path, payload) {
-  const raw = await client.requestJson(path, {
+  const raw = await requestPortalFirstJson(client, path, {
     method: "POST",
     body: payload
   });
@@ -4607,10 +5072,14 @@ async function getGuardPreExecutionVerdict(client, payload) {
   );
 }
 async function ingestGuardPainSignals(client, items) {
-  const raw = await client.requestJson("/guard/signals/pain", {
-    method: "POST",
-    body: { items }
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/signals/pain",
+    {
+      method: "POST",
+      body: { items }
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardPainSignalListResponseSchema,
@@ -4618,10 +5087,14 @@ async function ingestGuardPainSignals(client, items) {
   );
 }
 async function submitGuardReceipts(client, payload) {
-  const raw = await client.requestJson("/guard/receipts/submit", {
-    method: "POST",
-    body: payload
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/receipts/submit",
+    {
+      method: "POST",
+      body: payload
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardReceiptSyncResponseSchema,
@@ -4629,10 +5102,14 @@ async function submitGuardReceipts(client, payload) {
   );
 }
 async function addGuardWatchlistItem(client, payload) {
-  const raw = await client.requestJson("/guard/watchlist", {
-    method: "POST",
-    body: payload
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/watchlist",
+    {
+      method: "POST",
+      body: payload
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardWatchlistResponseSchema,
@@ -4644,7 +5121,8 @@ async function removeGuardWatchlistItem(client, artifactId) {
   if (!normalizedArtifactId) {
     throw new Error("artifactId is required");
   }
-  const raw = await client.requestJson(
+  const raw = await requestPortalFirstJson(
+    client,
     `/guard/watchlist/${encodeURIComponent(normalizedArtifactId)}`,
     { method: "DELETE" }
   );
@@ -4655,10 +5133,14 @@ async function removeGuardWatchlistItem(client, artifactId) {
   );
 }
 async function addGuardException(client, payload) {
-  const raw = await client.requestJson("/guard/exceptions", {
-    method: "POST",
-    body: payload
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/exceptions",
+    {
+      method: "POST",
+      body: payload
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardExceptionListResponseSchema,
@@ -4666,10 +5148,14 @@ async function addGuardException(client, payload) {
   );
 }
 async function requestGuardException(client, payload) {
-  const raw = await client.requestJson("/guard/exceptions/request", {
-    method: "POST",
-    body: payload
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/exceptions/request",
+    {
+      method: "POST",
+      body: payload
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardExceptionListResponseSchema,
@@ -4677,10 +5163,14 @@ async function requestGuardException(client, payload) {
   );
 }
 async function syncGuardInventory(client, payload) {
-  const raw = await client.requestJson("/guard/inventory/sync", {
-    method: "POST",
-    body: payload
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/inventory/sync",
+    {
+      method: "POST",
+      body: payload
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardReceiptSyncResponseSchema,
@@ -4692,7 +5182,8 @@ async function removeGuardException(client, exceptionId) {
   if (!normalizedExceptionId) {
     throw new Error("exceptionId is required");
   }
-  const raw = await client.requestJson(
+  const raw = await requestPortalFirstJson(
+    client,
     `/guard/exceptions/${encodeURIComponent(normalizedExceptionId)}`,
     { method: "DELETE" }
   );
@@ -4703,9 +5194,13 @@ async function removeGuardException(client, exceptionId) {
   );
 }
 async function getGuardTeamPolicyPack(client) {
-  const raw = await client.requestJson("/guard/team/policy-pack", {
-    method: "GET"
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/team/policy-pack",
+    {
+      method: "GET"
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardTeamPolicyPackSchema,
@@ -4713,10 +5208,14 @@ async function getGuardTeamPolicyPack(client) {
   );
 }
 async function updateGuardTeamPolicyPack(client, payload) {
-  const raw = await client.requestJson("/guard/team/policy-pack", {
-    method: "PUT",
-    body: payload
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/team/policy-pack",
+    {
+      method: "PUT",
+      body: payload
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardTeamPolicyPackSchema,
@@ -4724,10 +5223,14 @@ async function updateGuardTeamPolicyPack(client, payload) {
   );
 }
 async function syncGuardReceipts(client, payload) {
-  const raw = await client.requestJson("/guard/receipts/sync", {
-    method: "POST",
-    body: payload
-  });
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/receipts/sync",
+    {
+      method: "POST",
+      body: payload
+    }
+  );
   return client.parseWithSchema(
     raw,
     guardReceiptSyncResponseSchema,
@@ -6063,7 +6566,7 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
     const normalisedPath = path.startsWith("/") ? path : `/${path}`;
     return `${this.baseUrl}${normalisedPath}`;
   }
-  async request(path, config) {
+  buildRequestInit(config) {
     const headers = new Headers();
     Object.entries(this.defaultHeaders).forEach(([key, value]) => {
       headers.set(key, value);
@@ -6089,6 +6592,10 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
         headers.set("content-type", "application/json");
       }
     }
+    return init;
+  }
+  async request(path, config) {
+    const init = this.buildRequestInit(config);
     const response = await this.fetchImpl(this.buildUrl(path), init);
     if (response.ok) {
       return response;
@@ -6100,6 +6607,19 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
       body: errorBody
     });
   }
+  async requestAbsolute(url, config) {
+    const init = this.buildRequestInit(config);
+    const response = await this.fetchImpl(url, init);
+    if (response.ok) {
+      return response;
+    }
+    const errorBody = await this.extractErrorBody(response);
+    throw new RegistryBrokerError("Registry broker request failed", {
+      status: response.status,
+      statusText: response.statusText,
+      body: errorBody
+    });
+  }
   async requestJson(path, config) {
     const response = await this.request(path, config);
     const contentType = response.headers?.get("content-type") ?? "";
@@ -6112,6 +6632,18 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
     }
     return await response.json();
   }
+  async requestAbsoluteJson(url, config) {
+    const response = await this.requestAbsolute(url, config);
+    const contentType = response.headers?.get("content-type") ?? "";
+    if (!JSON_CONTENT_TYPE.test(contentType)) {
+      const body = await response.text();
+      throw new RegistryBrokerParseError(
+        "Expected JSON response from registry broker",
+        body
+      );
+    }
+    return await response.json();
+  }
   async getAgentFeedback(uaid, options = {}) {
     const normalized = uaid.trim();
     if (!normalized) {
@@ -6746,6 +7278,9 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async createSession(payload, allowHistoryAutoTopUp = true) {
     return createSession(this, payload, allowHistoryAutoTopUp);
   }
+  async checkChatReadiness(payload) {
+    return checkChatReadiness(this, payload);
+  }
   async startChat(options) {
     return startChat(this, this.getEncryptedChatManager(), options);
   }
@@ -6771,6 +7306,12 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   sendMessage(payload) {
     return sendMessage(this, payload);
   }
+  retryMessage(messageId, payload) {
+    return retryMessage(this, messageId, payload);
+  }
+  cancelSession(sessionId) {
+    return cancelSession(this, sessionId);
+  }
   endSession(sessionId) {
     return endSession(this, sessionId);
   }
@@ -7037,6 +7578,10 @@ var isPendingRegisterAgentResponse = (response) => response.status === "pending"
 var isPartialRegisterAgentResponse = (response) => response.status === "partial" && response.success === false;
 var isSuccessRegisterAgentResponse = (response) => response.success === true && response.status !== "pending";
 
+// ../../src/services/registry-broker/types.ts
+var GUARD_CANONICAL_PATH_PREFIX = "/api/guard";
+var GUARD_COMPAT_PATH_PREFIX = "/guard";
+
 // ../../src/services/registry-broker/hol-chat-ops.ts
 var HOL_CHAT_PROTOCOL_ID = "hol-chat";
 var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -7094,6 +7639,8 @@ var buildJobStatusMessage = (input) => JSON.stringify({
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  GUARD_CANONICAL_PATH_PREFIX,
+  GUARD_COMPAT_PATH_PREFIX,
   HOL_CHAT_PROTOCOL_ID,
   RegistryBrokerClient,
   RegistryBrokerError,