privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-CYQB2USO.mjs

@@ -0,0 +1,32 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  classifySystemOne
+} from "./c-TT6BCUJD.mjs";
+import {
+  isRecord
+} from "./c-WETGB2CF.mjs";
+import "./c-ZWUVHKMK.mjs";
+import "./c-EYZGSAJU.mjs";
+import "./c-ZJYLGIC3.mjs";
+import "./c-WO3QSZUU.mjs";
+import "./c-S2RVHR3M.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-ai/dist/api/typesafe-system-one.js
+var transport = {
+  api: "typesafe-system-one",
+  label: "System One API",
+  url: /* @__PURE__ */ __name((model) => new URL("systemone", `${model.baseUrl.replace(/\/+$/u, "")}/`), "url"),
+  payload: /* @__PURE__ */ __name((model, request) => ({ model: model.id, ...request }), "payload"),
+  output: /* @__PURE__ */ __name((body) => {
+    if (!isRecord(body))
+      throw new Error("System One API returned an unexpected response");
+    return body;
+  }, "output")
+};
+var classify = /* @__PURE__ */ __name((model, context, options) => classifySystemOne(transport, model, context, options), "classify");
+export {
+  classify
+};

package/dist-boot/c-DEE67DJO.mjs

@@ -0,0 +1,379 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  __commonJS,
+  __name,
+  __toESM
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/partial-json/dist/options.js
+var require_options = __commonJS({
+  "node_modules/partial-json/dist/options.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Allow = exports.ALL = exports.COLLECTION = exports.ATOM = exports.SPECIAL = exports.INF = exports._INFINITY = exports.INFINITY = exports.NAN = exports.BOOL = exports.NULL = exports.OBJ = exports.ARR = exports.NUM = exports.STR = void 0;
+    exports.STR = 1;
+    exports.NUM = 2;
+    exports.ARR = 4;
+    exports.OBJ = 8;
+    exports.NULL = 16;
+    exports.BOOL = 32;
+    exports.NAN = 64;
+    exports.INFINITY = 128;
+    exports._INFINITY = 256;
+    exports.INF = exports.INFINITY | exports._INFINITY;
+    exports.SPECIAL = exports.NULL | exports.BOOL | exports.INF | exports.NAN;
+    exports.ATOM = exports.STR | exports.NUM | exports.SPECIAL;
+    exports.COLLECTION = exports.ARR | exports.OBJ;
+    exports.ALL = exports.ATOM | exports.COLLECTION;
+    exports.Allow = { STR: exports.STR, NUM: exports.NUM, ARR: exports.ARR, OBJ: exports.OBJ, NULL: exports.NULL, BOOL: exports.BOOL, NAN: exports.NAN, INFINITY: exports.INFINITY, _INFINITY: exports._INFINITY, INF: exports.INF, SPECIAL: exports.SPECIAL, ATOM: exports.ATOM, COLLECTION: exports.COLLECTION, ALL: exports.ALL };
+    exports.default = exports.Allow;
+  }
+});
+
+// node_modules/partial-json/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/partial-json/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
+          return m[k];
+        }, "get") };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Allow = exports.MalformedJSON = exports.PartialJSON = exports.parseJSON = exports.parse = void 0;
+    var options_1 = require_options();
+    Object.defineProperty(exports, "Allow", { enumerable: true, get: /* @__PURE__ */ __name(function() {
+      return options_1.Allow;
+    }, "get") });
+    __exportStar(require_options(), exports);
+    var PartialJSON = class extends Error {
+      static {
+        __name(this, "PartialJSON");
+      }
+    };
+    exports.PartialJSON = PartialJSON;
+    var MalformedJSON = class extends Error {
+      static {
+        __name(this, "MalformedJSON");
+      }
+    };
+    exports.MalformedJSON = MalformedJSON;
+    function parseJSON(jsonString, allowPartial = options_1.Allow.ALL) {
+      if (typeof jsonString !== "string") {
+        throw new TypeError(`expecting str, got ${typeof jsonString}`);
+      }
+      if (!jsonString.trim()) {
+        throw new Error(`${jsonString} is empty`);
+      }
+      return _parseJSON(jsonString.trim(), allowPartial);
+    }
+    __name(parseJSON, "parseJSON");
+    exports.parseJSON = parseJSON;
+    var _parseJSON = /* @__PURE__ */ __name((jsonString, allow) => {
+      const length = jsonString.length;
+      let index = 0;
+      const markPartialJSON = /* @__PURE__ */ __name((msg) => {
+        throw new PartialJSON(`${msg} at position ${index}`);
+      }, "markPartialJSON");
+      const throwMalformedError = /* @__PURE__ */ __name((msg) => {
+        throw new MalformedJSON(`${msg} at position ${index}`);
+      }, "throwMalformedError");
+      const parseAny = /* @__PURE__ */ __name(() => {
+        skipBlank();
+        if (index >= length)
+          markPartialJSON("Unexpected end of input");
+        if (jsonString[index] === '"')
+          return parseStr();
+        if (jsonString[index] === "{")
+          return parseObj();
+        if (jsonString[index] === "[")
+          return parseArr();
+        if (jsonString.substring(index, index + 4) === "null" || options_1.Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index))) {
+          index += 4;
+          return null;
+        }
+        if (jsonString.substring(index, index + 4) === "true" || options_1.Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index))) {
+          index += 4;
+          return true;
+        }
+        if (jsonString.substring(index, index + 5) === "false" || options_1.Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index))) {
+          index += 5;
+          return false;
+        }
+        if (jsonString.substring(index, index + 8) === "Infinity" || options_1.Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index))) {
+          index += 8;
+          return Infinity;
+        }
+        if (jsonString.substring(index, index + 9) === "-Infinity" || options_1.Allow._INFINITY & allow && 1 < length - index && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index))) {
+          index += 9;
+          return -Infinity;
+        }
+        if (jsonString.substring(index, index + 3) === "NaN" || options_1.Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index))) {
+          index += 3;
+          return NaN;
+        }
+        return parseNum();
+      }, "parseAny");
+      const parseStr = /* @__PURE__ */ __name(() => {
+        const start = index;
+        let escape = false;
+        index++;
+        while (index < length && (jsonString[index] !== '"' || escape && jsonString[index - 1] === "\\")) {
+          escape = jsonString[index] === "\\" ? !escape : false;
+          index++;
+        }
+        if (jsonString.charAt(index) == '"') {
+          try {
+            return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
+          } catch (e) {
+            throwMalformedError(String(e));
+          }
+        } else if (options_1.Allow.STR & allow) {
+          try {
+            return JSON.parse(jsonString.substring(start, index - Number(escape)) + '"');
+          } catch (e) {
+            return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("\\")) + '"');
+          }
+        }
+        markPartialJSON("Unterminated string literal");
+      }, "parseStr");
+      const parseObj = /* @__PURE__ */ __name(() => {
+        index++;
+        skipBlank();
+        const obj = {};
+        try {
+          while (jsonString[index] !== "}") {
+            skipBlank();
+            if (index >= length && options_1.Allow.OBJ & allow)
+              return obj;
+            const key = parseStr();
+            skipBlank();
+            index++;
+            try {
+              const value = parseAny();
+              obj[key] = value;
+            } catch (e) {
+              if (options_1.Allow.OBJ & allow)
+                return obj;
+              else
+                throw e;
+            }
+            skipBlank();
+            if (jsonString[index] === ",")
+              index++;
+          }
+        } catch (e) {
+          if (options_1.Allow.OBJ & allow)
+            return obj;
+          else
+            markPartialJSON("Expected '}' at end of object");
+        }
+        index++;
+        return obj;
+      }, "parseObj");
+      const parseArr = /* @__PURE__ */ __name(() => {
+        index++;
+        const arr = [];
+        try {
+          while (jsonString[index] !== "]") {
+            arr.push(parseAny());
+            skipBlank();
+            if (jsonString[index] === ",") {
+              index++;
+            }
+          }
+        } catch (e) {
+          if (options_1.Allow.ARR & allow) {
+            return arr;
+          }
+          markPartialJSON("Expected ']' at end of array");
+        }
+        index++;
+        return arr;
+      }, "parseArr");
+      const parseNum = /* @__PURE__ */ __name(() => {
+        if (index === 0) {
+          if (jsonString === "-")
+            throwMalformedError("Not sure what '-' is");
+          try {
+            return JSON.parse(jsonString);
+          } catch (e) {
+            if (options_1.Allow.NUM & allow)
+              try {
+                return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e")));
+              } catch (e2) {
+              }
+            throwMalformedError(String(e));
+          }
+        }
+        const start = index;
+        if (jsonString[index] === "-")
+          index++;
+        while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1)
+          index++;
+        if (index == length && !(options_1.Allow.NUM & allow))
+          markPartialJSON("Unterminated number literal");
+        try {
+          return JSON.parse(jsonString.substring(start, index));
+        } catch (e) {
+          if (jsonString.substring(start, index) === "-")
+            markPartialJSON("Not sure what '-' is");
+          try {
+            return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("e")));
+          } catch (e2) {
+            throwMalformedError(String(e2));
+          }
+        }
+      }, "parseNum");
+      const skipBlank = /* @__PURE__ */ __name(() => {
+        while (index < length && " \n\r	".includes(jsonString[index])) {
+          index++;
+        }
+      }, "skipBlank");
+      return parseAny();
+    }, "_parseJSON");
+    var parse = parseJSON;
+    exports.parse = parse;
+  }
+});
+
+// node_modules/@earendil-works/pi-ai/dist/utils/json-parse.js
+var import_partial_json = __toESM(require_dist(), 1);
+var VALID_JSON_ESCAPES = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t"]);
+function isControlCharacter(char) {
+  const codePoint = char.codePointAt(0);
+  return codePoint !== void 0 && codePoint >= 0 && codePoint <= 31;
+}
+__name(isControlCharacter, "isControlCharacter");
+function escapeControlCharacter(char) {
+  switch (char) {
+    case "\b":
+      return "\\b";
+    case "\f":
+      return "\\f";
+    case "\n":
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "	":
+      return "\\t";
+    default:
+      return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+  }
+}
+__name(escapeControlCharacter, "escapeControlCharacter");
+function repairJson(json) {
+  let repaired = "";
+  let inString = false;
+  for (let index = 0; index < json.length; index++) {
+    const char = json[index];
+    if (!inString) {
+      repaired += char;
+      if (char === '"') {
+        inString = true;
+      }
+      continue;
+    }
+    if (char === '"') {
+      repaired += char;
+      inString = false;
+      continue;
+    }
+    if (char === "\\") {
+      const nextChar = json[index + 1];
+      if (nextChar === void 0) {
+        repaired += "\\\\";
+        continue;
+      }
+      if (nextChar === "u") {
+        const unicodeDigits = json.slice(index + 2, index + 6);
+        if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+          repaired += `\\u${unicodeDigits}`;
+          index += 5;
+          continue;
+        }
+      }
+      if (VALID_JSON_ESCAPES.has(nextChar)) {
+        repaired += `\\${nextChar}`;
+        index += 1;
+        continue;
+      }
+      repaired += "\\\\";
+      continue;
+    }
+    repaired += isControlCharacter(char) ? escapeControlCharacter(char) : char;
+  }
+  return repaired;
+}
+__name(repairJson, "repairJson");
+function parseJsonWithRepair(json) {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    const repairedJson = repairJson(json);
+    if (repairedJson !== json) {
+      return JSON.parse(repairedJson);
+    }
+    throw error;
+  }
+}
+__name(parseJsonWithRepair, "parseJsonWithRepair");
+function parseToolCallArguments(json) {
+  if (!json?.trim())
+    return { arguments: {} };
+  try {
+    const parsed = parseJsonWithRepair(json);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Tool arguments must be a JSON object");
+    }
+    return { arguments: parsed };
+  } catch (error) {
+    return {
+      arguments: {},
+      argumentsError: `${error instanceof Error ? error.message : String(error)}
+
+Received arguments:
+${json}`
+    };
+  }
+}
+__name(parseToolCallArguments, "parseToolCallArguments");
+function parseStreamingJson(partialJson) {
+  if (!partialJson || partialJson.trim() === "") {
+    return {};
+  }
+  try {
+    return parseJsonWithRepair(partialJson);
+  } catch {
+    try {
+      const result = (0, import_partial_json.parse)(partialJson);
+      return result ?? {};
+    } catch {
+      try {
+        const result = (0, import_partial_json.parse)(repairJson(partialJson));
+        return result ?? {};
+      } catch {
+        return {};
+      }
+    }
+  }
+}
+__name(parseStreamingJson, "parseStreamingJson");
+
+export {
+  repairJson,
+  parseJsonWithRepair,
+  parseToolCallArguments,
+  parseStreamingJson
+};