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

package/src/toolHandle.js

@@ -0,0 +1,332 @@
+import { TOOL_FENCE_CLOSE, TOOL_FENCE_OPEN } from "./constant.js";
+
+export const jsonFormat = (val) => {
+  try {
+    const obj = typeof val === "string" ? JSON.parse(val) : val,
+      json_str = JSON.stringify(obj, null, 2);
+    if (process.stdout?.isTTY) {
+      return json_str.replaceAll(
+        /("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g,
+        (match) => {
+          if (match.startsWith('"')) {
+            if (match.endsWith(":")) return "\x1b[36m" + match + "\x1b[0m";
+            return "\x1b[32m" + match + "\x1b[0m";
+          }
+          if (match === "true" || match === "false") return "\x1b[33m" + match + "\x1b[0m";
+          if (match === "null") return "\x1b[35m" + match + "\x1b[0m";
+          return "\x1b[34m" + match + "\x1b[0m";
+        },
+      );
+    }
+    return json_str;
+  } catch {
+    return String(val ?? "");
+  }
+},
+
+jsonParseSafe = (str) => {
+  if (!str) return null;
+  const trimmed = str.trim().replaceAll("\\_", "_");
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    try {
+      const repaired = trimmed
+        .replaceAll(/\\([^"\\/bfnrtu])/g, "$1")
+        .replaceAll(/,\s*([\]}])/g, "$1")
+        .replaceAll(/([{,]\s*)([a-zA-Z0-9_]+)\s*:/g, '$1"$2":');
+      return JSON.parse(repaired);
+    } catch {
+      return null;
+    }
+  }
+},
+
+toolObjectNormalize = (data) => {
+  const result_li = [];
+  if (!data) return result_li;
+
+  const itemPush = (item) => {
+    if (!item || typeof item !== "object") return;
+    const name = item.name ?? item.function?.name ?? "",
+      raw_args = item.arguments ?? item.args ?? item.input ?? item.function?.arguments ?? {},
+      args_str = typeof raw_args === "string" ? raw_args : JSON.stringify(raw_args);
+    if (name) {
+      result_li.push({
+        id: "call_" + crypto.randomUUID().replaceAll("-", "").slice(0, 24),
+        type: "function",
+        function: {
+          name,
+          arguments: args_str,
+        },
+      });
+    }
+  };
+
+  if (Array.isArray(data)) {
+    data.forEach(itemPush);
+  } else if (Array.isArray(data.tool_calls)) {
+    data.tool_calls.forEach(itemPush);
+  } else if (data.name || data.function?.name) {
+    itemPush(data);
+  }
+
+  return result_li;
+},
+
+toolPromptBuild = (tool_li, tool_choice) => {
+  if (!tool_li || tool_li.length === 0) return "";
+  let forced_name = "";
+  if (typeof tool_choice === "string") {
+    if (tool_choice === "none") return "";
+  } else if (tool_choice?.function?.name) {
+    forced_name = tool_choice.function.name;
+  }
+
+  const def_li = tool_li
+    .map((tool) => {
+      const fn = tool.function ?? tool;
+      return {
+        name: fn.name ?? "",
+        description: fn.description ?? "",
+        parameters: fn.parameters ?? { type: "object", properties: {} },
+      };
+    })
+    .filter((def_item) => !forced_name || def_item.name === forced_name);
+
+  if (def_li.length === 0) return "";
+
+  const rule = forced_name
+      ? "You MUST call the tool \"" +
+        forced_name +
+        "\". Reply with the tool_call block and nothing else. Do not answer yourself."
+      : tool_choice === "required"
+        ? "You MUST call at least one of the tools above. Reply with the tool_call block and nothing else. Do not answer yourself."
+        : "Only use tool_call blocks when a tool execution is needed.",
+    defs_json = JSON.stringify(def_li, null, 2);
+  return (
+    "# TOOLS\n\n" +
+    "You have access to the following tools. To call a tool, respond with:\n" +
+    "```tool_call\n" +
+    "{\"name\": \"tool_name\", \"arguments\": {...}}\n" +
+    "```\n\n" +
+    rule +
+    "\n\n" +
+    "Available tools:\n" +
+    defs_json
+  );
+},
+
+toolTailAnchorBuild = () =>
+  "[System instruction — highest priority]: To run a tool, you MUST output a ```tool_call``` block. " +
+  "When the request needs a tool, your reply is ONE ```tool_call``` block and nothing else. " +
+  "Do not output conversational filler or explanation before or after the tool_call block. Act, do not explain.",
+
+toolResultFormat = (name, raw) => {
+  const label = name ? "Tool result for " + name : "Tool result",
+    trimmed = (raw ?? "").trim();
+  if (!trimmed) {
+    return "[" + label + "]: ✅ 完成，无输出（正常，动作已生效，请勿重复执行）。";
+  }
+  const match = trimmed.match(/exit(?:ed with|\s*code)?\s*(?:code\s*)?(\d+)/i);
+  if (match) {
+    const code = match[1],
+      out_idx = trimmed.lastIndexOf("Output:");
+    let out = trimmed;
+    if (out_idx >= 0) {
+      out = trimmed.slice(out_idx + 7).trim();
+    }
+    if (code === "0") {
+      if (!out) {
+        return "[" + label + "]: ✅ 命令成功（exit 0），无文本输出（正常，动作已生效，请勿重复执行）。";
+      }
+      return "[" + label + "]: ✅ 命令成功（exit 0）。输出：\n" + out;
+    }
+    return "[" + label + "]: ❌ 命令失败（exit " + code + "）。输出：\n" + out;
+  }
+  return "[" + label + "]: " + trimmed;
+},
+
+toolBracketExtract = (text, start_ch, close_ch, start_idx) => {
+  let depth = 0,
+    in_str = false,
+    escape = false;
+  for (let i = start_idx; i < text.length; ++i) {
+    const c = text[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (c === "\\") {
+      escape = true;
+      continue;
+    }
+    if (c === '"') {
+      in_str = !in_str;
+      continue;
+    }
+    if (!in_str) {
+      if (c === start_ch) {
+        ++depth;
+      } else if (c === close_ch) {
+        --depth;
+        if (depth === 0) {
+          return text.slice(start_idx, i + 1);
+        }
+      }
+    }
+  }
+  return null;
+},
+
+toolCallExtract = (text) => {
+  if (!text) return ["", []];
+  const tool_call_li = [],
+    fence_re = /```(?:tool_calls?|json)?\s*([\s\S]*?)```/gi;
+  let cleaned = text.replaceAll("\\_", "_"),
+    match;
+
+  // Strategy 1: Fenced code blocks ```tool_call, ```tool_calls, ```json, or bare ```
+  while ((match = fence_re.exec(cleaned)) !== null) {
+    const body = match[1].trim(),
+      data = jsonParseSafe(body);
+    if (data) {
+      const parsed_li = toolObjectNormalize(data);
+      if (parsed_li.length > 0) {
+        tool_call_li.push(...parsed_li);
+      }
+    }
+  }
+
+  // Strategy 2: Array matching on "tool_calls"
+  if (tool_call_li.length === 0) {
+    let key_idx = cleaned.indexOf('"tool_calls"');
+    while (key_idx !== -1) {
+      const arr_start = cleaned.indexOf("[", key_idx);
+      if (arr_start !== -1) {
+        const arr_blob = toolBracketExtract(cleaned, "[", "]", arr_start);
+        if (arr_blob) {
+          const arr = jsonParseSafe(arr_blob);
+          if (Array.isArray(arr)) {
+            const parsed_li = toolObjectNormalize({ tool_calls: arr });
+            if (parsed_li.length > 0) {
+              tool_call_li.push(...parsed_li);
+            }
+          }
+          key_idx = cleaned.indexOf('"tool_calls"', arr_start + arr_blob.length);
+          continue;
+        }
+      }
+      key_idx = cleaned.indexOf('"tool_calls"', key_idx + 12);
+    }
+  }
+
+  // Strategy 3: Missing opening backticks or unclosed fence (e.g. tool_call\n{...}``` or tool_call\n{...})
+  if (tool_call_li.length === 0) {
+    const unfenced_re = /(?:^|\n)\s*(?:tool_calls?|json)?\s*(\{[\s\S]*?\})\s*(?:```|$)/gi;
+    while ((match = unfenced_re.exec(cleaned)) !== null) {
+      const data = jsonParseSafe(match[1]);
+      if (data) {
+        const parsed_li = toolObjectNormalize(data);
+        if (parsed_li.length > 0) {
+          tool_call_li.push(...parsed_li);
+        }
+      }
+    }
+  }
+
+  // Strategy 4: Bracket matching on any JSON object containing "name" and ("arguments" | "args" | "input")
+  if (tool_call_li.length === 0) {
+    let name_idx = cleaned.indexOf('"name"');
+    while (name_idx !== -1) {
+      const brace_start = cleaned.lastIndexOf("{", name_idx);
+      if (brace_start !== -1) {
+        const obj_blob = toolBracketExtract(cleaned, "{", "}", brace_start);
+        if (obj_blob) {
+          const data = jsonParseSafe(obj_blob);
+          if (data && (data.arguments || data.args || data.input || data.function)) {
+            const parsed_li = toolObjectNormalize(data);
+            if (parsed_li.length > 0) {
+              tool_call_li.push(...parsed_li);
+            }
+          }
+          name_idx = cleaned.indexOf('"name"', brace_start + obj_blob.length);
+          continue;
+        }
+      }
+      name_idx = cleaned.indexOf('"name"', name_idx + 6);
+    }
+  }
+
+  let clean_text = cleaned;
+  if (tool_call_li.length > 0) {
+    clean_text = clean_text
+      .replaceAll(/```(?:tool_calls?|json)?\s*[\s\S]*?```/gi, "")
+      .replaceAll(/(?:^|\n)\s*(?:tool_calls?|json)?\s*\{[\s\S]*?\}\s*(?:```|$)/gi, "")
+      .replaceAll(/\{\s*"tool_calls"\s*:[\s\S]*?\]\s*\}/g, "")
+      .replaceAll(/^\s*tool_calls?\s*/gi, "")
+      .trim();
+  }
+
+  return [clean_text, tool_call_li];
+},
+
+toolFenceGateCreate = (onEmit) => {
+  const state = {
+      buf: "",
+      sent: "",
+      in_fence: false,
+    },
+    partialPrefixLen = (s, marker) => {
+      const max = Math.min(s.length, marker.length - 1);
+      for (let k = max; k > 0; --k) {
+        if (marker.startsWith(s.slice(s.length - k))) {
+          return k;
+        }
+      }
+      return 0;
+    },
+    send = (s) => {
+      if (!s) return;
+      state.sent += s;
+      onEmit(s);
+    },
+    push = (delta) => {
+      state.buf += delta;
+      while (state.buf.length > 0) {
+        if (state.in_fence) {
+          const close_idx = state.buf.indexOf(TOOL_FENCE_CLOSE);
+          if (close_idx < 0) {
+            return;
+          }
+          state.buf = state.buf.slice(close_idx + TOOL_FENCE_CLOSE.length);
+          state.in_fence = false;
+          continue;
+        }
+
+        const open_idx = state.buf.indexOf(TOOL_FENCE_OPEN);
+        if (open_idx >= 0) {
+          send(state.buf.slice(0, open_idx));
+          state.buf = state.buf.slice(open_idx + TOOL_FENCE_OPEN.length);
+          state.in_fence = true;
+          continue;
+        }
+
+        const keep = partialPrefixLen(state.buf, TOOL_FENCE_OPEN),
+          yield_len = state.buf.length - keep;
+        if (yield_len > 0) {
+          send(state.buf.slice(0, yield_len));
+          state.buf = state.buf.slice(yield_len);
+        }
+        return;
+      }
+    },
+    flush = () => {
+      if (!state.in_fence && state.buf.length > 0) {
+        send(state.buf);
+        state.buf = "";
+      }
+    };
+
+  return { push, flush, state };
+};

package/test/modelDiscover.test.js

@@ -0,0 +1,105 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  modelListFormat,
+  modelMap,
+  stringPadEnd,
+  stringVisualWidth,
+  versionCompare,
+} from "../src/modelDiscover.js";
+import { DEFAULT_MODEL_LI } from "../src/constant.js";
+
+test("stringVisualWidth correctly measures ASCII and East Asian characters", () => {
+  assert.equal(stringVisualWidth("abc 123"), 7);
+  assert.equal(stringVisualWidth("你好"), 4);
+  assert.equal(stringVisualWidth("Gemini 模型"), 11);
+  assert.equal(stringVisualWidth(""), 0);
+  assert.equal(stringVisualWidth(null), 0);
+});
+
+test("stringPadEnd pads string to target visual width", () => {
+  const padded_ascii = stringPadEnd("abc", 6),
+    padded_cjk = stringPadEnd("你好", 6);
+  assert.equal(padded_ascii, "abc   ");
+  assert.equal(stringVisualWidth(padded_ascii), 6);
+  assert.equal(padded_cjk, "你好  ");
+  assert.equal(stringVisualWidth(padded_cjk), 6);
+});
+
+test("versionCompare correctly orders semantic versions", () => {
+  assert.ok(versionCompare("2.5", "1.5") > 0);
+  assert.ok(versionCompare("1.5", "2.5") < 0);
+  assert.equal(versionCompare("2.0", "2.0"), 0);
+  assert.ok(versionCompare("3.8 Flash", "3.1 Pro") > 0);
+});
+
+test("modelListFormat formats models cleanly with colors and without tables or tag symbols", () => {
+  const custom_model_li = [
+      {
+        id: "gemini-3.8-flash",
+        disp: "3.8 Flash",
+        alias_li: [
+          "56fdd199312815e2",
+          "gemini-3.8-flash",
+          "gemini-flash",
+          "flash",
+          "3.8-flash",
+        ],
+      },
+      {
+        id: "gemini-3.1-pro",
+        disp: "3.1 Pro",
+        alias_li: ["797f3d0293f288ad", "gemini-3.1-pro", "gemini-pro", "pro"],
+      },
+    ],
+    default_model = custom_model_li[0],
+    output = modelListFormat(custom_model_li, default_model);
+
+  assert.ok(output.includes("模型列表"));
+  assert.ok(output.includes("gemini-3.8-flash 当前模型"));
+  assert.ok(output.includes("gemini-3.1-pro"));
+  assert.ok(!output.includes("gemini-flash"));
+  assert.ok(!output.includes("56fdd199312815e2"));
+  assert.ok(!output.includes("┌"));
+  assert.ok(!output.includes("│"));
+  assert.ok(!output.includes("★"));
+  assert.ok(!output.includes("(默认)"));
+  assert.ok(!output.includes("支持在请求中传"));
+});
+
+test("modelListFormat sorts default model first even when not first in array", () => {
+  const custom_model_li = [
+      {
+        id: "gemini-3.5-flash-lite",
+        disp: "3.5 Flash-Lite",
+        alias_li: ["flash-lite"],
+      },
+      {
+        id: "gemini-3.8-flash",
+        disp: "3.8 Flash",
+        alias_li: ["flash"],
+      },
+    ],
+    default_model = custom_model_li[1],
+    output = modelListFormat(custom_model_li, default_model),
+    flash_idx = output.indexOf("gemini-3.8-flash"),
+    lite_idx = output.indexOf("gemini-3.5-flash-lite");
+
+  assert.ok(flash_idx < lite_idx);
+  assert.ok(output.includes("gemini-3.8-flash 当前模型"));
+});
+
+test("modelListFormat falls back to DEFAULT_MODEL_LI when empty", () => {
+  const output = modelListFormat([], null);
+  assert.ok(output.includes(DEFAULT_MODEL_LI[0].id));
+  assert.ok(output.includes(DEFAULT_MODEL_LI[1].id));
+});
+
+test("modelMap resolves alias or ID correctly", () => {
+  const mapped_pro = modelMap("pro"),
+    mapped_flash = modelMap("gemini-flash"),
+    mapped_unknown = modelMap("unknown-model-foo");
+  assert.ok(mapped_pro.id.includes("pro"));
+  assert.ok(mapped_flash.id.includes("flash"));
+  assert.ok(Boolean(mapped_unknown));
+});

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");
+});
+