@ynhcj/xiaoyi-channel 0.0.39-beta → 0.0.41-beta

package/dist/src/bot.js

@@ -1,11 +1,11 @@
 import { getXYRuntime } from "./runtime.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
 import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId } from "./parser.js";
-import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse } from "./formatter.js";
 import { registerSession, unregisterSession, runWithSessionContext } from "./tools/session-manager.js";
 import { configManager } from "./utils/config-manager.js";
+import { addPushId } from "./utils/pushid-manager.js";
 import { registerTaskId, decrementTaskIdRef, lockTaskId, unlockTaskId, hasActiveTask, } from "./task-manager.js";
 /**
  * Handle an incoming A2A message.
@@ -81,6 +81,10 @@ export async function handleXYMessage(params) {
             log(`[BOT]   - Push ID preview: ${pushId.substring(0, 20)}...`);
             log(`[BOT]   - Full push_id: ${pushId}`);
             configManager.updatePushId(parsed.sessionId, pushId);
+            // 持久化 pushId 到本地文件（异步，不阻塞主流程）
+            addPushId(pushId).catch((err) => {
+                error(`[BOT] Failed to persist pushId:`, err);
+            });
         }
         else {
             log(`[BOT] ℹ️  No push_id found in message, will use config default`);
@@ -129,10 +133,9 @@ export async function handleXYMessage(params) {
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
         const fileParts = extractFileParts(parsed.parts);
-        // Download files if present (using core's media download)
-        const mediaList = await downloadFilesFromParts(fileParts);
-        // Build media payload for inbound context (following feishu pattern)
-        const mediaPayload = buildXYMediaPayload(mediaList);
+        // Build media payload directly from file URIs (openclaw can download them)
+        // No need to download files locally - pass URIs directly to openclaw
+        const mediaPayload = buildXYMediaPayload(fileParts);
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // Build message body with speaker prefix (following feishu pattern)
@@ -276,17 +279,18 @@ export async function handleXYMessage(params) {
 /**
  * Build media payload for inbound context.
  * Following feishu pattern: buildFeishuMediaPayload().
+ * Uses remote URIs directly - openclaw will download them.
  */
-function buildXYMediaPayload(mediaList) {
-    const first = mediaList[0];
-    const mediaPaths = mediaList.map((media) => media.path);
-    const mediaTypes = mediaList.map((media) => media.mimeType).filter(Boolean);
+function buildXYMediaPayload(fileParts) {
+    const first = fileParts[0];
+    const uris = fileParts.map((file) => file.uri);
+    const mediaTypes = fileParts.map((file) => file.mimeType).filter(Boolean);
     return {
-        MediaPath: first?.path,
+        MediaPath: first?.uri,
         MediaType: first?.mimeType,
-        MediaUrl: first?.path,
-        MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
-        MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrl: first?.uri,
+        MediaPaths: uris.length > 0 ? uris : undefined,
+        MediaUrls: uris.length > 0 ? uris : undefined,
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }

package/dist/src/channel.js

@@ -21,6 +21,8 @@ import { searchAlarmTool } from "./tools/search-alarm-tool.js";
 import { modifyAlarmTool } from "./tools/modify-alarm-tool.js";
 import { deleteAlarmTool } from "./tools/delete-alarm-tool.js";
 import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
+import { xiaoyiCollectionTool } from "./tools/xiaoyi-collection-tool.js";
+import { viewPushResultTool } from "./tools/view-push-result-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -60,7 +62,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendFileToUserTool],
+    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendFileToUserTool, xiaoyiCollectionTool, viewPushResultTool],
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();
@@ -87,10 +89,9 @@ export const xyPlugin = {
             const account = resolveXYConfig(context.cfg);
             context.setStatus?.({
                 accountId: context.accountId,
-                wsUrl1: account.wsUrl1,
-                wsUrl2: account.wsUrl2,
+                wsUrl: account.wsUrl,
             });
-            context.log?.info(`[${context.accountId}] starting xiaoyi channel (wsUrl1: ${account.wsUrl1}, wsUrl2: ${account.wsUrl2})`);
+            context.log?.info(`[${context.accountId}] starting xiaoyi channel (wsUrl: ${account.wsUrl})`);
             return monitorXYProvider({
                 config: context.cfg,
                 runtime: context.runtime,

package/dist/src/client.js

@@ -89,29 +89,16 @@ export function diagnoseAllManagers() {
         console.log(`📌 Manager: ${key}`);
         console.log(`   Shutting down: ${diag.isShuttingDown}`);
         console.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
-        // Server 1
-        console.log(`   🔌 Server1:`);
-        console.log(`      - Exists: ${diag.server1.exists}`);
-        console.log(`      - ReadyState: ${diag.server1.readyState}`);
-        console.log(`      - State connected/ready: ${diag.server1.stateConnected}/${diag.server1.stateReady}`);
-        console.log(`      - Reconnect attempts: ${diag.server1.reconnectAttempts}`);
-        console.log(`      - Listeners on WebSocket: ${diag.server1.listenerCount}`);
-        console.log(`      - Heartbeat active: ${diag.server1.heartbeatActive}`);
-        console.log(`      - Has reconnect timer: ${diag.server1.hasReconnectTimer}`);
-        if (diag.server1.isOrphan) {
-            console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
-            orphanCount++;
-        }
-        // Server 2
-        console.log(`   🔌 Server2:`);
-        console.log(`      - Exists: ${diag.server2.exists}`);
-        console.log(`      - ReadyState: ${diag.server2.readyState}`);
-        console.log(`      - State connected/ready: ${diag.server2.stateConnected}/${diag.server2.stateReady}`);
-        console.log(`      - Reconnect attempts: ${diag.server2.reconnectAttempts}`);
-        console.log(`      - Listeners on WebSocket: ${diag.server2.listenerCount}`);
-        console.log(`      - Heartbeat active: ${diag.server2.heartbeatActive}`);
-        console.log(`      - Has reconnect timer: ${diag.server2.hasReconnectTimer}`);
-        if (diag.server2.isOrphan) {
+        // Connection
+        console.log(`   🔌 Connection:`);
+        console.log(`      - Exists: ${diag.connection.exists}`);
+        console.log(`      - ReadyState: ${diag.connection.readyState}`);
+        console.log(`      - State connected/ready: ${diag.connection.stateConnected}/${diag.connection.stateReady}`);
+        console.log(`      - Reconnect attempts: ${diag.connection.reconnectAttempts}`);
+        console.log(`      - Listeners on WebSocket: ${diag.connection.listenerCount}`);
+        console.log(`      - Heartbeat active: ${diag.connection.heartbeatActive}`);
+        console.log(`      - Has reconnect timer: ${diag.connection.hasReconnectTimer}`);
+        if (diag.connection.isOrphan) {
             console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
             orphanCount++;
         }
@@ -134,7 +121,7 @@ export function cleanupOrphanConnections() {
     let cleanedCount = 0;
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
-        if (diag.server1.isOrphan || diag.server2.isOrphan) {
+        if (diag.connection.isOrphan) {
             console.log(`🧹 Cleaning up orphan connections in manager: ${key}`);
             manager.disconnect();
             cleanedCount++;

package/dist/src/config.js

@@ -17,8 +17,8 @@ export function resolveXYConfig(cfg) {
     // Return configuration with defaults
     return {
         enabled: xyConfig.enabled ?? false,
-        wsUrl1: xyConfig.wsUrl1 ?? "ws://localhost:8765/ws/link",
-        wsUrl2: xyConfig.wsUrl2 ?? "ws://localhost:8768/ws/link",
+        // ✅ 兼容旧配置：优先使用 wsUrl，然后 wsUrl2（wsUrl1 被忽略）
+        wsUrl: xyConfig.wsUrl ?? xyConfig.wsUrl2 ?? "ws://localhost:8768/ws/link",
         apiKey: xyConfig.apiKey,
         uid: xyConfig.uid,
         agentId: xyConfig.agentId,

package/dist/src/monitor.js

@@ -3,6 +3,7 @@ import { getXYWebSocketManager, diagnoseAllManagers, cleanupOrphanConnections, r
 import { handleXYMessage } from "./bot.js";
 import { parseA2AMessage } from "./parser.js";
 import { hasActiveTask } from "./task-manager.js";
+import { handleTriggerEvent } from "./trigger-handler.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
  * in arrival order while allowing different sessions to run concurrently.
@@ -150,6 +151,15 @@ export async function monitorXYProvider(opts = {}) {
         const errorHandler = (err, serverId) => {
             error(`XY gateway: ${serverId} error: ${String(err)}`);
         };
+        const triggerEventHandler = (context) => {
+            log(`[MONITOR] 📌 Received trigger-event, dispatching to handler...`);
+            log(`[MONITOR]   - sessionId: ${context.sessionId}`);
+            log(`[MONITOR]   - taskId: ${context.taskId}`);
+            // 异步处理 Trigger 事件，不阻塞主流程
+            handleTriggerEvent(context, cfg, runtime, accountId).catch((err) => {
+                error(`[MONITOR] Failed to handle trigger-event:`, err);
+            });
+        };
         const cleanup = () => {
             log("XY gateway: cleaning up...");
             // 🔍 Diagnose before cleanup
@@ -166,6 +176,7 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.off("connected", connectedHandler);
             wsManager.off("disconnected", disconnectedHandler);
             wsManager.off("error", errorHandler);
+            wsManager.off("trigger-event", triggerEventHandler);
             // ✅ Disconnect the wsManager to prevent connection leaks
             // This is safe because each gateway lifecycle should have clean connections
             wsManager.disconnect();
@@ -195,6 +206,7 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("connected", connectedHandler);
         wsManager.on("disconnected", disconnectedHandler);
         wsManager.on("error", errorHandler);
+        wsManager.on("trigger-event", triggerEventHandler);
         // Start periodic health check (every 5 minutes)
         console.log("🏥 Starting periodic health check (every 5 minutes)...");
         healthCheckInterval = setInterval(() => {

package/dist/src/outbound.js

@@ -1,6 +1,9 @@
 import { resolveXYConfig } from "./config.js";
+import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { savePushData } from "./utils/pushdata-manager.js";
+import { getAllPushIds } from "./utils/pushid-manager.js";
 // Special marker for default push delivery when no target is specified
 const DEFAULT_PUSH_MARKER = "default";
 // File extension to MIME type mapping
@@ -104,19 +107,63 @@ export const xyOutbound = {
             // The push service will handle it based on config
             actualTo = config.defaultSessionId || "";
         }
+        // 1. 持久化推送消息内容，获取 pushDataId
+        console.log(`[xyOutbound.sendText] Saving push data to local storage...`);
+        let pushDataId;
+        try {
+            pushDataId = await savePushData(text);
+            console.log(`[xyOutbound.sendText] ✅ Push data saved with ID: ${pushDataId}`);
+        }
+        catch (error) {
+            console.error(`[xyOutbound.sendText] ❌ Failed to save push data:`, error);
+            // 如果持久化失败，仍然继续发送（不阻塞主流程）
+            pushDataId = "";
+        }
+        // 2. 读取所有 pushId
+        console.log(`[xyOutbound.sendText] Loading all pushIds...`);
+        let pushIdList = [];
+        try {
+            pushIdList = await getAllPushIds();
+            console.log(`[xyOutbound.sendText] ✅ Loaded ${pushIdList.length} pushIds`);
+        }
+        catch (error) {
+            console.error(`[xyOutbound.sendText] ❌ Failed to load pushIds:`, error);
+        }
+        // 3. 如果 pushIdList 为空，回退到原有逻辑（使用 config pushId）
+        if (pushIdList.length === 0) {
+            console.log(`[xyOutbound.sendText] ⚠️ No pushIds found, falling back to config pushId`);
+            pushIdList = [config.pushId];
+        }
         // Create push service
         const pushService = new XYPushService(config);
         // Extract title (first 57 chars or first line)
         const title = text.split("\n")[0].slice(0, 57);
         // Truncate push content to max length 1000
         const pushText = text.length > 1000 ? text.slice(0, 1000) : text;
-        // Send push message (content, title, data, sessionId)
-        await pushService.sendPush(pushText, title, undefined, actualTo);
+        // 4. 遍历所有 pushId，依次发送推送通知
+        console.log(`[xyOutbound.sendText] 📤 Broadcasting to ${pushIdList.length} pushId(s)...`);
+        let successCount = 0;
+        let failureCount = 0;
+        for (const pushId of pushIdList) {
+            try {
+                console.log(`[xyOutbound.sendText] Sending to pushId: ${pushId.substring(0, 20)}...`);
+                // 传入 pushDataId，使用 kind="data" 格式
+                await pushService.sendPush(pushText, title, undefined, actualTo, pushDataId);
+                successCount++;
+                console.log(`[xyOutbound.sendText] ✅ Sent successfully to pushId: ${pushId.substring(0, 20)}...`);
+            }
+            catch (error) {
+                failureCount++;
+                console.error(`[xyOutbound.sendText] ❌ Failed to send to pushId: ${pushId.substring(0, 20)}...`, error);
+                // 单个 pushId 发送失败不影响其他，继续处理下一个
+            }
+        }
+        console.log(`[xyOutbound.sendText] 📊 Broadcast summary: ${successCount} success, ${failureCount} failures`);
         console.log(`[xyOutbound.sendText] Completed successfully`);
         // Return message info
         return {
             channel: "xiaoyi-channel",
-            messageId: Date.now().toString(),
+            messageId: pushDataId || Date.now().toString(),
             chatId: actualTo,
         };
     },
@@ -129,94 +176,81 @@ export const xyOutbound = {
             mediaUrl,
             mediaLocalRoots,
         });
-        // All sendMedia processing logic has been disabled
-        // Use send_file_to_user tool instead for file transfers to user device
-        console.log(`[xyOutbound.sendMedia] Processing disabled, use send_file_to_user tool`);
-        // Return empty message info
+        // Parse to: "sessionId::taskId"
+        const parts = to.split("::");
+        if (parts.length !== 2) {
+            throw new Error(`Invalid to format: "${to}". Expected "sessionId::taskId"`);
+        }
+        const [sessionId, taskId] = parts;
+        // Resolve configuration
+        const config = resolveXYConfig(cfg);
+        // Create upload service
+        const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+        // Validate mediaUrl
+        if (!mediaUrl) {
+            throw new Error("mediaUrl is required for sendMedia");
+        }
+        // Upload file
+        const fileId = await uploadService.uploadFile(mediaUrl);
+        // Check if fileId is empty
+        if (!fileId) {
+            console.log(`[xyOutbound.sendMedia] ⚠️ File upload failed: fileId is empty, aborting sendMedia`);
+            return {
+                channel: "xiaoyi-channel",
+                messageId: "",
+                chatId: to,
+            };
+        }
+        console.log(`[xyOutbound.sendMedia] File uploaded:`, {
+            fileId,
+            sessionId,
+            taskId,
+        });
+        // Get filename and mime type from mediaUrl
+        // mediaUrl may be a local file path or URL
+        const fileName = mediaUrl.split("/").pop() || "unknown";
+        const mimeType = getMimeTypeFromFilename(fileName);
+        // Build agent_response message
+        const agentResponse = {
+            msgType: "agent_response",
+            agentId: config.agentId,
+            sessionId: sessionId,
+            taskId: taskId,
+            msgDetail: JSON.stringify({
+                jsonrpc: "2.0",
+                id: taskId,
+                result: {
+                    kind: "artifact-update",
+                    append: true,
+                    lastChunk: false,
+                    final: false,
+                    artifact: {
+                        artifactId: taskId,
+                        parts: [
+                            {
+                                kind: "file",
+                                file: {
+                                    name: fileName,
+                                    mimeType: mimeType,
+                                    fileId: fileId,
+                                },
+                            },
+                        ],
+                    },
+                },
+                error: { code: 0 },
+            }),
+        };
+        // Get WebSocket manager and send message
+        const { getXYWebSocketManager } = await import("./client.js");
+        const wsManager = getXYWebSocketManager(config);
+        await wsManager.sendMessage(sessionId, agentResponse);
+        console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
+        // Return message info
         return {
             channel: "xiaoyi-channel",
-            messageId: "把文件/图片发送给用户请使用send_file_to_user工具",
+            messageId: fileId,
             chatId: to,
         };
-        // // Parse to: "sessionId::taskId"
-        // const parts = to.split("::");
-        // if (parts.length !== 2) {
-        //   throw new Error(`Invalid to format: "${to}". Expected "sessionId::taskId"`);
-        // }
-        // const [sessionId, taskId] = parts;
-        // // Resolve configuration
-        // const config = resolveXYConfig(cfg);
-        // // Create upload service
-        // const uploadService = new XYFileUploadService(
-        //   config.fileUploadUrl,
-        //   config.apiKey,
-        //   config.uid
-        // );
-        // // Validate mediaUrl
-        // if (!mediaUrl) {
-        //   throw new Error("mediaUrl is required for sendMedia");
-        // }
-        // // Upload file
-        // const fileId = await uploadService.uploadFile(mediaUrl);
-        // // Check if fileId is empty
-        // if (!fileId) {
-        //   console.log(`[xyOutbound.sendMedia] ⚠️ File upload failed: fileId is empty, aborting sendMedia`);
-        //   return {
-        //     channel: "xiaoyi-channel",
-        //     messageId: "",
-        //     chatId: to,
-        //   };
-        // }
-        // console.log(`[xyOutbound.sendMedia] File uploaded:`, {
-        //   fileId,
-        //   sessionId,
-        //   taskId,
-        // });
-        // // Get filename and mime type from mediaUrl
-        // // mediaUrl may be a local file path or URL
-        // const fileName = mediaUrl.split("/").pop() || "unknown";
-        // const mimeType = getMimeTypeFromFilename(fileName);
-        // // Build agent_response message
-        // const agentResponse: OutboundWebSocketMessage = {
-        //   msgType: "agent_response",
-        //   agentId: config.agentId,
-        //   sessionId: sessionId,
-        //   taskId: taskId,
-        //   msgDetail: JSON.stringify({
-        //     jsonrpc: "2.0",
-        //     id: taskId,
-        //     result: {
-        //       kind: "artifact-update",
-        //       append: true,
-        //       lastChunk: false,
-        //       final: false,
-        //       artifact: {
-        //         artifactId: taskId,
-        //         parts: [
-        //           {
-        //             kind: "file",
-        //             file: {
-        //               name: fileName,
-        //               mimeType: mimeType,
-        //               fileId: fileId,
-        //             },
-        //           },
-        //         ],
-        //       },
-        //     },
-        //     error: { code: 0 },
-        //   }),
-        // };
-        // // Get WebSocket manager and send message
-        // const { getXYWebSocketManager } = await import("./client.js");
-        // const wsManager = getXYWebSocketManager(config);
-        // await wsManager.sendMessage(sessionId, agentResponse);
-        // console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
-        // // Return message info
-        // return {
-        //   channel: "xiaoyi-channel",
-        //   messageId: fileId,
-        //   chatId: to,
-        // };
     },
 };

package/dist/src/push.d.ts

@@ -14,8 +14,14 @@ export declare class XYPushService {
     private generateTraceId;
     /**
      * Send a push message to a user session.
+     *
+     * @param content - Push message content
+     * @param title - Push message title
+     * @param data - Optional additional data
+     * @param sessionId - Optional session ID
+     * @param pushDataId - Optional pushDataId for kind="data" format
      */
-    sendPush(content: string, title: string, data?: Record<string, any>, sessionId?: string): Promise<void>;
+    sendPush(content: string, title: string, data?: Record<string, any>, sessionId?: string, pushDataId?: string): Promise<void>;
     /**
      * Send a push message with file attachments.
      */

package/dist/src/push.js

@@ -21,8 +21,14 @@ export class XYPushService {
     }
     /**
      * Send a push message to a user session.
+     *
+     * @param content - Push message content
+     * @param title - Push message title
+     * @param data - Optional additional data
+     * @param sessionId - Optional session ID
+     * @param pushDataId - Optional pushDataId for kind="data" format
      */
-    async sendPush(content, title, data, sessionId) {
+    async sendPush(content, title, data, sessionId, pushDataId) {
         const pushUrl = this.config.pushUrl || this.DEFAULT_PUSH_URL;
         const traceId = this.generateTraceId();
         // Get dynamic pushId for the session (falls back to config pushId)
@@ -57,12 +63,21 @@ export class XYPushService {
                     artifacts: [
                         {
                             artifactId: randomUUID(),
-                            parts: [
-                                {
-                                    kind: "text",
-                                    text: content,
-                                },
-                            ],
+                            parts: pushDataId
+                                ? [
+                                    {
+                                        kind: "data",
+                                        data: {
+                                            pushDataId: pushDataId,
+                                        },
+                                    },
+                                ]
+                                : [
+                                    {
+                                        kind: "text",
+                                        text: content,
+                                    },
+                                ],
                         },
                     ],
                 },

package/dist/src/tools/search-photo-gallery-tool.js

@@ -13,23 +13,51 @@ export const searchPhotoGalleryTool = {
     name: "search_photo_gallery",
     label: "Search Photo Gallery",
     description: `插件功能描述：搜索用户手机图库中的照片
+
   工具使用约束：如果用户说从手机图库中或者从相册中查询xx图片时调用此工具。
+
   工具输入输出简介：
   a. 根据图像描述语料检索匹配的照片,返回照片在手机本地的 mediaUri以及thumbnailUri。
   b. 返回的 mediaUri以及thumbnailUri 是本地路径,无法直接下载或访问。如果需要下载、查看、使用或展示照片,请使用 upload_photo 工具将 mediaUri或者thumbnailUri 转换为可访问的公网 URL。
   c. mediaUri代表手机相册中的图片原图路径，图片大小比较大，清晰度比较高
   d. thumbnailUri代表手机相册中的图片缩略图路径，图片大小比较小，清晰度适中，建议在upload_photo 工具的入参中优先使用此路径，不容易引起上传超时等问题
-  
+
+  搜索能力边界：
+  a. ✅ 支持口语化输入：改写模型会自动提取姓名、种类、地点等实体，可以使用自然语言描述（如"小狗的照片"、"南京拍的风景"）
+  b. ✅ 支持相册搜索：可以在query中包含相册名称（如"西安之行相册的照片"）
+  c. ✅ 支持人像搜索：前提是照片有人像tag，且需要口语化描述（如"张三的照片"）
+  d. ❌ 不支持时间相对词：不支持"最新"、"最旧"、"最早"等表述，需要使用具体时间（如"2024年的照片"而非"去年的照片"）
+  e. ❌ 不支持多实体查询：不支持"或"逻辑和时间范围（如"南京或上海的照片"、"近三年的照片"），需要拆分成多次独立查询
+  f. ❌ 不支持POI逆地理映射：照片的location是门牌号，用真实场地名称可能搜不到
+  g. ❌ 不支持收藏感知：无法感知照片是否被收藏
+  h. ❌ 不支持细粒度品种：对于动物、植物等的具体品种识别能力有限
+  i. ⚠️  POI提取可能不准确：地名可能作为语义搜索条件，可能导致"xx湖"搜到"yy江"或"zz湾"的照片
+
+  查询优化建议：
+  a. 时间查询：将"最新"、"去年"、"近三年"等转换为具体年份（如"2024年"、"2023年到2025年"需拆分成"2023年"、"2024年"、"2025年"三次查询）
+  b. 多条件查询：将"或"逻辑拆分成多次查询（如"南京或上海的照片"→先查"南京的照片"，再查"上海的照片"）
+  c. 实体原子化：确保每个query只包含一个原子实体（地点、人名、物品等）
+  d. 相册名称：如果知道相册名，直接在query中包含相册名可以提高准确度
+
   注意事项：
   a. 只有当用户明确表达从手机相册搜索或者从图库搜索时才执行此工具，如果用户仅表达要搜索xxx图片，并没有说明搜索数据源，则不要贸然调用此插件，可以优先尝试websearch或者询问用户是否要从手机图库中搜索。
   b. 操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。
+  c. 如果用户请求包含多个实体或时间范围，需要主动拆分成多次查询并告知用户。
   `,
     parameters: {
         type: "object",
         properties: {
             query: {
                 type: "string",
-                description: "图像描述语料，用于检索匹配的照片（例如：'小狗的照片'、'带有键盘的图片'等）",
+                description: `图像描述语料，用于检索匹配的照片。支持口语化输入，会自动提取姓名、种类、地点等实体。
+
+使用示例：
+- 正确："小狗的照片"、"南京拍的风景"、"张三的照片"、"西安之行相册的照片"、"2024年的照片"
+- 错误："最新的照片"（应改为具体年份如"2024年的照片"）
+- 错误："南京或上海的照片"（需拆分成两次查询："南京的照片" 和 "上海的照片"）
+- 错误："近三年的照片"（需拆分成"2023年的照片"、"2024年的照片"、"2025年的照片"）
+
+重要：每次查询只能包含一个原子实体（单个地点、单个人名、单个年份等），不支持多实体或"或"逻辑。`,
             },
         },
         required: ["query"],

package/dist/src/tools/view-push-result-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 查看推送任务执行结果工具
+ * 支持关键词搜索或查看最近的推送记录
+ */
+export declare const viewPushResultTool: any;