@scalemule/chat 0.0.4 → 0.0.7

package/dist/{chunk-ZLMMNFZL.js → chunk-5O5YLRJL.js}

@@ -61,6 +61,9 @@ var MessageCache = class {
   getMessages(conversationId) {
     return this.cache.get(conversationId) ?? [];
   }
+  getMessage(conversationId, messageId) {
+    return this.getMessages(conversationId).find((message) => message.id === messageId);
+  }
   setMessages(conversationId, messages) {
     this.cache.set(conversationId, messages.slice(0, this.maxMessages));
     this.evictOldConversations();
@@ -75,6 +78,13 @@ var MessageCache = class {
     }
     this.cache.set(conversationId, messages);
   }
+  upsertMessage(conversationId, message) {
+    if (this.getMessage(conversationId, message.id)) {
+      this.updateMessage(conversationId, message);
+      return;
+    }
+    this.addMessage(conversationId, message);
+  }
   updateMessage(conversationId, message) {
     const messages = this.cache.get(conversationId);
     if (!messages) return;
@@ -83,6 +93,23 @@ var MessageCache = class {
       messages[idx] = message;
     }
   }
+  reconcileOptimisticMessage(conversationId, message) {
+    const messages = this.cache.get(conversationId);
+    if (!messages) return message;
+    const incomingAttachmentIds = (message.attachments ?? []).map((attachment) => attachment.file_id).sort();
+    const pendingIndex = messages.findIndex((cached) => {
+      if (!cached.id.startsWith("pending-")) return false;
+      if (cached.sender_id !== message.sender_id) return false;
+      if (cached.content !== message.content) return false;
+      const cachedAttachmentIds = (cached.attachments ?? []).map((attachment) => attachment.file_id).sort();
+      if (cachedAttachmentIds.length !== incomingAttachmentIds.length) return false;
+      return cachedAttachmentIds.every((fileId, index) => fileId === incomingAttachmentIds[index]);
+    });
+    if (pendingIndex >= 0) {
+      messages[pendingIndex] = message;
+    }
+    return message;
+  }
   removeMessage(conversationId, messageId) {
     const messages = this.cache.get(conversationId);
     if (!messages) return;
@@ -198,8 +225,7 @@ var HttpTransport = class {
         method,
         headers,
         body: body ? JSON.stringify(body) : void 0,
-        signal: controller.signal,
-        credentials: "include"
+        signal: controller.signal
       });
       clearTimeout(timeoutId);
       if (response.status === 204) {
@@ -346,8 +372,7 @@ var WebSocketTransport = class extends EventEmitter {
     try {
       const response = await fetch(this.ticketUrl, {
         method: "POST",
-        headers,
-        credentials: "include"
+        headers
       });
       if (!response.ok) return null;
       const json = await response.json();
@@ -429,14 +454,14 @@ var WebSocketTransport = class extends EventEmitter {
     }
     this.setStatus("reconnecting");
     this.emit("reconnecting", { attempt: this.reconnectAttempt + 1 });
-    const delay = Math.min(
+    const delay2 = Math.min(
       this.baseDelay * Math.pow(2, this.reconnectAttempt) + Math.random() * this.baseDelay * 0.3,
       this.maxDelay
     );
     this.reconnectTimer = setTimeout(() => {
       this.reconnectAttempt++;
       this.connect();
-    }, delay);
+    }, delay2);
   }
   setStatus(status) {
     if (this.status !== status) {
@@ -446,6 +471,173 @@ var WebSocketTransport = class extends EventEmitter {
   }
 };
 
+// src/shared/upload.ts
+var RETRY_DELAYS_MS = [0, 1e3, 3e3];
+var STALL_TIMEOUT_MS = 45e3;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([0, 408, 429, 500, 502, 503, 504]);
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shouldRetry(status, code) {
+  if (code === "aborted") {
+    return false;
+  }
+  return RETRYABLE_STATUS_CODES.has(status) || code === "upload_stalled";
+}
+function uploadOnce(url, file, onProgress, signal) {
+  return new Promise((resolve) => {
+    if (typeof XMLHttpRequest === "undefined") {
+      resolve({
+        data: null,
+        error: {
+          code: "unsupported_environment",
+          message: "XMLHttpRequest is not available in this environment",
+          status: 0
+        }
+      });
+      return;
+    }
+    const xhr = new XMLHttpRequest();
+    let settled = false;
+    let stallTimer = null;
+    let lastLoaded = 0;
+    let totalBytes = file.size;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (stallTimer) {
+        clearTimeout(stallTimer);
+        stallTimer = null;
+      }
+      resolve(result);
+    };
+    const resetStallTimer = () => {
+      if (stallTimer) {
+        clearTimeout(stallTimer);
+      }
+      stallTimer = setTimeout(() => {
+        xhr.abort();
+        finish({
+          data: null,
+          error: {
+            code: "upload_stalled",
+            message: `Upload stalled (no progress for ${STALL_TIMEOUT_MS / 1e3}s)`,
+            status: 0,
+            details: {
+              bytes_sent: lastLoaded,
+              total_bytes: totalBytes
+            }
+          }
+        });
+      }, STALL_TIMEOUT_MS);
+    };
+    if (signal) {
+      if (signal.aborted) {
+        finish({
+          data: null,
+          error: { code: "aborted", message: "Upload aborted", status: 0 }
+        });
+        return;
+      }
+      signal.addEventListener(
+        "abort",
+        () => {
+          xhr.abort();
+          finish({
+            data: null,
+            error: { code: "aborted", message: "Upload aborted", status: 0 }
+          });
+        },
+        { once: true }
+      );
+    }
+    xhr.upload.addEventListener("progress", (event) => {
+      resetStallTimer();
+      lastLoaded = event.loaded;
+      totalBytes = event.total || totalBytes;
+      if (event.lengthComputable) {
+        onProgress?.(Math.round(event.loaded / event.total * 100));
+      }
+    });
+    xhr.addEventListener("load", () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        onProgress?.(100);
+        finish({ data: null, error: null });
+        return;
+      }
+      finish({
+        data: null,
+        error: {
+          code: "upload_error",
+          message: `S3 upload failed: ${xhr.status}`,
+          status: xhr.status,
+          details: {
+            bytes_sent: lastLoaded,
+            total_bytes: totalBytes
+          }
+        }
+      });
+    });
+    xhr.addEventListener("error", () => {
+      finish({
+        data: null,
+        error: {
+          code: "upload_error",
+          message: "S3 upload failed",
+          status: xhr.status || 0,
+          details: {
+            bytes_sent: lastLoaded,
+            total_bytes: totalBytes
+          }
+        }
+      });
+    });
+    xhr.addEventListener("abort", () => {
+      if (settled) return;
+      finish({
+        data: null,
+        error: { code: "aborted", message: "Upload aborted", status: 0 }
+      });
+    });
+    xhr.open("PUT", url, true);
+    if (file.type) {
+      xhr.setRequestHeader("Content-Type", file.type);
+    }
+    resetStallTimer();
+    xhr.send(file);
+  });
+}
+async function uploadToPresignedUrl(url, file, onProgress, signal) {
+  let lastError = null;
+  for (const [attempt, delayMs] of RETRY_DELAYS_MS.entries()) {
+    if (delayMs > 0) {
+      await delay(delayMs);
+    }
+    const result = await uploadOnce(url, file, onProgress, signal);
+    if (!result.error) {
+      return result;
+    }
+    lastError = {
+      ...result.error,
+      details: {
+        ...result.error.details,
+        attempt: attempt + 1
+      }
+    };
+    if (!shouldRetry(result.error.status, result.error.code)) {
+      break;
+    }
+  }
+  return {
+    data: null,
+    error: lastError ?? {
+      code: "upload_error",
+      message: "Upload failed",
+      status: 0
+    }
+  };
+}
+
 // src/core/ChatClient.ts
 var ChatClient = class extends EventEmitter {
   constructor(config) {
@@ -453,6 +645,7 @@ var ChatClient = class extends EventEmitter {
     this.conversationSubs = /* @__PURE__ */ new Map();
     this.conversationTypes = /* @__PURE__ */ new Map();
     const baseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+    this.currentUserId = config.userId;
     this.http = new HttpTransport({
       baseUrl,
       apiKey: config.apiKey,
@@ -511,6 +704,9 @@ var ChatClient = class extends EventEmitter {
   get status() {
     return this.ws.getStatus();
   }
+  get userId() {
+    return this.currentUserId;
+  }
   connect() {
     this.ws.connect();
   }
@@ -562,9 +758,15 @@ var ChatClient = class extends EventEmitter {
       }
     );
     if (result.data) {
-      this.cache.addMessage(conversationId, result.data);
+      const reconciled = this.cache.reconcileOptimisticMessage(conversationId, result.data);
+      this.cache.upsertMessage(conversationId, reconciled);
     } else if (result.error?.status === 0) {
-      this.offlineQueue.enqueue(conversationId, options.content, options.message_type ?? "text");
+      this.offlineQueue.enqueue(
+        conversationId,
+        options.content,
+        options.message_type ?? "text",
+        options.attachments
+      );
     }
     return result;
   }
@@ -593,9 +795,60 @@ var ChatClient = class extends EventEmitter {
   async deleteMessage(messageId) {
     return this.http.del(`/v1/chat/messages/${messageId}`);
   }
+  async uploadAttachment(file, onProgress, signal) {
+    const filename = typeof File !== "undefined" && file instanceof File ? file.name : "attachment";
+    const contentType = file.type || "application/octet-stream";
+    const initResult = await this.http.post("/v1/storage/signed-url/upload", {
+      filename,
+      content_type: contentType,
+      size_bytes: file.size,
+      is_public: false,
+      metadata: {
+        source: "chat_sdk"
+      }
+    });
+    if (initResult.error || !initResult.data) {
+      return { data: null, error: initResult.error };
+    }
+    const uploadResult = await uploadToPresignedUrl(
+      initResult.data.upload_url,
+      file,
+      onProgress,
+      signal
+    );
+    if (uploadResult.error) {
+      return { data: null, error: uploadResult.error };
+    }
+    const completeResult = await this.http.post("/v1/storage/signed-url/complete", {
+      file_id: initResult.data.file_id,
+      completion_token: initResult.data.completion_token
+    });
+    if (completeResult.error || !completeResult.data) {
+      return { data: null, error: completeResult.error };
+    }
+    return {
+      data: {
+        file_id: completeResult.data.file_id,
+        file_name: completeResult.data.filename,
+        file_size: completeResult.data.size_bytes,
+        mime_type: completeResult.data.content_type,
+        presigned_url: completeResult.data.url
+      },
+      error: null
+    };
+  }
+  async refreshAttachmentUrl(messageId, fileId) {
+    return this.http.get(
+      `/v1/chat/messages/${messageId}/attachment/${fileId}/url`
+    );
+  }
   getCachedMessages(conversationId) {
     return this.cache.getMessages(conversationId);
   }
+  stageOptimisticMessage(conversationId, message) {
+    this.cache.upsertMessage(conversationId, message);
+    return message;
+  }
   // ============ Reactions ============
   async addReaction(messageId, emoji) {
     return this.http.post(`/v1/chat/messages/${messageId}/reactions`, { emoji });
@@ -603,6 +856,20 @@ var ChatClient = class extends EventEmitter {
   async removeReaction(messageId, emoji) {
     return this.http.del(`/v1/chat/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`);
   }
+  async reportMessage(messageId, reason, description) {
+    return this.http.post(`/v1/chat/messages/${messageId}/report`, {
+      reason,
+      description
+    });
+  }
+  async muteConversation(conversationId, mutedUntil) {
+    return this.http.post(`/v1/chat/conversations/${conversationId}/mute`, {
+      muted_until: mutedUntil
+    });
+  }
+  async unmuteConversation(conversationId) {
+    return this.http.del(`/v1/chat/conversations/${conversationId}/mute`);
+  }
   // ============ Unread Count ============
   async getUnreadTotal() {
     return this.http.get("/v1/chat/conversations/unread-total");
@@ -778,6 +1045,91 @@ var ChatClient = class extends EventEmitter {
       }
     }
   }
+  normalizeMessage(payload) {
+    return {
+      id: payload.id ?? payload.message_id ?? "",
+      content: payload.content ?? "",
+      message_type: payload.message_type ?? "text",
+      sender_id: payload.sender_id ?? payload.sender_user_id ?? "",
+      sender_type: payload.sender_type,
+      sender_agent_model: payload.sender_agent_model,
+      attachments: payload.attachments,
+      reactions: payload.reactions,
+      is_edited: Boolean(payload.is_edited ?? false),
+      created_at: payload.created_at ?? payload.updated_at ?? payload.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  buildEditedMessage(conversationId, update) {
+    const messageId = update.message_id ?? update.id;
+    if (!messageId) {
+      return null;
+    }
+    const existing = this.cache.getMessage(conversationId, messageId);
+    return {
+      id: existing?.id ?? messageId,
+      content: update.content ?? update.new_content ?? existing?.content ?? "",
+      message_type: existing?.message_type ?? "text",
+      sender_id: existing?.sender_id ?? "",
+      sender_type: existing?.sender_type,
+      sender_agent_model: existing?.sender_agent_model,
+      attachments: existing?.attachments,
+      reactions: existing?.reactions,
+      is_edited: true,
+      created_at: existing?.created_at ?? update.updated_at ?? update.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  applyReactionEvent(conversationId, reactionEvent) {
+    const reaction = {
+      id: `${reactionEvent.message_id}:${reactionEvent.user_id}:${reactionEvent.emoji}`,
+      message_id: reactionEvent.message_id,
+      user_id: reactionEvent.user_id,
+      emoji: reactionEvent.emoji,
+      action: reactionEvent.action,
+      timestamp: reactionEvent.timestamp
+    };
+    const existingMessage = this.cache.getMessage(conversationId, reactionEvent.message_id);
+    if (!existingMessage) {
+      return reaction;
+    }
+    const nextReactions = [...existingMessage.reactions ?? []];
+    const reactionIndex = nextReactions.findIndex((entry) => entry.emoji === reactionEvent.emoji);
+    if (reactionEvent.action === "added") {
+      if (reactionIndex >= 0) {
+        const current = nextReactions[reactionIndex];
+        if (!current.user_ids.includes(reactionEvent.user_id)) {
+          const user_ids = [...current.user_ids, reactionEvent.user_id];
+          nextReactions[reactionIndex] = {
+            ...current,
+            user_ids,
+            count: user_ids.length
+          };
+        }
+      } else {
+        nextReactions.push({
+          emoji: reactionEvent.emoji,
+          count: 1,
+          user_ids: [reactionEvent.user_id]
+        });
+      }
+    } else if (reactionIndex >= 0) {
+      const current = nextReactions[reactionIndex];
+      const user_ids = current.user_ids.filter((userId) => userId !== reactionEvent.user_id);
+      if (user_ids.length === 0) {
+        nextReactions.splice(reactionIndex, 1);
+      } else {
+        nextReactions[reactionIndex] = {
+          ...current,
+          user_ids,
+          count: user_ids.length
+        };
+      }
+    }
+    this.cache.updateMessage(conversationId, {
+      ...existingMessage,
+      reactions: nextReactions
+    });
+    return reaction;
+  }
   handleConversationMessage(channel, data) {
     const conversationId = channel.replace(/^conversation:(?:lr:|bc:|support:)?/, "");
     const raw = data;
@@ -786,15 +1138,32 @@ var ChatClient = class extends EventEmitter {
     const payload = raw.data ?? raw;
     switch (event) {
       case "new_message": {
-        const message = payload;
-        this.cache.addMessage(conversationId, message);
-        this.emit("message", { message, conversationId });
+        const message = this.normalizeMessage(payload);
+        const reconciled = this.cache.reconcileOptimisticMessage(conversationId, message);
+        this.cache.upsertMessage(conversationId, reconciled);
+        this.emit("message", { message: reconciled, conversationId });
         break;
       }
       case "message_edited": {
-        const message = payload;
-        this.cache.updateMessage(conversationId, message);
-        this.emit("message:updated", { message, conversationId });
+        const update = payload;
+        const message = this.buildEditedMessage(conversationId, update);
+        if (message) {
+          this.cache.upsertMessage(conversationId, message);
+          this.emit("message:updated", { message, conversationId, update });
+        }
+        break;
+      }
+      case "reaction": {
+        const reactionEvent = payload;
+        if (!reactionEvent.message_id || !reactionEvent.user_id || !reactionEvent.emoji) {
+          break;
+        }
+        const reaction = this.applyReactionEvent(conversationId, reactionEvent);
+        this.emit("reaction", {
+          reaction,
+          conversationId,
+          action: reactionEvent.action
+        });
         break;
       }
       case "message_deleted": {
@@ -855,10 +1224,11 @@ var ChatClient = class extends EventEmitter {
     for (const item of queued) {
       await this.sendMessage(item.conversationId, {
         content: item.content,
-        message_type: item.message_type
+        message_type: item.message_type,
+        attachments: item.attachments
       });
     }
   }
 };
 
-export { ChatClient };
+export { ChatClient, EventEmitter };