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

package/src/streamExtract.js

@@ -0,0 +1,75 @@
+import { ENABLE_THINKING } from "./constant.js";
+
+export const streamChunkExtract = (buf) => {
+  const extracted_li = [],
+    line_li = buf.split("\n"),
+    next_buf = line_li.pop() ?? "";
+
+  line_li.forEach((raw_line) => {
+    const line = raw_line.trim();
+    if (!line || !line.includes('"wrb.fr"')) return;
+    try {
+      const item_li = JSON.parse(line);
+      if (Array.isArray(item_li)) {
+        item_li.forEach((item) => {
+          if (Array.isArray(item) && item[2]) {
+            const inner = JSON.parse(item[2]),
+              cand_li = inner[4];
+            if (Array.isArray(cand_li) && cand_li.length > 0) {
+              const cand = cand_li[0],
+                thoughts = cand[37]?.[0]?.[0] ?? "",
+                raw_text = cand[1]?.[0] ?? "",
+                card_text = raw_text.startsWith("http://googleusercontent.com/card_content/")
+                  ? (cand[22]?.[0] ?? raw_text)
+                  : raw_text,
+                text = card_text.replaceAll(
+                  /https?:\/\/googleusercontent\.com\/(?:\w+\/)+\d+\n*/g,
+                  "",
+                );
+              extracted_li.push({ thoughts, text });
+            }
+          }
+        });
+      }
+    } catch {
+      // ignore non-json or malformed lines
+    }
+  });
+
+  return [extracted_li, next_buf];
+},
+
+fullResponseCollect = async (body) => {
+  const reader = body.getReader(),
+    decoder = new TextDecoder();
+  let buf = "",
+    final_text = "",
+    final_thought = "";
+
+  const textUpdate = ({ thoughts, text }) => {
+    if (text) final_text = text;
+    if (thoughts) final_thought = thoughts;
+  };
+
+  while (true) {
+    const read_res = await reader.read();
+    if (read_res.done) {
+      if (buf.trim()) {
+        const [remaining_li] = streamChunkExtract(buf + "\n");
+        remaining_li.forEach(textUpdate);
+      }
+      break;
+    }
+    buf += decoder.decode(read_res.value, { stream: true });
+
+    const [extracted_li, next_buf] = streamChunkExtract(buf);
+    buf = next_buf;
+    extracted_li.forEach(textUpdate);
+  }
+
+  let content = final_text;
+  if (ENABLE_THINKING && final_thought) {
+    content = "<think>\n" + final_thought + "\n</think>\n\n" + final_text;
+  }
+  return [content, final_text, final_thought];
+};

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 table with headers and models", () => {
+  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("支持的模型列表 (Supported Models):"));
+  assert.ok(output.includes("模型 ID (Model ID)"));
+  assert.ok(output.includes("显示名称 (Name)"));
+  assert.ok(output.includes("别名 (Aliases)"));
+  assert.ok(output.includes("gemini-3.8-flash"));
+  assert.ok(output.includes("★"));
+  assert.ok(output.includes("(默认)"));
+  assert.ok(output.includes("gemini-3.1-pro"));
+  assert.ok(output.includes("gemini-flash, flash, 3.8-flash"));
+  assert.ok(!output.includes("56fdd199312815e2"));
+});
+
+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));
+});