@8-/gemini-web-api 1.0.0 → 1.0.1

package/test/toolHandle.test.js

@@ -0,0 +1,243 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  jsonFormat,
+  jsonParseSafe,
+  toolCallExtract,
+  toolFenceGateCreate,
+  toolPromptBuild,
+  toolResultFormat,
+} from "../src/toolHandle.js";
+import { conversationFormat } from "../src/payloadBuild.js";
+
+test("toolPromptBuild generates prompt with function definitions", () => {
+  const tool_li = [
+      {
+        type: "function",
+        function: {
+          name: "get_weather",
+          description: "Get current weather",
+          parameters: {
+            type: "object",
+            properties: {
+              city: { type: "string" },
+            },
+            required: ["city"],
+          },
+        },
+      },
+    ],
+    prompt = toolPromptBuild(tool_li);
+
+  assert.ok(prompt.includes("# TOOLS"));
+  assert.ok(prompt.includes("get_weather"));
+  assert.ok(prompt.includes("```tool_call"));
+});
+
+test("toolPromptBuild respects tool_choice constraints", () => {
+  const tool_li = [
+    {
+      type: "function",
+      function: { name: "get_weather", description: "Get weather" },
+    },
+    {
+      type: "function",
+      function: { name: "search", description: "Search web" },
+    },
+  ];
+
+  assert.equal(toolPromptBuild(tool_li, "none"), "");
+
+  const required_prompt = toolPromptBuild(tool_li, "required");
+  assert.ok(required_prompt.includes("You MUST call at least one of the tools above"));
+
+  const forced_prompt = toolPromptBuild(tool_li, {
+    type: "function",
+    function: { name: "search" },
+  });
+  assert.ok(forced_prompt.includes('You MUST call the tool "search"'));
+  assert.ok(!forced_prompt.includes("get_weather"));
+});
+
+test("toolResultFormat handles exit codes and empty results cleanly", () => {
+  const empty_res = toolResultFormat("exec", ""),
+    exit_zero_empty = toolResultFormat("exec", "Process exited with code 0\nOutput:\n"),
+    exit_zero_output = toolResultFormat("exec", "Process exited with code 0\nOutput:\nhello world"),
+    exit_err = toolResultFormat("exec", "Process exited with code 127\nOutput:\ncommand not found");
+
+  assert.ok(empty_res.includes("✅ 完成，无输出"));
+  assert.ok(exit_zero_empty.includes("✅ 命令成功（exit 0），无文本输出"));
+  assert.ok(exit_zero_output.includes("✅ 命令成功（exit 0）。输出：\nhello world"));
+  assert.ok(exit_err.includes("❌ 命令失败（exit 127）"));
+});
+
+test("toolCallExtract parses fenced tool calls accurately", () => {
+  const text =
+      "Here is the data:\n" +
+      "```tool_call\n" +
+      '{"name": "get_weather", "arguments": {"city": "Tokyo"}}\n' +
+      "```\n" +
+      "Have a nice day!",
+    [clean_text, call_li] = toolCallExtract(text);
+
+  assert.equal(call_li.length, 1);
+  assert.equal(call_li[0].function.name, "get_weather");
+  assert.equal(call_li[0].function.arguments, '{"city":"Tokyo"}');
+  assert.ok(!clean_text.includes("```tool_call"));
+  assert.ok(clean_text.includes("Here is the data:"));
+  assert.ok(clean_text.includes("Have a nice day!"));
+});
+
+test("toolFenceGate prevents tool fence from leaking during streaming", () => {
+  const emitted_li = [],
+    gate = toolFenceGateCreate((chunk) => {
+      emitted_li.push(chunk);
+    });
+
+  gate.push("Hello! ");
+  gate.push("I will check the weather. ");
+  gate.push("```");
+  gate.push("tool_call\n");
+  gate.push('{"name": "get_weather", "arguments": {"city": "Paris"}}\n');
+  gate.push("```");
+  gate.push(" Hope that helps!");
+  gate.flush();
+
+  const joined = emitted_li.join("");
+  assert.ok(!joined.includes("```tool_call"));
+  assert.ok(!joined.includes("get_weather"));
+  assert.ok(joined.includes("Hello! I will check the weather. "));
+  assert.ok(joined.includes(" Hope that helps!"));
+});
+
+test("conversationFormat formats multi-turn tool history", () => {
+  const msg_li = [
+      { role: "user", content: "What is the weather in Paris?" },
+      {
+        role: "assistant",
+        content: "Let me check.",
+        tool_calls: [
+          {
+            id: "call_1",
+            type: "function",
+            function: { name: "get_weather", arguments: '{"city":"Paris"}' },
+          },
+        ],
+      },
+      { role: "tool", name: "get_weather", content: '{"temp": "22C"}' },
+    ],
+    tool_li = [
+      {
+        type: "function",
+        function: { name: "get_weather", description: "Get weather" },
+      },
+    ],
+    conversation = conversationFormat(msg_li, tool_li);
+
+  assert.ok(conversation.includes("[System instruction]:"));
+  assert.ok(conversation.includes("Human: What is the weather in Paris?"));
+  assert.ok(conversation.includes("Assistant: Let me check."));
+  assert.ok(conversation.includes('```tool_call\n{"name":"get_weather","arguments":{"city":"Paris"}}\n```'));
+  assert.ok(conversation.includes("[Tool result for get_weather]:"));
+  assert.ok(conversation.includes("[System instruction — highest priority]:"));
+});
+
+test("toolCallExtract parses ZCode actual failed output (missing opening backticks)", () => {
+  const text =
+      'tool_call\n{"name": "Agent", "arguments": {"description": "Search bftree in garnet", "prompt": "Search ./garnet code.", "subagent_type": "Explore"}}\n```',
+    [clean_text, call_li] = toolCallExtract(text);
+
+  assert.equal(call_li.length, 1);
+  assert.equal(call_li[0].function.name, "Agent");
+  const args = JSON.parse(call_li[0].function.arguments);
+  assert.equal(args.description, "Search bftree in garnet");
+  assert.equal(args.subagent_type, "Explore");
+  assert.equal(clean_text, "");
+});
+
+test("toolCallExtract handles markdown escaped underscores and json tool_calls array", () => {
+  const escaped_text =
+      '```tool_call\n{"name": "Agent", "arguments": {"subagent\\_type": "Explore"}}\n```',
+    [, escaped_call_li] = toolCallExtract(escaped_text);
+
+  assert.equal(escaped_call_li.length, 1);
+  const escaped_args = JSON.parse(escaped_call_li[0].function.arguments);
+  assert.equal(escaped_args.subagent_type, "Explore");
+
+  const json_array_text =
+      '```json\n{"tool_calls": [{"name": "read", "arguments": {"path": "a.txt"}}]}\n```',
+    [, arr_call_li] = toolCallExtract(json_array_text);
+
+  assert.equal(arr_call_li.length, 1);
+  assert.equal(arr_call_li[0].function.name, "read");
+  assert.equal(JSON.parse(arr_call_li[0].function.arguments).path, "a.txt");
+});
+
+test("toolCallExtract parses bare JSON tool call", () => {
+  const bare_text = '{"name": "Agent", "arguments": {"task": "inspect"}}',
+    [, call_li] = toolCallExtract(bare_text);
+
+  assert.equal(call_li.length, 1);
+  assert.equal(call_li[0].function.name, "Agent");
+  assert.equal(JSON.parse(call_li[0].function.arguments).task, "inspect");
+});
+
+test("conversationFormat supports Vercel AI-SDK / ZCode message format (toolCalls, input, toolName)", () => {
+  const msg_li = [
+      {
+        role: "assistant",
+        content: "",
+        toolCalls: [
+          {
+            id: "tool_123",
+            name: "Bash",
+            input: { command: "ls -la" },
+          },
+        ],
+      },
+      {
+        role: "tool",
+        toolName: "Bash",
+        toolCallId: "tool_123",
+        content: "Exit code 0\nOutput:\nfile1.txt",
+      },
+    ],
+    conversation = conversationFormat(msg_li);
+
+  assert.ok(conversation.includes('```tool_call\n{"name":"Bash","arguments":{"command":"ls -la"}}\n```'));
+  assert.ok(conversation.includes("[Tool result for Bash]:"));
+  assert.ok(conversation.includes("file1.txt"));
+});
+
+test("toolCallExtract parses restarted / duplicate fence output", () => {
+  const bad_text =
+      '```tool_call\n{"name```tool_call\n{"name": "get_weather", "arguments": {"city": "Tokyo"}}\n```',
+    [clean_text, call_li] = toolCallExtract(bad_text);
+
+  assert.equal(call_li.length, 1);
+  assert.equal(call_li[0].function.name, "get_weather");
+  assert.equal(JSON.parse(call_li[0].function.arguments).city, "Tokyo");
+  assert.equal(clean_text, "");
+});
+
+test("toolCallExtract parses multiple bare JSON tool calls", () => {
+  const multi_bare_text =
+      'Calling: {"name": "func_a", "arguments": {"x": 1}}, and {"name": "func_b", "arguments": {"y": 2}}',
+    [, call_li] = toolCallExtract(multi_bare_text);
+
+  assert.equal(call_li.length, 2);
+  assert.equal(call_li[0].function.name, "func_a");
+  assert.equal(call_li[1].function.name, "func_b");
+  assert.equal(JSON.parse(call_li[0].function.arguments).x, 1);
+  assert.equal(JSON.parse(call_li[1].function.arguments).y, 2);
+});
+
+test("jsonFormat formats objects and strings cleanly", () => {
+  const formatted = jsonFormat({ a: 1, b: "test" });
+  assert.ok(formatted.includes('"a"') && formatted.includes("1"));
+  assert.ok(formatted.includes('"b"') && formatted.includes("test"));
+
+  const raw_str = jsonFormat("simple text");
+  assert.equal(raw_str, "simple text");
+});
+