@openclaw/zalouser 2026.3.13 → 2026.5.2-beta.1

package/src/tool.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { sendImageZalouser, sendLinkZalouser, sendMessageZalouser } from "./send.js";
-import { executeZalouserTool } from "./tool.js";
+import { createZalouserTool, executeZalouserTool } from "./tool.js";
 import {
   checkZaloAuthenticated,
   getZaloUserInfo,
@@ -30,8 +30,8 @@ const mockGetUserInfo = vi.mocked(getZaloUserInfo);
 const mockListFriends = vi.mocked(listZaloFriendsMatching);
 const mockListGroups = vi.mocked(listZaloGroupsMatching);
 
-function extractDetails(result: Awaited<ReturnType<typeof executeZalouserTool>>): unknown {
-  const text = result.content[0]?.text ?? "{}";
+function extractDetails(result: { content?: Array<{ type: string; text?: string }> }): unknown {
+  const text = result.content?.[0]?.text ?? "{}";
   return JSON.parse(text) as unknown;
 }
 
@@ -69,6 +69,69 @@ describe("executeZalouserTool", () => {
     expect(extractDetails(result)).toEqual({ success: true, messageId: "m-1" });
   });
 
+  it("defaults send routing from ambient deliveryContext target", async () => {
+    mockSendMessage.mockResolvedValueOnce({ ok: true, messageId: "m-ambient" });
+    const tool = createZalouserTool({
+      deliveryContext: {
+        channel: "zalouser",
+        to: "zalouser:g-ambient",
+      },
+    });
+
+    const result = await tool.execute("tool-1", {
+      action: "send",
+      message: "hello",
+    });
+
+    expect(mockSendMessage).toHaveBeenCalledWith("g-ambient", "hello", {
+      profile: undefined,
+      isGroup: true,
+    });
+    expect(extractDetails(result)).toEqual({ success: true, messageId: "m-ambient" });
+  });
+
+  it("keeps explicit threadId over ambient delivery defaults", async () => {
+    mockSendMessage.mockResolvedValueOnce({ ok: true, messageId: "m-explicit" });
+    const tool = createZalouserTool({
+      deliveryContext: {
+        channel: "zalouser",
+        to: "zalouser:g-ambient",
+      },
+    });
+
+    await tool.execute("tool-1", {
+      action: "send",
+      threadId: "u-explicit",
+      message: "hello",
+      isGroup: false,
+    });
+
+    expect(mockSendMessage).toHaveBeenCalledWith("u-explicit", "hello", {
+      profile: undefined,
+      isGroup: false,
+    });
+  });
+
+  it("does not route send actions from foreign ambient thread defaults", async () => {
+    const tool = createZalouserTool({
+      deliveryContext: {
+        channel: "slack",
+        to: "channel:C123",
+        threadId: "1710000000.000100",
+      },
+    });
+
+    const result = await tool.execute("tool-1", {
+      action: "send",
+      message: "hello",
+    });
+
+    expect(mockSendMessage).not.toHaveBeenCalled();
+    expect(extractDetails(result)).toEqual({
+      error: "threadId and message required for send action",
+    });
+  });
+
   it("returns tool error when send action fails", async () => {
     mockSendMessage.mockResolvedValueOnce({ ok: false, error: "blocked" });
     const result = await executeZalouserTool("tool-1", {

package/src/tool.ts

@@ -1,5 +1,8 @@
-import { Type } from "@sinclair/typebox";
+import type { AnyAgentTool, OpenClawPluginToolContext } from "openclaw/plugin-sdk/core";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { Type } from "typebox";
 import { sendImageZalouser, sendLinkZalouser, sendMessageZalouser } from "./send.js";
+import { parseZalouserOutboundTarget } from "./session-route.js";
 import {
   checkZaloAuthenticated,
   getZaloUserInfo,
@@ -10,8 +13,8 @@ import {
 const ACTIONS = ["send", "image", "link", "friends", "groups", "me", "status"] as const;
 
 type AgentToolResult = {
-  content: Array<{ type: string; text: string }>;
-  details?: unknown;
+  content: Array<{ type: "text"; text: string }>;
+  details: unknown;
 };
 
 function stringEnum<T extends readonly string[]>(
@@ -25,7 +28,7 @@ function stringEnum<T extends readonly string[]>(
   });
 }
 
-export const ZalouserToolSchema = Type.Object(
+const ZalouserToolSchema = Type.Object(
   {
     action: stringEnum(ACTIONS, { description: `Action to perform: ${ACTIONS.join(", ")}` }),
     threadId: Type.Optional(Type.String({ description: "Thread ID for messaging" })),
@@ -48,6 +51,8 @@ type ToolParams = {
   url?: string;
 };
 
+type ZalouserToolContext = Pick<OpenClawPluginToolContext, "deliveryContext">;
+
 function json(payload: unknown): AgentToolResult {
   return {
     content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
@@ -55,21 +60,62 @@ function json(payload: unknown): AgentToolResult {
   };
 }
 
+function resolveAmbientZalouserTarget(context?: ZalouserToolContext): {
+  threadId?: string;
+  isGroup?: boolean;
+} {
+  const deliveryContext = context?.deliveryContext;
+  const rawTarget = deliveryContext?.to;
+  if (
+    (deliveryContext?.channel === undefined || deliveryContext.channel === "zalouser") &&
+    typeof rawTarget === "string" &&
+    rawTarget.trim()
+  ) {
+    try {
+      return parseZalouserOutboundTarget(rawTarget);
+    } catch {
+      // Ignore unrelated delivery targets; explicit tool params still win.
+    }
+  }
+  if (deliveryContext?.channel && deliveryContext.channel !== "zalouser") {
+    return {};
+  }
+  const ambientThreadId = deliveryContext?.threadId;
+  if (typeof ambientThreadId === "string" && ambientThreadId.trim()) {
+    return { threadId: ambientThreadId.trim() };
+  }
+  if (typeof ambientThreadId === "number" && Number.isFinite(ambientThreadId)) {
+    return { threadId: String(ambientThreadId) };
+  }
+  return {};
+}
+
+function resolveZalouserSendTarget(params: ToolParams, context?: ZalouserToolContext) {
+  const explicitThreadId = typeof params.threadId === "string" ? params.threadId.trim() : "";
+  const ambientTarget = resolveAmbientZalouserTarget(context);
+  return {
+    threadId: explicitThreadId || ambientTarget.threadId,
+    isGroup: typeof params.isGroup === "boolean" ? params.isGroup : ambientTarget.isGroup,
+  };
+}
+
 export async function executeZalouserTool(
   _toolCallId: string,
   params: ToolParams,
   _signal?: AbortSignal,
   _onUpdate?: unknown,
+  context?: ZalouserToolContext,
 ): Promise<AgentToolResult> {
   try {
     switch (params.action) {
       case "send": {
-        if (!params.threadId || !params.message) {
+        const target = resolveZalouserSendTarget(params, context);
+        if (!target.threadId || !params.message) {
           throw new Error("threadId and message required for send action");
         }
-        const result = await sendMessageZalouser(params.threadId, params.message, {
+        const result = await sendMessageZalouser(target.threadId, params.message, {
           profile: params.profile,
-          isGroup: params.isGroup,
+          isGroup: target.isGroup,
         });
         if (!result.ok) {
           throw new Error(result.error || "Failed to send message");
@@ -78,16 +124,17 @@ export async function executeZalouserTool(
       }
 
       case "image": {
-        if (!params.threadId) {
+        const target = resolveZalouserSendTarget(params, context);
+        if (!target.threadId) {
           throw new Error("threadId required for image action");
         }
         if (!params.url) {
           throw new Error("url required for image action");
         }
-        const result = await sendImageZalouser(params.threadId, params.url, {
+        const result = await sendImageZalouser(target.threadId, params.url, {
           profile: params.profile,
           caption: params.message,
-          isGroup: params.isGroup,
+          isGroup: target.isGroup,
         });
         if (!result.ok) {
           throw new Error(result.error || "Failed to send image");
@@ -96,13 +143,14 @@ export async function executeZalouserTool(
       }
 
       case "link": {
-        if (!params.threadId || !params.url) {
+        const target = resolveZalouserSendTarget(params, context);
+        if (!target.threadId || !params.url) {
           throw new Error("threadId and url required for link action");
         }
-        const result = await sendLinkZalouser(params.threadId, params.url, {
+        const result = await sendLinkZalouser(target.threadId, params.url, {
           profile: params.profile,
           caption: params.message,
-          isGroup: params.isGroup,
+          isGroup: target.isGroup,
         });
         if (!result.ok) {
           throw new Error(result.error || "Failed to send link");
@@ -142,7 +190,21 @@ export async function executeZalouserTool(
     }
   } catch (err) {
     return json({
-      error: err instanceof Error ? err.message : String(err),
+      error: formatErrorMessage(err),
     });
   }
 }
+
+export function createZalouserTool(context?: ZalouserToolContext): AnyAgentTool {
+  return {
+    name: "zalouser",
+    label: "Zalo Personal",
+    description:
+      "Send messages and access data via Zalo personal account. " +
+      "Actions: send (text message), image (send image URL), link (send link), " +
+      "friends (list/search friends), groups (list groups), me (profile info), status (auth check).",
+    parameters: ZalouserToolSchema,
+    execute: async (toolCallId, params, signal, onUpdate) =>
+      await executeZalouserTool(toolCallId, params as ToolParams, signal, onUpdate, context),
+  } satisfies AnyAgentTool;
+}

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Style } from "./zca-client.js";
+import type { Style } from "./zca-constants.js";
 
 export type ZcaFriend = {
   userId: string;
@@ -61,6 +61,7 @@ export type ZaloSendOptions = {
   caption?: string;
   isGroup?: boolean;
   mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
   textMode?: "markdown" | "plain";
   textChunkMode?: "length" | "newline";
   textChunkLimit?: number;
@@ -84,10 +85,9 @@ export type ZaloAuthStatus = {
   message: string;
 };
 
-export type ZalouserToolConfig = { allow?: string[]; deny?: string[] };
+type ZalouserToolConfig = { allow?: string[]; deny?: string[] };
 
 export type ZalouserGroupConfig = {
-  allow?: boolean;
   enabled?: boolean;
   requireMention?: boolean;
   tools?: ZalouserToolConfig;