@fased/fased 0.1.36 → 0.1.37

package/extensions/feishu/src/reply-dispatcher.ts

@@ -1,239 +0,0 @@
-import {
-  createReplyPrefixContext,
-  createTypingCallbacks,
-  logTypingFailure,
-  type FasedAgentConfig,
-  type ReplyPayload,
-  type RuntimeEnv,
-} from "fased/plugin-sdk";
-import { resolveFeishuAccount } from "./accounts.js";
-import { createFeishuClient } from "./client.js";
-import type { MentionTarget } from "./mention.js";
-import { buildMentionedCardContent } from "./mention.js";
-import { getFeishuRuntime } from "./runtime.js";
-import { sendMarkdownCardFeishu, sendMessageFeishu } from "./send.js";
-import { FeishuStreamingSession } from "./streaming-card.js";
-import { resolveReceiveIdType } from "./targets.js";
-import { addTypingIndicator, removeTypingIndicator, type TypingIndicatorState } from "./typing.js";
-
-/** Detect if text contains markdown elements that benefit from card rendering */
-function shouldUseCard(text: string): boolean {
-  return /```[\s\S]*?```/.test(text) || /\|.+\|[\r\n]+\|[-:| ]+\|/.test(text);
-}
-
-export type CreateFeishuReplyDispatcherParams = {
-  cfg: FasedAgentConfig;
-  agentId: string;
-  runtime: RuntimeEnv;
-  chatId: string;
-  replyToMessageId?: string;
-  mentionTargets?: MentionTarget[];
-  accountId?: string;
-};
-
-export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherParams) {
-  const core = getFeishuRuntime();
-  const { cfg, agentId, chatId, replyToMessageId, mentionTargets, accountId } = params;
-  const account = resolveFeishuAccount({ cfg, accountId });
-  const prefixContext = createReplyPrefixContext({ cfg, agentId });
-
-  let typingState: TypingIndicatorState | null = null;
-  const typingCallbacks = createTypingCallbacks({
-    start: async () => {
-      if (!replyToMessageId) {
-        return;
-      }
-      typingState = await addTypingIndicator({ cfg, messageId: replyToMessageId, accountId });
-    },
-    stop: async () => {
-      if (!typingState) {
-        return;
-      }
-      await removeTypingIndicator({ cfg, state: typingState, accountId });
-      typingState = null;
-    },
-    onStartError: (err) =>
-      logTypingFailure({
-        log: (message) => params.runtime.log?.(message),
-        channel: "feishu",
-        action: "start",
-        error: err,
-      }),
-    onStopError: (err) =>
-      logTypingFailure({
-        log: (message) => params.runtime.log?.(message),
-        channel: "feishu",
-        action: "stop",
-        error: err,
-      }),
-  });
-
-  const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, "feishu", accountId, {
-    fallbackLimit: 4000,
-  });
-  const chunkMode = core.channel.text.resolveChunkMode(cfg, "feishu");
-  const tableMode = core.channel.text.resolveMarkdownTableMode({ cfg, channel: "feishu" });
-  const renderMode = account.config?.renderMode ?? "auto";
-  const streamingEnabled = account.config?.streaming !== false && renderMode !== "raw";
-
-  let streaming: FeishuStreamingSession | null = null;
-  let streamText = "";
-  let lastPartial = "";
-  let partialUpdateQueue: Promise<void> = Promise.resolve();
-  let streamingStartPromise: Promise<void> | null = null;
-
-  const startStreaming = () => {
-    if (!streamingEnabled || streamingStartPromise || streaming) {
-      return;
-    }
-    streamingStartPromise = (async () => {
-      const creds =
-        account.appId && account.appSecret
-          ? { appId: account.appId, appSecret: account.appSecret, domain: account.domain }
-          : null;
-      if (!creds) {
-        return;
-      }
-
-      streaming = new FeishuStreamingSession(createFeishuClient(account), creds, (message) =>
-        params.runtime.log?.(`feishu[${account.accountId}] ${message}`),
-      );
-      try {
-        await streaming.start(chatId, resolveReceiveIdType(chatId));
-      } catch (error) {
-        params.runtime.error?.(`feishu: streaming start failed: ${String(error)}`);
-        streaming = null;
-      }
-    })();
-  };
-
-  const closeStreaming = async () => {
-    if (streamingStartPromise) {
-      await streamingStartPromise;
-    }
-    await partialUpdateQueue;
-    if (streaming?.isActive()) {
-      let text = streamText;
-      if (mentionTargets?.length) {
-        text = buildMentionedCardContent(mentionTargets, text);
-      }
-      await streaming.close(text);
-    }
-    streaming = null;
-    streamingStartPromise = null;
-    streamText = "";
-    lastPartial = "";
-  };
-
-  const { dispatcher, replyOptions, markDispatchIdle } =
-    core.channel.reply.createReplyDispatcherWithTyping({
-      responsePrefix: prefixContext.responsePrefix,
-      responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
-      humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
-      onReplyStart: () => {
-        if (streamingEnabled && renderMode === "card") {
-          startStreaming();
-        }
-        void typingCallbacks.onReplyStart?.();
-      },
-      deliver: async (payload: ReplyPayload, info) => {
-        const text = payload.text ?? "";
-        if (!text.trim()) {
-          return;
-        }
-
-        const useCard = renderMode === "card" || (renderMode === "auto" && shouldUseCard(text));
-
-        if ((info?.kind === "block" || info?.kind === "final") && streamingEnabled && useCard) {
-          startStreaming();
-          if (streamingStartPromise) {
-            await streamingStartPromise;
-          }
-        }
-
-        if (streaming?.isActive()) {
-          if (info?.kind === "final") {
-            streamText = text;
-            await closeStreaming();
-          }
-          return;
-        }
-
-        let first = true;
-        if (useCard) {
-          for (const chunk of core.channel.text.chunkTextWithMode(
-            text,
-            textChunkLimit,
-            chunkMode,
-          )) {
-            await sendMarkdownCardFeishu({
-              cfg,
-              to: chatId,
-              text: chunk,
-              replyToMessageId,
-              mentions: first ? mentionTargets : undefined,
-              accountId,
-            });
-            first = false;
-          }
-        } else {
-          const converted = core.channel.text.convertMarkdownTables(text, tableMode);
-          for (const chunk of core.channel.text.chunkTextWithMode(
-            converted,
-            textChunkLimit,
-            chunkMode,
-          )) {
-            await sendMessageFeishu({
-              cfg,
-              to: chatId,
-              text: chunk,
-              replyToMessageId,
-              mentions: first ? mentionTargets : undefined,
-              accountId,
-            });
-            first = false;
-          }
-        }
-      },
-      onError: async (error, info) => {
-        params.runtime.error?.(
-          `feishu[${account.accountId}] ${info.kind} reply failed: ${String(error)}`,
-        );
-        await closeStreaming();
-        typingCallbacks.onIdle?.();
-      },
-      onIdle: async () => {
-        await closeStreaming();
-        typingCallbacks.onIdle?.();
-      },
-      onCleanup: () => {
-        typingCallbacks.onCleanup?.();
-      },
-    });
-
-  return {
-    dispatcher,
-    replyOptions: {
-      ...replyOptions,
-      onModelSelected: prefixContext.onModelSelected,
-      onPartialReply: streamingEnabled
-        ? (payload: ReplyPayload) => {
-            if (!payload.text || payload.text === lastPartial) {
-              return;
-            }
-            lastPartial = payload.text;
-            streamText = payload.text;
-            partialUpdateQueue = partialUpdateQueue.then(async () => {
-              if (streamingStartPromise) {
-                await streamingStartPromise;
-              }
-              if (streaming?.isActive()) {
-                await streaming.update(streamText);
-              }
-            });
-          }
-        : undefined,
-    },
-    markDispatchIdle,
-  };
-}

package/extensions/feishu/src/runtime.ts

@@ -1,14 +0,0 @@
-import type { PluginRuntime } from "fased/plugin-sdk";
-
-let runtime: PluginRuntime | null = null;
-
-export function setFeishuRuntime(next: PluginRuntime) {
-  runtime = next;
-}
-
-export function getFeishuRuntime(): PluginRuntime {
-  if (!runtime) {
-    throw new Error("Feishu runtime not initialized");
-  }
-  return runtime;
-}

package/extensions/feishu/src/send-result.ts

@@ -1,29 +0,0 @@
-export type FeishuMessageApiResponse = {
-  code?: number;
-  msg?: string;
-  data?: {
-    message_id?: string;
-  };
-};
-
-export function assertFeishuMessageApiSuccess(
-  response: FeishuMessageApiResponse,
-  errorPrefix: string,
-) {
-  if (response.code !== 0) {
-    throw new Error(`${errorPrefix}: ${response.msg || `code ${response.code}`}`);
-  }
-}
-
-export function toFeishuSendResult(
-  response: FeishuMessageApiResponse,
-  chatId: string,
-): {
-  messageId: string;
-  chatId: string;
-} {
-  return {
-    messageId: response.data?.message_id ?? "unknown",
-    chatId,
-  };
-}

package/extensions/feishu/src/send-target.ts

@@ -1,25 +0,0 @@
-import type { FasedAgentConfig } from "fased/plugin-sdk";
-import { resolveFeishuAccount } from "./accounts.js";
-import { createFeishuClient } from "./client.js";
-import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";
-
-export function resolveFeishuSendTarget(params: {
-  cfg: FasedAgentConfig;
-  to: string;
-  accountId?: string;
-}) {
-  const account = resolveFeishuAccount({ cfg: params.cfg, accountId: params.accountId });
-  if (!account.configured) {
-    throw new Error(`Feishu account "${account.accountId}" not configured`);
-  }
-  const client = createFeishuClient(account);
-  const receiveId = normalizeFeishuTarget(params.to);
-  if (!receiveId) {
-    throw new Error(`Invalid Feishu target: ${params.to}`);
-  }
-  return {
-    client,
-    receiveId,
-    receiveIdType: resolveReceiveIdType(receiveId),
-  };
-}

package/extensions/feishu/src/send.ts

@@ -1,313 +0,0 @@
-import type { FasedAgentConfig } from "fased/plugin-sdk";
-import { resolveFeishuAccount } from "./accounts.js";
-import { createFeishuClient } from "./client.js";
-import type { MentionTarget } from "./mention.js";
-import { buildMentionedMessage, buildMentionedCardContent } from "./mention.js";
-import { getFeishuRuntime } from "./runtime.js";
-import { assertFeishuMessageApiSuccess, toFeishuSendResult } from "./send-result.js";
-import { resolveFeishuSendTarget } from "./send-target.js";
-import type { FeishuSendResult } from "./types.js";
-
-export type FeishuMessageInfo = {
-  messageId: string;
-  chatId: string;
-  senderId?: string;
-  senderOpenId?: string;
-  content: string;
-  contentType: string;
-  createTime?: number;
-};
-
-/**
- * Get a message by its ID.
- * Useful for fetching quoted/replied message content.
- */
-export async function getMessageFeishu(params: {
-  cfg: FasedAgentConfig;
-  messageId: string;
-  accountId?: string;
-}): Promise<FeishuMessageInfo | null> {
-  const { cfg, messageId, accountId } = params;
-  const account = resolveFeishuAccount({ cfg, accountId });
-  if (!account.configured) {
-    throw new Error(`Feishu account "${account.accountId}" not configured`);
-  }
-
-  const client = createFeishuClient(account);
-
-  try {
-    const response = (await client.im.message.get({
-      path: { message_id: messageId },
-    })) as {
-      code?: number;
-      msg?: string;
-      data?: {
-        items?: Array<{
-          message_id?: string;
-          chat_id?: string;
-          msg_type?: string;
-          body?: { content?: string };
-          sender?: {
-            id?: string;
-            id_type?: string;
-            sender_type?: string;
-          };
-          create_time?: string;
-        }>;
-      };
-    };
-
-    if (response.code !== 0) {
-      return null;
-    }
-
-    const item = response.data?.items?.[0];
-    if (!item) {
-      return null;
-    }
-
-    // Parse content based on message type
-    let content = item.body?.content ?? "";
-    try {
-      const parsed = JSON.parse(content);
-      if (item.msg_type === "text" && parsed.text) {
-        content = parsed.text;
-      }
-    } catch {
-      // Keep raw content if parsing fails
-    }
-
-    return {
-      messageId: item.message_id ?? messageId,
-      chatId: item.chat_id ?? "",
-      senderId: item.sender?.id,
-      senderOpenId: item.sender?.id_type === "open_id" ? item.sender?.id : undefined,
-      content,
-      contentType: item.msg_type ?? "text",
-      createTime: item.create_time ? parseInt(item.create_time, 10) : undefined,
-    };
-  } catch {
-    return null;
-  }
-}
-
-export type SendFeishuMessageParams = {
-  cfg: FasedAgentConfig;
-  to: string;
-  text: string;
-  replyToMessageId?: string;
-  /** Mention target users */
-  mentions?: MentionTarget[];
-  /** Account ID (optional, uses default if not specified) */
-  accountId?: string;
-};
-
-function buildFeishuPostMessagePayload(params: { messageText: string }): {
-  content: string;
-  msgType: string;
-} {
-  const { messageText } = params;
-  return {
-    content: JSON.stringify({
-      zh_cn: {
-        content: [
-          [
-            {
-              tag: "md",
-              text: messageText,
-            },
-          ],
-        ],
-      },
-    }),
-    msgType: "post",
-  };
-}
-
-export async function sendMessageFeishu(
-  params: SendFeishuMessageParams,
-): Promise<FeishuSendResult> {
-  const { cfg, to, text, replyToMessageId, mentions, accountId } = params;
-  const { client, receiveId, receiveIdType } = resolveFeishuSendTarget({ cfg, to, accountId });
-  const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
-    cfg,
-    channel: "feishu",
-  });
-
-  // Build message content (with @mention support)
-  let rawText = text ?? "";
-  if (mentions && mentions.length > 0) {
-    rawText = buildMentionedMessage(mentions, rawText);
-  }
-  const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(rawText, tableMode);
-
-  const { content, msgType } = buildFeishuPostMessagePayload({ messageText });
-
-  if (replyToMessageId) {
-    const response = await client.im.message.reply({
-      path: { message_id: replyToMessageId },
-      data: {
-        content,
-        msg_type: msgType,
-      },
-    });
-    assertFeishuMessageApiSuccess(response, "Feishu reply failed");
-    return toFeishuSendResult(response, receiveId);
-  }
-
-  const response = await client.im.message.create({
-    params: { receive_id_type: receiveIdType },
-    data: {
-      receive_id: receiveId,
-      content,
-      msg_type: msgType,
-    },
-  });
-  assertFeishuMessageApiSuccess(response, "Feishu send failed");
-  return toFeishuSendResult(response, receiveId);
-}
-
-export type SendFeishuCardParams = {
-  cfg: FasedAgentConfig;
-  to: string;
-  card: Record<string, unknown>;
-  replyToMessageId?: string;
-  accountId?: string;
-};
-
-export async function sendCardFeishu(params: SendFeishuCardParams): Promise<FeishuSendResult> {
-  const { cfg, to, card, replyToMessageId, accountId } = params;
-  const { client, receiveId, receiveIdType } = resolveFeishuSendTarget({ cfg, to, accountId });
-  const content = JSON.stringify(card);
-
-  if (replyToMessageId) {
-    const response = await client.im.message.reply({
-      path: { message_id: replyToMessageId },
-      data: {
-        content,
-        msg_type: "interactive",
-      },
-    });
-    assertFeishuMessageApiSuccess(response, "Feishu card reply failed");
-    return toFeishuSendResult(response, receiveId);
-  }
-
-  const response = await client.im.message.create({
-    params: { receive_id_type: receiveIdType },
-    data: {
-      receive_id: receiveId,
-      content,
-      msg_type: "interactive",
-    },
-  });
-  assertFeishuMessageApiSuccess(response, "Feishu card send failed");
-  return toFeishuSendResult(response, receiveId);
-}
-
-export async function updateCardFeishu(params: {
-  cfg: FasedAgentConfig;
-  messageId: string;
-  card: Record<string, unknown>;
-  accountId?: string;
-}): Promise<void> {
-  const { cfg, messageId, card, accountId } = params;
-  const account = resolveFeishuAccount({ cfg, accountId });
-  if (!account.configured) {
-    throw new Error(`Feishu account "${account.accountId}" not configured`);
-  }
-
-  const client = createFeishuClient(account);
-  const content = JSON.stringify(card);
-
-  const response = await client.im.message.patch({
-    path: { message_id: messageId },
-    data: { content },
-  });
-
-  if (response.code !== 0) {
-    throw new Error(`Feishu card update failed: ${response.msg || `code ${response.code}`}`);
-  }
-}
-
-/**
- * Build a Feishu interactive card with markdown content.
- * Cards render markdown properly (code blocks, tables, links, etc.)
- * Uses schema 2.0 format for proper markdown rendering.
- */
-export function buildMarkdownCard(text: string): Record<string, unknown> {
-  return {
-    schema: "2.0",
-    config: {
-      wide_screen_mode: true,
-    },
-    body: {
-      elements: [
-        {
-          tag: "markdown",
-          content: text,
-        },
-      ],
-    },
-  };
-}
-
-/**
- * Send a message as a markdown card (interactive message).
- * This renders markdown properly in Feishu (code blocks, tables, bold/italic, etc.)
- */
-export async function sendMarkdownCardFeishu(params: {
-  cfg: FasedAgentConfig;
-  to: string;
-  text: string;
-  replyToMessageId?: string;
-  /** Mention target users */
-  mentions?: MentionTarget[];
-  accountId?: string;
-}): Promise<FeishuSendResult> {
-  const { cfg, to, text, replyToMessageId, mentions, accountId } = params;
-  // Build message content (with @mention support)
-  let cardText = text;
-  if (mentions && mentions.length > 0) {
-    cardText = buildMentionedCardContent(mentions, text);
-  }
-  const card = buildMarkdownCard(cardText);
-  return sendCardFeishu({ cfg, to, card, replyToMessageId, accountId });
-}
-
-/**
- * Edit an existing text message.
- * Note: Feishu only allows editing messages within 24 hours.
- */
-export async function editMessageFeishu(params: {
-  cfg: FasedAgentConfig;
-  messageId: string;
-  text: string;
-  accountId?: string;
-}): Promise<void> {
-  const { cfg, messageId, text, accountId } = params;
-  const account = resolveFeishuAccount({ cfg, accountId });
-  if (!account.configured) {
-    throw new Error(`Feishu account "${account.accountId}" not configured`);
-  }
-
-  const client = createFeishuClient(account);
-  const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
-    cfg,
-    channel: "feishu",
-  });
-  const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(text ?? "", tableMode);
-
-  const { content, msgType } = buildFeishuPostMessagePayload({ messageText });
-
-  const response = await client.im.message.update({
-    path: { message_id: messageId },
-    data: {
-      msg_type: msgType,
-      content,
-    },
-  });
-
-  if (response.code !== 0) {
-    throw new Error(`Feishu message edit failed: ${response.msg || `code ${response.code}`}`);
-  }
-}