@cozeclaw/coze-openclaw-plugin 0.1.0 → 0.1.1

package/README.md

@@ -119,6 +119,7 @@ node {baseDir}/scripts/gen.mjs --prompt "A futuristic city at sunset"
 - The plugin requires `apiKey` in plugin config and does not fall back to `COZE_*` environment variables
 - Skill visibility depends on `plugins.entries.coze-openclaw-plugin.config.apiKey`
 - `coze_web_fetch` fetches URLs sequentially
+- Run `npm test` to execute the maintained unit tests under `./src`
 
 ## License
 

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@cozeclaw/coze-openclaw-plugin",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "OpenClaw Coze tools and bundled skills",
   "type": "module",
+  "scripts": {
+    "test": "vitest run src/config.test.ts src/skill-cli.test.ts src/tools/web-search.test.ts src/tools/web-fetch.test.ts"
+  },
   "devDependencies": {
-    "openclaw": "v2026.2.6"
+    "openclaw": "v2026.2.6",
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "@sinclair/typebox": "0.34.48",

package/src/skill-cli.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it, vi } from "vitest";
+
+const hoisted = vi.hoisted(() => ({
+  loadCozePluginConfigFromOpenClawConfig: vi.fn(),
+  resolveCozeClientConfig: vi.fn(),
+  synthesizeSpeech: vi.fn(),
+  transcribeSpeech: vi.fn(),
+}));
+
+vi.mock("./config.js", async () => {
+  const actual = await vi.importActual<typeof import("./config.js")>("./config.js");
+  return {
+    ...actual,
+    loadCozePluginConfigFromOpenClawConfig: (...args: unknown[]) =>
+      hoisted.loadCozePluginConfigFromOpenClawConfig(...args),
+    resolveCozeClientConfig: (...args: unknown[]) => hoisted.resolveCozeClientConfig(...args),
+  };
+});
+
+vi.mock("./shared/tts.js", () => ({
+  synthesizeSpeech: (...args: unknown[]) => hoisted.synthesizeSpeech(...args),
+}));
+
+vi.mock("./shared/asr.js", () => ({
+  transcribeSpeech: (...args: unknown[]) => hoisted.transcribeSpeech(...args),
+}));
+
+const { runAsrCli, runTtsCli } = await import("./skill-cli.js");
+
+function createIo() {
+  return {
+    logs: [] as string[],
+    errors: [] as string[],
+    log(message: string) {
+      this.logs.push(message);
+    },
+    error(message: string) {
+      this.errors.push(message);
+    },
+  };
+}
+
+describe("skill cli", () => {
+  it("rejects missing values for single-value flags", async () => {
+    const io = createIo();
+
+    const code = await runAsrCli(["--file", "--url", "https://example.com/audio.mp3"], {}, io);
+
+    expect(code).toBe(1);
+    expect(io.errors).toContain("Error: --file requires a value");
+    expect(hoisted.transcribeSpeech).not.toHaveBeenCalled();
+  });
+
+  it("rejects missing values in tts options before calling the sdk", async () => {
+    hoisted.loadCozePluginConfigFromOpenClawConfig.mockResolvedValue({});
+    hoisted.resolveCozeClientConfig.mockReturnValue({ apiKey: "test-key" });
+    const io = createIo();
+
+    const code = await runTtsCli(["--text", "Hello", "--speaker", "--format", "mp3"], {}, io);
+
+    expect(code).toBe(1);
+    expect(io.errors).toContain("Error: --speaker requires a value");
+    expect(hoisted.synthesizeSpeech).not.toHaveBeenCalled();
+  });
+});

package/src/skill-cli.ts

@@ -36,7 +36,14 @@ async function requireConfig(env: NodeJS.ProcessEnv): Promise<CozeConfig> {
 
 function readArg(args: string[], name: string): string | undefined {
   const index = args.indexOf(name);
-  return index >= 0 ? args[index + 1] : undefined;
+  if (index < 0) {
+    return undefined;
+  }
+  const value = args[index + 1];
+  if (!value || value.startsWith("-")) {
+    return undefined;
+  }
+  return value;
 }
 
 function readTrailingValues(args: string[], name: string): string[] {
@@ -64,11 +71,35 @@ function readNumberArg(args: string[], name: string): number | undefined {
   return Number.isFinite(parsed) ? parsed : undefined;
 }
 
+function findMissingValueFlag(args: string[], names: string[]): string | undefined {
+  for (const name of names) {
+    const index = args.indexOf(name);
+    if (index < 0) {
+      continue;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("-")) {
+      return name;
+    }
+  }
+  return undefined;
+}
+
 export async function runImageCli(
   args: string[],
   env: NodeJS.ProcessEnv = process.env,
   io: SkillIo = createDefaultIo(),
 ): Promise<number> {
+  const missingValueFlag = findMissingValueFlag(args, [
+    "--prompt",
+    "--count",
+    "--size",
+    "--max-sequential",
+  ]);
+  if (missingValueFlag) {
+    io.error(`Error: ${missingValueFlag} requires a value`);
+    return 1;
+  }
   const prompt = readArg(args, "--prompt");
   if (!prompt) {
     io.error("Error: --prompt is required");
@@ -104,6 +135,19 @@ export async function runTtsCli(
   env: NodeJS.ProcessEnv = process.env,
   io: SkillIo = createDefaultIo(),
 ): Promise<number> {
+  const missingValueFlag = findMissingValueFlag(args, [
+    "--text",
+    "--texts",
+    "--speaker",
+    "--format",
+    "--sample-rate",
+    "--speech-rate",
+    "--loudness-rate",
+  ]);
+  if (missingValueFlag) {
+    io.error(`Error: ${missingValueFlag} requires a value`);
+    return 1;
+  }
   const text = readArg(args, "--text");
   const texts = readTrailingValues(args, "--texts");
   const mergedTexts = text ? [text] : texts;
@@ -150,6 +194,11 @@ export async function runAsrCli(
   env: NodeJS.ProcessEnv = process.env,
   io: SkillIo = createDefaultIo(),
 ): Promise<number> {
+  const missingValueFlag = findMissingValueFlag(args, ["--url", "-u", "--file", "-f"]);
+  if (missingValueFlag) {
+    io.error(`Error: ${missingValueFlag} requires a value`);
+    return 1;
+  }
   const url = readArg(args, "--url") ?? readArg(args, "-u");
   const file = readArg(args, "--file") ?? readArg(args, "-f");
   if (!url && !file) {

package/src/tools/web-search.test.ts

@@ -103,4 +103,38 @@ describe("createCozeWebSearchTool", () => {
     });
     expect(getTextContent(result)).toContain("https://example.com/image.png");
   });
+
+  it("renders extracted content when needContent is enabled", async () => {
+    hoisted.searchWeb.mockResolvedValueOnce({
+      query: "OpenClaw",
+      type: "web",
+      items: [
+        {
+          title: "OpenClaw",
+          url: "https://openclaw.ai",
+          snippet: "Short summary",
+          content: "Long-form extracted page content.",
+        },
+      ],
+    });
+
+    const tool = createCozeWebSearchTool({
+      pluginConfig: { apiKey: "test-key" },
+      logger: {
+        debug() {},
+        info() {},
+        warn() {},
+        error() {},
+      },
+      env: {},
+    });
+
+    const result = await tool.execute("call-3", {
+      query: "OpenClaw",
+      type: "web",
+      needContent: true,
+    });
+
+    expect(getTextContent(result)).toContain("Long-form extracted page content.");
+  });
 });

package/src/tools/web-search.ts

@@ -53,7 +53,10 @@ const SearchToolSchema = Type.Object(
 
 type SearchToolParams = Static<typeof SearchToolSchema>;
 
-function buildSearchText(params: Awaited<ReturnType<typeof searchWeb>>): string {
+function buildSearchText(
+  params: Awaited<ReturnType<typeof searchWeb>>,
+  options: { includeContent: boolean },
+): string {
   const lines = [`Coze web search: ${params.query}`];
   if (params.summary) {
     lines.push("", `Summary: ${params.summary}`);
@@ -76,6 +79,10 @@ function buildSearchText(params: Awaited<ReturnType<typeof searchWeb>>): string
     if (item.snippet) {
       lines.push(`   ${item.snippet}`);
     }
+    if (options.includeContent && item.content) {
+      lines.push("   Content:");
+      lines.push(`   ${item.content}`);
+    }
   }
   return lines.join("\n");
 }
@@ -107,7 +114,12 @@ export function createCozeWebSearchTool(params: {
       try {
         const result = await searchWeb(toolParams, clientConfig);
         return {
-          content: [{ type: "text", text: buildSearchText(result) }],
+          content: [
+            {
+              type: "text",
+              text: buildSearchText(result, { includeContent: toolParams.needContent === true }),
+            },
+          ],
           details: {
             query: result.query,
             type: result.type,