@ai-setting/roy-agent-core 1.5.89 → 1.5.90

package/dist/shared/@ai-setting/{roy-agent-core-2q7cshpm.js → roy-agent-core-m683wd1n.js}

@@ -1,7 +1,7 @@
 import {
   TaskTagPlugin,
   createLarkCliTaskNotifyHook
-} from "./roy-agent-core-m3dkyprg.js";
+} from "./roy-agent-core-w0kb72ve.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";
@@ -192,6 +192,249 @@ var timerHandler = {
   }
 };
 
+// src/env/event-source/bounty-im-handler.ts
+function readBountyIMConfig(config) {
+  const topLevelAddress = config.address;
+  const topLevelUrl = config.imServerUrl;
+  const optionsAddress = config.options?.address;
+  const optionsUrl = config.options?.imServerUrl;
+  return {
+    address: topLevelAddress || optionsAddress,
+    imServerUrl: topLevelUrl || optionsUrl
+  };
+}
+function readBountyIMTlsSkipVerify(config) {
+  const topLevel = config.tlsSkipVerify;
+  const fromOptions = config.options?.tlsSkipVerify;
+  const raw = topLevel !== undefined ? topLevel : fromOptions;
+  return raw === true;
+}
+function shouldWriteBunTlsSkipEnv(tlsSkipVerify, isBunRuntimeOverride) {
+  const isBun = isBunRuntimeOverride ?? typeof Bun !== "undefined";
+  return tlsSkipVerify === true && isBun;
+}
+
+class BountyIMInstance {
+  config;
+  status = "created";
+  ws = null;
+  buffer = "";
+  eventHandler;
+  constructor(config) {
+    this.config = config;
+  }
+  getCurrentAddress() {
+    const { address } = readBountyIMConfig(this.config);
+    return address || "unknown";
+  }
+  getStatus() {
+    return this.status;
+  }
+  async start() {
+    if (this.status === "running")
+      return;
+    this.setStatus("starting");
+    const { address, imServerUrl } = readBountyIMConfig(this.config);
+    if (!imServerUrl) {
+      throw new Error("imServerUrl is required for bounty-im event source");
+    }
+    const wsUrl = new URL(imServerUrl);
+    if (address) {
+      wsUrl.searchParams.set("address", address);
+    }
+    console.log(`[BountyIM] Connecting to ${wsUrl.toString()}...`);
+    try {
+      const { WebSocket } = await import("ws");
+      const tlsSkipVerify = readBountyIMTlsSkipVerify(this.config);
+      const isWss = imServerUrl.startsWith("wss://");
+      if (isWss && shouldWriteBunTlsSkipEnv(tlsSkipVerify)) {
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+      }
+      this.ws = new WebSocket(wsUrl.toString(), {
+        headers: this.config.headers,
+        rejectUnauthorized: !tlsSkipVerify
+      });
+      this.ws.on("open", () => {
+        console.log(`[BountyIM] Connected${address ? ` as ${address}` : ""}`);
+        this.setStatus("running");
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data.toString());
+      });
+      this.ws.on("error", (error) => {
+        console.error(`[BountyIM] Error:`, error.message);
+        this.setStatus("error");
+      });
+      this.ws.on("close", () => {
+        console.log(`[BountyIM] Connection closed`);
+        this.setStatus("stopped");
+      });
+    } catch (error) {
+      this.setStatus("error");
+      throw new Error(`Failed to connect to Bounty IM server: ${error}`);
+    }
+  }
+  async stop() {
+    if (this.status === "stopped" || this.status === "created")
+      return;
+    this.setStatus("stopping");
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setStatus("stopped");
+  }
+  onEvent(handler) {
+    this.eventHandler = handler;
+  }
+  offEvent() {
+    this.eventHandler = undefined;
+  }
+  setStatus(status) {
+    this.status = status;
+  }
+  handleMessage(data) {
+    this.buffer += data;
+    try {
+      JSON.parse(this.buffer);
+      this.processLine(this.buffer);
+      this.buffer = "";
+    } catch {}
+  }
+  processLine(rawData) {
+    try {
+      let rawEvent;
+      try {
+        rawEvent = JSON.parse(rawData);
+      } catch {
+        rawEvent = {
+          event: "message",
+          data: { content: { type: "text", body: rawData } }
+        };
+      }
+      const evt = rawEvent;
+      const msg = evt.data || {};
+      if (evt.event !== "message") {
+        return;
+      }
+      const eventType = `bounty-im.${evt.event || "message"}`;
+      const fromAddress = msg.from || "unknown";
+      const currentAddress = this.getCurrentAddress();
+      const toAddress = msg.to || currentAddress;
+      if (msg.to && msg.to !== currentAddress) {
+        console.warn(`[BountyIM] Warning: message.to (${msg.to}) !== current address (${currentAddress})`);
+      }
+      const msgContent = msg.content;
+      const content = msgContent?.type === "text" ? String(msgContent.body || "") : "";
+      const { imServerUrl } = readBountyIMConfig(this.config);
+      const agent = this.config.handleRule?.agent;
+      const metadata = {
+        eventType,
+        senderId: fromAddress,
+        chatId: toAddress,
+        agent
+      };
+      let recommendedAction;
+      if (evt.event === "message") {
+        recommendedAction = {
+          action: `处理消息并通过 bounty com send 回复发件人。使用格式：bounty com send -f ${toAddress} -t ${fromAddress} -b "回复内容"`,
+          replyTo: {
+            chatId: fromAddress
+          }
+        };
+      }
+      const replyChannel = {
+        type: "bounty-im",
+        chatId: fromAddress,
+        params: {
+          from: toAddress,
+          to: fromAddress,
+          imServerUrl
+        }
+      };
+      const displayMessage = content ? `[From ${fromAddress}] ${content}
+
+\uD83D\uDCA1 回复: bounty com send -f ${toAddress} -t ${fromAddress} -b "回复内容"` : this.formatMessage(rawEvent);
+      const event = {
+        id: `es-${this.config.id}-${Date.now()}`,
+        type: eventType,
+        timestamp: Date.now(),
+        metadata: {
+          source: "event-source",
+          sourceId: this.config.id,
+          agent
+        },
+        payload: {
+          sourceId: this.config.id,
+          sourceType: "bounty-im",
+          rawEvent,
+          message: displayMessage,
+          metadata,
+          recommendedAction,
+          replyChannel,
+          timestamp: Date.now()
+        }
+      };
+      this.eventHandler?.(event);
+      if (msg.id && this.ws) {
+        try {
+          const ackPayload = JSON.stringify({
+            event: "ack",
+            data: { messageIds: [msg.id] }
+          });
+          this.ws.send(ackPayload);
+          console.log(`[BountyIM] 已发送 ACK for message: ${msg.id}`);
+        } catch (ackErr) {
+          console.error(`[BountyIM] 发送 ACK 失败:`, ackErr);
+        }
+      }
+    } catch (err) {
+      console.error(`[BountyIM] Error processing message:`, err);
+    }
+  }
+  formatMessage(rawEvent) {
+    const evt = rawEvent;
+    if (evt.event === "connected") {
+      return `✅ 已连接到 bounty IM 服务器`;
+    }
+    if (evt.event === "message") {
+      const msg = evt.data || {};
+      const from = msg.from || "unknown";
+      let content = "未知内容";
+      if (msg.content?.type === "text") {
+        content = String(msg.content?.body || "");
+      }
+      return `[${from}] ${content}`;
+    }
+    return `事件: ${evt.event || "unknown"}`;
+  }
+}
+var bountyIMHandler = {
+  type: "bounty-im",
+  validateConfig(config) {
+    const errors = [];
+    if (!config.id)
+      errors.push("EventSource ID is required");
+    if (!config.name)
+      errors.push("EventSource name is required");
+    const { address, imServerUrl } = readBountyIMConfig(config);
+    if (!address) {
+      errors.push("Bounty IM address is required (top-level address or options.address)");
+    } else if (!/^[\w-]+@[\w.-]+$/.test(address)) {
+      errors.push("Bounty IM address format invalid (expected: agent-id@host)");
+    }
+    if (!imServerUrl) {
+      errors.push("Bounty IM imServerUrl is required (top-level imServerUrl or options.imServerUrl)");
+    } else if (!imServerUrl.startsWith("ws://") && !imServerUrl.startsWith("wss://")) {
+      errors.push("Bounty IM imServerUrl must start with ws:// or wss://");
+    }
+    return errors;
+  },
+  createInstance(config) {
+    return new BountyIMInstance(config);
+  }
+};
+
 // src/env/event-source/event-source-handlers.ts
 init_global_hook_manager();
 import { spawn } from "child_process";
@@ -259,18 +502,24 @@ function extractMetadata(rawEvent, eventType) {
   }
   let recommendedAction;
   if (eventType === "im.message.receive_v1" || event.type === "im.message.receive_v1") {
+    const profile2 = event.profile;
+    const profileFlag = profile2 ? `--profile ${profile2} ` : "";
+    const profileHint = profile2 ? `（⚠️ 必须使用 profile="${profile2}" 调用 lark-cli，否则会因 openId 跨 app 失败）` : "";
     recommendedAction = {
-      action: '处理飞书消息并以机器人身份回复，比如lark-cli im +messages-reply --message-id "xxxxid" --as bot --text "回复内容"',
+      action: `处理飞书消息并以机器人身份回复${profileHint}，例如：lark-cli ${profileFlag}im +messages-reply --message-id "xxxxid" --as bot --text "回复内容"`,
       replyTo: {
         appId: metadata.appId,
+        profile: profile2,
         chatId: metadata.chatId,
         messageId: metadata.messageId
       }
     };
   }
+  const profile = event.profile;
   const replyChannel = {
     type: "lark-cli",
     appId: metadata.appId,
+    profile,
     chatId: messageData?.chat_id,
     messageId: messageData?.message_id
   };
@@ -291,7 +540,14 @@ class LarkCliInstance {
     if (this.status === "running")
       return;
     await this.loadPlugins();
-    const command = this.config.command || "lark-cli event consume im.message.receive_v1 --as bot";
+    const profile = this.config.profile;
+    const profileFlag = profile ? `--profile ${profile} ` : "";
+    let command;
+    if (this.config.command) {
+      command = this.config.command.replace(/^(lark-cli)(\s+|$)/, (_, head, tail) => `${head} ${profileFlag.trim()}${tail}`);
+    } else {
+      command = `lark-cli ${profileFlag}event consume im.message.receive_v1 --as bot`;
+    }
     this.child = spawn("exec " + command, [], {
       shell: true,
       stdio: ["pipe", "pipe", "pipe"],
@@ -530,7 +786,12 @@ class LarkCliInstance {
       if (this.config.eventTypes?.length && !matchEventType(eventType, this.config.eventTypes)) {
         return;
       }
-      const { metadata, replyChannel, recommendedAction } = extractMetadata(rawEvent, eventType);
+      const enrichedEvent = {
+        ...rawEvent,
+        profile: this.config.profile,
+        eventSourceId: this.config.id
+      };
+      const { metadata, replyChannel, recommendedAction } = extractMetadata(enrichedEvent, eventType);
       const message = JSON.stringify({
         rawData,
         recommendedAction
@@ -598,18 +859,21 @@ class LarkCliInstance {
     if (!replyChannel || !replyChannel.chatId && !replyChannel.messageId) {
       return;
     }
+    const profile = replyChannel.profile;
     return {
       type: replyChannel.type,
       messageId: replyChannel.messageId,
       chatId: replyChannel.chatId,
       userId: replyChannel.params?.userId,
+      profile,
       identity: "bot",
       sendText: async (text) => {
         await this.sendLarkMessage({
           chatId: replyChannel.chatId,
           userId: replyChannel.params?.userId,
           content: text,
-          as: "bot"
+          as: "bot",
+          profile
         });
       },
       sendMarkdown: async (markdown) => {
@@ -618,7 +882,8 @@ class LarkCliInstance {
           userId: replyChannel.params?.userId,
           content: markdown,
           as: "bot",
-          format: "markdown"
+          format: "markdown",
+          profile
         });
       },
       sendMessage: async (content) => {
@@ -626,7 +891,8 @@ class LarkCliInstance {
           chatId: replyChannel.chatId,
           userId: replyChannel.params?.userId,
           content: JSON.stringify(content),
-          as: "bot"
+          as: "bot",
+          profile
         });
       },
       reply: async (content) => {
@@ -634,7 +900,8 @@ class LarkCliInstance {
           await this.sendLarkMessage({
             messageId: replyChannel.messageId,
             content: JSON.stringify(content),
-            as: "bot"
+            as: "bot",
+            profile
           });
         }
       }
@@ -642,7 +909,7 @@ class LarkCliInstance {
   }
   async sendLarkMessage(options) {
     return new Promise((resolve, reject) => {
-      const { chatId, userId, messageId, content, as: identity, format = "text" } = options;
+      const { chatId, userId, messageId, content, as: identity, format = "text", profile } = options;
       const contentFlag = format === "markdown" ? "--markdown" : "--text";
       const args = ["im", "+messages-send", "--as", identity];
       if (messageId) {
@@ -655,6 +922,9 @@ class LarkCliInstance {
         reject(new Error("No target specified for sending message"));
         return;
       }
+      if (profile) {
+        args.unshift("--profile", profile);
+      }
       const proc = spawn("lark-cli", args, {
         shell: false,
         stdio: ["pipe", "pipe", "pipe"]
@@ -691,9 +961,6 @@ var larkCliHandler = {
   type: "lark-cli",
   validateConfig(config) {
     const errors = [];
-    if (!config.command) {
-      errors.push("command is optional, will use default: lark-cli event consume im.message.receive_v1 --as bot");
-    }
     return errors;
   },
   createInstance(config) {
@@ -702,7 +969,8 @@ var larkCliHandler = {
 };
 var builtInHandlers = [
   larkCliHandler,
-  timerHandler
+  timerHandler,
+  bountyIMHandler
 ];
 function getBuiltInHandler(type) {
   return builtInHandlers.find((h) => h.type === type);
@@ -804,7 +1072,7 @@ class EventSourceComponent extends BaseComponent {
     }
   }
   async executeInitHooks() {
-    const { EventSourceInitHooks } = await import("./roy-agent-core-vneyghpg.js");
+    const { EventSourceInitHooks } = await import("./roy-agent-core-ddq5hcp5.js");
     await EventSourceInitHooks.execute(this);
   }
   registerHandler(handler) {
@@ -1146,4 +1414,4 @@ __legacyDecorateClassTS([
   TracedAs("event-source.update", { recordParams: false, log: false })
 ], EventSourceComponent.prototype, "update", null);
 
-export { TimerInstance, timerHandler, larkCliHandler, builtInHandlers, getBuiltInHandler, EventSourceComponent };
+export { TimerInstance, timerHandler, BountyIMInstance, bountyIMHandler, larkCliHandler, builtInHandlers, getBuiltInHandler, EventSourceComponent };

package/dist/shared/@ai-setting/{roy-agent-core-qbq3jgrn.js → roy-agent-core-rkz8r2sx.js}

@@ -6,7 +6,7 @@ import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-3f6k060j.js";
+} from "./roy-agent-core-j0107ww1.js";
 import {
   askUserTool,
   createRunWorkflowTool,

package/dist/shared/@ai-setting/{roy-agent-core-c1j7ev4e.js → roy-agent-core-txwf64pd.js}

@@ -5,6 +5,41 @@ import {
 // src/env/session/session-message-converter.ts
 import { randomUUID } from "crypto";
 var DEFAULT_REASONING_BUDGET_TOKENS = 1e4;
+function toModelImagePart(imagePart) {
+  return {
+    type: "image",
+    image: normalizeImagePayload(imagePart.image, imagePart.mimeType),
+    mimeType: imagePart.mimeType
+  };
+}
+function isLegacyBufferShape(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Uint8Array) && !(v instanceof URL) && v.type === "Buffer" && Array.isArray(v.data);
+}
+function normalizeImagePayload(image, mimeType) {
+  if (typeof image === "string" || image instanceof URL) {
+    return image;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(image)) {
+    const mime = mimeType ?? "image/jpeg";
+    return `data:${mime};base64,${image.toString("base64")}`;
+  }
+  if (image instanceof Uint8Array) {
+    if (typeof Buffer !== "undefined") {
+      const mime2 = mimeType ?? "image/jpeg";
+      return `data:${mime2};base64,${Buffer.from(image).toString("base64")}`;
+    }
+    let binary = "";
+    for (let i = 0;i < image.length; i++) {
+      binary += String.fromCharCode(image[i]);
+    }
+    const mime = mimeType ?? "image/jpeg";
+    return `data:${mime};base64,${globalThis.btoa?.(binary) ?? binary}`;
+  }
+  if (isLegacyBufferShape(image)) {
+    return new Uint8Array(image.data);
+  }
+  return image;
+}
 
 class SessionMessageConverter {
   toModelMessage(msg) {
@@ -47,6 +82,8 @@ class SessionMessageConverter {
             mimeType: filePart.mime,
             filename: filePart.filename
           });
+        } else if (part.type === "image") {
+          content.push(toModelImagePart(part));
         } else if (part.type === "tool-result" || part.type === "checkpoint") {} else {
           console.debug(`[session-message-converter] Skipping unsupported part type in assistant: ${part.type}`);
         }
@@ -68,6 +105,32 @@ class SessionMessageConverter {
         }]
       };
     }
+    if (msg.role === "user" || msg.role === "system") {
+      const parts = msg.parts || [];
+      const hasMultimodal = parts.some((p) => p.type === "image" || p.type === "file");
+      if (hasMultimodal) {
+        const content = [];
+        for (const part of parts) {
+          if (part.type === "text") {
+            content.push({ type: "text", text: part.content });
+          } else if (part.type === "image") {
+            content.push(toModelImagePart(part));
+          } else if (part.type === "file") {
+            const filePart = part;
+            content.push({
+              type: "file",
+              url: filePart.url,
+              mimeType: filePart.mime,
+              filename: filePart.filename
+            });
+          }
+        }
+        return {
+          role: msg.role,
+          content
+        };
+      }
+    }
     return {
       role: msg.role,
       content: msg.content || ""
@@ -121,6 +184,13 @@ class SessionMessageConverter {
             url: p.url,
             filename: p.filename
           });
+        } else if (p.type === "image") {
+          const imageData = normalizeImagePayload(p.image, p.mimeType);
+          parts.push({
+            type: "image",
+            image: imageData,
+            mimeType: p.mimeType
+          });
         } else {
           console.debug(`[session-message-converter] Unknown part type: ${p.type}`);
         }

package/dist/shared/@ai-setting/{roy-agent-core-m3dkyprg.js → roy-agent-core-w0kb72ve.js}

@@ -461,10 +461,12 @@ ${content}`;
       if (isTaskNotifyDebugEnabled()) {
         logger2.debug(`Sending message - messageId: ${messageId}`);
       }
+      const profile = replyChannel?.profile;
       await this.sendLarkMessage({
         chatId,
         messageId,
-        content: message
+        content: message,
+        profile
       });
       logger2.info(`Notification sent: ${type}`);
     } catch (error) {
@@ -473,7 +475,7 @@ ${content}`;
   }
   sendLarkMessage(options) {
     return new Promise((resolve, reject) => {
-      const { chatId, messageId, content } = options;
+      const { chatId, messageId, content, profile } = options;
       let args;
       if (messageId) {
         args = [
@@ -496,6 +498,9 @@ ${content}`;
           content
         ];
       }
+      if (profile) {
+        args.unshift("--profile", profile);
+      }
       const proc = spawn("lark-cli", args, {
         shell: false,
         stdio: ["pipe", "pipe", "pipe"]

package/dist/shared/@ai-setting/{roy-agent-core-hc20420t.js → roy-agent-core-z240ts1r.js}

@@ -8,7 +8,22 @@ import {
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/nodes/tool-node.ts
-var ToolNode;
+function isPositiveNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+function getToolTimeoutMs(input, config) {
+  if (input && typeof input === "object") {
+    const inputTimeout = input.timeout;
+    if (isPositiveNumber(inputTimeout)) {
+      return inputTimeout;
+    }
+  }
+  if (config && isPositiveNumber(config.timeout)) {
+    return config.timeout;
+  }
+  return DEFAULT_TOOL_TIMEOUT_MS;
+}
+var DEFAULT_TOOL_TIMEOUT_MS = 60000, ToolNode;
 var init_tool_node = __esm(() => {
   init_decorator();
   ToolNode = class ToolNode {
@@ -88,11 +103,20 @@ var init_tool_node = __esm(() => {
               nodeId: context.nodeId
             }
           };
+          const toolTimeoutMs = getToolTimeoutMs(input, this.definition.config);
           const executePromise = tool.execute(input, toolContext);
+          let timeoutHandle;
           const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`Tool '${toolName}' execution timeout after 60 seconds`)), 60000);
+            timeoutHandle = setTimeout(() => reject(new Error(`Tool '${toolName}' execution timeout after ${Math.round(toolTimeoutMs / 1000)} seconds`)), toolTimeoutMs);
           });
-          output = await Promise.race([executePromise, timeoutPromise]);
+          try {
+            output = await Promise.race([executePromise, timeoutPromise]);
+          } finally {
+            if (timeoutHandle !== undefined) {
+              clearTimeout(timeoutHandle);
+              timeoutHandle = undefined;
+            }
+          }
         } catch (toolError) {
           if (toolError instanceof TypeError && toolError.message.includes("context") && toolError.message.includes("not a function")) {
             output = await tool.execute(input);