@hol-org/rb-client 0.1.181 → 0.1.183

package/dist/index.js

@@ -225,12 +225,173 @@ var sessionEncryptionSummarySchema = z2.object({
 });
 var chatHistoryEntrySchema = z2.object({
   messageId: z2.string(),
-  role: z2.enum(["user", "agent"]),
+  role: z2.enum([
+    "user",
+    "agent",
+    "system",
+    "tool",
+    "payment",
+    "delivery",
+    "error"
+  ]),
   content: z2.string(),
   timestamp: z2.string(),
   cipherEnvelope: cipherEnvelopeSchema.optional(),
   metadata: z2.record(jsonValueSchema).optional()
 });
+var chatDeliveryStateSchema = z2.enum([
+  "draft",
+  "queued",
+  "persisted",
+  "delivered",
+  "streaming",
+  "responded",
+  "failed",
+  "timeout",
+  "cancelled"
+]);
+var chatAttachmentStateSchema = z2.object({
+  supported: z2.boolean(),
+  status: z2.enum([
+    "unsupported",
+    "available",
+    "selected",
+    "uploading",
+    "scanning",
+    "ready",
+    "failed",
+    "rejected"
+  ]),
+  maxBytes: z2.number().nullable().optional(),
+  acceptedMimeTypes: z2.array(z2.string()).optional(),
+  reason: z2.string().optional()
+});
+var chatTimelineEntrySchema = z2.object({
+  messageId: z2.string(),
+  kind: z2.enum([
+    "user",
+    "assistant",
+    "system",
+    "tool",
+    "payment",
+    "delivery",
+    "error"
+  ]),
+  content: z2.string(),
+  timestamp: z2.string(),
+  deliveryState: chatDeliveryStateSchema.optional(),
+  errorCode: z2.string().optional(),
+  metadata: z2.record(jsonValueSchema).optional(),
+  attachment: chatAttachmentStateSchema.optional()
+});
+var chatReadinessStatusSchema = z2.enum([
+  "responsive",
+  "delivery_only",
+  "degraded",
+  "blocked",
+  "unknown"
+]);
+var chatReplyModeSchema = z2.enum([
+  "direct",
+  "stream",
+  "poll",
+  "delivery_only",
+  "none"
+]);
+var chatRouteTypeSchema = z2.enum([
+  "a2a",
+  "hcs-10",
+  "mcp",
+  "openrouter",
+  "acp",
+  "xmtp",
+  "moltbook",
+  "agentverse",
+  "nanda",
+  "http",
+  "erc-8004",
+  "x402",
+  "unknown"
+]);
+var chatSessionStateSchema = z2.enum([
+  "connecting",
+  "ready",
+  "blocked",
+  "ended",
+  "expired"
+]);
+var chatErrorCodeSchema = z2.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 = z2.object({
+  type: chatRouteTypeSchema,
+  replyMode: chatReplyModeSchema,
+  transport: z2.string(),
+  endpoint: z2.string().optional()
+});
+var chatPaymentStateSchema = z2.object({
+  required: z2.boolean(),
+  provider: z2.enum(["credits", "x402", "acp", "openrouter"]).optional(),
+  status: z2.enum([
+    "not_required",
+    "preflight",
+    "required",
+    "approved",
+    "paid",
+    "failed"
+  ]),
+  estimatedCredits: z2.number().nullable().optional(),
+  estimatedUsd: z2.number().nullable().optional()
+});
+var chatReadinessResponseSchema = z2.object({
+  status: chatReadinessStatusSchema,
+  routeType: chatRouteTypeSchema,
+  replyMode: chatReplyModeSchema,
+  transport: z2.string(),
+  endpoint: z2.string().optional(),
+  checkedAt: z2.string(),
+  cachedUntil: z2.string(),
+  latencyMs: z2.number().nullable().optional(),
+  lastSuccessfulReplyAt: z2.string().nullable().optional(),
+  lastDeliveryConfirmationAt: z2.string().nullable().optional(),
+  lastFailureCode: chatErrorCodeSchema.nullable().optional(),
+  supportsStreaming: z2.boolean(),
+  supportsHistory: z2.boolean(),
+  supportsEncryption: z2.boolean(),
+  supportsPayments: z2.boolean(),
+  supportsAttachments: z2.boolean(),
+  requiresAuth: z2.boolean(),
+  operatorActionRequired: z2.boolean(),
+  issue: z2.object({
+    code: z2.string(),
+    message: z2.string(),
+    details: z2.string().optional()
+  }).optional()
+});
+var chatSessionResumeResponseSchema = z2.object({
+  sessionId: z2.string(),
+  uaid: z2.string().nullable().optional(),
+  agentUrl: z2.string().nullable().optional(),
+  route: chatRouteSummarySchema,
+  transport: z2.string(),
+  history: z2.array(chatHistoryEntrySchema),
+  historyTtlSeconds: z2.number().optional(),
+  visibility: z2.enum(["private", "public"]).optional(),
+  state: chatSessionStateSchema
+});
 var metadataFacetSchema = z2.record(
   z2.union([
     z2.array(jsonValueSchema),
@@ -430,7 +591,16 @@ var createSessionResponseSchema = z2.object({
   }),
   history: z2.array(chatHistoryEntrySchema).optional().default([]),
   historyTtlSeconds: z2.number().nullable().optional(),
-  encryption: sessionEncryptionSummarySchema.nullable().optional()
+  encryption: sessionEncryptionSummarySchema.nullable().optional(),
+  route: chatRouteSummarySchema.optional(),
+  transport: z2.string().optional(),
+  senderUaid: z2.string().nullable().optional(),
+  visibility: z2.enum(["private", "public"]).optional(),
+  payment: chatPaymentStateSchema.optional(),
+  readiness: chatReadinessResponseSchema.optional(),
+  state: chatSessionStateSchema.optional(),
+  traceId: z2.string().optional(),
+  expiresAt: z2.string().nullable().optional()
 });
 var sendMessageResponseSchema = z2.object({
   sessionId: z2.string(),
@@ -442,7 +612,20 @@ var sendMessageResponseSchema = z2.object({
   ops: z2.array(z2.record(jsonValueSchema)).optional(),
   history: z2.array(chatHistoryEntrySchema).optional(),
   historyTtlSeconds: z2.number().nullable().optional(),
-  encrypted: z2.boolean().optional()
+  encrypted: z2.boolean().optional(),
+  messageId: z2.string().optional(),
+  assistantMessageId: z2.string().nullable().optional(),
+  deliveryState: chatDeliveryStateSchema.optional(),
+  replyMode: chatReplyModeSchema.optional(),
+  deliveryConfirmation: z2.boolean().optional(),
+  idempotent: z2.boolean().optional(),
+  metadata: z2.record(jsonValueSchema).optional(),
+  errorCode: chatErrorCodeSchema.optional()
+});
+var chatSessionEndResponseSchema = z2.object({
+  message: z2.string(),
+  sessionId: z2.string(),
+  state: chatSessionStateSchema.optional()
 });
 var chatHistorySnapshotResponseSchema = z2.object({
   sessionId: z2.string(),
@@ -2916,8 +3099,12 @@ var EncryptedChatManager = class {
 function createChatApi(client, encryptedManager) {
   return {
     start: (options) => client.startChat(options),
+    readiness: (payload) => client.checkChatReadiness(payload),
     createSession: (payload) => client.createSession(payload),
+    resumeSession: (sessionId) => client.resumeSession(sessionId),
     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),
@@ -2929,6 +3116,33 @@ 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;
+  }
+  if (payload.forceRefresh !== void 0) {
+    body.forceRefresh = payload.forceRefresh;
+  }
+  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) {
@@ -2949,6 +3163,12 @@ async function createSession(client, payload, allowHistoryAutoTopUp = true) {
   if (payload.senderUaid) {
     body.senderUaid = payload.senderUaid;
   }
+  if (payload.visibility) {
+    body.visibility = payload.visibility;
+  }
+  if (payload.idempotencyKey) {
+    body.idempotencyKey = payload.idempotencyKey;
+  }
   try {
     const raw = await client.requestJson("/chat/session", {
       method: "POST",
@@ -2969,6 +3189,21 @@ async function createSession(client, payload, allowHistoryAutoTopUp = true) {
     throw error;
   }
 }
+async function resumeSession(client, sessionId) {
+  const normalized = sessionId.trim();
+  if (!normalized) {
+    throw new Error("sessionId is required to resume a chat session");
+  }
+  const raw = await client.requestJson(
+    `/chat/session/${encodeURIComponent(normalized)}/resume`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    chatSessionResumeResponseSchema,
+    "chat session resume response"
+  );
+}
 async function startChat(client, encryptedManager, options) {
   if ("uaid" in options && options.uaid) {
     return startConversation(client, encryptedManager, {
@@ -3183,6 +3418,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);
   }
@@ -3226,9 +3470,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
@@ -6918,6 +7283,12 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async createSession(payload, allowHistoryAutoTopUp = true) {
     return createSession(this, payload, allowHistoryAutoTopUp);
   }
+  async resumeSession(sessionId) {
+    return resumeSession(this, sessionId);
+  }
+  async checkChatReadiness(payload) {
+    return checkChatReadiness(this, payload);
+  }
   async startChat(options) {
     return startChat(this, this.getEncryptedChatManager(), options);
   }
@@ -6943,6 +7314,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);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hol-org/rb-client",
-  "version": "0.1.181",
+  "version": "0.1.183",
   "description": "Lightweight Registry Broker client for HOL registries.",
   "type": "module",
   "files": [