hiloop-sdk 0.7.0 → 0.8.0

package/dist/client.js

@@ -1,6 +1,6 @@
 /** Hiloop SDK client for agents to interact with the Hiloop platform. */
 import { CryptoContext, computeFingerprint, decryptAes, deriveKeyPairFromApiKey, deriveWrappingKey, encryptAes, generateKeyPair } from "./crypto.js";
-import { parseChannel, parseChannelMessage, parseChannelParticipant, parseConvSession, parseConvSessionMessage, parseGuestToken, parseInteraction, parseMessage, } from "./types.js";
+import { parseChannel, parseChannelMessage, parseChannelParticipant, parseConvSession, parseConvSessionMessage, parseGuestToken, parseSessionMessage, } from "./types.js";
 export class HiloopError extends Error {
     constructor(statusCode, message) {
         super(`HTTP ${statusCode}: ${message}`);
@@ -201,242 +201,6 @@ export class HiloopClient {
             clearTimeout(timer);
         }
     }
-    // -- Interactions -----------------------------------------------------------
-    async createInteraction(opts) {
-        // Validate form schema before encrypting
-        if (opts.type === "form" && opts.formSchema === undefined) {
-            throw new Error("Form interactions require a formSchema with at least one field.");
-        }
-        if (opts.formSchema !== undefined) {
-            validateFormSchema(opts.formSchema);
-        }
-        // Encrypt all fields with a SINGLE shared content key to avoid
-        // DB unique constraint on (interaction_id, scope, recipient_key_id).
-        const { encrypted, contentWrappings } = await this.encryptFields({
-            encryptedTitle: opts.title,
-            encryptedDescription: opts.description,
-            encryptedOptions: opts.options,
-            encryptedContext: opts.context,
-            encryptedFormSchema: opts.formSchema,
-        });
-        const body = {
-            type: opts.type,
-            priority: opts.priority ?? "normal",
-            contentWrappings,
-            ...encrypted,
-        };
-        if (opts.routeToUser !== undefined)
-            body.routeToUser = opts.routeToUser;
-        if (opts.routeToTeam !== undefined)
-            body.routeToTeam = opts.routeToTeam;
-        if (opts.deadlineMinutes !== undefined)
-            body.deadlineMinutes = opts.deadlineMinutes;
-        if (opts.callbackUrl !== undefined)
-            body.callbackUrl = opts.callbackUrl;
-        if (opts.convSessionId !== undefined)
-            body.convSessionId = opts.convSessionId;
-        if (opts.presentation !== undefined)
-            body.presentation = opts.presentation;
-        const data = await this.request("POST", "/agent/interactions", { body });
-        return parseInteraction(data);
-    }
-    async getInteraction(interactionId) {
-        const data = await this.request("GET", `/agent/interactions/${interactionId}`);
-        return this.decryptInteractionFields(parseInteraction(data), data);
-    }
-    /** Try to decrypt encrypted interaction fields using content wrappings. */
-    async decryptInteractionFields(interaction, raw) {
-        const wrappings = raw.contentWrappings;
-        if (!wrappings?.length)
-            return interaction;
-        const tryDecrypt = async (ciphertext) => {
-            if (!ciphertext)
-                return undefined;
-            const plain = await this.crypto.decryptWrappedContent(ciphertext, wrappings);
-            return plain ?? ciphertext;
-        };
-        return {
-            ...interaction,
-            title: (await tryDecrypt(interaction.title)) ?? "",
-            description: await tryDecrypt(interaction.description),
-            options: await tryDecrypt(interaction.options),
-            context: await tryDecrypt(interaction.context),
-            formSchema: await tryDecrypt(interaction.formSchema),
-            response: await tryDecrypt(interaction.response),
-            comment: await tryDecrypt(interaction.comment),
-        };
-    }
-    async cancelInteraction(interactionId) {
-        const data = await this.request("POST", `/agent/interactions/${interactionId}/cancel`);
-        return parseInteraction(data);
-    }
-    /** Update description/context on an interaction. Accepts plaintext — auto-encrypts. */
-    async updateInteractionContext(interactionId, opts) {
-        const { encrypted, contentWrappings } = await this.encryptFields({
-            encryptedDescription: opts.description,
-            encryptedContext: opts.context,
-        });
-        return await this.request("PATCH", `/agent/interactions/${interactionId}/context`, { body: { contentWrappings, ...encrypted } });
-    }
-    async acknowledgeInteraction(interactionId) {
-        const data = await this.request("POST", `/agent/interactions/${interactionId}/acknowledge`);
-        return parseInteraction(data);
-    }
-    /** AG-018/019: Update priority, deadline, or context metadata on a pending interaction. */
-    async updateInteractionMetadata(interactionId, opts) {
-        return await this.request("PATCH", `/agent/interactions/${interactionId}/metadata`, { body: opts });
-    }
-    /** Get the transition log for an interaction. */
-    async getInteractionTransitions(interactionId) {
-        return await this.request("GET", `/agent/interactions/${interactionId}/transitions`);
-    }
-    /** HU-073 (agent side): Read pending task control signal (pause/resume/cancel). */
-    async getTaskControl(interactionId) {
-        return await this.request("GET", `/agent/interactions/${interactionId}/task-control`);
-    }
-    /** HU-073 (agent side): Acknowledge task control signal, clearing it. */
-    async ackTaskControl(interactionId) {
-        return await this.request("POST", `/agent/interactions/${interactionId}/task-control/ack`);
-    }
-    /** Single long-poll for a response (server-side timeout, max ~30s). */
-    async awaitResponse(interactionId, timeout = 30) {
-        const data = await this.request("GET", `/agent/interactions/${interactionId}/await`, { params: { timeout: String(timeout) }, timeout: (timeout + 5) * 1000 });
-        return parseInteraction(data);
-    }
-    /**
-     * Wait for a human to respond to an interaction, polling repeatedly.
-     * Returns the interaction once it has a response (status is responded/completed),
-     * or throws after the timeout expires.
-     *
-     * @param interactionId - The interaction to wait for
-     * @param timeoutSeconds - Maximum wait time in seconds (default 300, max 3600)
-     */
-    async waitForResponse(interactionId, timeoutSeconds = 300) {
-        const deadline = Date.now() + timeoutSeconds * 1000;
-        const pollInterval = Math.min(30, timeoutSeconds); // server long-poll max 30s
-        while (Date.now() < deadline) {
-            const remaining = Math.ceil((deadline - Date.now()) / 1000);
-            if (remaining <= 0)
-                break;
-            const pollTimeout = Math.min(pollInterval, remaining);
-            const interaction = await this.awaitResponse(interactionId, pollTimeout);
-            // Check if the human has responded
-            if (interaction.status === "responded" ||
-                interaction.status === "completed" ||
-                interaction.status === "cancelled" ||
-                interaction.status === "expired") {
-                return interaction;
-            }
-            // Still pending — loop and poll again
-        }
-        // Final check before timeout
-        const final = await this.getInteraction(interactionId);
-        if (final.status !== "created" && final.status !== "pending" && final.status !== "viewed") {
-            return final;
-        }
-        throw new HiloopError(408, `Timed out waiting for response after ${timeoutSeconds}s`);
-    }
-    async listInteractions(filters) {
-        const params = {};
-        if (filters?.status !== undefined)
-            params.status = filters.status;
-        if (filters?.type !== undefined)
-            params.type = filters.type;
-        params.page = String(filters?.page ?? 1);
-        params.pageSize = String(filters?.pageSize ?? 20);
-        const data = await this.request("GET", "/agent/interactions", { params });
-        return {
-            items: data.items.map((i) => parseInteraction(i)),
-            total: data.total,
-            page: data.page,
-            pageSize: data.pageSize,
-        };
-    }
-    // -- Messages ---------------------------------------------------------------
-    async sendMessage(interactionId, content) {
-        const { encrypted, contentWrappings } = await this.encryptFields({
-            encryptedContent: content,
-        });
-        const data = await this.request("POST", `/agent/interactions/${interactionId}/messages`, { body: { contentWrappings, ...encrypted } });
-        return parseMessage(data);
-    }
-    /** Push content blocks to an interaction. */
-    async pushContentBlocks(interactionId, blocks) {
-        await this.ensureInitialized();
-        const encryptedBlocks = await Promise.all(blocks.map(async (block) => {
-            const plaintext = JSON.stringify(block.data);
-            const wrapped = await this.crypto.encryptWithWrapping(plaintext);
-            return {
-                blockType: block.blockType,
-                encryptedData: wrapped.ciphertext,
-                contentWrappings: wrapped.wrappings,
-                position: block.position,
-            };
-        }));
-        return await this.request("POST", `/agent/interactions/${interactionId}/blocks`, { body: { blocks: encryptedBlocks } });
-    }
-    /** List content blocks for an interaction. */
-    async listContentBlocks(interactionId) {
-        return await this.request("GET", `/agent/interactions/${interactionId}/blocks`);
-    }
-    /** Update a content block. */
-    async updateContentBlock(interactionId, blockId, data) {
-        return await this.request("PUT", `/agent/interactions/${interactionId}/blocks/${blockId}`, { body: { data } });
-    }
-    /** Delete a content block. */
-    async deleteContentBlock(interactionId, blockId) {
-        return await this.request("DELETE", `/agent/interactions/${interactionId}/blocks/${blockId}`);
-    }
-    /** Upload a file attachment to an interaction (base64-encoded). */
-    async uploadAttachment(interactionId, opts) {
-        return await this.request("POST", `/agent/interactions/${interactionId}/attachments`, { body: opts });
-    }
-    /** List attachments for an interaction, optionally filtered by messageId. */
-    async listAttachments(interactionId, messageId) {
-        const qs = messageId ? `?messageId=${encodeURIComponent(messageId)}` : "";
-        return await this.request("GET", `/agent/interactions/${interactionId}/attachments${qs}`);
-    }
-    /** Download raw binary content of a specific attachment. */
-    async getAttachment(interactionId, fileId) {
-        return await this.requestBinary(`/agent/interactions/${interactionId}/attachments/${fileId}`);
-    }
-    /** List all reactions for messages in an interaction. */
-    async listInteractionReactions(interactionId) {
-        return await this.request("GET", `/agent/interactions/${interactionId}/reactions`);
-    }
-    /** Add a reaction emoji to a message in an interaction. */
-    async addInteractionReaction(interactionId, messageId, emoji) {
-        return await this.request("POST", `/agent/interactions/${interactionId}/messages/${messageId}/reactions`, { body: { emoji } });
-    }
-    /** Remove a reaction emoji from a message in an interaction. */
-    async removeInteractionReaction(interactionId, messageId, emoji) {
-        return await this.request("DELETE", `/agent/interactions/${interactionId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`);
-    }
-    /** Mark all messages in an interaction as read by this agent. */
-    async markInteractionRead(interactionId) {
-        return await this.request("POST", `/agent/interactions/${interactionId}/messages/read`);
-    }
-    /** Send a typing indicator for an interaction. */
-    async sendInteractionTyping(interactionId, isTyping) {
-        return await this.request("POST", `/agent/interactions/${interactionId}/typing`, { body: { isTyping } });
-    }
-    async listMessages(interactionId, page = 1, pageSize = 50) {
-        const params = { page: String(page), pageSize: String(pageSize) };
-        const data = await this.request("GET", `/agent/interactions/${interactionId}/messages`, { params });
-        const rawItems = data.messages ?? data.items ?? [];
-        const items = rawItems.map((m) => parseMessage(m));
-        // Try to decrypt messages using content wrappings
-        await Promise.all(items.map(async (msg, i) => {
-            const raw = rawItems[i];
-            const wrappings = raw.contentWrappings;
-            if (wrappings?.length && msg.content) {
-                const plain = await this.crypto.decryptWrappedContent(msg.content, wrappings);
-                if (plain !== null)
-                    msg.content = plain;
-            }
-        }));
-        return { items, total: data.total, page: data.page, pageSize: data.pageSize };
-    }
     /** AD-060: Push agent telemetry activity status + plan to the platform. */
     async pushTelemetry(opts) {
         return await this.request("POST", "/agent/activity", { body: opts });
@@ -544,19 +308,60 @@ export class HiloopClient {
         const data = await this.request("POST", `/agent/sessions/${sessionId}/close`);
         return parseConvSession(data);
     }
+    // -- Unified Message API ----------------------------------------------------
     /**
-     * Send a message to a conversation session.
-     * The content must be pre-encrypted using encryptAes() with the shared session key.
-     */
-    /**
-     * Send a message in a conv session. Accepts plaintext — encrypts automatically
-     * using the session message key (`{agentPub}:{AES-GCM ciphertext}` format).
+     * Send a message to a session. Accepts plaintext content and optional
+     * rich components. Encrypts content and components automatically.
+     *
+     * This is the primary method for agent-to-human communication.
      */
-    async sendConvSessionMessage(sessionId, content, opts) {
+    async sendMessage(sessionId, content, opts) {
         await this.ensureInitialized();
         const encryptedContent = await this.crypto.encryptSessionMessage(content);
-        const data = await this.request("POST", `/agent/sessions/${sessionId}/messages`, { body: { encryptedContent }, agentName: opts?.agentName });
-        return parseConvSessionMessage(data);
+        const body = { encryptedContent };
+        if (opts?.components && opts.components.length > 0) {
+            body.encryptedComponents = await this.crypto.encryptSessionMessage(JSON.stringify(opts.components));
+            // Extract metadata from components for server-side routing
+            const hasResponseRequired = opts.components.some((n) => n.type === "button_group" &&
+                n.data?.responseRequired === true);
+            if (hasResponseRequired) {
+                body.responseRequired = true;
+                body.category = "decide";
+            }
+        }
+        if (opts?.priority)
+            body.priority = opts.priority;
+        if (opts?.deadlineMinutes)
+            body.deadlineMinutes = opts.deadlineMinutes;
+        if (opts?.replyToMessageId)
+            body.replyToMessageId = opts.replyToMessageId;
+        const data = await this.request("POST", `/agent/sessions/${sessionId}/messages`, { body, agentName: opts?.agentName });
+        return parseSessionMessage(data);
+    }
+    /**
+     * Long-poll for a response to a specific message.
+     * Returns the updated message once the human has responded, or after timeout.
+     */
+    async awaitResponse(sessionId, messageId, timeoutSeconds = 300) {
+        const data = await this.request("GET", `/agent/sessions/${sessionId}/messages/${messageId}/await`, {
+            params: { timeout: String(Math.min(timeoutSeconds, 30)) },
+            timeout: (Math.min(timeoutSeconds, 30) + 5) * 1000,
+        });
+        return parseSessionMessage(data);
+    }
+    /**
+     * Acknowledge a message (mark it as seen/handled by the agent).
+     */
+    async acknowledge(sessionId, messageId) {
+        const data = await this.request("POST", `/agent/sessions/${sessionId}/messages/${messageId}/acknowledge`);
+        return parseSessionMessage(data);
+    }
+    /**
+     * Cancel a previously sent message (e.g. withdraw an approval request).
+     */
+    async cancel(sessionId, messageId) {
+        const data = await this.request("POST", `/agent/sessions/${sessionId}/messages/${messageId}/cancel`);
+        return parseSessionMessage(data);
     }
     /** Send a typing indicator to a conv session (HU-034). */
     async sendConvSessionTyping(sessionId, typing) {
@@ -580,7 +385,7 @@ export class HiloopClient {
         if (opts?.after !== undefined)
             params.after = opts.after;
         const result = await this.request("GET", `/agent/sessions/${sessionId}/timeline`, { params });
-        // Decrypt timeline items (session messages + interaction fields)
+        // Decrypt timeline items (session messages)
         if (Array.isArray(result.items)) {
             await Promise.all(result.items.map(async (item) => {
                 if (item.kind === "message" && typeof item.encryptedContent === "string") {
@@ -590,20 +395,6 @@ export class HiloopClient {
                     else
                         item.content = "[Encrypted]";
                 }
-                if (item.kind === "interaction") {
-                    const wrappings = item.contentWrappings;
-                    if (wrappings?.length) {
-                        for (const field of ["encryptedTitle", "encryptedDescription", "encryptedOptions", "encryptedFormSchema", "encryptedContext"]) {
-                            if (typeof item[field] === "string") {
-                                const plain = await this.crypto.decryptWrappedContent(item[field], wrappings);
-                                if (plain !== null) {
-                                    const readableKey = field.replace(/^encrypted/, "").replace(/^./, (c) => c.toLowerCase());
-                                    item[readableKey] = plain;
-                                }
-                            }
-                        }
-                    }
-                }
             }));
         }
         return result;
@@ -634,117 +425,31 @@ export class HiloopClient {
     async revokeGuestToken(sessionId, tokenId) {
         await this.request("DELETE", `/human/sessions/${sessionId}/guest-tokens/${tokenId}`);
     }
-    /** AG-060: Create multiple interactions in a single API call. */
-    async createInteractionBatch(interactions) {
-        const items = await Promise.all(interactions.map(async (opts) => {
-            const { encrypted, contentWrappings } = await this.encryptFields({
-                encryptedTitle: opts.title,
-                encryptedDescription: opts.description,
-                encryptedOptions: opts.options,
-                encryptedContext: opts.context,
-            });
-            const body = {
-                type: opts.type,
-                priority: opts.priority ?? "normal",
-                contentWrappings,
-                ...encrypted,
-            };
-            if (opts.routeToUser !== undefined)
-                body.routeToUser = opts.routeToUser;
-            if (opts.routeToTeam !== undefined)
-                body.routeToTeam = opts.routeToTeam;
-            if (opts.deadlineMinutes !== undefined)
-                body.deadlineMinutes = opts.deadlineMinutes;
-            if (opts.convSessionId !== undefined)
-                body.convSessionId = opts.convSessionId;
-            return body;
-        }));
-        return this.request("POST", "/agent/interactions/batch", { body: { interactions: items } });
-    }
     /** Archive a conversation session. */
     async archiveConvSession(sessionId) {
         const data = await this.request("POST", `/agent/sessions/${sessionId}/archive`);
         return parseConvSession(data);
     }
-    /** Create a group interaction involving multiple participants (AG-061). */
-    async createGroupInteraction(opts, participants) {
-        const { encrypted, contentWrappings } = await this.encryptFields({
-            encryptedTitle: opts.title,
-            encryptedDescription: opts.description,
-            encryptedContext: opts.context,
-        });
-        const body = {
-            type: opts.type,
-            priority: opts.priority ?? "normal",
-            participants,
-            contentWrappings,
-            ...encrypted,
-        };
-        if (opts.routeToUser !== undefined)
-            body.routeToUser = opts.routeToUser;
-        if (opts.routeToTeam !== undefined)
-            body.routeToTeam = opts.routeToTeam;
-        if (opts.deadlineMinutes !== undefined)
-            body.deadlineMinutes = opts.deadlineMinutes;
-        if (opts.callbackUrl !== undefined)
-            body.callbackUrl = opts.callbackUrl;
-        return this.request("POST", "/agent/interactions/group", { body });
-    }
-    /** Add a reference from one interaction to another (AG-062). */
-    async addInteractionReference(interactionId, targetInteractionId, opts) {
-        return this.request("POST", `/agent/interactions/${interactionId}/references`, {
-            body: { targetInteractionId, referenceType: opts?.referenceType, note: opts?.note },
-        });
+    // -- Session attachments -----------------------------------------------------
+    /** Upload an attachment to a session. Content must be base64-encoded. */
+    async uploadSessionAttachment(sessionId, opts) {
+        const data = await this.request("POST", `/agent/sessions/${sessionId}/attachments`, { body: opts });
+        return data.attachment;
     }
-    /** List all references for an interaction (AG-062). */
-    async listInteractionReferences(interactionId) {
-        return this.request("GET", `/agent/interactions/${interactionId}/references`);
+    /** List attachments for a session. */
+    async listSessionAttachments(sessionId) {
+        const data = await this.request("GET", `/agent/sessions/${sessionId}/attachments`);
+        return data.attachments;
     }
-    /** Remove an interaction reference by its ID (AG-062). */
-    async removeInteractionReference(interactionId, refId) {
-        return this.request("DELETE", `/agent/interactions/${interactionId}/references/${refId}`);
+    /** Download an attachment's binary content. */
+    async downloadSessionAttachment(sessionId, fileId) {
+        return this.requestBinary(`/agent/sessions/${sessionId}/attachments/${fileId}`);
     }
     // -- Public agent routes (no auth required) ---------------------------------
     /** Get public metadata for a public agent by slug. */
     async getPublicAgentInfo(slug) {
         return this.request("GET", `/public/${slug}/info`);
     }
-    /** Create an interaction as a public (anonymous) user on a public agent. */
-    async createPublicInteraction(slug, opts) {
-        return this.request("POST", `/public/${slug}/interactions`, { body: opts });
-    }
-    /** Get the status of a public interaction by slug + ID. */
-    async getPublicInteraction(slug, interactionId) {
-        return this.request("GET", `/public/${slug}/interactions/${interactionId}`);
-    }
-    /** Long-poll for a response on a public interaction (returns when responded/completed/cancelled/expired). */
-    async awaitPublicInteraction(slug, interactionId, timeoutMs = 30000) {
-        return this.request("GET", `/public/${slug}/interactions/${interactionId}/await`, {
-            params: { timeout: String(timeoutMs) },
-            timeout: timeoutMs + 5000,
-        });
-    }
-    /** Send a message to a public interaction as an anonymous user. */
-    async sendPublicMessage(slug, interactionId, encryptedContent) {
-        return this.request("POST", `/public/${slug}/interactions/${interactionId}/messages`, { body: { encryptedContent } });
-    }
-    /** List interactions created on a public agent (paginated). */
-    async listPublicInteractions(slug, opts) {
-        const params = {};
-        if (opts?.page !== undefined)
-            params.page = String(opts.page);
-        if (opts?.pageSize !== undefined)
-            params.pageSize = String(opts.pageSize);
-        return this.request("GET", `/public/${slug}/interactions`, Object.keys(params).length > 0 ? { params } : undefined);
-    }
-    /** Cancel a public interaction (anonymous user side). */
-    async cancelPublicInteraction(slug, interactionId) {
-        return this.request("DELETE", `/public/${slug}/interactions/${interactionId}`);
-    }
-    /** Get the transition log for a public interaction. */
-    async getPublicInteractionTransitions(slug, interactionId) {
-        return this.request("GET", `/public/${slug}/interactions/${interactionId}/transitions`);
-    }
     /** Look up a public session by its public token (no auth required). */
     async getPublicSession(publicToken) {
         return this.request("GET", `/public/sessions/${publicToken}`);
@@ -753,298 +458,6 @@ export class HiloopClient {
     async joinPublicSession(publicToken, displayName) {
         return this.request("POST", `/public/sessions/${publicToken}/join`, { body: { displayName } });
     }
-    // -- Human Interaction Detail -----------------------------------------------
-    /** Get a human-facing interaction detail view. */
-    async getHumanInteraction(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}`);
-    }
-    /** Mark an interaction as viewed by the authenticated user. */
-    async viewInteraction(interactionId) {
-        return this.request("POST", `/human/interactions/${interactionId}/view`);
-    }
-    /** Submit a response to an interaction. */
-    async respondToHumanInteraction(interactionId, opts) {
-        return this.request("POST", `/human/interactions/${interactionId}/respond`, { body: opts });
-    }
-    /** Snooze an interaction until a given ISO datetime. */
-    async snoozeInteraction(interactionId, snoozedUntil) {
-        return this.request("POST", `/human/interactions/${interactionId}/snooze`, { body: { snoozedUntil } });
-    }
-    /** Toggle the pinned state of an interaction. */
-    async pinInteraction(interactionId, pinned) {
-        return this.request("POST", `/human/interactions/${interactionId}/pin`, { body: { pinned } });
-    }
-    // -- Human Inbox / Feed ----------------------------------------------------
-    // getInbox removed -- use getFeed with view param
-    /** Get the human user's activity feed (all interactions). */
-    async getFeed(opts) {
-        const params = new URLSearchParams();
-        if (opts?.page)
-            params.set("page", String(opts.page));
-        if (opts?.pageSize)
-            params.set("pageSize", String(opts.pageSize));
-        if (opts?.view)
-            params.set("view", opts.view);
-        if (opts?.q)
-            params.set("q", opts.q);
-        if (opts?.type)
-            params.set("type", opts.type);
-        if (opts?.priority)
-            params.set("priority", opts.priority);
-        if (opts?.pinned !== undefined)
-            params.set("pinned", String(opts.pinned));
-        if (opts?.agentId)
-            params.set("agentId", opts.agentId);
-        const qs = params.toString() ? `?${params.toString()}` : "";
-        return this.request("GET", `/human/feed${qs}`);
-    }
-    // searchInteractions removed -- use getFeed with q param
-    // getHistory removed -- use getFeed with view param
-    /** Get badge counts (e.g. open interactions) for the authenticated user. */
-    async getBadges() {
-        return this.request("GET", "/human/badges");
-    }
-    // -- Account ----------------------------------------------------------------
-    /** Get the authenticated user's current availability status. */
-    async getMyAvailability() {
-        return this.request("GET", "/human/availability");
-    }
-    /** Update the authenticated user's availability status. */
-    async updateMyAvailability(status) {
-        return this.request("PATCH", "/human/availability", { body: { status } });
-    }
-    /** List delegation rules for the authenticated user. */
-    async listDelegations() {
-        return this.request("GET", "/human/delegations");
-    }
-    /** Create a delegation rule for the authenticated user. */
-    async createDelegation(opts) {
-        return this.request("POST", "/human/delegations", { body: opts });
-    }
-    /** Remove a delegation rule by delegateId. */
-    async deleteDelegation(delegateId) {
-        return this.request("DELETE", `/human/delegations/${delegateId}`);
-    }
-    // -- Notifications ----------------------------------------------------------
-    /** List sent notifications for the authenticated user. */
-    async listNotifications() {
-        return this.request("GET", "/human/notifications");
-    }
-    /** Get notification preferences for the authenticated user. */
-    async getNotificationPreferences() {
-        return this.request("GET", "/human/notifications/preferences");
-    }
-    /** Update notification preference for a specific channel. */
-    async updateNotificationPreference(channel, opts) {
-        return this.request("PUT", `/human/notifications/preferences/${channel}`, { body: opts });
-    }
-    /** Register a push token for the authenticated user's device. */
-    async registerPushToken(opts) {
-        return this.request("POST", "/human/notifications/push-tokens", { body: opts });
-    }
-    /** Remove the push token for the authenticated user's device. */
-    async deletePushToken(opts) {
-        return this.request("DELETE", "/human/notifications/push-tokens", { body: opts });
-    }
-    /** Save (upsert) a response draft for an interaction. */
-    async saveDraft(interactionId, encryptedDraft) {
-        return this.request("PUT", `/human/interactions/${interactionId}/draft`, { body: { encryptedDraft } });
-    }
-    /** Get the saved response draft for an interaction. */
-    async getDraft(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/draft`);
-    }
-    /** Delete the saved response draft for an interaction. */
-    async deleteDraft(interactionId) {
-        return this.request("DELETE", `/human/interactions/${interactionId}/draft`);
-    }
-    /** Unsnooze an interaction before its scheduled snooze time. */
-    async unsnoozeInteraction(interactionId) {
-        return this.request("POST", `/human/interactions/${interactionId}/unsnooze`);
-    }
-    // -- Collaboration (milestone alerts + approval chain) -----------------------
-    /** Create a milestone alert for an interaction. */
-    async createMilestoneAlert(interactionId, opts) {
-        return this.request("POST", `/human/interactions/${interactionId}/milestone-alerts`, { body: opts });
-    }
-    /** List milestone alerts for an interaction. */
-    async listMilestoneAlerts(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/milestone-alerts`);
-    }
-    /** Delete a milestone alert. */
-    async deleteMilestoneAlert(interactionId, alertId) {
-        return this.request("DELETE", `/human/interactions/${interactionId}/milestone-alerts/${alertId}`);
-    }
-    /** Get the approval chain for an interaction. */
-    async getApprovalChain(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/approval-chain`);
-    }
-    /** Respond to an approval chain step. */
-    async respondToApprovalChain(interactionId, opts) {
-        return this.request("POST", `/human/interactions/${interactionId}/approval-chain/respond`, { body: opts });
-    }
-    // -- Phase 628: Comments + review feedback ------------------------------------
-    /** List comments on an interaction. */
-    async listInteractionComments(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/comments`);
-    }
-    /** Post a comment on an interaction. */
-    async createInteractionComment(interactionId, opts) {
-        return this.request("POST", `/human/interactions/${interactionId}/comments`, { body: opts });
-    }
-    /** Mark a comment as resolved. */
-    async resolveInteractionComment(interactionId, commentId) {
-        return this.request("PATCH", `/human/interactions/${interactionId}/comments/${commentId}/resolve`);
-    }
-    /** Delete a comment. */
-    async deleteInteractionComment(interactionId, commentId) {
-        return this.request("DELETE", `/human/interactions/${interactionId}/comments/${commentId}`);
-    }
-    /** Submit review feedback for an interaction. */
-    async submitReviewFeedback(interactionId, opts) {
-        return this.request("POST", `/human/interactions/${interactionId}/review-feedback`, { body: opts });
-    }
-    // -- Phase 629: Voting + tags --------------------------------------------------
-    /** Cast a vote on an interaction. */
-    async voteOnInteraction(interactionId, opts) {
-        return this.request("POST", `/human/interactions/${interactionId}/vote`, { body: opts });
-    }
-    /** Get aggregate vote results for an interaction. */
-    async getVoteResults(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/vote/results`);
-    }
-    /** Get the current user's vote on an interaction. */
-    async getMyVote(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/vote/mine`);
-    }
-    /** List tags on an interaction. */
-    async getInteractionTags(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/tags`);
-    }
-    /** Add a tag to an interaction. */
-    async addInteractionTag(interactionId, tag) {
-        return this.request("POST", `/human/interactions/${interactionId}/tags`, { body: { tag } });
-    }
-    // -- Phase 630: More tags + response templates ---------------------------------
-    /** Remove a tag from an interaction. */
-    async deleteInteractionTag(interactionId, tag) {
-        return this.request("DELETE", `/human/interactions/${interactionId}/tags/${encodeURIComponent(tag)}`);
-    }
-    /** List all space-wide tags. */
-    async listSpaceTags() {
-        return this.request("GET", "/human/tags");
-    }
-    /** List response templates for the current user. */
-    async listResponseTemplates() {
-        return this.request("GET", "/human/response-templates");
-    }
-    /** Create a response template. */
-    async createResponseTemplate(opts) {
-        return this.request("POST", "/human/response-templates", { body: opts });
-    }
-    /** Delete a response template. */
-    async deleteResponseTemplate(templateId) {
-        return this.request("DELETE", `/human/response-templates/${templateId}`);
-    }
-    // -- Phase 631: Review feedback + template use + message routes ----------------
-    /** Get review feedback for an interaction. */
-    async getReviewFeedback(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/review-feedback`);
-    }
-    /** Use a response template (increments usage count). */
-    async useResponseTemplate(templateId) {
-        return this.request("POST", `/human/response-templates/${templateId}/use`);
-    }
-    /** List messages for a human interaction. */
-    async listInteractionMessages(interactionId, opts) {
-        const params = {};
-        if (opts?.before !== undefined)
-            params.before = opts.before;
-        if (opts?.limit !== undefined)
-            params.limit = String(opts.limit);
-        return this.request("GET", `/human/interactions/${interactionId}/messages`, { params });
-    }
-    /** Send a message to a human interaction thread. */
-    async sendInteractionMessage(interactionId, opts) {
-        return this.request("POST", `/human/interactions/${interactionId}/messages`, { body: opts });
-    }
-    /** Mark messages as read for an interaction. */
-    async markMessagesRead(interactionId) {
-        return this.request("POST", `/human/interactions/${interactionId}/messages/read`);
-    }
-    // -- Phase 632: Reactions + agent activity + references ------------------------
-    /** Get aggregated reactions for all messages in an interaction. */
-    async getInteractionReactions(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/reactions`);
-    }
-    /** Add a reaction to a specific message. */
-    async addMessageReaction(interactionId, messageId, emoji) {
-        return this.request("POST", `/human/interactions/${interactionId}/messages/${messageId}/reactions`, { body: { emoji } });
-    }
-    /** Remove a reaction from a specific message. */
-    async removeMessageReaction(interactionId, messageId, emoji) {
-        return this.request("DELETE", `/human/interactions/${interactionId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`);
-    }
-    /** Get agent activity data for the space (for human dashboard). */
-    async getAgentActivity() {
-        return this.request("GET", "/human/agents/activity");
-    }
-    /** List interaction references for a human interaction. */
-    async listHumanInteractionReferences(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/references`);
-    }
-    // -- Phase 633: References + usage + feature gates + presence ------------------
-    /** Add a reference link between two interactions. */
-    async addHumanInteractionReference(interactionId, opts) {
-        return this.request("POST", `/human/interactions/${interactionId}/references`, { body: opts });
-    }
-    /** Get current usage and quota for the space. */
-    async getUsage() {
-        return this.request("GET", "/human/usage");
-    }
-    /** Get feature gate flags for the current user. */
-    async getFeatureGates() {
-        return this.request("GET", "/human/feature-gates");
-    }
-    /** Track that the current user is viewing an interaction. */
-    async trackInteractionViewing(interactionId) {
-        return this.request("POST", `/human/interactions/${interactionId}/viewing`);
-    }
-    /** Get who is currently viewing an interaction. */
-    async getInteractionViewers(interactionId) {
-        return this.request("GET", `/human/interactions/${interactionId}/viewers`);
-    }
-    // -- Phase 634: More account routes + inbox grouped + members ------------------
-    /** Stop tracking viewing presence for an interaction. */
-    async stopTrackingViewing(interactionId) {
-        return this.request("DELETE", `/human/interactions/${interactionId}/viewing`);
-    }
-    /** Get human-assigned tasks (interactions requiring action). */
-    async getHumanTasks(opts) {
-        const params = {};
-        if (opts?.page !== undefined)
-            params.page = String(opts.page);
-        if (opts?.pageSize !== undefined)
-            params.pageSize = String(opts.pageSize);
-        return this.request("GET", "/human/tasks", { params });
-    }
-    // getInboxGrouped removed -- use getFeed with view param
-    /** List space members (humans). */
-    async getHumanMembers(opts) {
-        const params = {};
-        if (opts?.page !== undefined)
-            params.page = String(opts.page);
-        if (opts?.pageSize !== undefined)
-            params.pageSize = String(opts.pageSize);
-        return this.request("GET", "/human/members", { params });
-    }
-    /** Get aggregated notification digest for the current user. */
-    async getNotificationDigest(opts) {
-        const params = {};
-        if (opts?.since !== undefined)
-            params.since = opts.since;
-        return this.request("GET", "/human/notifications/digest", { params });
-    }
     // -- Channels ---------------------------------------------------------------
     /** Create a new agent-to-agent channel. */
     async createChannel(opts) {
@@ -1238,30 +651,19 @@ export class HiloopClient {
         return this.crypto.decryptSessionMessage(encryptedContent);
     }
     /**
-     * Decrypt an interaction webhook payload in place.
-     * Decrypts encryptedTitle, encryptedResponse, encryptedComment using contentWrappings.
-     * Returns the payload with added `title`, `response`, `comment` fields.
+     * Decrypt a webhook payload in place.
+     * Decrypts encryptedContent from session messages.
+     * Returns the payload with an added `content` field.
      */
     async decryptWebhookPayload(payload) {
         await this.ensureInitialized();
         const result = { ...payload };
-        const wrappings = payload.contentWrappings;
         // Session message
         if (typeof payload.encryptedContent === "string") {
             const plain = await this.crypto.decryptSessionMessage(payload.encryptedContent);
             if (plain !== null)
                 result.content = plain;
         }
-        // Interaction fields (need content wrappings)
-        if (wrappings?.length) {
-            for (const [encrypted, decrypted] of [["encryptedTitle", "title"], ["encryptedResponse", "response"], ["encryptedComment", "comment"]]) {
-                if (typeof payload[encrypted] === "string") {
-                    const plain = await this.crypto.decryptWrappedContent(payload[encrypted], wrappings);
-                    if (plain !== null)
-                        result[decrypted] = plain;
-                }
-            }
-        }
         return result;
     }
     // -- Crypto -----------------------------------------------------------------
@@ -1277,47 +679,3 @@ export class HiloopClient {
         return decryptAes(ciphertextBase64, keyBase64);
     }
 }
-/**
- * Validate a form schema JSON string before encrypting.
- * - Must be valid JSON with a non-empty `fields` array.
- * - select / multi-select / radio fields must have at least 2 options.
- */
-function validateFormSchema(schemaJson) {
-    if (schemaJson === undefined || schemaJson.trim() === "") {
-        throw new Error("formSchema must not be empty.");
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(schemaJson);
-    }
-    catch {
-        throw new Error("formSchema must be valid JSON.");
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new Error("formSchema must be a JSON object.");
-    }
-    const schema = parsed;
-    const fields = schema["fields"];
-    if (!Array.isArray(fields) || fields.length === 0) {
-        throw new Error("formSchema must contain a non-empty 'fields' array. " +
-            "A form requires at least one input field.");
-    }
-    for (const field of fields) {
-        if (typeof field !== "object" || field === null)
-            continue;
-        const f = field;
-        const type = f["type"];
-        if (type === "select" || type === "multi-select" || type === "radio") {
-            const options = f["options"];
-            if (!Array.isArray(options) || options.length < 2) {
-                const name = f["name"] ?? "(unnamed)";
-                throw new Error(`Form field '${name}' of type '${type}' must have at least 2 options.`);
-            }
-        }
-    }
-}
-/**
- * Return all wrappings as-is. Each encrypted field has its own random content
- * key, so every wrapping is unique even when scope + recipientKeyId match.
- * The frontend tries each wrapping until one successfully decrypts.
- */