@kairyou/agent-tools 0.3.0 → 0.5.0

package/dist/usage/core.mjs

@@ -0,0 +1,1876 @@
+#!/usr/bin/env node
+
+// integrations/usage/core.mjs
+import { pathToFileURL } from "node:url";
+
+// integrations/usage/lib/config.mjs
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// integrations/usage/lib/config.mjs
+var CODEX_HOME = process.env.CODEX_HOME || join(homedir(), ".codex");
+var AGENT_TOOLS_HOME = process.env.AGENT_TOOLS_HOME || join(homedir(), ".agent-tools");
+var AUTH_PATH = join(CODEX_HOME, "auth.json");
+var CODEX_CONFIG_PATH = join(CODEX_HOME, "config.toml");
+var AGENT_CONFIG_PATH = join(AGENT_TOOLS_HOME, "config.jsonc");
+var DEBUG_PATH = join(AGENT_TOOLS_HOME, "logs", "usage-debug.log");
+var ROUTE_CACHE_PATH = join(AGENT_TOOLS_HOME, "cache", "usage-routes.json");
+var SNAPSHOT_PATH = join(AGENT_TOOLS_HOME, "cache", "usage-snapshot.json");
+var REFRESH_STATE_PATH = join(AGENT_TOOLS_HOME, "cache", "usage-refresh-state.json");
+var DEFAULT_USAGE_DAYS = 30;
+var MAX_USAGE_DAYS = 90;
+var DEFAULT_NEW_API_QUOTA_SCALE = 5e5;
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+async function readTextIfExists(path) {
+  if (!existsSync(path)) return "";
+  return readFile(path, "utf8");
+}
+var agentConfigCache;
+async function agentConfig() {
+  if (agentConfigCache) return agentConfigCache;
+  try {
+    const raw = await readTextIfExists(AGENT_CONFIG_PATH);
+    if (!raw.trim()) {
+      agentConfigCache = {};
+      return agentConfigCache;
+    }
+    const errors = [];
+    const parsed = parse2(raw.replace(/^\uFEFF/, ""), errors, { allowTrailingComma: true });
+    agentConfigCache = errors.length === 0 && parsed?.providerUsage || {};
+  } catch {
+    agentConfigCache = {};
+  }
+  return agentConfigCache;
+}
+async function debugLog(event) {
+  const config = await agentConfig();
+  if (process.env.PROVIDER_USAGE_DEBUG !== "1" && config.debug !== true) return;
+  await mkdir(dirname(DEBUG_PATH), { recursive: true });
+  const line = JSON.stringify({
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...event
+  });
+  await writeFile(DEBUG_PATH, `${line}
+`, { flag: "a" });
+}
+async function providerUsageDays() {
+  const config = await agentConfig();
+  const value = Number(process.env.PROVIDER_USAGE_DAYS || config.days || DEFAULT_USAGE_DAYS);
+  if (!Number.isInteger(value) || value <= 0 || value > MAX_USAGE_DAYS) return DEFAULT_USAGE_DAYS;
+  return value;
+}
+async function usagePreset() {
+  const config = await agentConfig();
+  return String(process.env.PROVIDER_USAGE_PRESET || config.preset || "auto").toLowerCase();
+}
+async function panelUserId() {
+  const config = await agentConfig();
+  const raw = process.env.PROVIDER_USAGE_USER_ID || config.userId || "";
+  const parsed = Number.parseInt(String(raw), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+async function panelUserHeaders() {
+  const userId = await panelUserId();
+  if (!userId) return {};
+  const value = String(userId);
+  return {
+    "New-API-User": value,
+    "Veloera-User": value,
+    "voapi-user": value,
+    "User-id": value,
+    "X-User-Id": value,
+    "Rix-Api-User": value,
+    "neo-api-user": value
+  };
+}
+async function newApiQuotaScale() {
+  const config = await agentConfig();
+  const scale = Number(config.newApiQuotaScale || DEFAULT_NEW_API_QUOTA_SCALE);
+  return Number.isFinite(scale) && scale > 0 ? scale : 0;
+}
+
+// integrations/usage/lib/urls.mjs
+function isOfficialBaseUrl(baseUrl) {
+  if (!baseUrl) return true;
+  const clean = baseUrl.replace(/\/+$/, "");
+  return [
+    "https://api.openai.com",
+    "https://api.openai.com/v1",
+    "https://api.anthropic.com",
+    "https://api.anthropic.com/v1"
+  ].includes(clean);
+}
+function cleanBaseUrl(baseUrl) {
+  return String(baseUrl || "").replace(/\/+$/, "");
+}
+function serviceRoot(baseUrl) {
+  const clean = cleanBaseUrl(baseUrl);
+  return clean.endsWith("/v1") ? clean.slice(0, -3) : clean;
+}
+function usageRouteCacheKey(baseUrl) {
+  try {
+    const url = new URL(cleanBaseUrl(baseUrl));
+    url.hash = "";
+    url.search = "";
+    url.pathname = url.pathname.replace(/\/+$/, "").replace(/\/api\/v1$/i, "").replace(/\/v1$/i, "");
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return serviceRoot(baseUrl);
+  }
+}
+function joinUrl(baseUrl, path) {
+  return `${cleanBaseUrl(baseUrl)}${path.startsWith("/") ? path : `/${path}`}`;
+}
+function hostIncludes(baseUrl, value) {
+  try {
+    return new URL(baseUrl).hostname.toLowerCase().includes(value);
+  } catch {
+    return false;
+  }
+}
+
+// integrations/usage/lib/cache.mjs
+import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+var ROUTE_CACHE_VERSION = 1;
+var SNAPSHOT_VERSION = 1;
+var REFRESH_STATE_VERSION = 1;
+async function readRouteCache() {
+  try {
+    const raw = await readTextIfExists(ROUTE_CACHE_PATH);
+    if (!raw.trim()) return { version: ROUTE_CACHE_VERSION, routes: {} };
+    const parsed = JSON.parse(raw);
+    return {
+      version: ROUTE_CACHE_VERSION,
+      routes: parsed?.routes && typeof parsed.routes === "object" ? parsed.routes : {}
+    };
+  } catch {
+    return { version: ROUTE_CACHE_VERSION, routes: {} };
+  }
+}
+async function rememberUsageRoute(context, route, result) {
+  try {
+    const cache = await readRouteCache();
+    const key = usageRouteCacheKey(context.baseUrl);
+    cache.routes[key] = {
+      route: route.id,
+      path: route.path,
+      source: result.source,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await mkdir2(dirname2(ROUTE_CACHE_PATH), { recursive: true });
+    await writeFile2(ROUTE_CACHE_PATH, `${JSON.stringify(cache, null, 2)}
+`);
+  } catch (error) {
+    await debugLog({ source: "route-cache", error: error.message });
+  }
+}
+async function readSnapshotCache() {
+  try {
+    const raw = await readTextIfExists(SNAPSHOT_PATH);
+    if (!raw.trim()) return { version: SNAPSHOT_VERSION, items: {} };
+    const parsed = JSON.parse(raw);
+    return {
+      version: SNAPSHOT_VERSION,
+      items: parsed?.items && typeof parsed.items === "object" ? parsed.items : {}
+    };
+  } catch {
+    return { version: SNAPSHOT_VERSION, items: {} };
+  }
+}
+async function rememberUsageSnapshot(context, result) {
+  if (!result?.text) return;
+  try {
+    const cache = await readSnapshotCache();
+    const key = usageRouteCacheKey(context.baseUrl);
+    cache.items[key] = {
+      text: result.text,
+      source: result.source,
+      baseUrl: context.baseUrl,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await mkdir2(dirname2(SNAPSHOT_PATH), { recursive: true });
+    await writeFile2(SNAPSHOT_PATH, `${JSON.stringify(cache, null, 2)}
+`);
+  } catch (error) {
+    await debugLog({ source: "snapshot-cache", error: error.message });
+  }
+}
+async function readRefreshState() {
+  try {
+    const raw = await readTextIfExists(REFRESH_STATE_PATH);
+    if (!raw.trim()) return { version: REFRESH_STATE_VERSION, items: {} };
+    const parsed = JSON.parse(raw);
+    return {
+      version: REFRESH_STATE_VERSION,
+      items: parsed?.items && typeof parsed.items === "object" ? parsed.items : {}
+    };
+  } catch {
+    return { version: REFRESH_STATE_VERSION, items: {} };
+  }
+}
+async function rememberRefreshState(context, patch) {
+  try {
+    const state = await readRefreshState();
+    const key = usageRouteCacheKey(context.baseUrl);
+    state.items[key] = {
+      ...state.items[key] || {},
+      ...patch,
+      baseUrl: context.baseUrl
+    };
+    await mkdir2(dirname2(REFRESH_STATE_PATH), { recursive: true });
+    await writeFile2(REFRESH_STATE_PATH, `${JSON.stringify(state, null, 2)}
+`);
+  } catch (error) {
+    await debugLog({ source: "refresh-state", error: error.message });
+  }
+}
+
+// integrations/usage/lib/http.mjs
+import { createContext, runInContext } from "node:vm";
+var REQUEST_TIMEOUT_MS = 5e3;
+var SHIELD_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36";
+function shortPreview(text) {
+  return String(text || "").replace(/\s+/g, " ").trim().slice(0, 220);
+}
+function isShieldChallenge(contentType, text) {
+  const normalizedType = String(contentType || "").toLowerCase();
+  return normalizedType.includes("text/html") && /var\s+arg1\s*=|acw_sc__v2|cdn_sec_tc|<script/i.test(text) || /var\s+arg1\s*=/.test(text);
+}
+function parseChallengeArg1(html) {
+  const match = String(html).match(/var\s+arg1\s*=\s*['"]([0-9a-fA-F]+)['"]/);
+  return match?.[1]?.toUpperCase() || "";
+}
+function parseChallengeMapping(html) {
+  const match = String(html).match(/for\(var m=\[([^\]]+)\],p=L\(0x115\)/);
+  if (!match?.[1]) return null;
+  const values = match[1].split(",").map((raw) => {
+    const value = raw.trim().toLowerCase();
+    if (!value) return Number.NaN;
+    return value.startsWith("0x") ? Number.parseInt(value.slice(2), 16) : Number.parseInt(value, 10);
+  });
+  return values.some((value) => Number.isNaN(value)) ? null : values;
+}
+function parseChallengeXorSeed(html) {
+  const text = String(html);
+  const fnStart = text.indexOf("function a0i()");
+  const bStart = text.indexOf("function b(");
+  const rotateStart = text.indexOf("(function(a,c){");
+  const rotateEnd = text.indexOf("),!(function", rotateStart);
+  if (fnStart < 0 || bStart < 0 || bStart <= fnStart || rotateStart < 0 || rotateEnd < 0) {
+    return "";
+  }
+  const helperCode = text.slice(fnStart, bStart);
+  const rotateCode = `${text.slice(rotateStart, rotateEnd + 1)})`;
+  try {
+    const sandbox = { decodeURIComponent };
+    createContext(sandbox);
+    runInContext(helperCode, sandbox, { timeout: 100 });
+    runInContext(rotateCode, sandbox, { timeout: 100 });
+    const decoder = sandbox.a0j;
+    if (typeof decoder !== "function") return "";
+    const seed = decoder(277);
+    return typeof seed === "string" && /^[0-9a-f]+$/i.test(seed) ? seed : "";
+  } catch {
+    return "";
+  }
+}
+function solveNewApiAcwScV2(html) {
+  const arg1 = parseChallengeArg1(html);
+  const mapping = parseChallengeMapping(html);
+  const xorSeed = parseChallengeXorSeed(html);
+  if (!arg1 || !mapping || !xorSeed) return "";
+  const reordered = [];
+  for (let i = 0; i < arg1.length; i += 1) {
+    const ch = arg1[i];
+    for (let j = 0; j < mapping.length; j += 1) {
+      if (mapping[j] === i + 1) reordered[j] = ch;
+    }
+  }
+  const source = reordered.join("");
+  let out = "";
+  for (let i = 0; i < source.length && i < xorSeed.length; i += 2) {
+    const left = Number.parseInt(source.slice(i, i + 2), 16);
+    const right = Number.parseInt(xorSeed.slice(i, i + 2), 16);
+    if (Number.isNaN(left) || Number.isNaN(right)) return "";
+    out += (left ^ right).toString(16).padStart(2, "0");
+  }
+  return out;
+}
+function upsertCookie(cookieHeader, name, value) {
+  const parts = String(cookieHeader || "").split(";").map((part) => part.trim()).filter(Boolean);
+  let replaced = false;
+  const next = parts.map((part) => {
+    const eq = part.indexOf("=");
+    if (eq < 0) return part;
+    const key = part.slice(0, eq).trim();
+    if (key !== name) return part;
+    replaced = true;
+    return `${name}=${value}`;
+  });
+  if (!replaced) next.push(`${name}=${value}`);
+  return next.join("; ");
+}
+function collectSetCookieHeaders(headers) {
+  const getSetCookie = headers?.getSetCookie;
+  if (typeof getSetCookie === "function") return getSetCookie.call(headers) || [];
+  const single = headers?.get?.("set-cookie");
+  return single ? [single] : [];
+}
+function mergeSetCookiePairs(cookieHeader, setCookieHeaders) {
+  let merged = cookieHeader || "";
+  for (const raw of setCookieHeaders || []) {
+    const firstPair = String(raw || "").split(";")[0]?.trim();
+    if (!firstPair) continue;
+    const eq = firstPair.indexOf("=");
+    if (eq <= 0) continue;
+    merged = upsertCookie(merged, firstPair.slice(0, eq).trim(), firstPair.slice(eq + 1));
+  }
+  return merged;
+}
+async function requestJson(url, key, options = {}) {
+  let cookieHeader = "";
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    const response = await fetch(url, {
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${options.authKey || key}`,
+        "user-agent": SHIELD_USER_AGENT,
+        ...cookieHeader ? { cookie: cookieHeader } : {},
+        ...options.headers || {}
+      },
+      signal: controller.signal
+    });
+    try {
+      const body = await response.text();
+      cookieHeader = mergeSetCookiePairs(cookieHeader, collectSetCookieHeaders(response.headers));
+      let json = {};
+      try {
+        json = body ? JSON.parse(body) : {};
+      } catch {
+        const contentType = response.headers.get("content-type") || "";
+        const acwScV2 = isShieldChallenge(contentType, body) ? solveNewApiAcwScV2(body) : "";
+        await debugLog({
+          source: options.name || "usage",
+          url,
+          status: response.status,
+          contentType,
+          shieldRetry: Boolean(acwScV2 && attempt === 0),
+          bodyPreview: shortPreview(body)
+        });
+        if (acwScV2 && attempt === 0) {
+          cookieHeader = upsertCookie(cookieHeader, "acw_sc__v2", acwScV2);
+          continue;
+        }
+        throw new Error(`${options.name || "usage"} returned non-JSON (${response.status})`);
+      }
+      if (!response.ok) {
+        const message = json?.error?.message || json?.message || response.statusText;
+        await debugLog({
+          source: options.name || "usage",
+          url,
+          status: response.status,
+          message,
+          bodyPreview: shortPreview(body)
+        });
+        throw new Error(`${options.name || "usage"} failed (${response.status} ${message})`);
+      }
+      return json;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  throw new Error(`${options.name || "usage"} unavailable`);
+}
+
+// integrations/usage/lib/format.mjs
+function pickNumber(obj, keys) {
+  for (const key of keys) {
+    const value = obj?.[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) return Number(value);
+  }
+  return void 0;
+}
+function formatMoney(value) {
+  return `$${value.toFixed(value >= 100 ? 0 : 1)}`;
+}
+function formatMaybeMoney(value, unit = "USD") {
+  if (unit === "USD" || unit === "$") return formatMoney(value);
+  return `${value.toLocaleString("en-US", { maximumFractionDigits: 1 })} ${unit}`;
+}
+function usageParts() {
+  return ["API"];
+}
+async function formatNewApiQuota(value) {
+  const scale = await newApiQuotaScale();
+  if (Number.isFinite(scale) && scale > 0) return formatMoney(value / scale);
+  return value.toLocaleString("en-US", { maximumFractionDigits: 0 });
+}
+function usageRoot(data) {
+  return data?.data && typeof data.data === "object" ? data.data : data;
+}
+function shortDate(value) {
+  if (!value) return "";
+  const match = String(value).match(/^(\d{4})-(\d{2})-(\d{2})/);
+  return match ? `${match[2]}-${match[3]}` : "";
+}
+function hasSubscriptionLimits(root) {
+  const sub = root?.subscription || {};
+  return [
+    "daily_limit_usd",
+    "weekly_limit_usd",
+    "monthly_limit_usd",
+    "daily_usage_usd",
+    "weekly_usage_usd",
+    "monthly_usage_usd"
+  ].some((key) => pickNumber(sub, [key]) !== void 0);
+}
+function isQuotaLimitedUsage(root) {
+  return root?.mode === "quota_limited" || root?.quota;
+}
+function isSubscriptionUsage(root) {
+  return hasSubscriptionLimits(root) || root?.mode === "unrestricted" && root?.subscription;
+}
+function isWalletUsage(root) {
+  const planName = String(root?.planName || "");
+  return root?.mode === "unrestricted" && !isSubscriptionUsage(root) || planName.includes("\u94B1\u5305") || planName.toLowerCase().includes("wallet") || pickNumber(root, ["balance"]) !== void 0 && !hasSubscriptionLimits(root);
+}
+function hasV1UsageFields(root) {
+  return hasSubscriptionLimits(root) || pickNumber(root, [
+    "balance",
+    "remaining",
+    "remain",
+    "available",
+    "hard_limit_usd",
+    "hard_limit",
+    "total_granted",
+    "quota",
+    "total_usage",
+    "used",
+    "usage"
+  ]) !== void 0 || pickNumber(root?.quota, ["limit", "quota", "used", "quota_used", "remaining"]) !== void 0 || pickNumber(root?.usage?.today, ["actual_cost", "cost"]) !== void 0 || Array.isArray(root?.daily_usage) && root.daily_usage.length > 0;
+}
+async function formatQuota(label, data) {
+  const root = usageRoot(data);
+  const unit = root?.unit || "USD";
+  const remaining = pickNumber(root, ["remaining"]);
+  const hardLimit = pickNumber(root, ["hard_limit_usd", "hard_limit", "total_granted", "quota"]);
+  const used = pickNumber(root, ["total_usage", "used", "usage"]);
+  const balance = pickNumber(root, ["balance", "remaining", "remain", "available"]);
+  if (isQuotaLimitedUsage(root)) return formatQuotaLimitedLine(label, root);
+  if (isSubscriptionUsage(root)) return formatUsageLine(label, root);
+  if (isWalletUsage(root)) return await formatWalletLine(label, root);
+  if (remaining !== void 0) return formatUsageLine(label, root);
+  if (balance !== void 0) return `API | balance ${formatMaybeMoney(balance, unit)}`;
+  if (hardLimit !== void 0 && used !== void 0) {
+    return `API | remaining ${formatMaybeMoney(Math.max(0, hardLimit - used), unit)}`;
+  }
+  if (hardLimit !== void 0) return `API | total ${formatMaybeMoney(hardLimit, unit)}`;
+  const keys = Object.keys(root || {}).slice(0, 4).join(", ");
+  return keys ? `API | received (${keys})` : `API | checked ${unit}`;
+}
+async function formatNewApiTokenLine(label, data) {
+  const root = usageRoot(data);
+  const unlimited = root?.unlimited_quota === true || root?.unlimitedQuota === true;
+  const quota = pickNumber(root, ["quota", "limit", "total_quota", "totalQuota"]);
+  const used = pickNumber(root, ["used_quota", "usedQuota", "used"]);
+  let remaining = pickNumber(root, ["remain_quota", "remainQuota", "remaining", "balance"]);
+  if (remaining === void 0 && quota !== void 0 && used !== void 0) {
+    remaining = Math.max(0, quota - used);
+  }
+  if (!unlimited && quota === void 0 && used === void 0 && remaining === void 0) {
+    throw new Error("NewAPI token usage payload has no quota fields");
+  }
+  const parts = usageParts();
+  if (unlimited) parts.push("unlimited");
+  if (remaining !== void 0) parts.push(`balance ${await formatNewApiQuota(remaining)}`);
+  if (used !== void 0 && quota !== void 0) {
+    parts.push(`used ${await formatNewApiQuota(used)}/${await formatNewApiQuota(quota)}`);
+  } else if (used !== void 0) {
+    parts.push(`used ${await formatNewApiQuota(used)}`);
+  }
+  return parts.join(" | ");
+}
+function formatOpenRouterLine(label, data) {
+  const root = usageRoot(data);
+  const limit = pickNumber(root, ["limit", "limit_remaining", "total_credits"]);
+  const remaining = pickNumber(root, ["limit_remaining", "remaining_credits"]);
+  const used = pickNumber(root, ["usage", "total_usage", "spend"]);
+  const reset = root?.limit_reset || root?.reset_at ? shortDate(root.limit_reset || root.reset_at) : "";
+  const parts = usageParts();
+  if (remaining !== void 0) parts.push(`balance ${formatMoney(remaining)}`);
+  if (used !== void 0 && limit !== void 0 && limit !== remaining) {
+    parts.push(`used ${formatMoney(used)}/${formatMoney(limit)}`);
+  } else if (used !== void 0) {
+    parts.push(`used ${formatMoney(used)}`);
+  }
+  if (reset) parts.push(`Reset ${reset}`);
+  if (parts.length === 1) throw new Error("OpenRouter payload has no usage fields");
+  return parts.join(" | ");
+}
+function panelQuotaScale(kind) {
+  return kind === "veloera" ? 1e6 : DEFAULT_NEW_API_QUOTA_SCALE;
+}
+function panelQuotaLooksRemaining(kind) {
+  return ["new-api", "anyrouter", "agentrouter", "done-hub", "donehub"].includes(kind);
+}
+async function formatPanelUserSelfLine(label, data, kind) {
+  const root = usageRoot(data);
+  const scale = panelQuotaScale(kind);
+  const quota = pickNumber(root, ["quota"]);
+  const used = pickNumber(root, ["used_quota", "usedQuota"]);
+  const todayIncome = pickNumber(root, ["today_income", "todayIncome"]);
+  const todayUsed = pickNumber(root, ["today_quota_consumption", "todayQuotaConsumption"]);
+  if (quota === void 0 && used === void 0) {
+    throw new Error("panel /api/user/self payload has no quota fields");
+  }
+  const quotaUsd = quota === void 0 ? void 0 : quota / scale;
+  const usedUsd = used === void 0 ? void 0 : used / scale;
+  const remainingUsd = panelQuotaLooksRemaining(kind) ? quotaUsd : quotaUsd === void 0 || usedUsd === void 0 ? quotaUsd : Math.max(0, quotaUsd - usedUsd);
+  const totalUsd = panelQuotaLooksRemaining(kind) ? quotaUsd === void 0 || usedUsd === void 0 ? quotaUsd : quotaUsd + usedUsd : quotaUsd;
+  const parts = usageParts();
+  if (remainingUsd !== void 0) parts.push(`balance ${formatMoney(remainingUsd)}`);
+  if (usedUsd !== void 0 && totalUsd !== void 0) {
+    parts.push(`used ${formatMoney(usedUsd)}/${formatMoney(totalUsd)}`);
+  } else if (usedUsd !== void 0) {
+    parts.push(`used ${formatMoney(usedUsd)}`);
+  }
+  if (todayUsed !== void 0) parts.push(`today ${formatMoney(todayUsed / scale)}`);
+  if (todayIncome !== void 0) parts.push(`income ${formatMoney(todayIncome / scale)}`);
+  return parts.join(" | ");
+}
+function formatQuotaLimitedLine(label, root) {
+  const quota = root?.quota || {};
+  const limit = pickNumber(quota, ["limit", "quota"]);
+  const used = pickNumber(quota, ["used", "quota_used"]);
+  const remaining = pickNumber(quota, ["remaining"]) ?? pickNumber(root, ["remaining"]);
+  const parts = usageParts();
+  if (limit !== void 0 && used !== void 0) {
+    parts.push(`Q ${formatMoney(used)}/${formatMoney(limit)}`);
+  } else if (remaining !== void 0) {
+    parts.push(`remaining ${formatMoney(remaining)}`);
+  }
+  if (Array.isArray(root?.rate_limits) && root.rate_limits.length > 0) {
+    const rateParts = root.rate_limits.map((entry) => {
+      const window = entry?.window;
+      const rateLimit = pickNumber(entry, ["limit"]);
+      const rateUsed = pickNumber(entry, ["used"]);
+      return window && rateLimit !== void 0 && rateUsed !== void 0 ? `${window} ${formatMoney(rateUsed)}/${formatMoney(rateLimit)}` : "";
+    }).filter(Boolean);
+    if (rateParts.length > 0) parts.push(rateParts.join(", "));
+  }
+  return parts.join(" | ");
+}
+async function formatWalletLine(label, root) {
+  const balance = pickNumber(root, ["balance", "remaining", "remain", "available"]);
+  const todayCost = pickNumber(root?.usage?.today, ["actual_cost", "cost"]);
+  const recentUsage = Array.isArray(root?.daily_usage) ? root.daily_usage.reduce((sum, day) => sum + (pickNumber(day, ["actual_cost", "cost"]) || 0), 0) : void 0;
+  const parts = usageParts();
+  if (balance !== void 0) parts.push(`balance ${formatMoney(balance)}`);
+  if (todayCost !== void 0) parts.push(`today ${formatMoney(todayCost)}`);
+  if (recentUsage !== void 0 && root.daily_usage.length > 0) {
+    parts.push(`${await providerUsageDays()}d ${formatMoney(recentUsage)}`);
+  }
+  return parts.join(" | ");
+}
+function formatUsageLine(label, root) {
+  const sub = root?.subscription || {};
+  const dailyLimit = pickNumber(sub, ["daily_limit_usd"]);
+  const dailyUsage = pickNumber(sub, ["daily_usage_usd"]);
+  const weeklyLimit = pickNumber(sub, ["weekly_limit_usd"]);
+  const weeklyUsage = pickNumber(sub, ["weekly_usage_usd"]);
+  const monthlyLimit = pickNumber(sub, ["monthly_limit_usd"]);
+  const monthlyUsage = pickNumber(sub, ["monthly_usage_usd"]);
+  const expires = shortDate(sub.expires_at);
+  const parts = usageParts();
+  if (dailyLimit > 0 && dailyUsage !== void 0) parts.push(`D ${formatMoney(dailyUsage)}/${formatMoney(dailyLimit)}`);
+  if (weeklyLimit > 0 && weeklyUsage !== void 0) parts.push(`W ${formatMoney(weeklyUsage)}/${formatMoney(weeklyLimit)}`);
+  if (monthlyLimit > 0 && monthlyUsage !== void 0) parts.push(`M ${formatMoney(monthlyUsage)}/${formatMoney(monthlyLimit)}`);
+  if (expires) parts.push(`Exp ${expires}`);
+  return parts.join(" | ");
+}
+
+// integrations/usage/lib/routes.mjs
+async function subscriptionUrl(baseUrl) {
+  const clean = baseUrl.replace(/\/+$/, "");
+  const url = clean.endsWith("/v1") ? `${clean}/usage` : `${clean}/v1/usage`;
+  return `${url}?days=${await providerUsageDays()}`;
+}
+function usageResult(context, source, text, raw) {
+  return {
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    baseUrl: context.baseUrl,
+    provider: context.providerName,
+    source,
+    text,
+    raw
+  };
+}
+async function fetchV1Usage(context) {
+  const json = await requestJson(await subscriptionUrl(context.baseUrl), context.key, {
+    name: "v1 usage"
+  });
+  if (!hasV1UsageFields(usageRoot(json))) throw new Error("v1 usage payload has no usage fields");
+  return usageResult(context, "v1-usage", await formatQuota(context.label, json), json);
+}
+async function fetchNewApiTokenUsage(context) {
+  const json = await requestJson(joinUrl(serviceRoot(context.baseUrl), "/api/usage/token/"), context.key, {
+    name: "NewAPI token usage"
+  });
+  const root = usageRoot(json);
+  const quota = pickNumber(root, ["quota", "limit", "total_quota", "totalQuota"]);
+  const used = pickNumber(root, ["used_quota", "usedQuota", "used"]);
+  let remaining = pickNumber(root, ["remain_quota", "remainQuota", "remaining", "balance"]);
+  if (remaining === void 0 && quota !== void 0 && used !== void 0) {
+    remaining = Math.max(0, quota - used);
+  }
+  const scale = await newApiQuotaScale();
+  const quotaForWarning = scale ? quota / scale : quota;
+  const usedForWarning = scale ? used / scale : used;
+  const remainingForWarning = scale ? remaining / scale : remaining;
+  const normalized = {
+    mode: "quota_limited",
+    quota: {
+      limit: quotaForWarning,
+      used: usedForWarning,
+      remaining: remainingForWarning
+    },
+    unit: scale ? "USD" : "quota",
+    source: "newapi-token",
+    raw: json
+  };
+  return usageResult(context, "newapi-token", await formatNewApiTokenLine(context.label, json), normalized);
+}
+async function fetchPanelUserSelfUsage(context) {
+  const preset = await usagePreset();
+  const kind = preset === "auto" ? "new-api" : preset;
+  const json = await requestJson(joinUrl(serviceRoot(context.baseUrl), "/api/user/self"), context.key, {
+    name: "panel /api/user/self",
+    headers: await panelUserHeaders()
+  });
+  const root = usageRoot(json);
+  if (pickNumber(root, ["quota"]) === void 0 && pickNumber(root, ["used_quota", "usedQuota"]) === void 0) {
+    await debugLog({
+      source: "panel /api/user/self",
+      payloadKeys: Object.keys(root || {}).slice(0, 20),
+      success: root?.success,
+      message: root?.message || root?.error?.message || ""
+    });
+  }
+  const scale = panelQuotaScale(kind);
+  const quota = pickNumber(root, ["quota"]);
+  const used = pickNumber(root, ["used_quota", "usedQuota"]);
+  const remaining = panelQuotaLooksRemaining(kind) ? quota : quota === void 0 || used === void 0 ? quota : Math.max(0, quota - used);
+  const total = panelQuotaLooksRemaining(kind) ? quota === void 0 || used === void 0 ? quota : quota + used : quota;
+  const normalized = {
+    mode: "quota_limited",
+    quota: {
+      limit: total === void 0 ? void 0 : total / scale,
+      used: used === void 0 ? void 0 : used / scale,
+      remaining: remaining === void 0 ? void 0 : remaining / scale
+    },
+    unit: "USD",
+    source: "panel-user-self",
+    raw: json
+  };
+  return usageResult(
+    context,
+    "panel-user-self",
+    await formatPanelUserSelfLine(context.label, json, kind),
+    normalized
+  );
+}
+async function fetchSub2ApiAuthMeUsage(context) {
+  const json = await requestJson(joinUrl(serviceRoot(context.baseUrl), "/api/v1/auth/me"), context.key, {
+    name: "Sub2API auth/me"
+  });
+  const root = usageRoot(json);
+  const balance = pickNumber(root, ["balance"]);
+  if (balance === void 0) throw new Error("Sub2API auth/me payload has no balance field");
+  const normalized = {
+    mode: "unrestricted",
+    planName: root?.username || root?.email || context.label || "Sub2API",
+    balance,
+    unit: "USD",
+    source: "sub2api-auth-me",
+    raw: json
+  };
+  return usageResult(
+    context,
+    "sub2api-auth-me",
+    `API | balance ${formatMoney(balance)}`,
+    normalized
+  );
+}
+async function fetchOpenRouterUsage(context) {
+  const base = cleanBaseUrl(context.baseUrl).includes("/api/v1") ? cleanBaseUrl(context.baseUrl) : joinUrl(serviceRoot(context.baseUrl), "/api/v1");
+  const endpoints = [
+    { source: "openrouter-key", url: joinUrl(base, "/key") },
+    { source: "openrouter-credits", url: joinUrl(base, "/credits") }
+  ];
+  let lastError;
+  for (const endpoint of endpoints) {
+    try {
+      const json = await requestJson(endpoint.url, context.key, { name: endpoint.source });
+      return usageResult(context, endpoint.source, formatOpenRouterLine("OpenRouter", json), json);
+    } catch (error) {
+      lastError = error;
+      await debugLog({ source: endpoint.source, error: error.message });
+    }
+  }
+  throw lastError || new Error("OpenRouter usage unavailable");
+}
+var USAGE_ROUTES = {
+  "v1-usage": {
+    id: "v1-usage",
+    path: "/v1/usage",
+    run: fetchV1Usage
+  },
+  "sub2api-auth-me": {
+    id: "sub2api-auth-me",
+    path: "/api/v1/auth/me",
+    run: fetchSub2ApiAuthMeUsage
+  },
+  "newapi-token": {
+    id: "newapi-token",
+    path: "/api/usage/token/",
+    run: fetchNewApiTokenUsage
+  },
+  "panel-user-self": {
+    id: "panel-user-self",
+    path: "/api/user/self",
+    run: fetchPanelUserSelfUsage
+  },
+  "openrouter": {
+    id: "openrouter",
+    path: "/api/v1/key",
+    run: fetchOpenRouterUsage
+  }
+};
+async function usageRouteIds(context) {
+  const preset = await usagePreset();
+  const routes = {
+    "sub2api": ["v1-usage", "sub2api-auth-me"],
+    "openai-compatible": ["v1-usage"],
+    "new-api": ["newapi-token", "panel-user-self"],
+    "one-api": ["newapi-token", "panel-user-self"],
+    "onehub": ["newapi-token", "panel-user-self"],
+    "one-hub": ["newapi-token", "panel-user-self"],
+    "donehub": ["newapi-token", "panel-user-self"],
+    "done-hub": ["newapi-token", "panel-user-self"],
+    "veloera": ["panel-user-self", "newapi-token"],
+    "anyrouter": ["newapi-token", "panel-user-self", "v1-usage"],
+    "agentrouter": ["newapi-token", "panel-user-self", "v1-usage"],
+    "openrouter": ["openrouter"]
+  };
+  if (routes[preset]) return routes[preset];
+  if (preset !== "auto") return [];
+  if (hostIncludes(context.baseUrl, "openrouter.ai")) return ["openrouter"];
+  return ["v1-usage", "sub2api-auth-me", "newapi-token", "panel-user-self"];
+}
+async function cachedUsageRoute(context) {
+  const cache = await readRouteCache();
+  const key = usageRouteCacheKey(context.baseUrl);
+  const route = cache.routes[key];
+  return route?.route && USAGE_ROUTES[route.route] ? route : null;
+}
+async function orderedUsageRoutes(context) {
+  const routeIds = await usageRouteIds(context);
+  const cached = await cachedUsageRoute(context);
+  if (!cached || !routeIds.includes(cached.route)) return routeIds.map((id) => USAGE_ROUTES[id]).filter(Boolean);
+  await debugLog({
+    source: "route-cache",
+    key: usageRouteCacheKey(context.baseUrl),
+    route: cached.route,
+    path: cached.path || USAGE_ROUTES[cached.route]?.path || ""
+  });
+  return [cached.route, ...routeIds.filter((id) => id !== cached.route)].map((id) => USAGE_ROUTES[id]).filter(Boolean);
+}
+
+// integrations/usage/lib/context.mjs
+import { existsSync as existsSync2 } from "node:fs";
+function stripInlineComment(value) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    const prev = value[i - 1];
+    if (char === "'" && !inDouble) inSingle = !inSingle;
+    if (char === '"' && !inSingle && prev !== "\\") inDouble = !inDouble;
+    if (char === "#" && !inSingle && !inDouble) return value.slice(0, i).trim();
+  }
+  return value.trim();
+}
+function parseTomlLite(source) {
+  const root = {};
+  let current = root;
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const table = line.match(/^\[([^\]]+)\]$/);
+    if (table) {
+      current = root;
+      for (const part of table[1].split(".")) {
+        const key2 = part.replace(/^['"]|['"]$/g, "");
+        current[key2] ||= {};
+        current = current[key2];
+      }
+      continue;
+    }
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    const rawValue = stripInlineComment(line.slice(eq + 1));
+    current[key] = parseTomlValue(rawValue);
+  }
+  return root;
+}
+function parseTomlValue(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}
+function activeProvider(config) {
+  const providerName = config.model_provider || "openai";
+  const provider = config.model_providers?.[providerName] || {};
+  return { providerName, provider };
+}
+function apiKeyFor(auth, provider) {
+  if (process.env.PROVIDER_USAGE_API_KEY) return process.env.PROVIDER_USAGE_API_KEY;
+  if (process.env.SUB2API_API_KEY) return process.env.SUB2API_API_KEY;
+  if (provider.env_key && process.env[provider.env_key]) return process.env[provider.env_key];
+  if (auth.OPENAI_API_KEY) return auth.OPENAI_API_KEY;
+  if (process.env.OPENAI_API_KEY) return process.env.OPENAI_API_KEY;
+  return "";
+}
+function apiKeyForClaude() {
+  return process.env.PROVIDER_USAGE_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_API_KEY || "";
+}
+function providerLabel(providerName, provider) {
+  return String(provider.name || providerName || "API").toUpperCase();
+}
+async function contextForCodex() {
+  const auth = existsSync2(AUTH_PATH) ? await readJson(AUTH_PATH) : {};
+  const codexConfig = parseTomlLite(await readTextIfExists(CODEX_CONFIG_PATH));
+  const { providerName, provider } = activeProvider(codexConfig);
+  const baseUrl = process.env.PROVIDER_USAGE_BASE_URL || process.env.SUB2API_BASE_URL || process.env.OPENAI_BASE_URL || provider.base_url || "";
+  const key = apiKeyFor(auth, provider);
+  return {
+    providerName,
+    provider,
+    baseUrl,
+    key,
+    label: providerLabel(providerName, provider)
+  };
+}
+function contextForClaude() {
+  const baseUrl = process.env.PROVIDER_USAGE_BASE_URL || process.env.ANTHROPIC_BASE_URL || "";
+  return {
+    providerName: "claude",
+    provider: { name: "Claude" },
+    baseUrl,
+    key: apiKeyForClaude(),
+    label: "Claude"
+  };
+}
+async function usageContext(agent) {
+  return agent === "claude" ? contextForClaude() : await contextForCodex();
+}
+function normalizeUsageContext(input) {
+  const providerName = String(input?.providerName || "provider");
+  const provider = input?.provider && typeof input.provider === "object" ? input.provider : { name: providerName };
+  return {
+    providerName,
+    provider,
+    baseUrl: String(input?.baseUrl || ""),
+    key: String(input?.key || ""),
+    label: String(input?.label || provider.name || providerName)
+  };
+}
+
+// integrations/usage/core.mjs
+function parseArgs(argv) {
+  const opts = { mode: "hook", agent: "codex" };
+  let modeSet = false;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--agent" && argv[i + 1]) {
+      opts.agent = argv[++i];
+    } else if (arg.startsWith("--agent=")) {
+      opts.agent = arg.slice("--agent=".length);
+    } else if (!arg.startsWith("-") && !modeSet) {
+      opts.mode = arg;
+      modeSet = true;
+    }
+  }
+  return opts;
+}
+var cli = parseArgs(process.argv.slice(2));
+var mode = cli.mode;
+function hookOut(message) {
+  const payload = { continue: true };
+  if (message) payload.systemMessage = message;
+  process.stdout.write(`${JSON.stringify(payload)}
+`);
+}
+function textOut(message) {
+  if (message) process.stdout.write(`${message}
+`);
+}
+function failSoft(message, error) {
+  const detail = error?.message ? `: ${error.message}` : "";
+  if (mode === "hook") hookOut();
+  else if (mode !== "refresh") textOut(`${message}${detail}`);
+}
+async function queryUsageContext(context, { agent = "external", rememberSnapshot = false } = {}) {
+  await debugLog({
+    mode,
+    agent,
+    providerName: context.providerName,
+    baseUrl: context.baseUrl,
+    preset: await usagePreset(),
+    providerEnvKey: context.provider?.env_key || "",
+    hasProviderUsageKey: Boolean(process.env.PROVIDER_USAGE_API_KEY),
+    hasSub2apiKey: Boolean(process.env.SUB2API_API_KEY),
+    hasProviderEnvKey: Boolean(context.provider?.env_key && process.env[context.provider.env_key]),
+    hasAnthropicAuthToken: Boolean(process.env.ANTHROPIC_AUTH_TOKEN),
+    hasAnthropicApiKey: Boolean(process.env.ANTHROPIC_API_KEY),
+    hasEnvOpenaiKey: Boolean(process.env.OPENAI_API_KEY)
+  });
+  if (!context.key || isOfficialBaseUrl(context.baseUrl)) {
+    return { skipped: true, text: "" };
+  }
+  let lastError;
+  for (const route of await orderedUsageRoutes(context)) {
+    try {
+      const result = await route.run(context);
+      await rememberUsageRoute(context, route, result);
+      if (rememberSnapshot) {
+        await rememberUsageSnapshot(context, result);
+        await rememberRefreshState(context, {
+          lastSuccessAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastError: ""
+        });
+      }
+      return result;
+    } catch (error) {
+      lastError = error;
+      await debugLog({ route: route.id, path: route.path, error: error.message });
+    }
+  }
+  if (lastError) {
+    if (rememberSnapshot) {
+      await rememberRefreshState(context, {
+        lastFailureAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastError: lastError.message
+      });
+    }
+    throw lastError;
+  }
+  return { skipped: true, text: "" };
+}
+async function queryProviderUsage(input, options = {}) {
+  return await queryUsageContext(normalizeUsageContext(input), options);
+}
+async function refresh(agent = "codex") {
+  return await queryAgentProviderUsage(agent);
+}
+async function queryAgentProviderUsage(agent = "codex") {
+  return await queryUsageContext(await usageContext(agent), {
+    agent,
+    rememberSnapshot: agent === "claude"
+  });
+}
+async function main() {
+  try {
+    if (mode === "refresh") {
+      await refresh(cli.agent);
+    } else if (mode === "print" || mode === "print-or-refresh") {
+      const result = await refresh(cli.agent);
+      textOut(result?.text || "");
+    } else if (mode === "hook") {
+      const result = await refresh(cli.agent);
+      hookOut(result?.text || "");
+    } else {
+      throw new Error(`unknown mode: ${mode}`);
+    }
+  } catch (error) {
+    failSoft("Provider usage unavailable", error);
+  }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await main();
+}
+export {
+  queryAgentProviderUsage,
+  queryProviderUsage
+};