kimiflare 0.37.0 → 0.38.1

package/dist/index.js

@@ -1,5 +1,9 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -9,10 +13,29 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/config.ts
 var config_exports = {};
@@ -486,6 +509,7 @@ async function* runKimi(opts2) {
   if (opts2.cloudMode && !opts2.cloudToken) {
     throw new KimiApiError("kimiflare: cloud mode requires a cloud token. Run `kimiflare auth cloud` to authenticate.", void 0, 401);
   }
+  const requestId = opts2.requestId ?? crypto.randomUUID();
   const { url, headers: gatewayHeaders } = buildKimiRequestTarget(opts2);
   const body = {
     messages: sanitizeMessagesForApi(opts2.messages),
@@ -510,6 +534,7 @@ async function* runKimi(opts2) {
         headers["X-Session-ID"] = opts2.sessionId;
         headers["x-session-affinity"] = opts2.sessionId;
       }
+      headers["X-Request-ID"] = requestId;
       res = await fetch(url, {
         method: "POST",
         headers,
@@ -547,7 +572,31 @@ async function* runKimi(opts2) {
     if (!res.body) throw new KimiApiError("kimiflare: empty response body", void 0, res.status);
     const meta = readGatewayMeta(res.headers);
     if (meta) yield { type: "gateway_meta", meta };
-    yield* parseStream(res.body, opts2.signal);
+    let lastUsage = null;
+    for await (const ev of parseStream(res.body, opts2.signal)) {
+      if (ev.type === "usage") lastUsage = ev.usage;
+      yield ev;
+    }
+    if (opts2.cloudMode && lastUsage && opts2.cloudToken) {
+      const reportUrl = "https://api.kimiflare.com/v1/usage/report";
+      const reportHeaders = {
+        Authorization: `Bearer ${opts2.cloudToken}`,
+        "Content-Type": "application/json"
+      };
+      if (opts2.cloudDeviceId) reportHeaders["X-Device-ID"] = opts2.cloudDeviceId;
+      if (opts2.sessionId) reportHeaders["X-Session-ID"] = opts2.sessionId;
+      fetch(reportUrl, {
+        method: "POST",
+        headers: reportHeaders,
+        body: JSON.stringify({
+          request_id: requestId,
+          prompt_tokens: lastUsage.prompt_tokens,
+          completion_tokens: lastUsage.completion_tokens,
+          cached_tokens: lastUsage.prompt_tokens_details?.cached_tokens ?? 0
+        })
+      }).catch(() => {
+      });
+    }
     return;
   }
 }
@@ -1391,6 +1440,197 @@ var init_api_generator = __esm({
   }
 });
 
+// node_modules/node-gyp-build/node-gyp-build.js
+var require_node_gyp_build = __commonJS({
+  "node_modules/node-gyp-build/node-gyp-build.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var os2 = __require("os");
+    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+    var vars = process.config && process.config.variables || {};
+    var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
+    var abi = process.versions.modules;
+    var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
+    var arch = process.env.npm_config_arch || os2.arch();
+    var platform3 = process.env.npm_config_platform || os2.platform();
+    var libc = process.env.LIBC || (isAlpine(platform3) ? "musl" : "glibc");
+    var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
+    var uv = (process.versions.uv || "").split(".")[0];
+    module.exports = load;
+    function load(dir) {
+      return runtimeRequire(load.resolve(dir));
+    }
+    load.resolve = load.path = function(dir) {
+      dir = path.resolve(dir || ".");
+      try {
+        var name = runtimeRequire(path.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+        if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
+      } catch (err) {
+      }
+      if (!prebuildsOnly) {
+        var release2 = getFirst(path.join(dir, "build/Release"), matchBuild);
+        if (release2) return release2;
+        var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
+        if (debug) return debug;
+      }
+      var prebuild = resolve2(dir);
+      if (prebuild) return prebuild;
+      var nearby = resolve2(path.dirname(process.execPath));
+      if (nearby) return nearby;
+      var target = [
+        "platform=" + platform3,
+        "arch=" + arch,
+        "runtime=" + runtime,
+        "abi=" + abi,
+        "uv=" + uv,
+        armv ? "armv=" + armv : "",
+        "libc=" + libc,
+        "node=" + process.versions.node,
+        process.versions.electron ? "electron=" + process.versions.electron : "",
+        typeof __webpack_require__ === "function" ? "webpack=true" : ""
+        // eslint-disable-line
+      ].filter(Boolean).join(" ");
+      throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
+      function resolve2(dir2) {
+        var tuples = readdirSync(path.join(dir2, "prebuilds")).map(parseTuple);
+        var tuple = tuples.filter(matchTuple(platform3, arch)).sort(compareTuples)[0];
+        if (!tuple) return;
+        var prebuilds = path.join(dir2, "prebuilds", tuple.name);
+        var parsed = readdirSync(prebuilds).map(parseTags);
+        var candidates = parsed.filter(matchTags(runtime, abi));
+        var winner = candidates.sort(compareTags(runtime))[0];
+        if (winner) return path.join(prebuilds, winner.file);
+      }
+    };
+    function readdirSync(dir) {
+      try {
+        return fs.readdirSync(dir);
+      } catch (err) {
+        return [];
+      }
+    }
+    function getFirst(dir, filter) {
+      var files = readdirSync(dir).filter(filter);
+      return files[0] && path.join(dir, files[0]);
+    }
+    function matchBuild(name) {
+      return /\.node$/.test(name);
+    }
+    function parseTuple(name) {
+      var arr = name.split("-");
+      if (arr.length !== 2) return;
+      var platform4 = arr[0];
+      var architectures = arr[1].split("+");
+      if (!platform4) return;
+      if (!architectures.length) return;
+      if (!architectures.every(Boolean)) return;
+      return { name, platform: platform4, architectures };
+    }
+    function matchTuple(platform4, arch2) {
+      return function(tuple) {
+        if (tuple == null) return false;
+        if (tuple.platform !== platform4) return false;
+        return tuple.architectures.includes(arch2);
+      };
+    }
+    function compareTuples(a, b) {
+      return a.architectures.length - b.architectures.length;
+    }
+    function parseTags(file) {
+      var arr = file.split(".");
+      var extension = arr.pop();
+      var tags = { file, specificity: 0 };
+      if (extension !== "node") return;
+      for (var i = 0; i < arr.length; i++) {
+        var tag = arr[i];
+        if (tag === "node" || tag === "electron" || tag === "node-webkit") {
+          tags.runtime = tag;
+        } else if (tag === "napi") {
+          tags.napi = true;
+        } else if (tag.slice(0, 3) === "abi") {
+          tags.abi = tag.slice(3);
+        } else if (tag.slice(0, 2) === "uv") {
+          tags.uv = tag.slice(2);
+        } else if (tag.slice(0, 4) === "armv") {
+          tags.armv = tag.slice(4);
+        } else if (tag === "glibc" || tag === "musl") {
+          tags.libc = tag;
+        } else {
+          continue;
+        }
+        tags.specificity++;
+      }
+      return tags;
+    }
+    function matchTags(runtime2, abi2) {
+      return function(tags) {
+        if (tags == null) return false;
+        if (tags.runtime && tags.runtime !== runtime2 && !runtimeAgnostic(tags)) return false;
+        if (tags.abi && tags.abi !== abi2 && !tags.napi) return false;
+        if (tags.uv && tags.uv !== uv) return false;
+        if (tags.armv && tags.armv !== armv) return false;
+        if (tags.libc && tags.libc !== libc) return false;
+        return true;
+      };
+    }
+    function runtimeAgnostic(tags) {
+      return tags.runtime === "node" && tags.napi;
+    }
+    function compareTags(runtime2) {
+      return function(a, b) {
+        if (a.runtime !== b.runtime) {
+          return a.runtime === runtime2 ? -1 : 1;
+        } else if (a.abi !== b.abi) {
+          return a.abi ? -1 : 1;
+        } else if (a.specificity !== b.specificity) {
+          return a.specificity > b.specificity ? -1 : 1;
+        } else {
+          return 0;
+        }
+      };
+    }
+    function isNwjs() {
+      return !!(process.versions && process.versions.nw);
+    }
+    function isElectron() {
+      if (process.versions && process.versions.electron) return true;
+      if (process.env.ELECTRON_RUN_AS_NODE) return true;
+      return typeof window !== "undefined" && window.process && window.process.type === "renderer";
+    }
+    function isAlpine(platform4) {
+      return platform4 === "linux" && fs.existsSync("/etc/alpine-release");
+    }
+    load.parseTags = parseTags;
+    load.matchTags = matchTags;
+    load.compareTags = compareTags;
+    load.parseTuple = parseTuple;
+    load.matchTuple = matchTuple;
+    load.compareTuples = compareTuples;
+  }
+});
+
+// node_modules/node-gyp-build/index.js
+var require_node_gyp_build2 = __commonJS({
+  "node_modules/node-gyp-build/index.js"(exports, module) {
+    "use strict";
+    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+    if (typeof runtimeRequire.addon === "function") {
+      module.exports = runtimeRequire.addon.bind(runtimeRequire);
+    } else {
+      module.exports = require_node_gyp_build();
+    }
+  }
+});
+
+// node_modules/isolated-vm/isolated-vm.js
+var require_isolated_vm = __commonJS({
+  "node_modules/isolated-vm/isolated-vm.js"(exports, module) {
+    "use strict";
+    module.exports = require_node_gyp_build2()(__dirname).ivm;
+  }
+});
+
 // src/code-mode/sandbox.ts
 import { join as join6, dirname as dirname3 } from "path";
 import { pathToFileURL } from "url";
@@ -1446,7 +1686,7 @@ async function transpileOrStrip(code, cwd) {
   };
 }
 async function runWithIsolatedVm(opts2) {
-  const { Isolate } = await import("isolated-vm");
+  const { Isolate } = await Promise.resolve().then(() => __toESM(require_isolated_vm(), 1));
   const isolate = new Isolate({ memoryLimit: opts2.memoryLimitMB ?? 128 });
   const context = await isolate.createContext();
   const jail = context.global;
@@ -1463,7 +1703,7 @@ async function runWithIsolatedVm(opts2) {
   await context.eval(`var console = { log: function(...args) { _log(args.map(String).join(" ")); } };`);
   const toolMap = new Map(opts2.tools.map((t) => [t.name, t]));
   for (const tool of opts2.tools) {
-    const ref = new (await import("isolated-vm")).Reference(
+    const ref = new (await Promise.resolve().then(() => __toESM(require_isolated_vm(), 1))).Reference(
       async (argsJson) => {
         const args = JSON.parse(argsJson);
         const toolCallId = `code_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
@@ -1596,14 +1836,18 @@ async function runInSandbox(opts2) {
   } catch (err) {
     const message2 = err instanceof Error ? err.message : String(err);
     if (message2.includes("isolated-vm") || message2.includes("Cannot find module") || message2.includes("bindings")) {
-      return runWithNodeVm(opts2);
+      const result2 = await runWithNodeVm(opts2);
+      return { ...result2, warnings: [ISOLATED_VM_FALLBACK_WARNING, ...result2.warnings ?? []] };
     }
-    return runWithNodeVm(opts2);
+    const result = await runWithNodeVm(opts2);
+    return { ...result, warnings: [ISOLATED_VM_FALLBACK_WARNING, ...result.warnings ?? []] };
   }
 }
+var ISOLATED_VM_FALLBACK_WARNING;
 var init_sandbox = __esm({
   "src/code-mode/sandbox.ts"() {
     "use strict";
+    ISOLATED_VM_FALLBACK_WARNING = "\u26A0\uFE0F  Code sandbox is running without memory limits or true process isolation (isolated-vm unavailable or failed to load). For a secure sandbox, install with Node 22 LTS: nvm install 22 && nvm use 22 && npm install -g kimiflare";
   }
 });
 
@@ -4049,13 +4293,13 @@ async function checkDeployStatus() {
   }
   return { wrangler, wranglerAuth, docker, workerUrl };
 }
-var __dirname, REMOTE_DIR, WORKER_DIR;
+var __dirname2, REMOTE_DIR, WORKER_DIR;
 var init_deploy = __esm({
   "src/remote/deploy.ts"() {
     "use strict";
     init_config();
-    __dirname = dirname6(fileURLToPath3(import.meta.url));
-    REMOTE_DIR = join11(__dirname, "..", "..", "..", "remote");
+    __dirname2 = dirname6(fileURLToPath3(import.meta.url));
+    REMOTE_DIR = join11(__dirname2, "..", "..", "..", "remote");
     WORKER_DIR = join11(REMOTE_DIR, "worker");
   }
 });