@ynhcj/xiaoyi-channel 0.0.128-beta → 0.0.130-beta

package/dist/src/formatter.js

@@ -2,6 +2,7 @@
 import { v4 as uuidv4 } from "uuid";
 import { getXYWebSocketManager } from "./client.js";
 import { logger } from "./utils/logger.js";
+import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 /**
  * Send an A2A artifact update response.
  */
@@ -111,9 +112,13 @@ export async function sendReasoningTextUpdate(params) {
 export async function sendStatusUpdate(params) {
     const { config, sessionId, taskId, messageId, text, state, runtime } = params;
     const log = runtime?.log ?? console.log;
+    // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
+    // fall back to closure-captured values
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
     // Build status update event following A2A protocol standard
     const statusUpdate = {
-        taskId,
+        taskId: currentTaskId,
         kind: "status-update",
         final: false, // Status updates should not end the stream
         status: {
@@ -132,7 +137,7 @@ export async function sendStatusUpdate(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: messageId,
+        id: currentMessageId,
         result: statusUpdate,
     };
     // Send via WebSocket
@@ -141,12 +146,12 @@ export async function sendStatusUpdate(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId,
+        taskId: currentTaskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
     log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
-    log(`[A2A_STATUS]   - taskId: ${taskId}`);
+    log(`[A2A_STATUS]   - taskId: ${currentTaskId}`);
     log(`[A2A_STATUS]   - text: "${text}"`);
     await wsManager.sendMessage(sessionId, outboundMessage);
 }
@@ -155,10 +160,14 @@ export async function sendStatusUpdate(params) {
  */
 export async function sendCommand(params) {
     const { config, sessionId, taskId, messageId, command } = params;
+    // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
+    // fall back to closure-captured values
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
     // Build artifact update with command as data
     // Wrap command in commands array as per protocol requirement
     const artifact = {
-        taskId,
+        taskId: currentTaskId,
         kind: "artifact-update",
         append: false,
         lastChunk: true,
@@ -178,7 +187,7 @@ export async function sendCommand(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: messageId,
+        id: currentMessageId,
         result: artifact,
     };
     // Send via WebSocket
@@ -187,11 +196,11 @@ export async function sendCommand(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId,
+        taskId: currentTaskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
-    logger.log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${taskId}`);
+    logger.log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${currentTaskId}`);
     await wsManager.sendMessage(sessionId, outboundMessage);
     logger.log(`[A2A_COMMAND] ✅ Command sent successfully`);
 }

package/dist/src/provider.js

@@ -463,10 +463,18 @@ export const xiaoyiProvider = {
                     }
                 }
                 else {
-                    // Session mode: use pre-resolved session headers + fresh timestamp
+                    // Session mode: get session context at request time via ALS.
+                    // OpenClaw caches prepareExtraParams by provider/modelId, so
+                    // ctx.extraParams holds the first session's values. We must
+                    // call getCurrentSessionContext() here to get the correct
+                    // sessionId/interactionId for the current concurrent request.
+                    const sessionCtx = getCurrentSessionContext();
                     const traceId = ctx.extraParams[HEADER_TRACE_ID];
-                    const sessionId = ctx.extraParams[HEADER_SESSION_ID];
-                    const interactionId = ctx.extraParams[HEADER_INTERACTION_ID];
+                    const sessionId = sessionCtx?.taskId?.split("&")[0]
+                        ?? ctx.extraParams[HEADER_SESSION_ID];
+                    const interactionId = sessionCtx?.taskId?.split("&")[1]
+                        ?? ctx.extraParams[HEADER_INTERACTION_ID]
+                        ?? "";
                     if (typeof traceId === "string") {
                         const isCron = isCronTriggered(context.messages);
                         dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${traceId}_${Date.now()}` : traceId;

package/dist/src/tools/image-reading-tool.d.ts

@@ -1,6 +1,6 @@
 import type { SessionContext } from "./session-manager.js";
 /**
  * XY Image Reading tool - performs image understanding using local or remote image URLs.
- * Supports both local file paths and remote URLs.
+ * Supports both local file paths and remote URLs, up to 10 images at once.
  */
 export declare function createImageReadingTool(ctx: SessionContext): any;

package/dist/src/tools/image-reading-tool.js

@@ -2,7 +2,6 @@
 import { XYFileUploadService } from "../file-upload.js";
 import fetch from "node-fetch";
 import fs from "fs/promises";
-import path from "path";
 import { v4 as uuidv4 } from "uuid";
 /**
  * Check if value is a remote URL
@@ -29,64 +28,29 @@ async function isLocalFile(value) {
     }
 }
 /**
- * Download remote file to local temp directory
- */
-async function downloadRemoteFile(url) {
-    try {
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        // Get filename from URL or use default
-        let filename = url.split("/").pop() || "downloaded_image";
-        filename = filename.split("?")[0];
-        // Ensure temp directory exists
-        const tempDir = "/tmp/xy_channel";
-        await fs.mkdir(tempDir, { recursive: true });
-        // Generate unique filename to avoid conflicts
-        const timestamp = Date.now();
-        const ext = path.extname(filename) || ".jpg";
-        const baseName = path.basename(filename, ext);
-        const uniqueFilename = `${baseName}_${timestamp}${ext}`;
-        const localPath = path.join(tempDir, uniqueFilename);
-        // Save file to local temp directory
-        const arrayBuffer = await response.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
-        await fs.writeFile(localPath, buffer);
-        return localPath;
-    }
-    catch (error) {
-        throw new Error(`Failed to download remote file: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Process image input: validate and convert local file to OBS URL, keep remote URL unchanged
+ * Process image input: remote URL passed directly, local file uploaded to OBS
  */
 async function processImageInput(imageInput, uploadService) {
-    // Check if it's a remote URL
+    // Remote URL: pass directly
     if (isRemoteUrl(imageInput)) {
-        const localPath = await downloadRemoteFile(imageInput);
-        const imageUrl = await uploadService.uploadFileAndGetUrl(localPath, "TEMPORARY_MATERIAL_DOC");
-        if (!imageUrl) {
-            throw new Error("图片上传失败：无法获取图片访问地址");
-        }
-        return { imageUrl, localPath };
+        return imageInput;
     }
-    // Check if it's a local file
+    // Local file: upload to OBS
     const isLocal = await isLocalFile(imageInput);
     if (isLocal) {
         const imageUrl = await uploadService.uploadFileAndGetUrl(imageInput, "TEMPORARY_MATERIAL_DOC");
         if (!imageUrl) {
             throw new Error("图片上传失败：无法获取图片访问地址");
         }
-        return { imageUrl };
+        return imageUrl;
     }
     throw new Error(`Invalid image input: must be a remote URL or local file path, got: ${imageInput}`);
 }
 /**
  * Call image understanding API with streaming response
+ * Supports both single image and multiple images (imageUrls array)
  */
-async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid, fileUploadUrl) {
+async function callImageUnderstandingAPI(imageUrls, text, apiKey, uid, fileUploadUrl) {
     const apiUrl = `${fileUploadUrl}/celia-claw/v1/sse-api/skill/execute`;
     const traceId = uuidv4();
     const headers = {
@@ -128,7 +92,7 @@ async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid, fileUpload
                     pluginId: "aeac4e92c32949c1b7fc02de262615e6",
                     agentState: "OnShelf",
                     actionName: "imageUnderStandStream",
-                    content: { imageUrl, text },
+                    content: { imageUrls, text },
                 },
             },
         ],
@@ -198,85 +162,54 @@ async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid, fileUpload
 }
 /**
  * XY Image Reading tool - performs image understanding using local or remote image URLs.
- * Supports both local file paths and remote URLs.
+ * Supports both local file paths and remote URLs, up to 10 images at once.
  */
 export function createImageReadingTool(ctx) {
-    const { config, sessionId, taskId, messageId } = ctx;
+    const { config } = ctx;
     return {
         name: "image_reading",
         label: "Image Reading",
-        description: `
-工具使用场景：
-【必须调用此工具的情况】
-1. 用户消息中包含 mediaPath 字段且不为空（表示用户发送了图片）
-2. 用户希望理解图片内容，询问图片是什么，例如：
-   - "这是什么？"
-   - "图片里有什么？"
-   - "帮我看看这张图"
-   - "描述一下这张图片"
-   - "分析一下这张照片"
-   - "这个图片是什么意思"
-   - "识别一下图片内容"
-   - 或任何关于图片内容的理解、识别、分析类询问
-
-当同时满足以上两个条件时，必须优先调用此工具进行图像理解。
-
-工具能力描述：对图片进行理解和分析，返回图片的描述内容。
-
-工具参数说明：
-localUrl 与 remoteUrl 任意一个不为空即可，优先使用 localUrl
-
-注意事项：
-a. 支持常见图片格式（jpg, png, gif等）
-b. 远程图片会先下载到本地再处理
-c. 操作超时时间为2分钟（120秒）
-d. 返回图像理解的文本描述内容`,
+        description: `图片理解工具，支持单图/多图（最多10张），返回图片描述文本。调用条件：用户消息含 media 图片或询问图片内容时必须调用。`,
         parameters: {
             type: "object",
             properties: {
-                localUrl: {
-                    type: "string",
-                    description: "本地图片文件路径（可选，通常从用户消息的 mediaPath 字段获取）",
-                },
-                remoteUrl: {
-                    type: "string",
-                    description: "公网图片地址（可选）,公网图片地址（HTTP/HTTPS URL），注意不要对原始url做任何截断（例如裁减掉链接后面的鉴权信息或者修改域名后缀），必须使用上下文中完整的图片地址",
+                images: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "图片路径数组，支持本地路径或公网URL，最多10张",
                 },
                 prompt: {
                     type: "string",
-                    description: "对图片的提示问题，默认为'描述这张图片内容'，可根据用户的具体问题自定义",
+                    description: "提示词，默认'描述图片内容'。多图可用'对比这些图片'等",
                 },
             },
+            required: ["images"],
         },
         async execute(toolCallId, params) {
-            // Validate that at least one parameter is provided
-            if (!params.localUrl && !params.remoteUrl) {
-                throw new Error("At least one of localUrl or remoteUrl must be provided");
+            // Normalize images param
+            const images = params.images
+                ? (Array.isArray(params.images) ? params.images : [params.images])
+                : [];
+            // Validate that at least one image is provided
+            if (images.length === 0) {
+                throw new Error("images 参数不能为空");
+            }
+            // Validate max image count
+            if (images.length > 10) {
+                throw new Error("最多支持 10 张图片，当前提供了 " + images.length + " 张");
             }
-            // Get prompt (default to "描述这张图片内容")
-            const prompt = params.prompt || "描述这张图片内容";
+            // Get prompt (default to "描述这些图片内容")
+            const prompt = params.prompt || "描述这些图片内容";
             // Create upload service
             const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
-            let processedImage = null;
-            let downloadedFile = null;
+            // Process images: local files upload to OBS, remote URLs pass directly
+            const allImageUrls = [];
             try {
-                // Process image input (prefer localUrl over remoteUrl)
-                const imageInput = params.localUrl || params.remoteUrl;
-                processedImage = await processImageInput(imageInput, uploadService);
-                // Track downloaded file for cleanup
-                if (processedImage.localPath) {
-                    downloadedFile = processedImage.localPath;
-                }
-                // Call image understanding API
-                const caption = await callImageUnderstandingAPI(processedImage.imageUrl, prompt, config.apiKey, config.uid, config.fileUploadUrl);
-                // Clean up downloaded file if any
-                if (downloadedFile) {
-                    try {
-                        await fs.unlink(downloadedFile);
-                    }
-                    catch (error) {
-                    }
+                for (const imageInput of images) {
+                    allImageUrls.push(await processImageInput(imageInput, uploadService));
                 }
+                // Call image understanding API with all image URLs
+                const caption = await callImageUnderstandingAPI(allImageUrls, prompt, config.apiKey, config.uid, config.fileUploadUrl);
                 return {
                     content: [
                         {
@@ -284,7 +217,7 @@ d. 返回图像理解的文本描述内容`,
                             text: JSON.stringify({
                                 caption,
                                 prompt,
-                                imageSource: params.localUrl ? "local" : "remote",
+                                imageCount: allImageUrls.length,
                                 success: true,
                             }),
                         },
@@ -292,16 +225,7 @@ d. 返回图像理解的文本描述内容`,
                 };
             }
             catch (error) {
-                // Clean up downloaded file on error
-                if (downloadedFile) {
-                    try {
-                        await fs.unlink(downloadedFile);
-                    }
-                    catch (cleanupError) {
-                    }
-                }
                 const errorMessage = error instanceof Error ? error.message : "图片分析失败";
-                // Return error result instead of throwing
                 return {
                     content: [
                         {
@@ -309,7 +233,7 @@ d. 返回图像理解的文本描述内容`,
                             text: JSON.stringify({
                                 error: errorMessage,
                                 prompt,
-                                imageSource: params.localUrl ? "local" : "remote",
+                                imageCount: images.length,
                                 success: false,
                             }),
                         },

package/dist/src/tools/send-file-to-user-tool.js

@@ -1,6 +1,7 @@
 import { getXYWebSocketManager } from "../client.js";
 import { XYFileUploadService } from "../file-upload.js";
 import { logger } from "../utils/logger.js";
+import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
 import fetch from "node-fetch";
 import fs from "fs/promises";
 import path from "path";
@@ -122,6 +123,9 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
             },
         },
         async execute(toolCallId, params) {
+            // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt)
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+            const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
             // Set timeout for the entire operation (2 minutes)
             const TOOL_TIMEOUT = 120000; // 2 minutes in milliseconds
             let timeoutHandle = null;
@@ -211,17 +215,17 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                         msgType: "agent_response",
                         agentId: config.agentId,
                         sessionId: sessionId,
-                        taskId: taskId,
+                        taskId: currentTaskId,
                         msgDetail: JSON.stringify({
                             jsonrpc: "2.0",
-                            id: taskId,
+                            id: currentMessageId,
                             result: {
                                 kind: "artifact-update",
                                 append: true,
                                 lastChunk: false,
                                 final: false,
                                 artifact: {
-                                    artifactId: taskId,
+                                    artifactId: currentTaskId,
                                     parts: [
                                         {
                                             kind: "file",
@@ -237,7 +241,7 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                             error: { code: 0 },
                         }),
                     };
-                    logger.log(`[SEND-FILE-TO-USER] 🚀 EXEC sending: sessionId=${sessionId} taskId=${taskId} fileName=${fileName}`);
+                    logger.log(`[SEND-FILE-TO-USER] 🚀 EXEC sending: sessionId=${sessionId} taskId=${currentTaskId} fileName=${fileName}`);
                     // Send WebSocket message
                     await wsManager.sendMessage(sessionId, agentResponse);
                     logger.log(`send ${fileName} file to user success`);

package/dist/src/tools/xiaoyi-gui-tool.js

@@ -1,6 +1,7 @@
 // XiaoYi GUI tool implementation - simulates phone screen interactions
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
+import { getCurrentTaskId } from "../task-manager.js";
 /**
  * XiaoYi GUI tool - executes phone app interactions through GUI agent.
  * Simulates user interactions on phone screen (click, swipe, input, navigation, etc.)
@@ -38,6 +39,8 @@ export function createXiaoyiGuiTool(ctx) {
             required: ["query"],
         },
         async execute(toolCallId, params) {
+            // Dynamic lookup: use latest taskId from task-manager (handles steer/interrupt)
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
             // Validate parameters
             if (!params.query || typeof params.query !== "string") {
                 throw new Error("Missing or invalid required parameter: query must be a non-empty string");
@@ -53,7 +56,7 @@ export function createXiaoyiGuiTool(ctx) {
                 payload: {
                     query: params.query,
                     sessionId: sessionId,
-                    interactionId: taskId, // taskId corresponds to interactionId
+                    interactionId: currentTaskId, // taskId corresponds to interactionId; use dynamic lookup for steer safety
                 },
             };
             // Send command and wait for response (5 minute timeout)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.128-beta",
+  "version": "0.0.130-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",