@ynhcj/xiaoyi-channel 0.0.152-next → 0.0.153-next

package/dist/src/file-upload.d.ts

@@ -17,6 +17,11 @@ export declare class XYFileUploadService {
      * Uses completeAndQuery endpoint to get the file URL directly.
      */
     uploadFileAndGetUrl(filePath: string, objectType?: string): Promise<string>;
+    /**
+     * Upload a file and return a preview-able URL (needPreview=true).
+     * Same as uploadFileAndGetUrl but adds needPreview flag to get a directly viewable URL.
+     */
+    uploadFileAndGetPreviewUrl(filePath: string, objectType?: string): Promise<string>;
     /**
      * Upload multiple files and return their file IDs.
      */

package/dist/src/file-upload.js

@@ -235,6 +235,107 @@ export class XYFileUploadService {
             }
         }
     }
+    /**
+     * Upload a file and return a preview-able URL (needPreview=true).
+     * Same as uploadFileAndGetUrl but adds needPreview flag to get a directly viewable URL.
+     */
+    async uploadFileAndGetPreviewUrl(filePath, objectType = "TEMPORARY_MATERIAL_DOC") {
+        let localFilePath = filePath;
+        let isTempFile = false;
+        try {
+            // Handle remote URLs by downloading first
+            if (isRemoteUrl(filePath)) {
+                localFilePath = await downloadToTempFile(filePath);
+                isTempFile = true;
+            }
+            // Read file
+            const fileBuffer = await fs.readFile(localFilePath);
+            const fileName = path.basename(localFilePath);
+            const fileSha256 = calculateSHA256(fileBuffer);
+            const fileSize = fileBuffer.length;
+            // Phase 1: Prepare
+            logger.log(`[XY File Upload] Phase 1 (preview): Prepare upload for ${fileName}`);
+            const prepareResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/prepare`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-uid": this.uid,
+                    "x-api-key": this.apiKey,
+                    "x-request-from": "openclaw",
+                },
+                body: JSON.stringify({
+                    objectType,
+                    fileName,
+                    fileSha256,
+                    fileSize,
+                    fileOwnerInfo: {
+                        uid: this.uid,
+                        teamId: this.uid,
+                    },
+                    useEdge: false,
+                }),
+            });
+            if (!prepareResp.ok) {
+                throw new Error(`Prepare failed: HTTP ${prepareResp.status}`);
+            }
+            const prepareData = await prepareResp.json();
+            if (prepareData.code !== "0") {
+                throw new Error(`Prepare failed: ${prepareData.desc}`);
+            }
+            const { objectId, draftId, uploadInfos } = prepareData;
+            logger.log(`[XY File Upload] Prepare (preview) complete: objectId=${objectId}, draftId=${draftId}`);
+            // Phase 2: Upload
+            logger.log(`[XY File Upload] Phase 2 (preview): Upload file data`);
+            const uploadInfo = uploadInfos[0];
+            const uploadResp = await fetch(uploadInfo.url, {
+                method: uploadInfo.method,
+                headers: uploadInfo.headers,
+                body: fileBuffer,
+            });
+            if (!uploadResp.ok) {
+                throw new Error(`Upload failed: HTTP ${uploadResp.status}`);
+            }
+            logger.log(`[XY File Upload] Upload (preview) complete`);
+            // Phase 3: CompleteAndQuery with needPreview=true
+            logger.log(`[XY File Upload] Phase 3 (preview): CompleteAndQuery with needPreview=true`);
+            const completeResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/completeAndQuery`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-uid": this.uid,
+                    "x-api-key": this.apiKey,
+                    "x-request-from": "openclaw",
+                },
+                body: JSON.stringify({
+                    objectId,
+                    draftId,
+                    needPreview: true,
+                }),
+            });
+            if (!completeResp.ok) {
+                throw new Error(`CompleteAndQuery (preview) failed: HTTP ${completeResp.status}`);
+            }
+            const completeData = await completeResp.json();
+            const fileUrl = completeData?.fileDetailInfo?.url || "";
+            if (!fileUrl) {
+                throw new Error("No file URL returned from completeAndQuery (preview)");
+            }
+            logger.log(`[XY File Upload] File upload with preview URL successful`);
+            return fileUrl;
+        }
+        catch (error) {
+            logger.error(`[XY File Upload] File upload with preview URL failed for ${filePath}:`, error);
+            throw error;
+        }
+        finally {
+            if (isTempFile) {
+                try {
+                    await fs.unlink(localFilePath);
+                }
+                catch { }
+            }
+        }
+    }
     /**
      * Upload multiple files and return their file IDs.
      */

package/dist/src/formatter.d.ts

@@ -82,6 +82,35 @@ export interface SendCommandParams {
  * listening in the calling tool works unchanged.
  */
 export declare function sendCommand(params: SendCommandParams): Promise<void>;
+/**
+ * Parameters for sending a card (e.g., HTML H5 card).
+ */
+export interface SendCardParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    /** toolCallId from the tool's execute() — used for cron detection via hook-set Map. */
+    toolCallId?: string;
+    /** When true, the artifact-update is sent with final=true. Default: false. */
+    final?: boolean;
+    /** Array of card data objects to send. */
+    cardsInfo: CardDataObject[];
+}
+/**
+ * Card data object for sending display cards.
+ */
+export interface CardDataObject {
+    cardName: string;
+    cardData: Record<string, any>;
+    displayType: string;
+}
+/**
+ * Send a card (e.g., HTML H5 card) as an artifact update (final=false).
+ *
+ * Cron-aware: same routing logic as sendCommand.
+ */
+export declare function sendCard(params: SendCardParams): Promise<void>;
 /**
  * Parameters for sending a clearContext response.
  */

package/dist/src/formatter.js

@@ -272,6 +272,59 @@ export async function sendCommand(params) {
     await wsManager.sendMessage(sessionId, outboundMessage);
     log.log(`[A2A_COMMAND] Command sent successfully`);
 }
+/**
+ * Send a card (e.g., HTML H5 card) as an artifact update (final=false).
+ *
+ * Cron-aware: same routing logic as sendCommand.
+ */
+export async function sendCard(params) {
+    const { config, sessionId, taskId, messageId, toolCallId } = params;
+    // ── Cron mode: route through push channel ──────────────────────
+    if (sessionId.startsWith("cron-") || isCronToolCall(toolCallId)) {
+        throw new Error("sendCard does not support cron mode");
+    }
+    // ── Normal mode: WebSocket ─────────────────────────────────────
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+    const log = logger.withContext(sessionId, currentTaskId);
+    // Build artifact update with cardsInfo as data
+    const artifact = {
+        taskId: currentTaskId,
+        kind: "artifact-update",
+        append: false,
+        lastChunk: true,
+        final: params.final ?? false,
+        artifact: {
+            artifactId: uuidv4(),
+            parts: [
+                {
+                    kind: "data",
+                    data: {
+                        cardsInfo: params.cardsInfo,
+                    },
+                },
+            ],
+        },
+    };
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: currentMessageId,
+        result: artifact,
+    };
+    // Send via WebSocket
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId: currentTaskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    log.log(`[A2A_CARD] Sending card`);
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log.log(`[A2A_CARD] Card sent successfully`);
+}
 /**
  * Send a clearContext response.
  */

package/dist/src/parser.d.ts

@@ -52,8 +52,8 @@ export declare function extractPushId(parts: A2AMessagePart[]): string | null;
 export declare function extractDeviceType(parts: A2AMessagePart[]): string | null;
 /**
  * Extract modelName from message parts.
- * Looks for modelName in data parts under variables.systemVariables.modelName
- * (same level as push_id / device_type).
+ * Looks for modelName in data parts under variables.memoryVariables.modelName
+ * (same level as systemVariables).
  */
 export declare function extractModelName(parts: A2AMessagePart[]): string | null;
 /**

package/dist/src/parser.js

@@ -145,14 +145,14 @@ export function extractDeviceType(parts) {
 }
 /**
  * Extract modelName from message parts.
- * Looks for modelName in data parts under variables.systemVariables.modelName
- * (same level as push_id / device_type).
+ * Looks for modelName in data parts under variables.memoryVariables.modelName
+ * (same level as systemVariables).
  */
 export function extractModelName(parts) {
     for (const part of parts) {
         if (part.kind === "data" && part.data) {
-            const modelName = part.data.variables?.systemVariables?.modelName;
-            if (modelName && typeof modelName === "string") {
+            const modelName = part.data.variables?.memoryVariables?.modelName;
+            if (modelName && typeof modelName === "string" && modelName.trim() !== "" && modelName.toLowerCase() !== "none") {
                 return modelName;
             }
         }

package/dist/src/provider.js

@@ -589,7 +589,7 @@ export const xiaoyiProvider = {
             }
             // ── Override model.id if A2A message specified modelName ──
             const modelNameOverride = getCurrentSessionContext()?.modelName;
-            if (modelNameOverride) {
+            if (modelNameOverride && modelNameOverride.trim() !== "" && modelNameOverride.toLowerCase() !== "none") {
                 logger.log(`[xiaoyiprovider] overriding model.id: ${model.id} → ${modelNameOverride}`);
                 model = { ...model, id: modelNameOverride };
             }

package/dist/src/tools/create-all-tools.js

@@ -1,6 +1,7 @@
 import { createLocationTool } from "./location-tool.js";
 import { createXiaoyiGuiTool } from "./xiaoyi-gui-tool.js";
 import { createSendFileToUserTool } from "./send-file-to-user-tool.js";
+import { createSendHtmlCardTool } from "./send-html-card-tool.js";
 import { viewPushResultTool } from "./view-push-result-tool.js";
 import { createImageReadingTool } from "./image-reading-tool.js";
 import { timestampToUtc8Tool } from "./timestamp-to-utc8-tool.js";
@@ -48,6 +49,7 @@ export function createAllTools(ctx) {
         createGetAlarmToolSchemaTool(ctx),
         createGetCollectionToolSchemaTool(ctx),
         createSendFileToUserTool(ctx),
+        createSendHtmlCardTool(ctx),
         // createGetEmailToolSchemaTool(ctx),
         viewPushResultTool,
         createImageReadingTool(ctx),

package/dist/src/tools/send-html-card-tool.d.ts

@@ -0,0 +1,7 @@
+import type { SessionContext } from "./session-manager.js";
+/**
+ * XY send HTML card tool - sends HTML content as an H5 card to user's device.
+ * Prefer this tool over send_file_to_user when sending HTML files to users.
+ * Only use send_file_to_user for HTML files when the user explicitly requests the raw file.
+ */
+export declare function createSendHtmlCardTool(ctx: SessionContext): any;

package/dist/src/tools/send-html-card-tool.js

@@ -0,0 +1,112 @@
+import { XYFileUploadService } from "../file-upload.js";
+import { sendCard } from "../formatter.js";
+import { getCurrentTaskId } from "../task-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY send HTML card tool - sends HTML content as an H5 card to user's device.
+ * Prefer this tool over send_file_to_user when sending HTML files to users.
+ * Only use send_file_to_user for HTML files when the user explicitly requests the raw file.
+ */
+export function createSendHtmlCardTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "send_html_card",
+        label: "Send HTML Card",
+        description: `工具能力描述：当需要把生成的html文件发送给用户时，优先使用这个工具。以H5卡片的形式展示HTML页面内容，用户可以直接在卡片中查看。如果用户要求原始文件，才使用send_file_to_user发送html文件，否则html的文件回传均使用此工具。
+
+工具参数说明：
+a. htmlUrl 和 htmlLocal 至少填写一个
+b. htmlUrl 是在线链接，可以直接公网访问的HTML页面地址
+c. htmlLocal 是本地HTML文件路径，会先上传获取预览链接再以卡片形式发送
+
+注意事项：
+a. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如果超时或失败，最多重试一次`,
+        parameters: {
+            type: "object",
+            properties: {
+                htmlUrl: {
+                    type: "string",
+                    description: "在线HTML页面链接，可直接公网访问的URL地址",
+                },
+                htmlLocal: {
+                    type: "string",
+                    description: "本地HTML文件路径",
+                },
+            },
+            required: [],
+        },
+        async execute(toolCallId, params) {
+            // Validate at least one parameter is provided
+            if (!params.htmlUrl && !params.htmlLocal) {
+                throw new Error("htmlUrl 和 htmlLocal 至少需要填写一个");
+            }
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+            // Set timeout for the entire operation (2 minutes)
+            const TOOL_TIMEOUT = 120000;
+            let timeoutHandle = null;
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => {
+                    reject(new Error("操作超时（2分钟）"));
+                }, TOOL_TIMEOUT);
+            });
+            const executionPromise = (async () => {
+                let url = params.htmlUrl;
+                // If htmlLocal is provided, upload it to get a preview URL
+                if (params.htmlLocal) {
+                    const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+                    logger.log(`[SEND-HTML-CARD] Uploading local HTML file: ${params.htmlLocal}`);
+                    const previewUrl = await uploadService.uploadFileAndGetPreviewUrl(params.htmlLocal);
+                    logger.log(`[SEND-HTML-CARD] Upload complete, preview URL obtained`);
+                    url = previewUrl;
+                }
+                if (!url) {
+                    throw new Error("未能获取HTML页面的URL");
+                }
+                // Build card data
+                const cardsInfo = [
+                    {
+                        cardName: "clawH5",
+                        cardData: {
+                            url,
+                        },
+                        displayType: "DisplayFaCard",
+                    },
+                ];
+                // Send card via sendCard
+                await sendCard({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId,
+                    toolCallId,
+                    cardsInfo,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                url,
+                                message: "HTML卡片发送成功",
+                            }),
+                        },
+                    ],
+                };
+            })();
+            try {
+                const result = await Promise.race([executionPromise, timeoutPromise]);
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                return result;
+            }
+            catch (error) {
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                throw error;
+            }
+        },
+    };
+}

package/dist/src/tools/session-manager.d.ts

@@ -8,7 +8,7 @@ export interface SessionContext {
     messageId: string;
     agentId: string;
     deviceType?: string;
-    /** Model name extracted from A2A user variables (variables.systemVariables.modelName).
+    /** Model name extracted from A2A user variables (variables.memoryVariables.modelName).
      *  When set, provider.ts replaces model.id in the OpenAI request body. */
     modelName?: string;
     runCrossTaskContext?: RunCrossTaskContext;

package/package.json

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