@ynhcj/xiaoyi 2.5.2 → 2.5.5

package/dist/config-schema.d.ts

@@ -23,24 +23,24 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
     /** Multi-account configuration */
     accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    enabled: boolean;
-    debug: boolean;
-    enableStreaming: boolean;
-    name?: string | undefined;
-    wsUrl?: string | undefined;
-    ak?: string | undefined;
-    sk?: string | undefined;
-    agentId?: string | undefined;
-    accounts?: Record<string, unknown> | undefined;
+    enabled?: boolean;
+    wsUrl?: string;
+    ak?: string;
+    sk?: string;
+    agentId?: string;
+    enableStreaming?: boolean;
+    name?: string;
+    debug?: boolean;
+    accounts?: Record<string, unknown>;
 }, {
-    enabled?: boolean | undefined;
-    name?: string | undefined;
-    wsUrl?: string | undefined;
-    ak?: string | undefined;
-    sk?: string | undefined;
-    agentId?: string | undefined;
-    debug?: boolean | undefined;
-    enableStreaming?: boolean | undefined;
-    accounts?: Record<string, unknown> | undefined;
+    enabled?: boolean;
+    wsUrl?: string;
+    ak?: string;
+    sk?: string;
+    agentId?: string;
+    enableStreaming?: boolean;
+    name?: string;
+    debug?: boolean;
+    accounts?: Record<string, unknown>;
 }>;
 export type XiaoYiConfig = z.infer<typeof XiaoYiConfigSchema>;

package/dist/onboarding.d.ts

@@ -0,0 +1,6 @@
+/**
+ * XiaoYi onboarding adapter for CLI setup wizard.
+ */
+type ChannelOnboardingAdapter = any;
+export declare const xiaoyiOnboardingAdapter: ChannelOnboardingAdapter;
+export {};

package/dist/onboarding.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * XiaoYi onboarding adapter for CLI setup wizard.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xiaoyiOnboardingAdapter = void 0;
+const channel = "xiaoyi";
+/**
+ * Get XiaoYi channel config from OpenClaw config
+ */
+function getXiaoYiConfig(cfg) {
+    return cfg?.channels?.xiaoyi;
+}
+/**
+ * Check if XiaoYi is properly configured
+ */
+function isXiaoYiConfigured(config) {
+    if (!config) {
+        return false;
+    }
+    // Check required fields: ak, sk, agentId
+    // wsUrl1/wsUrl2 are optional (defaults will be used if not provided)
+    const hasAk = typeof config.ak === "string" && config.ak.trim().length > 0;
+    const hasSk = typeof config.sk === "string" && config.sk.trim().length > 0;
+    const hasAgentId = typeof config.agentId === "string" && config.agentId.trim().length > 0;
+    return hasAk && hasSk && hasAgentId;
+}
+/**
+ * Set XiaoYi channel configuration
+ */
+function setXiaoYiConfig(cfg, config) {
+    const existing = getXiaoYiConfig(cfg);
+    const merged = {
+        enabled: config.enabled ?? existing?.enabled ?? true,
+        wsUrl: config.wsUrl ?? existing?.wsUrl ?? "",
+        wsUrl1: config.wsUrl1 ?? existing?.wsUrl1 ?? "",
+        wsUrl2: config.wsUrl2 ?? existing?.wsUrl2 ?? "",
+        ak: config.ak ?? existing?.ak ?? "",
+        sk: config.sk ?? existing?.sk ?? "",
+        agentId: config.agentId ?? existing?.agentId ?? "",
+        enableStreaming: config.enableStreaming ?? existing?.enableStreaming ?? true,
+    };
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            xiaoyi: merged,
+        },
+    };
+}
+/**
+ * Note about XiaoYi setup
+ */
+async function noteXiaoYiSetupHelp(prompter) {
+    await prompter.note([
+        "XiaoYi (小艺) uses A2A protocol via WebSocket connection.",
+        "",
+        "Required credentials:",
+        "  - ak: Access Key for authentication",
+        "  - sk: Secret Key for authentication",
+        "  - agentId: Your agent identifier",
+        "",
+        "WebSocket URLs will use default values.",
+        "",
+        "Docs: https://docs.openclaw.ai/channels/xiaoyi",
+    ].join("\n"), "XiaoYi setup");
+}
+/**
+ * Prompt for Access Key
+ */
+async function promptAk(prompter, config) {
+    const existing = config?.ak ?? "";
+    return String(await prompter.text({
+        message: "XiaoYi Access Key (ak)",
+        initialValue: existing,
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    })).trim();
+}
+/**
+ * Prompt for Secret Key
+ */
+async function promptSk(prompter, config) {
+    const existing = config?.sk ?? "";
+    return String(await prompter.text({
+        message: "XiaoYi Secret Key (sk)",
+        initialValue: existing,
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    })).trim();
+}
+/**
+ * Prompt for Agent ID
+ */
+async function promptAgentId(prompter, config) {
+    const existing = config?.agentId ?? "";
+    return String(await prompter.text({
+        message: "XiaoYi Agent ID",
+        initialValue: existing,
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    })).trim();
+}
+exports.xiaoyiOnboardingAdapter = {
+    channel,
+    getStatus: async ({ cfg }) => {
+        const config = getXiaoYiConfig(cfg);
+        const configured = isXiaoYiConfigured(config);
+        const enabled = config?.enabled !== false;
+        const statusLines = [];
+        if (configured) {
+            statusLines.push(`XiaoYi: ${enabled ? "enabled" : "disabled"}`);
+            if (config?.wsUrl1 || config?.wsUrl) {
+                statusLines.push(`  WebSocket: ${config.wsUrl1 || config.wsUrl}`);
+            }
+            if (config?.wsUrl2) {
+                statusLines.push(`  Secondary: ${config.wsUrl2}`);
+            }
+            if (config?.agentId) {
+                statusLines.push(`  Agent ID: ${config.agentId}`);
+            }
+        }
+        else {
+            statusLines.push("XiaoYi: needs ak, sk, and agentId");
+        }
+        return {
+            channel,
+            configured,
+            statusLines,
+            selectionHint: configured ? "configured" : "needs setup",
+            quickstartScore: 50,
+        };
+    },
+    configure: async ({ cfg, prompter }) => {
+        const config = getXiaoYiConfig(cfg);
+        if (!isXiaoYiConfigured(config)) {
+            await noteXiaoYiSetupHelp(prompter);
+        }
+        else {
+            const reconfigure = await prompter.confirm({
+                message: "XiaoYi already configured. Reconfigure?",
+                initialValue: false,
+            });
+            if (!reconfigure) {
+                return { cfg, accountId: "default" };
+            }
+        }
+        // Prompt for required credentials
+        const ak = await promptAk(prompter, config);
+        const sk = await promptSk(prompter, config);
+        const agentId = await promptAgentId(prompter, config);
+        const cfgWithConfig = setXiaoYiConfig(cfg, {
+            ak,
+            sk,
+            agentId,
+            enabled: true,
+        });
+        return { cfg: cfgWithConfig, accountId: "default" };
+    },
+    disable: (cfg) => {
+        const xiaoyi = getXiaoYiConfig(cfg);
+        return {
+            ...cfg,
+            channels: {
+                ...cfg.channels,
+                xiaoyi: { ...xiaoyi, enabled: false },
+            },
+        };
+    },
+};

package/dist/runtime.d.ts

@@ -22,6 +22,7 @@ export declare class XiaoYiRuntime {
     private sessionTimeoutSent;
     private timeoutConfig;
     private sessionAbortControllerMap;
+    private sessionActiveRunMap;
     constructor();
     getInstanceId(): string;
     /**
@@ -52,11 +53,16 @@ export declare class XiaoYiRuntime {
      * Set timeout for a session
      * @param sessionId - Session ID
      * @param callback - Function to call when timeout occurs
-     * @returns The timeout ID (for cancellation)
+     * @returns The interval ID (for cancellation)
+     *
+     * IMPORTANT: This now uses setInterval instead of setTimeout
+     * - First trigger: after 60 seconds
+     * - Subsequent triggers: every 60 seconds after that
+     * - Cleared when: response received, session completed, or explicitly cleared
      */
     setTimeoutForSession(sessionId: string, callback: () => void): NodeJS.Timeout | undefined;
     /**
-     * Clear timeout for a session
+     * Clear timeout interval for a session
      * @param sessionId - Session ID
      */
     clearSessionTimeout(sessionId: string): void;
@@ -71,7 +77,7 @@ export declare class XiaoYiRuntime {
      */
     markSessionCompleted(sessionId: string): void;
     /**
-     * Clear all timeouts
+     * Clear all timeout intervals
      */
     clearAllTimeouts(): void;
     /**
@@ -101,12 +107,18 @@ export declare class XiaoYiRuntime {
     /**
      * Create and register an AbortController for a session
      * @param sessionId - Session ID
-     * @returns The AbortController and its signal
+     * @returns The AbortController and its signal, or null if session is busy
      */
     createAbortControllerForSession(sessionId: string): {
         controller: AbortController;
         signal: AbortSignal;
-    };
+    } | null;
+    /**
+     * Check if a session has an active agent run
+     * @param sessionId - Session ID
+     * @returns true if session is busy
+     */
+    isSessionActive(sessionId: string): boolean;
     /**
      * Abort a session's agent run
      * @param sessionId - Session ID

package/dist/runtime.js

@@ -10,7 +10,7 @@ const websocket_1 = require("./websocket");
 const DEFAULT_TIMEOUT_CONFIG = {
     enabled: true,
     duration: 60000, // 60 seconds
-    message: "任务还在处理中，请稍后回来查看",
+    message: "任务正在处理中，请稍后",
 };
 /**
  * Runtime state for XiaoYi channel
@@ -28,6 +28,8 @@ class XiaoYiRuntime {
         this.timeoutConfig = DEFAULT_TIMEOUT_CONFIG;
         // AbortController management for canceling agent runs
         this.sessionAbortControllerMap = new Map();
+        // Track if a session has an active agent run (for concurrent request detection)
+        this.sessionActiveRunMap = new Map();
         this.instanceId = `runtime_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         console.log(`XiaoYi: Created new runtime instance: ${this.instanceId}`);
     }
@@ -122,7 +124,12 @@ class XiaoYiRuntime {
      * Set timeout for a session
      * @param sessionId - Session ID
      * @param callback - Function to call when timeout occurs
-     * @returns The timeout ID (for cancellation)
+     * @returns The interval ID (for cancellation)
+     *
+     * IMPORTANT: This now uses setInterval instead of setTimeout
+     * - First trigger: after 60 seconds
+     * - Subsequent triggers: every 60 seconds after that
+     * - Cleared when: response received, session completed, or explicitly cleared
      */
     setTimeoutForSession(sessionId, callback) {
         if (!this.timeoutConfig.enabled) {
@@ -133,32 +140,33 @@ class XiaoYiRuntime {
         const hadExistingTimeout = this.sessionTimeoutMap.has(sessionId);
         const hadSentTimeout = this.sessionTimeoutSent.has(sessionId);
         this.clearSessionTimeout(sessionId);
-        // Also clear the timeout sent flag to allow this session to timeout again
+        // Clear the timeout sent flag to allow this session to timeout again
         if (hadSentTimeout) {
             this.sessionTimeoutSent.delete(sessionId);
             console.log(`[TIMEOUT] Previous timeout flag cleared for session ${sessionId} (session reuse)`);
         }
-        const timeoutId = setTimeout(() => {
-            console.log(`[TIMEOUT] Timeout triggered for session ${sessionId}`);
-            this.sessionTimeoutMap.delete(sessionId);
+        // Use setInterval for periodic timeout triggers
+        // First trigger after duration, then every duration after that
+        const intervalId = setInterval(() => {
+            console.log(`[TIMEOUT] Timeout triggered for session ${sessionId} (will trigger again in ${this.timeoutConfig.duration}ms if still active)`);
             this.sessionTimeoutSent.add(sessionId);
             callback();
         }, this.timeoutConfig.duration);
-        this.sessionTimeoutMap.set(sessionId, timeoutId);
-        const logSuffix = hadExistingTimeout ? " (replacing existing timeout)" : "";
-        console.log(`[TIMEOUT] ${this.timeoutConfig.duration}ms timeout started for session ${sessionId}${logSuffix}`);
-        return timeoutId;
+        this.sessionTimeoutMap.set(sessionId, intervalId);
+        const logSuffix = hadExistingTimeout ? " (replacing existing interval)" : "";
+        console.log(`[TIMEOUT] ${this.timeoutConfig.duration}ms periodic timeout started for session ${sessionId}${logSuffix}`);
+        return intervalId;
     }
     /**
-     * Clear timeout for a session
+     * Clear timeout interval for a session
      * @param sessionId - Session ID
      */
     clearSessionTimeout(sessionId) {
-        const timeoutId = this.sessionTimeoutMap.get(sessionId);
-        if (timeoutId) {
-            clearTimeout(timeoutId);
+        const intervalId = this.sessionTimeoutMap.get(sessionId);
+        if (intervalId) {
+            clearInterval(intervalId);
             this.sessionTimeoutMap.delete(sessionId);
-            console.log(`[TIMEOUT] Timeout cleared for session ${sessionId}`);
+            console.log(`[TIMEOUT] Timeout interval cleared for session ${sessionId}`);
         }
     }
     /**
@@ -178,15 +186,15 @@ class XiaoYiRuntime {
         console.log(`[TIMEOUT] Session ${sessionId} marked as completed`);
     }
     /**
-     * Clear all timeouts
+     * Clear all timeout intervals
      */
     clearAllTimeouts() {
-        for (const [sessionId, timeoutId] of this.sessionTimeoutMap.entries()) {
-            clearTimeout(timeoutId);
+        for (const [sessionId, intervalId] of this.sessionTimeoutMap.entries()) {
+            clearInterval(intervalId);
         }
         this.sessionTimeoutMap.clear();
         this.sessionTimeoutSent.clear();
-        console.log("[TIMEOUT] All timeouts cleared");
+        console.log("[TIMEOUT] All timeout intervals cleared");
     }
     /**
      * Get WebSocket manager
@@ -227,16 +235,28 @@ class XiaoYiRuntime {
     /**
      * Create and register an AbortController for a session
      * @param sessionId - Session ID
-     * @returns The AbortController and its signal
+     * @returns The AbortController and its signal, or null if session is busy
      */
     createAbortControllerForSession(sessionId) {
-        // Abort any existing controller for this session
-        this.abortSession(sessionId);
+        // Check if there's an active agent run for this session
+        if (this.sessionActiveRunMap.get(sessionId)) {
+            console.log(`[CONCURRENT] Session ${sessionId} has an active agent run, cannot create new AbortController`);
+            return null;
+        }
         const controller = new AbortController();
         this.sessionAbortControllerMap.set(sessionId, controller);
+        this.sessionActiveRunMap.set(sessionId, true);
         console.log(`[ABORT] Created AbortController for session ${sessionId}`);
         return { controller, signal: controller.signal };
     }
+    /**
+     * Check if a session has an active agent run
+     * @param sessionId - Session ID
+     * @returns true if session is busy
+     */
+    isSessionActive(sessionId) {
+        return this.sessionActiveRunMap.get(sessionId) || false;
+    }
     /**
      * Abort a session's agent run
      * @param sessionId - Session ID
@@ -272,6 +292,9 @@ class XiaoYiRuntime {
             this.sessionAbortControllerMap.delete(sessionId);
             console.log(`[ABORT] Cleared AbortController for session ${sessionId}`);
         }
+        // Also clear the active run flag
+        this.sessionActiveRunMap.delete(sessionId);
+        console.log(`[CONCURRENT] Session ${sessionId} marked as inactive`);
     }
     /**
      * Clear all AbortControllers

package/dist/websocket.d.ts

@@ -75,6 +75,22 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
      * This uses "status-update" event type which keeps the conversation active
      */
     sendStatusUpdate(taskId: string, sessionId: string, message: string, targetServer?: ServerId): Promise<void>;
+    /**
+     * Send PUSH message (主动推送) via HTTP API
+     *
+     * This is used when SubAgent completes execution and needs to push results to user
+     * independently of the original A2A request-response flow.
+     *
+     * Unlike sendResponse (which responds to a specific request via WebSocket), push messages are
+     * sent through HTTP API asynchronously.
+     *
+     * @param sessionId - User's session ID
+     * @param message - Message content to push
+     *
+     * Reference: 华为小艺推送消息 API
+     * TODO: 实现实际的推送消息发送逻辑
+     */
+    sendPushMessage(sessionId: string, message: string): Promise<void>;
     /**
      * Send tasks cancel response to specific server
      */

package/dist/websocket.js

@@ -514,6 +514,27 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             throw error;
         }
     }
+    /**
+     * Send PUSH message (主动推送) via HTTP API
+     *
+     * This is used when SubAgent completes execution and needs to push results to user
+     * independently of the original A2A request-response flow.
+     *
+     * Unlike sendResponse (which responds to a specific request via WebSocket), push messages are
+     * sent through HTTP API asynchronously.
+     *
+     * @param sessionId - User's session ID
+     * @param message - Message content to push
+     *
+     * Reference: 华为小艺推送消息 API
+     * TODO: 实现实际的推送消息发送逻辑
+     */
+    async sendPushMessage(sessionId, message) {
+        console.log(`[PUSH] Would send push message to session ${sessionId}, length: ${message.length} chars`);
+        console.log(`[PUSH] Content: ${message.substring(0, 50)}${message.length > 50 ? "..." : ""}`);
+        // TODO: Implement actual push message sending via HTTP API
+        // Need to confirm correct push message format with XiaoYi API documentation
+    }
     /**
      * Send tasks cancel response to specific server
      */

package/dist/xiaoyi-media.d.ts

@@ -0,0 +1,81 @@
+/**
+ * XiaoYi Media Handler - Downloads and saves media files locally
+ * Similar to clawdbot-feishu's media.ts approach
+ */
+type PluginRuntime = any;
+export interface DownloadedMedia {
+    path: string;
+    contentType: string;
+    placeholder: string;
+    fileName?: string;
+}
+export interface MediaDownloadOptions {
+    maxBytes?: number;
+    timeoutMs?: number;
+}
+/**
+ * Check if a MIME type is an image
+ */
+export declare function isImageMimeType(mimeType: string | undefined): boolean;
+/**
+ * Check if a MIME type is a PDF
+ */
+export declare function isPdfMimeType(mimeType: string | undefined): boolean;
+/**
+ * Check if a MIME type is text-based
+ */
+export declare function isTextMimeType(mimeType: string | undefined): boolean;
+/**
+ * Download and save media file to local disk
+ * This is the key function that follows clawdbot-feishu's approach
+ */
+export declare function downloadAndSaveMedia(runtime: PluginRuntime, uri: string, mimeType: string, fileName: string, options?: MediaDownloadOptions): Promise<DownloadedMedia>;
+/**
+ * Download and save multiple media files
+ */
+export declare function downloadAndSaveMediaList(runtime: PluginRuntime, files: Array<{
+    uri: string;
+    mimeType: string;
+    name: string;
+}>, options?: MediaDownloadOptions): Promise<DownloadedMedia[]>;
+/**
+ * Build media payload for inbound context
+ * Similar to clawdbot-feishu's buildFeishuMediaPayload()
+ */
+export declare function buildXiaoYiMediaPayload(mediaList: DownloadedMedia[]): {
+    MediaPath?: string;
+    MediaType?: string;
+    MediaUrl?: string;
+    MediaPaths?: string[];
+    MediaUrls?: string[];
+    MediaTypes?: string[];
+};
+/**
+ * Extract text from downloaded file for including in message body
+ */
+export declare function extractTextFromFile(path: string, mimeType: string): Promise<string | null>;
+/**
+ * Input image content type for AI processing
+ */
+export interface InputImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+/**
+ * Image download limits
+ */
+export interface ImageLimits {
+    maxBytes?: number;
+    timeoutMs?: number;
+}
+/**
+ * Extract image from URL and return base64 encoded data
+ */
+export declare function extractImageFromUrl(url: string, limits?: Partial<ImageLimits>): Promise<InputImageContent>;
+/**
+ * Extract text content from URL
+ * Supports text-based files (txt, md, json, xml, csv, etc.)
+ */
+export declare function extractTextFromUrl(url: string, maxBytes?: number, timeoutMs?: number): Promise<string>;
+export {};