@hol-org/rb-client 0.1.182 → 0.1.184

package/dist/index.cjs

@@ -39,6 +39,13 @@ __export(src_exports, {
   buildPaymentApproveMessage: () => buildPaymentApproveMessage,
   buildPaymentDeclineMessage: () => buildPaymentDeclineMessage,
   canonicalizeLedgerNetwork: () => canonicalizeLedgerNetwork,
+  chatDeliveryStateSchema: () => chatDeliveryStateSchema,
+  chatErrorCodeSchema: () => chatErrorCodeSchema,
+  chatReadinessStatusSchema: () => chatReadinessStatusSchema,
+  chatReplyModeSchema: () => chatReplyModeSchema,
+  chatRouteTypeSchema: () => chatRouteTypeSchema,
+  chatSessionStateSchema: () => chatSessionStateSchema,
+  chatTimelineEntrySchema: () => chatTimelineEntrySchema,
   closeUaidConnection: () => closeUaidConnection,
   createPrivateKeySigner: () => createPrivateKeySigner,
   createPrivateKeySignerAsync: () => createPrivateKeySignerAsync,
@@ -311,6 +318,40 @@ var chatDeliveryStateSchema = import_zod2.z.enum([
   "timeout",
   "cancelled"
 ]);
+var chatAttachmentStateSchema = import_zod2.z.object({
+  supported: import_zod2.z.boolean(),
+  status: import_zod2.z.enum([
+    "unsupported",
+    "available",
+    "selected",
+    "uploading",
+    "scanning",
+    "ready",
+    "failed",
+    "rejected"
+  ]),
+  maxBytes: import_zod2.z.number().nullable().optional(),
+  acceptedMimeTypes: import_zod2.z.array(import_zod2.z.string()).optional(),
+  reason: import_zod2.z.string().optional()
+});
+var chatTimelineEntrySchema = import_zod2.z.object({
+  messageId: import_zod2.z.string(),
+  kind: import_zod2.z.enum([
+    "user",
+    "assistant",
+    "system",
+    "tool",
+    "payment",
+    "delivery",
+    "error"
+  ]),
+  content: import_zod2.z.string(),
+  timestamp: import_zod2.z.string(),
+  deliveryState: chatDeliveryStateSchema.optional(),
+  errorCode: import_zod2.z.string().optional(),
+  metadata: import_zod2.z.record(jsonValueSchema).optional(),
+  attachment: chatAttachmentStateSchema.optional()
+});
 var chatReadinessStatusSchema = import_zod2.z.enum([
   "responsive",
   "delivery_only",
@@ -408,6 +449,17 @@ var chatReadinessResponseSchema = import_zod2.z.object({
     details: import_zod2.z.string().optional()
   }).optional()
 });
+var chatSessionResumeResponseSchema = import_zod2.z.object({
+  sessionId: import_zod2.z.string(),
+  uaid: import_zod2.z.string().nullable().optional(),
+  agentUrl: import_zod2.z.string().nullable().optional(),
+  route: chatRouteSummarySchema,
+  transport: import_zod2.z.string(),
+  history: import_zod2.z.array(chatHistoryEntrySchema),
+  historyTtlSeconds: import_zod2.z.number().optional(),
+  visibility: import_zod2.z.enum(["private", "public"]).optional(),
+  state: chatSessionStateSchema
+});
 var metadataFacetSchema = import_zod2.z.record(
   import_zod2.z.union([
     import_zod2.z.array(jsonValueSchema),
@@ -3117,6 +3169,7 @@ function createChatApi(client, encryptedManager) {
     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),
@@ -3144,6 +3197,9 @@ async function checkChatReadiness(client, payload) {
   if (agentUrl) {
     body.agentUrl = agentUrl;
   }
+  if (payload.forceRefresh !== void 0) {
+    body.forceRefresh = payload.forceRefresh;
+  }
   const raw = await client.requestJson("/chat/readiness", {
     method: "POST",
     body,
@@ -3178,6 +3234,9 @@ async function createSession(client, payload, allowHistoryAutoTopUp = true) {
   if (payload.visibility) {
     body.visibility = payload.visibility;
   }
+  if (payload.idempotencyKey) {
+    body.idempotencyKey = payload.idempotencyKey;
+  }
   try {
     const raw = await client.requestJson("/chat/session", {
       method: "POST",
@@ -3198,6 +3257,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, {
@@ -7278,6 +7352,9 @@ 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);
   }
@@ -7649,6 +7726,13 @@ var buildJobStatusMessage = (input) => JSON.stringify({
   buildPaymentApproveMessage,
   buildPaymentDeclineMessage,
   canonicalizeLedgerNetwork,
+  chatDeliveryStateSchema,
+  chatErrorCodeSchema,
+  chatReadinessStatusSchema,
+  chatReplyModeSchema,
+  chatRouteTypeSchema,
+  chatSessionStateSchema,
+  chatTimelineEntrySchema,
   closeUaidConnection,
   createPrivateKeySigner,
   createPrivateKeySignerAsync,