@keyou007/agent-bot 0.1.7 → 0.1.8

package/docs/technical-reference.md

@@ -93,7 +93,8 @@ Core configuration required for basic messaging:
 - Bot capability
 - Persistent-connection event delivery
 - `im.message.receive_v1`
-- Tenant permissions for group @ messages and private messages
+- `im:message.group_msg:readonly` for all user messages in groups containing the bot
+- Tenant permission for private messages
 - `im:message:send_as_bot` or a broader equivalent
 - `application:application:self_manage` so initialization can inspect the published version
 
@@ -120,6 +121,7 @@ feishu:
   appId: "${FEISHU_APP_ID}"
   appSecret: "${FEISHU_APP_SECRET}"
   userOpenId: "${FEISHU_USER_OPEN_ID}"
+  respondToAllGroupMessages: true
 
 console:
   enabled: true
@@ -144,6 +146,8 @@ logging:
   path: "./logs/agent-bot.log"
 ```
 
+`feishu.respondToAllGroupMessages` defaults to `true`. Set it to `false` to ignore group messages unless they mention the current bot. The worker resolves the bot's Open ID at startup so mentioning another member does not trigger it. Private messages are always accepted. Initialization requests all-user group-message delivery regardless of this runtime option, allowing it to be changed later without another authorization.
+
 `agent-bot server start` requires both Feishu credentials. The worker starts the SDK's persistent connection without inspecting SDK logs or private connection state, then sends startup status cards as an outbound readiness check. Each startup card includes the Agent Bot version read from the installed package metadata. It normally targets known private chats and recently active groups. If the database has no known chat yet, it sends the card to `feishu.userOpenId` using an `open_id` private message. When notification targets exist, at least one card must be delivered before the server reports ready; individual target failures remain isolated. If neither a known chat nor `feishu.userOpenId` is available, startup continues without the outbound check. Missing credentials still fail startup with an initialization hint. `agent-bot console` is the explicit local-only path and does not require Feishu credentials.
 
 At least one agent must be configured. `defaults.agent` must name a configured agent.

package/docs/technical-reference.zh.md

@@ -93,7 +93,8 @@ CLI 界面文本不受系统语言影响，统一使用英文。系统生成的
 - 机器人能力
 - 长连接事件接收
 - `im.message.receive_v1`
-- 接收群聊 @ 消息和私聊消息所需的租户权限
+- `im:message.group_msg:readonly`，用于接收机器人所在群内的全部用户消息
+- 接收私聊消息所需的租户权限
 - `im:message:send_as_bot` 或覆盖它的更大权限
 - `application:application:self_manage`，供初始化检查已发布版本
 
@@ -120,6 +121,7 @@ feishu:
   appId: "${FEISHU_APP_ID}"
   appSecret: "${FEISHU_APP_SECRET}"
   userOpenId: "${FEISHU_USER_OPEN_ID}"
+  respondToAllGroupMessages: true
 
 console:
   enabled: true
@@ -144,6 +146,8 @@ logging:
   path: "./logs/agent-bot.log"
 ```
 
+`feishu.respondToAllGroupMessages` 默认为 `true`。设为 `false` 后，未 @ 当前机器人的群消息会被忽略；Worker 启动时会解析机器人的 Open ID，因此 @ 其他成员不会误触发。私聊始终正常处理。无论该运行时配置如何，初始化都会申请接收全部群消息的权限，之后切换配置无需再次授权。
+
 `agent-bot server start` 要求同时配置飞书 `appId` 和 `appSecret`。Worker 启动 SDK 长连接时不读取 SDK 日志或私有连接状态，随后通过发送启动状态卡片检查出站能力。每张启动卡片都会显示从已安装包元数据读取的 Agent Bot 版本。通知通常发往已知私聊和最近活跃的群聊；数据库里尚无已知会话时，改用 `feishu.userOpenId`，按 `open_id` 私聊发送。存在通知目标时，至少一张卡片发送成功后 Server 才报告就绪，单个目标发送失败仍相互隔离。如果既没有已知会话，也没有 `feishu.userOpenId`，启动会跳过出站检查并继续。缺少凭据时仍会启动失败并提示先初始化。`agent-bot console` 是明确的纯本地入口，不需要飞书凭据。
 
 必须至少配置一个 Agent，`defaults.agent` 必须指向已配置的 Agent。

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@keyou007/agent-bot",
-      "version": "0.1.7",
+      "version": "0.1.8",
       "license": "GPL-3.0-only",
       "dependencies": {
         "@agentclientprotocol/sdk": "1.2.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "type": "module",
   "description": "Using Codex in Lark/Feishu feels just like using native Codex.",
   "license": "GPL-3.0-only",

package/skills/agent-bot/SKILL.md

@@ -48,6 +48,10 @@ agent-bot init
 
 Initialization creates the Agent Bot home, `config.yaml`, `.env`, `data/`, and `logs/` from the bundled examples. If Feishu credentials are absent, it starts Feishu one-click app registration, prints a QR code followed by its authorization URL, waits for the user to approve the request, and stores the returned app ID and secret in `.env`. It then audits the app's currently published tenant permissions, event subscriptions, and callbacks. Core and optional missing items produce separate incremental-configuration URLs. Core configuration is always polled until ready. For optional configuration, the CLI prints the QR code followed by the authorization URL and immediately waits up to five minutes for activation. The only terminal choice is `Y`, which skips optional authorization and continues initialization.
 
+Core messaging configuration includes `im:message.group_msg:readonly`, not merely the narrower group-mention scope. Agent Bot groups accept ordinary messages without requiring users to @ the bot, so initialization must keep waiting until all-user group-message delivery is active.
+
+Initialization always requests all-user group-message delivery. The runtime option `feishu.respondToAllGroupMessages` controls whether Agent Bot uses it: the default `true` responds to ordinary group messages, while `false` requires a mention of the current bot. Private messages are unaffected.
+
 After Feishu initialization succeeds, `init` releases its initialization lock and automatically starts the selected profile's server, waiting until it is ready. It does not create another supervisor when that profile is already running. `init --skip-feishu` is the exception: it prepares Console-only files and does not start the server. With `--json`, inspect `server.status` for `started`, `already-running`, or `skipped`.
 
 When running `init` on the user's behalf, relay every exact authorization or incremental-configuration URL and let the user complete it in their own browser. Optional polling starts automatically after the link is shown. Do not enter `Y` unless the user explicitly asks to skip optional authorization; there is no separate accept action. Optional capabilities such as group creation, group-title synchronization, reactions, images, and card actions never block initialization when skipped, timed out, or still unavailable; relay the final affected-feature warnings. In a non-interactive terminal, optional polling continues until activation or timeout because skip input is unavailable. Neither URL contains the app secret, and the secret itself is never printed.
@@ -151,7 +155,7 @@ Keep action labels placed to the right of card content or at the bottom of a car
 
 Messages whose trimmed text starts with `/` are always parsed as Agent Bot commands. Unknown slash commands are reported to the user with a `/help` hint and must never fall through to the model, including slash-prefixed messages that also contain images.
 
-When a group body has a current task, renaming the Feishu group to `[agent-name] new title` also renames that current task if the prefix matches the task's configured agent. Malformed names, agent mismatches, empty groups, and thread-specific tasks are ignored.
+When a group body has a current task, renaming the Feishu group to `[agent-name] [project directory] new title` also renames that current task if the Agent prefix matches the task's configured agent. Only `new title` is written to the task; the Agent and project-directory prefixes remain group metadata. The older `[agent-name] new title` shape remains supported. Malformed names, agent mismatches, empty groups, and thread-specific tasks are ignored.
 
 Use `--context <key>` or `--status <status>` to narrow `task list`. Use `--profile <directory>` before the command when controlling an isolated Agent Bot instance, or `--config <path>` for only a non-default configuration.
 

package/src/cli/FeishuAppConfiguration.ts

@@ -28,11 +28,8 @@ const REQUIRED_SCOPE_REQUIREMENTS: ScopeRequirement[] = [
     accepted: ["im:chat:read", "im:chat:readonly", "im:chat"],
   },
   {
-    requested: "im:message.group_at_msg:readonly",
+    requested: "im:message.group_msg:readonly",
     accepted: [
-      "im:message.group_at_msg:readonly",
-      "im:message.group_at_msg.include_bot:readonly",
-      "im:message.group_at_msg",
       "im:message.group_msg:readonly",
       "im:message.group_msg",
     ],
@@ -69,7 +66,7 @@ export const REQUIRED_FEISHU_CALLBACKS = ["card.action.trigger"] as const;
 
 const CORE_FEISHU_SCOPES = new Set([
   "application:application:self_manage",
-  "im:message.group_at_msg:readonly",
+  "im:message.group_msg:readonly",
   "im:message.p2p_msg:readonly",
   "im:message:send_as_bot",
 ]);

package/src/codex/CodexEventMapper.ts

@@ -201,6 +201,19 @@ function mapTool(
       completedAt,
     };
   }
+  if (type === "imageGeneration") {
+    const imagePath = nonEmptyString(item.savedPath);
+    return {
+      id,
+      title: "生成图片",
+      kind: "image_generation",
+      status,
+      command: nonEmptyString(item.revisedPrompt),
+      imagePath,
+      startedAt,
+      completedAt,
+    };
+  }
   return undefined;
 }
 

package/src/codex/CodexRuntime.ts

@@ -17,6 +17,7 @@ import type {
   RuntimeSession,
   RuntimeSessionMetadata,
 } from "../runtime/types.js";
+import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import { mapCodexNotification } from "./CodexEventMapper.js";
 import { CodexLocalActivityDetector } from "./CodexLocalActivityDetector.js";
@@ -59,6 +60,7 @@ interface CodexSession extends RuntimeSession {
   activeTurnStartedAt?: number;
   terminalTurnIds: Set<string>;
   finalText: string;
+  generatedImagePaths: string[];
   messagePhases: Map<string, "commentary" | "final_answer">;
   needsResume: boolean;
 }
@@ -548,6 +550,14 @@ export class CodexRuntime implements AgentRuntime {
     } else if (mapped.kind === "plan") {
       this.emit({ type: "plan_updated", sessionId, turnId: mapped.turnId, steps: mapped.steps });
     } else if (mapped.kind === "tool") {
+      if (
+        mapped.phase === "updated"
+        && mapped.tool.kind === "image_generation"
+        && mapped.tool.status === "completed"
+        && mapped.tool.imagePath
+      ) {
+        session.generatedImagePaths = uniqueStrings([...session.generatedImagePaths, mapped.tool.imagePath]);
+      }
       this.emit({
         type: mapped.phase === "started" ? "tool_started" : "tool_updated",
         sessionId,
@@ -572,14 +582,16 @@ export class CodexRuntime implements AgentRuntime {
       } else if (mapped.status === "failed") {
         this.emit({ type: "turn_failed", sessionId, turnId: mapped.turnId, message: mapped.error ?? "Codex turn failed." });
       } else {
+        const finalResponse = appendGeneratedImageMarkdown(session.finalText, session.generatedImagePaths);
         this.emit({
           type: "turn_completed",
           sessionId,
           turnId: mapped.turnId,
-          finalResponse: session.finalText,
+          finalResponse,
           durationMs: mapped.durationMs,
         });
       }
+      session.generatedImagePaths = [];
     }
   }
 
@@ -693,6 +705,7 @@ export class CodexRuntime implements AgentRuntime {
     session.activeTurnId = turnId;
     session.activeTurnStartedAt = startedAt;
     session.finalText = "";
+    session.generatedImagePaths = [];
     session.messagePhases.clear();
     this.emit({ type: "turn_started", sessionId: session.localSessionId, turnId, startedAt });
   }
@@ -726,8 +739,16 @@ export class CodexRuntime implements AgentRuntime {
       });
       return;
     }
-    const finalResponse = extractFinalResponse(turn) || session.finalText;
+    const generatedImagePaths = uniqueStrings([
+      ...session.generatedImagePaths,
+      ...extractGeneratedImagePaths(turn),
+    ]);
+    const finalResponse = appendGeneratedImageMarkdown(
+      extractFinalResponse(turn) || session.finalText,
+      generatedImagePaths,
+    );
     session.finalText = finalResponse;
+    session.generatedImagePaths = [];
     this.emit({
       type: "turn_completed",
       sessionId: session.localSessionId,
@@ -765,6 +786,7 @@ export class CodexRuntime implements AgentRuntime {
           : [],
       ),
       finalText: "",
+      generatedImagePaths: [],
       messagePhases: new Map(),
       needsResume: false,
     };
@@ -796,6 +818,7 @@ export class CodexRuntime implements AgentRuntime {
       if (!turnId) continue;
       session.activeTurnId = undefined;
       session.activeTurnStartedAt = undefined;
+      session.generatedImagePaths = [];
       this.emit({
         type: "turn_failed",
         sessionId: session.localSessionId,
@@ -841,7 +864,13 @@ interface CodexThreadSnapshot {
 interface CodexTurnSnapshot {
   id: string;
   status: "completed" | "interrupted" | "failed" | "inProgress";
-  items?: Array<{ type?: string; text?: string; phase?: string | null; status?: string }>;
+  items?: Array<{
+    type?: string;
+    text?: string;
+    phase?: string | null;
+    status?: string;
+    savedPath?: string;
+  }>;
   error?: { message?: string } | null;
   startedAt?: number | null;
   durationMs?: number | null;
@@ -893,6 +922,17 @@ function extractFinalResponse(turn: CodexTurnSnapshot): string {
     .join("\n\n");
 }
 
+function extractGeneratedImagePaths(turn: CodexTurnSnapshot): string[] {
+  return uniqueStrings((turn.items ?? []).flatMap((item) => {
+    const savedPath = stringValue(item.savedPath)?.trim();
+    return item.type === "imageGeneration" && item.status !== "failed" && savedPath ? [savedPath] : [];
+  }));
+}
+
+function uniqueStrings(values: string[]): string[] {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+
 function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary {
   const lastTurn = thread.turns?.at(-1);
   const lastCompletedTurn = [...(thread.turns ?? [])]
@@ -923,7 +963,9 @@ function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary
     lastCompletedTurnId: lastCompletedTurn?.id,
     lastTurnStatus,
     lastActivity: lastText,
-    finalResponse: lastTurn && lastTurn.status !== "inProgress" ? extractFinalResponse(lastTurn) || undefined : undefined,
+    finalResponse: lastTurn && lastTurn.status !== "inProgress"
+      ? appendGeneratedImageMarkdown(extractFinalResponse(lastTurn), extractGeneratedImagePaths(lastTurn)) || undefined
+      : undefined,
     lastError: lastTurn?.error?.message,
     lastTurnToolCount: toolCounts?.total,
     lastTurnCompletedToolCount: toolCounts?.completed,
@@ -956,7 +998,8 @@ function isToolItemType(type: string | undefined): boolean {
     || type === "mcpToolCall"
     || type === "dynamicToolCall"
     || type === "webSearch"
-    || type === "imageView";
+    || type === "imageView"
+    || type === "imageGeneration";
 }
 
 function mergeRemoteSessionSummary(

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;
+}