@keyou007/agent-bot 0.1.6 → 0.1.8

package/src/config/loadConfig.ts

@@ -15,6 +15,7 @@ const DEFAULT_CONFIG = `feishu:
   appId: "\${FEISHU_APP_ID}"
   appSecret: "\${FEISHU_APP_SECRET}"
   userOpenId: "\${FEISHU_USER_OPEN_ID}"
+  respondToAllGroupMessages: true
 
 console:
   enabled: true

package/src/config/schema.ts

@@ -22,6 +22,7 @@ export const appConfigSchema = z.object({
     appId: z.string().optional(),
     appSecret: z.string().optional(),
     userOpenId: z.string().optional(),
+    respondToAllGroupMessages: z.boolean().default(true),
     useConsoleWhenMissingCredentials: z.boolean().default(false),
   }),
   agents: z.record(z.string().min(1), agentConfigSchema).refine(

package/src/feishu/CardRenderer.ts

@@ -790,8 +790,8 @@ function turnActivities(state: TurnViewState): TurnActivity[] {
 
 function toolPanel(tool: ToolState, projectCwd?: string): Record<string, unknown> {
   const elements = [markdown(renderToolDetails(tool, projectCwd))];
-  if (tool.kind === "image_view" && tool.imagePath) {
-    elements.push(localCardImage(tool.imagePath, "view_image 图片"));
+  if ((tool.kind === "image_view" || tool.kind === "image_generation") && tool.imagePath) {
+    elements.push(localCardImage(tool.imagePath, tool.kind === "image_generation" ? "生成图片" : "view_image 图片"));
   }
   return collapsiblePanel(toolPanelTitle(tool), elements, { elementId: toolPanelElementId(tool.id) });
 }

package/src/feishu/FeishuBotIdentity.ts

@@ -0,0 +1,55 @@
+const TENANT_TOKEN_URL = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal";
+const BOT_INFO_URL = "https://open.feishu.cn/open-apis/bot/v3/info";
+
+interface TenantTokenResponse {
+  code?: number;
+  msg?: string;
+  tenant_access_token?: string;
+}
+
+interface BotInfoResponse {
+  code?: number;
+  msg?: string;
+  bot?: {
+    open_id?: string;
+  };
+}
+
+export async function resolveFeishuBotOpenId(
+  appId: string,
+  appSecret: string,
+  fetchImpl: typeof globalThis.fetch = globalThis.fetch,
+): Promise<string> {
+  const tokenResponse = await fetchImpl(TENANT_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json; charset=utf-8" },
+    body: JSON.stringify({ app_id: appId, app_secret: appSecret }),
+  });
+  const tokenPayload = await readJson<TenantTokenResponse>(tokenResponse, "get the Lark tenant access token");
+  const token = tokenPayload.tenant_access_token;
+  if (!tokenResponse.ok || tokenPayload.code !== 0 || !token) {
+    throw new Error(`Failed to get the Lark tenant access token: ${responseMessage(tokenPayload, tokenResponse)}`);
+  }
+
+  const infoResponse = await fetchImpl(BOT_INFO_URL, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  const infoPayload = await readJson<BotInfoResponse>(infoResponse, "get Lark bot information");
+  const openId = infoPayload.bot?.open_id;
+  if (!infoResponse.ok || infoPayload.code !== 0 || !openId) {
+    throw new Error(`Failed to get Lark bot information: ${responseMessage(infoPayload, infoResponse)}`);
+  }
+  return openId;
+}
+
+async function readJson<T>(response: Response, operation: string): Promise<T> {
+  try {
+    return await response.json() as T;
+  } catch {
+    throw new Error(`Failed to ${operation}: Lark returned an invalid response (HTTP ${response.status}).`);
+  }
+}
+
+function responseMessage(payload: { msg?: string }, response: Response): string {
+  return payload.msg || response.statusText || `HTTP ${response.status}`;
+}

package/src/feishu/FeishuConnector.ts

@@ -1,13 +1,17 @@
 import type { Logger } from "pino";
 import type { AppConfig } from "../config/schema.js";
 import { threadContextKey } from "./contextKey.js";
+import { resolveFeishuBotOpenId } from "./FeishuBotIdentity.js";
 import type { ChatUpdatedEvent, FeishuEventHandler, IncomingMessage } from "./types.js";
 
+type BotOpenIdResolver = (appId: string, appSecret: string) => Promise<string>;
+
 export class FeishuConnector {
   constructor(
     private readonly config: AppConfig,
     private readonly handler: FeishuEventHandler,
     private readonly logger: Logger,
+    private readonly botOpenIdResolver: BotOpenIdResolver = resolveFeishuBotOpenId,
   ) {}
 
   async start(): Promise<void> {
@@ -16,18 +20,22 @@ export class FeishuConnector {
       throw new Error("Feishu appId/appSecret are required.");
     }
 
-    await this.startFeishuWs(appId, appSecret);
+    const respondToAllGroupMessages = this.config.feishu.respondToAllGroupMessages !== false;
+    const botOpenId = respondToAllGroupMessages
+      ? undefined
+      : await this.botOpenIdResolver(appId, appSecret);
+    await this.startFeishuWs(appId, appSecret, botOpenId);
   }
 
   stop(): void {
     // SDK connector currently relies on process lifetime.
   }
 
-  private async startFeishuWs(appId: string, appSecret: string): Promise<void> {
+  private async startFeishuWs(appId: string, appSecret: string, requiredMentionOpenId?: string): Promise<void> {
     const lark = (await import("@larksuiteoapi/node-sdk")) as Record<string, any>;
     const eventDispatcher = new lark.EventDispatcher({}).register({
       "im.message.receive_v1": async (data: unknown) => {
-        const message = toIncomingMessage(data);
+        const message = toIncomingMessage(data, requiredMentionOpenId);
         if (!message) {
           this.logger.debug({ data }, "Ignored unsupported Feishu message event.");
           return;
@@ -98,7 +106,7 @@ function toChatUpdatedEvent(data: unknown): ChatUpdatedEvent | undefined {
   };
 }
 
-function toIncomingMessage(data: unknown): IncomingMessage | undefined {
+function toIncomingMessage(data: unknown, requiredMentionOpenId?: string): IncomingMessage | undefined {
   const event = getFeishuEvent(data);
   const message = event?.message;
   if (!message) {
@@ -111,6 +119,13 @@ function toIncomingMessage(data: unknown): IncomingMessage | undefined {
   if (!parsed) return undefined;
   const chatId = message.chat_id;
   const chatType = message.chat_type === "group" ? "group" : "p2p";
+  if (
+    chatType === "group" &&
+    requiredMentionOpenId &&
+    !mentionsOpenId(message.mentions, requiredMentionOpenId)
+  ) {
+    return undefined;
+  }
   const threadId = typeof message.thread_id === "string" && message.thread_id ? message.thread_id : undefined;
   const rootMessageId = typeof message.root_id === "string" && message.root_id ? message.root_id : undefined;
   const parentMessageId = typeof message.parent_id === "string" && message.parent_id ? message.parent_id : undefined;
@@ -142,6 +157,11 @@ function toIncomingMessage(data: unknown): IncomingMessage | undefined {
   };
 }
 
+function mentionsOpenId(value: unknown, openId: string): boolean {
+  return Array.isArray(value) && value.some((mention) =>
+    isRecord(mention) && mention.id === openId);
+}
+
 function parseMessageContent(
   messageType: unknown,
   content: Record<string, unknown>,

package/src/presentation/TurnStateReducer.ts

@@ -1,4 +1,5 @@
 import type { AgentEvent, ToolState } from "../runtime/types.js";
+import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import type { MessageReplyTarget } from "../feishu/types.js";
 import type { FileSummary, TurnActivity, TurnViewState } from "./turnViewTypes.js";
 
@@ -107,7 +108,11 @@ export function reduceTurnEvent(state: TurnViewState, event: AgentEvent): TurnVi
         approval: undefined,
         completedAt: state.startedAt + (event.durationMs ?? Date.now() - state.startedAt),
         durationMs: event.durationMs ?? Date.now() - state.startedAt,
-        finalResponse: event.finalResponse,
+        finalResponse: appendGeneratedImageMarkdown(
+          event.finalResponse,
+          state.completedTools.flatMap((tool) =>
+            tool.kind === "image_generation" && tool.imagePath ? [tool.imagePath] : []),
+        ),
       };
     case "turn_cancelled":
       return { ...state, status: "cancelled", activeTool: undefined, approval: undefined, completedAt: Date.now() };

package/src/proxy/ProxySessionController.ts

@@ -3264,7 +3264,10 @@ function truncateTail(value: string, maxLength: number): string {
 function parseAgentGroupName(value: string): { agentName: string; title: string } | undefined {
   const match = /^\[([^[\]]+)\]\s+(.+)$/.exec(value.trim());
   const agentName = match?.[1]?.trim();
-  const title = match?.[2]?.trim();
+  const remainder = match?.[2]?.trim();
+  if (!agentName || !remainder) return undefined;
+  const projectPrefix = /^\[([^[\]]+)\](?:\s+(.+))?$/.exec(remainder);
+  const title = projectPrefix ? projectPrefix[2]?.trim() : remainder;
   return agentName && title ? { agentName, title } : undefined;
 }
 

package/src/utils/generatedImageMarkdown.ts

@@ -0,0 +1,10 @@
+export function appendGeneratedImageMarkdown(finalResponse: string, imagePaths: string[]): string {
+  const text = finalResponse.trim();
+  const normalizedText = text.replaceAll("\\", "/");
+  const images = [...new Set(imagePaths.map((imagePath) => imagePath.trim().replaceAll("\\", "/")).filter(Boolean))]
+    .filter((imagePath) => !normalizedText.includes(imagePath));
+  if (images.length === 0) return text;
+  const imageMarkdown = images.map((imagePath, index) =>
+    `![生成图片 ${index + 1}](<${imagePath}>)`).join("\n\n");
+  return text ? `${text}\n\n${imageMarkdown}` : imageMarkdown;
+}