@ascegu/teamily 1.0.22 → 1.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ascegu/teamily",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "OpenClaw Teamily channel plugin - Team instant messaging server integration",
   "keywords": [
     "channel",

package/src/channel.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import {
   applyAccountNameToChannelSection,
   buildChannelConfigSchema,
@@ -14,6 +15,9 @@ import {
   type ChannelOutboundContext,
   type ChannelStatusIssue,
   type HistoryEntry,
+  loadOutboundMediaFromUrl,
+  resolveOutboundMediaUrls,
+  sendMediaWithLeadingCaption,
 } from "openclaw/plugin-sdk";
 import {
   buildAccountScopedDmSecurityPolicy,
@@ -26,12 +30,18 @@ import {
 } from "./accounts.js";
 import { TeamilyConfigSchema } from "./config-schema.js";
 import type { CoreConfig } from "./config-schema.js";
-import { getTeamilyMonitor, startTeamilyMonitoring, stopTeamilyMonitoring } from "./monitor.js";
+import {
+  getTeamilyMonitor,
+  startTeamilyMonitoring,
+  stopTeamilyMonitoring,
+  type TeamilyMonitor,
+} from "./monitor.js";
 import { normalizeTeamilyTarget, normalizeTeamilyAllowEntry } from "./normalize.js";
 import { probeTeamily } from "./probe.js";
 import { getTeamilyRuntime } from "./runtime.js";
 import type { ResolvedTeamilyAccount } from "./types.js";
 import { isGroupSession } from "./types.js";
+import { detectMediaCategory, guessContentType, isLocalMediaPath } from "./upload.js";
 
 const meta = {
   id: "teamily",
@@ -60,6 +70,11 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
     threads: false,
     polls: false,
   },
+  agentPrompt: {
+    messageToolHints: () => [
+      "- To send a local file or image to the user, use MEDIA:./relative-path in your reply (e.g. MEDIA:./image.png). The path must be relative to the workspace. You can also use the message tool with media/path/filePath. Avoid absolute paths and ~ paths — they are blocked for security.",
+    ],
+  },
   reload: { configPrefixes: ["channels.teamily"] },
   setup: {
     resolveAccountId: ({ accountId, input }) => {
@@ -178,27 +193,27 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
       const monitor = requireMonitor(accountId);
       const target = normalizeTeamilyTarget(to);
 
-      let messageId: string;
-      const urlLower = mediaUrl.toLowerCase();
-      if (urlLower.endsWith(".mp4") || urlLower.endsWith(".mov") || urlLower.endsWith(".webm")) {
-        messageId = await monitor.sendVideo(target, mediaUrl);
-      } else if (
-        urlLower.endsWith(".mp3") ||
-        urlLower.endsWith(".m4a") ||
-        urlLower.endsWith(".wav")
-      ) {
-        messageId = await monitor.sendAudio(target, mediaUrl);
-      } else if (
-        urlLower.endsWith(".pdf") ||
-        urlLower.endsWith(".doc") ||
-        urlLower.endsWith(".docx") ||
-        urlLower.endsWith(".zip")
-      ) {
-        messageId = await monitor.sendFile(target, mediaUrl);
-      } else {
-        messageId = await monitor.sendImage(target, mediaUrl);
+      // Local file path: load buffer and send via SDK's *ByFile methods
+      // (SDK handles the upload internally, like Telegram's InputFile).
+      if (isLocalMediaPath(mediaUrl)) {
+        const media = await loadOutboundMediaFromUrl(mediaUrl, {
+          mediaLocalRoots: ctx.mediaLocalRoots,
+        });
+        const fileName = media.fileName || path.basename(mediaUrl) || "media";
+        const contentType = media.contentType || guessContentType(mediaUrl);
+        const messageId = await sendMediaBuffer(
+          monitor,
+          target,
+          media.buffer,
+          fileName,
+          contentType,
+          mediaUrl,
+        );
+        return { channel: "teamily" as const, messageId };
       }
 
+      // Remote URL: use existing *ByURL methods.
+      const messageId = await sendMediaByUrl(monitor, target, mediaUrl);
       return { channel: "teamily" as const, messageId };
     },
   },
@@ -368,16 +383,38 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
             ctx: msgCtx,
             cfg: currentCfg,
             dispatcherOptions: {
-              deliver: async (payload: { text?: string; body?: string }) => {
-                const replyText = payload?.text ?? payload?.body;
-                if (replyText) {
-                  const monitor = getTeamilyMonitor(accountId);
-                  if (!monitor)
-                    throw new Error(`Teamily monitor not running for account ${accountId}`);
+              deliver: async (payload) => {
+                const monitor = getTeamilyMonitor(accountId);
+                if (!monitor)
+                  throw new Error(`Teamily monitor not running for account ${accountId}`);
+                const target = normalizeTeamilyTarget(replyTarget);
+                const replyText =
+                  ((payload as Record<string, unknown>)?.text as string | undefined) ??
+                  ((payload as Record<string, unknown>)?.body as string | undefined) ??
+                  "";
+
+                // Send media attachments (first with caption, rest without).
+                const mediaUrls = resolveOutboundMediaUrls(payload as Record<string, unknown>);
+                const sentMedia = await sendMediaWithLeadingCaption({
+                  mediaUrls,
+                  caption: replyText,
+                  send: async ({ mediaUrl: url, caption }) => {
+                    await loadAndSendMedia(monitor, target, url);
+                    // OpenIM doesn't support inline captions on media; send separately.
+                    if (caption) {
+                      await monitor.sendText(target, caption);
+                    }
+                  },
+                  onError: (error) => {
+                    log?.warn?.(`[${accountId}] Media send failed: ${String(error)}`);
+                  },
+                });
+
+                // If no media was sent, send text only.
+                if (!sentMedia && replyText) {
                   log?.info?.(
                     `[${accountId}] Sending reply to: ${replyTarget} (isGroup=${isGroup})`,
                   );
-                  const target = normalizeTeamilyTarget(replyTarget);
                   await monitor.sendText(target, replyText);
                 }
               },
@@ -457,6 +494,66 @@ function applyTeamilyAccountConfig(params: {
   } as CoreConfig;
 }
 
+/** Send a local media buffer using SDK's *ByFile methods (SDK handles upload). */
+async function sendMediaBuffer(
+  monitor: TeamilyMonitor,
+  target: ReturnType<typeof normalizeTeamilyTarget>,
+  buffer: Buffer,
+  fileName: string,
+  contentType: string,
+  originalPath: string,
+): Promise<string> {
+  const category = detectMediaCategory(originalPath);
+  switch (category) {
+    case "video":
+      return monitor.sendVideoBuffer(target, buffer, fileName, contentType);
+    case "audio":
+      return monitor.sendAudioBuffer(target, buffer, fileName, contentType);
+    case "file":
+      return monitor.sendFileBuffer(target, buffer, fileName, contentType);
+    default:
+      return monitor.sendImageBuffer(target, buffer, fileName, contentType);
+  }
+}
+
+/** Send media by remote URL using existing *ByURL methods. */
+async function sendMediaByUrl(
+  monitor: TeamilyMonitor,
+  target: ReturnType<typeof normalizeTeamilyTarget>,
+  url: string,
+): Promise<string> {
+  const category = detectMediaCategory(url);
+  switch (category) {
+    case "video":
+      return monitor.sendVideo(target, url);
+    case "audio":
+      return monitor.sendAudio(target, url);
+    case "file":
+      return monitor.sendFile(target, url);
+    default:
+      return monitor.sendImage(target, url);
+  }
+}
+
+/**
+ * Load a local media file and send it via SDK buffer upload.
+ * For remote URLs, send directly via *ByURL methods.
+ */
+async function loadAndSendMedia(
+  monitor: TeamilyMonitor,
+  target: ReturnType<typeof normalizeTeamilyTarget>,
+  mediaUrl: string,
+): Promise<void> {
+  if (isLocalMediaPath(mediaUrl)) {
+    const media = await loadOutboundMediaFromUrl(mediaUrl);
+    const fileName = media.fileName || path.basename(mediaUrl) || "media";
+    const contentType = media.contentType || guessContentType(mediaUrl);
+    await sendMediaBuffer(monitor, target, media.buffer, fileName, contentType, mediaUrl);
+  } else {
+    await sendMediaByUrl(monitor, target, mediaUrl);
+  }
+}
+
 function requireMonitor(accountId?: string | null) {
   const id = accountId || "default";
   const monitor = getTeamilyMonitor(id);

package/src/monitor.ts

@@ -36,11 +36,6 @@ async function loadSDK() {
  * reconnection to the official OpenIM SDK. Also exposes send methods
  * so outbound replies flow through the same WebSocket connection.
  */
-/** Returns true when the string looks like an HTTP(S) URL rather than a local file path. */
-function isHttpUrl(s: string): boolean {
-  return s.startsWith("http://") || s.startsWith("https://");
-}
-
 export class TeamilyMonitor {
   private account: ResolvedTeamilyAccount;
   private onMessage: TeamilyMessageHandler;
@@ -131,29 +126,9 @@ export class TeamilyMonitor {
     return result.data?.serverMsgID || result.data?.clientMsgID || "";
   }
 
-  /**
-   * Upload a local file to the OpenIM server and return its download URL.
-   * Uses the SDK's built-in uploadFile which handles multipart upload to
-   * the server's object storage. Requires Node.js 20+ for global File.
-   */
-  async uploadLocalFile(localPath: string, contentType?: string): Promise<string> {
-    const sdk = this.requireSdk();
-    const { readFileSync } = await import("node:fs");
-    const { basename, extname } = await import("node:path");
-    const buffer = readFileSync(localPath);
-    const fileName = basename(localPath);
-    const mime = contentType || guessMimeType(extname(localPath));
-    const file = new File([buffer], fileName, { type: mime });
-    const result = await sdk.uploadFile({ file, name: fileName, contentType: mime });
-    const url = result.data?.url;
-    if (!url) throw new Error(`Upload failed for ${localPath}: no URL returned`);
-    return url;
-  }
-
   /** Send an image message through the SDK WebSocket connection. */
-  async sendImage(target: TeamilyMessageTarget, urlOrPath: string): Promise<string> {
+  async sendImage(target: TeamilyMessageTarget, url: string): Promise<string> {
     const sdk = this.requireSdk();
-    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const picInfo = { uuid: "", type: "", width: 0, height: 0, size: 0, url };
     const created = await sdk.createImageMessageByURL({
       sourcePicture: picInfo,
@@ -170,9 +145,8 @@ export class TeamilyMonitor {
   }
 
   /** Send a video message through the SDK WebSocket connection. */
-  async sendVideo(target: TeamilyMessageTarget, urlOrPath: string): Promise<string> {
+  async sendVideo(target: TeamilyMessageTarget, url: string): Promise<string> {
     const sdk = this.requireSdk();
-    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const created = await sdk.createVideoMessageByURL({
       videoPath: "",
       duration: 0,
@@ -196,9 +170,8 @@ export class TeamilyMonitor {
   }
 
   /** Send a sound/audio message through the SDK WebSocket connection. */
-  async sendAudio(target: TeamilyMessageTarget, urlOrPath: string): Promise<string> {
+  async sendAudio(target: TeamilyMessageTarget, url: string): Promise<string> {
     const sdk = this.requireSdk();
-    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const created = await sdk.createSoundMessageByURL({
       uuid: "",
       soundPath: "",
@@ -215,12 +188,11 @@ export class TeamilyMonitor {
   }
 
   /** Send a file message through the SDK WebSocket connection. */
-  async sendFile(target: TeamilyMessageTarget, urlOrPath: string, fileName?: string): Promise<string> {
+  async sendFile(target: TeamilyMessageTarget, url: string, fileName?: string): Promise<string> {
     const sdk = this.requireSdk();
-    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const created = await sdk.createFileMessageByURL({
       filePath: "",
-      fileName: fileName || urlOrPath.split("/").pop() || "file",
+      fileName: fileName || url.split("/").pop() || "file",
       uuid: "",
       sourceUrl: url,
       fileSize: 0,
@@ -233,6 +205,126 @@ export class TeamilyMonitor {
     return result.data?.serverMsgID || result.data?.clientMsgID || "";
   }
 
+  // ---- Buffer-based send methods (local file → SDK upload) ----
+  // Like Telegram's InputFile(buffer), pass a buffer and let the SDK upload.
+
+  /** Send an image from a local buffer. SDK handles the upload to object storage. */
+  async sendImageBuffer(
+    target: TeamilyMessageTarget,
+    buffer: Buffer,
+    fileName: string,
+    contentType: string,
+  ): Promise<string> {
+    const sdk = this.requireSdk();
+    const file = new File([new Uint8Array(buffer)], fileName, { type: contentType });
+    const picInfo = {
+      uuid: "",
+      type: contentType,
+      width: 0,
+      height: 0,
+      size: buffer.length,
+      url: "",
+    };
+    const created = await sdk.createImageMessageByFile({
+      sourcePicture: picInfo,
+      bigPicture: picInfo,
+      snapshotPicture: picInfo,
+      sourcePath: "",
+      file,
+    });
+    const result = await sdk.sendMessage({
+      recvID: target.type === "user" ? target.id : "",
+      groupID: target.type === "group" ? target.id : "",
+      message: created.data,
+    });
+    return result.data?.serverMsgID || result.data?.clientMsgID || "";
+  }
+
+  /** Send a video from a local buffer. SDK handles the upload to object storage. */
+  async sendVideoBuffer(
+    target: TeamilyMessageTarget,
+    buffer: Buffer,
+    fileName: string,
+    contentType: string,
+  ): Promise<string> {
+    const sdk = this.requireSdk();
+    const videoFile = new File([new Uint8Array(buffer)], fileName, { type: contentType });
+    // snapshotFile is required by the SDK type but we have no thumbnail; use an empty file.
+    const snapshotFile = new File([], "snapshot.jpg", { type: "image/jpeg" });
+    const created = await sdk.createVideoMessageByFile({
+      videoPath: "",
+      duration: 0,
+      videoType: contentType,
+      snapshotPath: "",
+      videoUUID: "",
+      videoUrl: "",
+      videoSize: buffer.length,
+      snapshotUUID: "",
+      snapshotSize: 0,
+      snapshotUrl: "",
+      snapshotWidth: 0,
+      snapshotHeight: 0,
+      videoFile,
+      snapshotFile,
+    });
+    const result = await sdk.sendMessage({
+      recvID: target.type === "user" ? target.id : "",
+      groupID: target.type === "group" ? target.id : "",
+      message: created.data,
+    });
+    return result.data?.serverMsgID || result.data?.clientMsgID || "";
+  }
+
+  /** Send an audio/sound from a local buffer. SDK handles the upload to object storage. */
+  async sendAudioBuffer(
+    target: TeamilyMessageTarget,
+    buffer: Buffer,
+    fileName: string,
+    contentType: string,
+  ): Promise<string> {
+    const sdk = this.requireSdk();
+    const file = new File([new Uint8Array(buffer)], fileName, { type: contentType });
+    const created = await sdk.createSoundMessageByFile({
+      uuid: "",
+      soundPath: "",
+      sourceUrl: "",
+      dataSize: buffer.length,
+      duration: 0,
+      file,
+    });
+    const result = await sdk.sendMessage({
+      recvID: target.type === "user" ? target.id : "",
+      groupID: target.type === "group" ? target.id : "",
+      message: created.data,
+    });
+    return result.data?.serverMsgID || result.data?.clientMsgID || "";
+  }
+
+  /** Send a document/file from a local buffer. SDK handles the upload to object storage. */
+  async sendFileBuffer(
+    target: TeamilyMessageTarget,
+    buffer: Buffer,
+    fileName: string,
+    contentType: string,
+  ): Promise<string> {
+    const sdk = this.requireSdk();
+    const file = new File([new Uint8Array(buffer)], fileName, { type: contentType });
+    const created = await sdk.createFileMessageByFile({
+      filePath: "",
+      fileName,
+      uuid: "",
+      sourceUrl: "",
+      fileSize: buffer.length,
+      file,
+    });
+    const result = await sdk.sendMessage({
+      recvID: target.type === "user" ? target.id : "",
+      groupID: target.type === "group" ? target.id : "",
+      message: created.data,
+    });
+    return result.data?.serverMsgID || result.data?.clientMsgID || "";
+  }
+
   private requireSdk(): SdkInstance {
     if (!this.sdk) {
       throw new Error("Teamily SDK not connected");
@@ -246,32 +338,6 @@ export class TeamilyMonitor {
   }
 }
 
-// ---- MIME type helper ----
-
-const MIME_MAP: Record<string, string> = {
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".bmp": "image/bmp",
-  ".mp4": "video/mp4",
-  ".mov": "video/quicktime",
-  ".webm": "video/webm",
-  ".mp3": "audio/mpeg",
-  ".m4a": "audio/mp4",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg",
-  ".pdf": "application/pdf",
-  ".doc": "application/msword",
-  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  ".zip": "application/zip",
-};
-
-function guessMimeType(ext: string): string {
-  return MIME_MAP[ext.toLowerCase()] || "application/octet-stream";
-}
-
 // ---- SDK message conversion helpers ----
 
 import type { MessageItem } from "@openim/client-sdk";
@@ -289,13 +355,12 @@ function convertSdkMessage(msg: MessageItem, selfUserID: string): TeamilyMessage
   // Determine whether this message @-mentions the bot
   const isAtSelf =
     contentType === CONTENT_TYPES.AT_TEXT &&
-    (msg.atTextElem?.isAtSelf === true ||
-      (msg.atTextElem?.atUserList ?? []).includes(selfUserID));
+    (msg.atTextElem?.isAtSelf === true || (msg.atTextElem?.atUserList ?? []).includes(selfUserID));
 
   return {
     serverMsgID: msg.serverMsgID || msg.clientMsgID || `${Date.now()}_${Math.random()}`,
     sendID: msg.sendID || "unknown",
-    recvID: isGroupSession(sessionType) ? (msg.groupID || "") : (msg.recvID || selfUserID),
+    recvID: isGroupSession(sessionType) ? msg.groupID || "" : msg.recvID || selfUserID,
     content,
     contentType,
     sessionType,

package/src/upload.ts

@@ -0,0 +1,46 @@
+import path from "node:path";
+
+/** Returns true if the media URL is a local file path rather than a remote URL. */
+export function isLocalMediaPath(mediaUrl: string): boolean {
+  return !/^https?:\/\//i.test(mediaUrl);
+}
+
+/** Detect the media category from a file extension. */
+export type MediaCategory = "image" | "video" | "audio" | "file";
+
+export function detectMediaCategory(filePath: string): MediaCategory {
+  const ext = path.extname(filePath).toLowerCase();
+  if ([".mp4", ".mov", ".webm"].includes(ext)) return "video";
+  if ([".mp3", ".m4a", ".wav", ".ogg"].includes(ext)) return "audio";
+  if ([".pdf", ".doc", ".docx", ".zip"].includes(ext)) return "file";
+  return "image";
+}
+
+/**
+ * Guess a reasonable MIME content type from a file extension.
+ * Falls back to application/octet-stream for unknown types.
+ */
+export function guessContentType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  const map: Record<string, string> = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".svg": "image/svg+xml",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".webm": "video/webm",
+    ".mp3": "audio/mpeg",
+    ".m4a": "audio/mp4",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".zip": "application/zip",
+  };
+  return map[ext] ?? "application/octet-stream";
+}

package/src/send.ts

@@ -1,271 +0,0 @@
-import { generateOperationID } from "./probe.js";
-import type { ResolvedTeamilyAccount, TeamilyMessageTarget } from "./types.js";
-import { CONTENT_TYPES, SESSION_TYPES } from "./types.js";
-
-export interface SendTeamilyMessageParams {
-  account: ResolvedTeamilyAccount;
-  target: TeamilyMessageTarget;
-  text: string;
-  replyToId?: string;
-  fetchImpl?: typeof fetch;
-}
-
-export interface SendTeamilyMediaParams {
-  account: ResolvedTeamilyAccount;
-  target: TeamilyMessageTarget;
-  mediaUrl: string;
-  mediaType: "image" | "video" | "audio" | "file";
-  caption?: string;
-  fetchImpl?: typeof fetch;
-}
-
-export interface TeamilySendResult {
-  success: boolean;
-  messageId?: string;
-  serverMsgID?: string;
-  clientMsgID?: string;
-  error?: string;
-}
-
-/**
- * Send a text message via Teamily REST API.
- *
- * @param params - Send parameters
- * @returns Send result with message ID or error
- */
-export async function sendMessageTeamily(
-  params: SendTeamilyMessageParams,
-): Promise<TeamilySendResult> {
-  const { account, target, text, replyToId, fetchImpl = fetch } = params;
-
-  const url = `${account.apiURL}/msg/send_msg`;
-
-  const payload = buildSendMessagePayload({
-    sendID: account.userID,
-    target,
-    content: { content: text },
-    contentType: CONTENT_TYPES.TEXT,
-    replyToId,
-  });
-
-  try {
-    const response = await fetchImpl(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        operationID: generateOperationID(),
-        token: account.token,
-      },
-      body: JSON.stringify(payload),
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      return {
-        success: false,
-        error: `HTTP ${response.status}: ${errorText}`,
-      };
-    }
-
-    const data = (await response.json()) as {
-      errCode: number;
-      errMsg: string;
-      data?: {
-        serverMsgID: string;
-        clientMsgID: string;
-        sendTime: number;
-      };
-    };
-
-    if (data.errCode !== 0) {
-      return {
-        success: false,
-        error: data.errMsg || "Send failed",
-      };
-    }
-
-    return {
-      success: true,
-      messageId: data.data?.serverMsgID,
-      serverMsgID: data.data?.serverMsgID,
-      clientMsgID: data.data?.clientMsgID,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-/**
- * Send a media message via Teamily REST API.
- *
- * @param params - Send parameters
- * @returns Send result with message ID or error
- */
-export async function sendMediaTeamily(params: SendTeamilyMediaParams): Promise<TeamilySendResult> {
-  const { account, target, mediaUrl, mediaType, caption, fetchImpl = fetch } = params;
-
-  const url = `${account.apiURL}/msg/send_msg`;
-
-  let content: Record<string, unknown>;
-  let contentType: number;
-
-  switch (mediaType) {
-    case "image":
-      contentType = CONTENT_TYPES.PICTURE;
-      content = {
-        sourcePicture: {
-          uuid: generateOperationID(),
-          type: "public",
-          width: 0,
-          height: 0,
-          url: mediaUrl,
-        },
-      };
-      break;
-
-    case "video":
-      contentType = CONTENT_TYPES.VIDEO;
-      content = {
-        videoPath: mediaUrl,
-        videoUUID: generateOperationID(),
-        videoUrl: mediaUrl,
-        videoType: "mp4",
-        videoSize: 0,
-        duration: 0,
-        snapshotUUID: `${generateOperationID()}_snap`,
-        snapshotUrl: "",
-        snapshotSize: 0,
-        snapshotWidth: 0,
-        snapshotHeight: 0,
-      };
-      break;
-
-    case "audio":
-      contentType = CONTENT_TYPES.VOICE;
-      content = {
-        uuid: generateOperationID(),
-        soundPath: mediaUrl,
-        sourceUrl: mediaUrl,
-        dataSize: 0,
-        duration: 0,
-        soundType: "mp3",
-      };
-      break;
-
-    case "file":
-      contentType = CONTENT_TYPES.FILE;
-      content = {
-        uuid: generateOperationID(),
-        fileName: mediaUrl.split("/").pop() || "file",
-        fileSize: 0,
-        sourceUrl: mediaUrl,
-        fileType: "application/octet-stream",
-      };
-      break;
-
-    default:
-      return {
-        success: false,
-        error: `Unsupported media type: ${mediaType}`,
-      };
-  }
-
-  // Add caption to text content for media messages
-  if (caption) {
-    content.text = caption;
-  }
-
-  const payload = buildSendMessagePayload({
-    sendID: account.userID,
-    target,
-    content,
-    contentType,
-  });
-
-  try {
-    const response = await fetchImpl(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        operationID: generateOperationID(),
-        token: account.token,
-      },
-      body: JSON.stringify(payload),
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      return {
-        success: false,
-        error: `HTTP ${response.status}: ${errorText}`,
-      };
-    }
-
-    const data = (await response.json()) as {
-      errCode: number;
-      errMsg: string;
-      data?: {
-        serverMsgID: string;
-        clientMsgID: string;
-        sendTime: number;
-      };
-    };
-
-    if (data.errCode !== 0) {
-      return {
-        success: false,
-        error: data.errMsg || "Send failed",
-      };
-    }
-
-    return {
-      success: true,
-      messageId: data.data?.serverMsgID,
-      serverMsgID: data.data?.serverMsgID,
-      clientMsgID: data.data?.clientMsgID,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-/**
- * Build the send message payload for Teamily API.
- */
-function buildSendMessagePayload(params: {
-  sendID: string;
-  target: TeamilyMessageTarget;
-  content: Record<string, unknown>;
-  contentType: number;
-  replyToId?: string;
-}): Record<string, unknown> {
-  const { sendID, target, content, contentType, replyToId } = params;
-
-  const payload: Record<string, unknown> = {
-    sendID,
-    recvID: target.type === "user" ? target.id : "",
-    groupID: target.type === "group" ? target.id : "",
-    content,
-    contentType,
-    sessionType: target.type === "group" ? SESSION_TYPES.GROUP : SESSION_TYPES.SINGLE,
-    isOnlineOnly: false,
-  };
-
-  if (replyToId) {
-    payload.quote = {
-      text: "",
-      content: {},
-      isReact: false,
-      userID: "",
-      msgID: replyToId,
-    };
-  }
-
-  return payload;
-}