| Server IP : 85.155.190.233 / Your IP : 216.73.216.103 Web Server : nginx/1.24.0 System : Linux antigravity-cli 6.8.0-31-generic #31-Ubuntu SMP PREEMPT_DYNAMIC Sat Apr 20 00:40:06 UTC 2024 x86_64 User : wp-moonbloom ( 1001) PHP Version : 8.3.6 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/node_modules/@google/gemini-cli/bundle/ |
Upload File : |
const require = (await import('node:module')).createRequire(import.meta.url); const __chunk_filename = (await import('node:url')).fileURLToPath(import.meta.url); const __chunk_dirname = (await import('node:path')).dirname(__chunk_filename);
import {
import_websocket
} from "./chunk-664ZODQF.js";
import {
__commonJS,
__export,
__require,
__toESM
} from "./chunk-34MYV7JD.js";
// packages/core/node_modules/ajv/dist/compile/codegen/code.js
var require_code = __commonJS({
"packages/core/node_modules/ajv/dist/compile/codegen/code.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
var _CodeOrName = class {
};
exports._CodeOrName = _CodeOrName;
exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
var Name = class extends _CodeOrName {
constructor(s) {
super();
if (!exports.IDENTIFIER.test(s))
throw new Error("CodeGen: name must be a valid identifier");
this.str = s;
}
toString() {
return this.str;
}
emptyStr() {
return false;
}
get names() {
return { [this.str]: 1 };
}
};
exports.Name = Name;
var _Code = class extends _CodeOrName {
constructor(code) {
super();
this._items = typeof code === "string" ? [code] : code;
}
toString() {
return this.str;
}
emptyStr() {
if (this._items.length > 1)
return false;
const item = this._items[0];
return item === "" || item === '""';
}
get str() {
var _a;
return (_a = this._str) !== null && _a !== void 0 ? _a : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
}
get names() {
var _a;
return (_a = this._names) !== null && _a !== void 0 ? _a : this._names = this._items.reduce((names, c) => {
if (c instanceof Name)
names[c.str] = (names[c.str] || 0) + 1;
return names;
}, {});
}
};
exports._Code = _Code;
exports.nil = new _Code("");
function _(strs, ...args) {
const code = [strs[0]];
let i = 0;
while (i < args.length) {
addCodeArg(code, args[i]);
code.push(strs[++i]);
}
return new _Code(code);
}
exports._ = _;
var plus = new _Code("+");
function str(strs, ...args) {
const expr = [safeStringify(strs[0])];
let i = 0;
while (i < args.length) {
expr.push(plus);
addCodeArg(expr, args[i]);
expr.push(plus, safeStringify(strs[++i]));
}
optimize(expr);
return new _Code(expr);
}
exports.str = str;
function addCodeArg(code, arg) {
if (arg instanceof _Code)
code.push(...arg._items);
else if (arg instanceof Name)
code.push(arg);
else
code.push(interpolate(arg));
}
exports.addCodeArg = addCodeArg;
function optimize(expr) {
let i = 1;
while (i < expr.length - 1) {
if (expr[i] === plus) {
const res = mergeExprItems(expr[i - 1], expr[i + 1]);
if (res !== void 0) {
expr.splice(i - 1, 3, res);
continue;
}
expr[i++] = "+";
}
i++;
}
}
function mergeExprItems(a, b) {
if (b === '""')
return a;
if (a === '""')
return b;
if (typeof a == "string") {
if (b instanceof Name || a[a.length - 1] !== '"')
return;
if (typeof b != "string")
return `${a.slice(0, -1)}${b}"`;
if (b[0] === '"')
return a.slice(0, -1) + b.slice(1);
return;
}
if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
return `"${a}${b.slice(1)}`;
return;
}
function strConcat(c1, c2) {
return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
}
exports.strConcat = strConcat;
function interpolate(x) {
return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
}
function stringify(x) {
return new _Code(safeStringify(x));
}
exports.stringify = stringify;
function safeStringify(x) {
return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
}
exports.safeStringify = safeStringify;
function getProperty(key) {
return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
}
exports.getProperty = getProperty;
function getEsmExportName(key) {
if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
return new _Code(`${key}`);
}
throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
}
exports.getEsmExportName = getEsmExportName;
function regexpCode(rx) {
return new _Code(rx.toString());
}
exports.regexpCode = regexpCode;
}
});
// packages/core/node_modules/ajv/dist/compile/codegen/scope.js
var require_scope = __commonJS({
"packages/core/node_modules/ajv/dist/compile/codegen/scope.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
var code_1 = require_code();
var ValueError = class extends Error {
constructor(name) {
super(`CodeGen: "code" for ${name} not defined`);
this.value = name.value;
}
};
var UsedValueState;
(function(UsedValueState2) {
UsedValueState2[UsedValueState2["Started"] = 0] = "Started";
UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed";
})(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
exports.varKinds = {
const: new code_1.Name("const"),
let: new code_1.Name("let"),
var: new code_1.Name("var")
};
var Scope = class {
constructor({ prefixes, parent } = {}) {
this._names = {};
this._prefixes = prefixes;
this._parent = parent;
}
toName(nameOrPrefix) {
return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
}
name(prefix) {
return new code_1.Name(this._newName(prefix));
}
_newName(prefix) {
const ng = this._names[prefix] || this._nameGroup(prefix);
return `${prefix}${ng.index++}`;
}
_nameGroup(prefix) {
var _a, _b;
if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) {
throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
}
return this._names[prefix] = { prefix, index: 0 };
}
};
exports.Scope = Scope;
var ValueScopeName = class extends code_1.Name {
constructor(prefix, nameStr) {
super(nameStr);
this.prefix = prefix;
}
setValue(value, { property, itemIndex }) {
this.value = value;
this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
}
};
exports.ValueScopeName = ValueScopeName;
var line = (0, code_1._)`\n`;
var ValueScope = class extends Scope {
constructor(opts) {
super(opts);
this._values = {};
this._scope = opts.scope;
this.opts = { ...opts, _n: opts.lines ? line : code_1.nil };
}
get() {
return this._scope;
}
name(prefix) {
return new ValueScopeName(prefix, this._newName(prefix));
}
value(nameOrPrefix, value) {
var _a;
if (value.ref === void 0)
throw new Error("CodeGen: ref must be passed in value");
const name = this.toName(nameOrPrefix);
const { prefix } = name;
const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
let vs = this._values[prefix];
if (vs) {
const _name = vs.get(valueKey);
if (_name)
return _name;
} else {
vs = this._values[prefix] = /* @__PURE__ */ new Map();
}
vs.set(valueKey, name);
const s = this._scope[prefix] || (this._scope[prefix] = []);
const itemIndex = s.length;
s[itemIndex] = value.ref;
name.setValue(value, { property: prefix, itemIndex });
return name;
}
getValue(prefix, keyOrRef) {
const vs = this._values[prefix];
if (!vs)
return;
return vs.get(keyOrRef);
}
scopeRefs(scopeName, values = this._values) {
return this._reduceValues(values, (name) => {
if (name.scopePath === void 0)
throw new Error(`CodeGen: name "${name}" has no value`);
return (0, code_1._)`${scopeName}${name.scopePath}`;
});
}
scopeCode(values = this._values, usedValues, getCode) {
return this._reduceValues(values, (name) => {
if (name.value === void 0)
throw new Error(`CodeGen: name "${name}" has no value`);
return name.value.code;
}, usedValues, getCode);
}
_reduceValues(values, valueCode, usedValues = {}, getCode) {
let code = code_1.nil;
for (const prefix in values) {
const vs = values[prefix];
if (!vs)
continue;
const nameSet = usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map();
vs.forEach((name) => {
if (nameSet.has(name))
return;
nameSet.set(name, UsedValueState.Started);
let c = valueCode(name);
if (c) {
const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
} else if (c = getCode === null || getCode === void 0 ? void 0 : getCode(name)) {
code = (0, code_1._)`${code}${c}${this.opts._n}`;
} else {
throw new ValueError(name);
}
nameSet.set(name, UsedValueState.Completed);
});
}
return code;
}
};
exports.ValueScope = ValueScope;
}
});
// packages/core/node_modules/ajv/dist/compile/codegen/index.js
var require_codegen = __commonJS({
"packages/core/node_modules/ajv/dist/compile/codegen/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
var code_1 = require_code();
var scope_1 = require_scope();
var code_2 = require_code();
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
return code_2._;
} });
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
return code_2.str;
} });
Object.defineProperty(exports, "strConcat", { enumerable: true, get: function() {
return code_2.strConcat;
} });
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
return code_2.nil;
} });
Object.defineProperty(exports, "getProperty", { enumerable: true, get: function() {
return code_2.getProperty;
} });
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
return code_2.stringify;
} });
Object.defineProperty(exports, "regexpCode", { enumerable: true, get: function() {
return code_2.regexpCode;
} });
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
return code_2.Name;
} });
var scope_2 = require_scope();
Object.defineProperty(exports, "Scope", { enumerable: true, get: function() {
return scope_2.Scope;
} });
Object.defineProperty(exports, "ValueScope", { enumerable: true, get: function() {
return scope_2.ValueScope;
} });
Object.defineProperty(exports, "ValueScopeName", { enumerable: true, get: function() {
return scope_2.ValueScopeName;
} });
Object.defineProperty(exports, "varKinds", { enumerable: true, get: function() {
return scope_2.varKinds;
} });
exports.operators = {
GT: new code_1._Code(">"),
GTE: new code_1._Code(">="),
LT: new code_1._Code("<"),
LTE: new code_1._Code("<="),
EQ: new code_1._Code("==="),
NEQ: new code_1._Code("!=="),
NOT: new code_1._Code("!"),
OR: new code_1._Code("||"),
AND: new code_1._Code("&&"),
ADD: new code_1._Code("+")
};
var Node = class {
optimizeNodes() {
return this;
}
optimizeNames(_names, _constants) {
return this;
}
};
var Def = class extends Node {
constructor(varKind, name, rhs) {
super();
this.varKind = varKind;
this.name = name;
this.rhs = rhs;
}
render({ es5, _n }) {
const varKind = es5 ? scope_1.varKinds.var : this.varKind;
const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
return `${varKind} ${this.name}${rhs};` + _n;
}
optimizeNames(names, constants2) {
if (!names[this.name.str])
return;
if (this.rhs)
this.rhs = optimizeExpr(this.rhs, names, constants2);
return this;
}
get names() {
return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
}
};
var Assign = class extends Node {
constructor(lhs, rhs, sideEffects) {
super();
this.lhs = lhs;
this.rhs = rhs;
this.sideEffects = sideEffects;
}
render({ _n }) {
return `${this.lhs} = ${this.rhs};` + _n;
}
optimizeNames(names, constants2) {
if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
return;
this.rhs = optimizeExpr(this.rhs, names, constants2);
return this;
}
get names() {
const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };
return addExprNames(names, this.rhs);
}
};
var AssignOp = class extends Assign {
constructor(lhs, op, rhs, sideEffects) {
super(lhs, rhs, sideEffects);
this.op = op;
}
render({ _n }) {
return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
}
};
var Label = class extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
return `${this.label}:` + _n;
}
};
var Break = class extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
const label = this.label ? ` ${this.label}` : "";
return `break${label};` + _n;
}
};
var Throw = class extends Node {
constructor(error) {
super();
this.error = error;
}
render({ _n }) {
return `throw ${this.error};` + _n;
}
get names() {
return this.error.names;
}
};
var AnyCode = class extends Node {
constructor(code) {
super();
this.code = code;
}
render({ _n }) {
return `${this.code};` + _n;
}
optimizeNodes() {
return `${this.code}` ? this : void 0;
}
optimizeNames(names, constants2) {
this.code = optimizeExpr(this.code, names, constants2);
return this;
}
get names() {
return this.code instanceof code_1._CodeOrName ? this.code.names : {};
}
};
var ParentNode = class extends Node {
constructor(nodes = []) {
super();
this.nodes = nodes;
}
render(opts) {
return this.nodes.reduce((code, n) => code + n.render(opts), "");
}
optimizeNodes() {
const { nodes } = this;
let i = nodes.length;
while (i--) {
const n = nodes[i].optimizeNodes();
if (Array.isArray(n))
nodes.splice(i, 1, ...n);
else if (n)
nodes[i] = n;
else
nodes.splice(i, 1);
}
return nodes.length > 0 ? this : void 0;
}
optimizeNames(names, constants2) {
const { nodes } = this;
let i = nodes.length;
while (i--) {
const n = nodes[i];
if (n.optimizeNames(names, constants2))
continue;
subtractNames(names, n.names);
nodes.splice(i, 1);
}
return nodes.length > 0 ? this : void 0;
}
get names() {
return this.nodes.reduce((names, n) => addNames(names, n.names), {});
}
};
var BlockNode = class extends ParentNode {
render(opts) {
return "{" + opts._n + super.render(opts) + "}" + opts._n;
}
};
var Root = class extends ParentNode {
};
var Else = class extends BlockNode {
};
Else.kind = "else";
var If = class _If extends BlockNode {
constructor(condition, nodes) {
super(nodes);
this.condition = condition;
}
render(opts) {
let code = `if(${this.condition})` + super.render(opts);
if (this.else)
code += "else " + this.else.render(opts);
return code;
}
optimizeNodes() {
super.optimizeNodes();
const cond = this.condition;
if (cond === true)
return this.nodes;
let e = this.else;
if (e) {
const ns = e.optimizeNodes();
e = this.else = Array.isArray(ns) ? new Else(ns) : ns;
}
if (e) {
if (cond === false)
return e instanceof _If ? e : e.nodes;
if (this.nodes.length)
return this;
return new _If(not(cond), e instanceof _If ? [e] : e.nodes);
}
if (cond === false || !this.nodes.length)
return void 0;
return this;
}
optimizeNames(names, constants2) {
var _a;
this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants2);
if (!(super.optimizeNames(names, constants2) || this.else))
return;
this.condition = optimizeExpr(this.condition, names, constants2);
return this;
}
get names() {
const names = super.names;
addExprNames(names, this.condition);
if (this.else)
addNames(names, this.else.names);
return names;
}
};
If.kind = "if";
var For = class extends BlockNode {
};
For.kind = "for";
var ForLoop = class extends For {
constructor(iteration) {
super();
this.iteration = iteration;
}
render(opts) {
return `for(${this.iteration})` + super.render(opts);
}
optimizeNames(names, constants2) {
if (!super.optimizeNames(names, constants2))
return;
this.iteration = optimizeExpr(this.iteration, names, constants2);
return this;
}
get names() {
return addNames(super.names, this.iteration.names);
}
};
var ForRange = class extends For {
constructor(varKind, name, from, to) {
super();
this.varKind = varKind;
this.name = name;
this.from = from;
this.to = to;
}
render(opts) {
const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;
const { name, from, to } = this;
return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);
}
get names() {
const names = addExprNames(super.names, this.from);
return addExprNames(names, this.to);
}
};
var ForIter = class extends For {
constructor(loop, varKind, name, iterable) {
super();
this.loop = loop;
this.varKind = varKind;
this.name = name;
this.iterable = iterable;
}
render(opts) {
return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
}
optimizeNames(names, constants2) {
if (!super.optimizeNames(names, constants2))
return;
this.iterable = optimizeExpr(this.iterable, names, constants2);
return this;
}
get names() {
return addNames(super.names, this.iterable.names);
}
};
var Func = class extends BlockNode {
constructor(name, args, async) {
super();
this.name = name;
this.args = args;
this.async = async;
}
render(opts) {
const _async = this.async ? "async " : "";
return `${_async}function ${this.name}(${this.args})` + super.render(opts);
}
};
Func.kind = "func";
var Return = class extends ParentNode {
render(opts) {
return "return " + super.render(opts);
}
};
Return.kind = "return";
var Try = class extends BlockNode {
render(opts) {
let code = "try" + super.render(opts);
if (this.catch)
code += this.catch.render(opts);
if (this.finally)
code += this.finally.render(opts);
return code;
}
optimizeNodes() {
var _a, _b;
super.optimizeNodes();
(_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes();
(_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
return this;
}
optimizeNames(names, constants2) {
var _a, _b;
super.optimizeNames(names, constants2);
(_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants2);
(_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants2);
return this;
}
get names() {
const names = super.names;
if (this.catch)
addNames(names, this.catch.names);
if (this.finally)
addNames(names, this.finally.names);
return names;
}
};
var Catch = class extends BlockNode {
constructor(error) {
super();
this.error = error;
}
render(opts) {
return `catch(${this.error})` + super.render(opts);
}
};
Catch.kind = "catch";
var Finally = class extends BlockNode {
render(opts) {
return "finally" + super.render(opts);
}
};
Finally.kind = "finally";
var CodeGen = class {
constructor(extScope, opts = {}) {
this._values = {};
this._blockStarts = [];
this._constants = {};
this.opts = { ...opts, _n: opts.lines ? "\n" : "" };
this._extScope = extScope;
this._scope = new scope_1.Scope({ parent: extScope });
this._nodes = [new Root()];
}
toString() {
return this._root.render(this.opts);
}
// returns unique name in the internal scope
name(prefix) {
return this._scope.name(prefix);
}
// reserves unique name in the external scope
scopeName(prefix) {
return this._extScope.name(prefix);
}
// reserves unique name in the external scope and assigns value to it
scopeValue(prefixOrName, value) {
const name = this._extScope.value(prefixOrName, value);
const vs = this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set());
vs.add(name);
return name;
}
getScopeValue(prefix, keyOrRef) {
return this._extScope.getValue(prefix, keyOrRef);
}
// return code that assigns values in the external scope to the names that are used internally
// (same names that were returned by gen.scopeName or gen.scopeValue)
scopeRefs(scopeName) {
return this._extScope.scopeRefs(scopeName, this._values);
}
scopeCode() {
return this._extScope.scopeCode(this._values);
}
_def(varKind, nameOrPrefix, rhs, constant) {
const name = this._scope.toName(nameOrPrefix);
if (rhs !== void 0 && constant)
this._constants[name.str] = rhs;
this._leafNode(new Def(varKind, name, rhs));
return name;
}
// `const` declaration (`var` in es5 mode)
const(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
}
// `let` declaration with optional assignment (`var` in es5 mode)
let(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
}
// `var` declaration with optional assignment
var(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
}
// assignment code
assign(lhs, rhs, sideEffects) {
return this._leafNode(new Assign(lhs, rhs, sideEffects));
}
// `+=` code
add(lhs, rhs) {
return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
}
// appends passed SafeExpr to code or executes Block
code(c) {
if (typeof c == "function")
c();
else if (c !== code_1.nil)
this._leafNode(new AnyCode(c));
return this;
}
// returns code for object literal for the passed argument list of key-value pairs
object(...keyValues) {
const code = ["{"];
for (const [key, value] of keyValues) {
if (code.length > 1)
code.push(",");
code.push(key);
if (key !== value || this.opts.es5) {
code.push(":");
(0, code_1.addCodeArg)(code, value);
}
}
code.push("}");
return new code_1._Code(code);
}
// `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
if(condition, thenBody, elseBody) {
this._blockNode(new If(condition));
if (thenBody && elseBody) {
this.code(thenBody).else().code(elseBody).endIf();
} else if (thenBody) {
this.code(thenBody).endIf();
} else if (elseBody) {
throw new Error('CodeGen: "else" body without "then" body');
}
return this;
}
// `else if` clause - invalid without `if` or after `else` clauses
elseIf(condition) {
return this._elseNode(new If(condition));
}
// `else` clause - only valid after `if` or `else if` clauses
else() {
return this._elseNode(new Else());
}
// end `if` statement (needed if gen.if was used only with condition)
endIf() {
return this._endBlockNode(If, Else);
}
_for(node, forBody) {
this._blockNode(node);
if (forBody)
this.code(forBody).endFor();
return this;
}
// a generic `for` clause (or statement if `forBody` is passed)
for(iteration, forBody) {
return this._for(new ForLoop(iteration), forBody);
}
// `for` statement for a range of values
forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {
const name = this._scope.toName(nameOrPrefix);
return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
}
// `for-of` statement (in es5 mode replace with a normal for loop)
forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
const name = this._scope.toName(nameOrPrefix);
if (this.opts.es5) {
const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => {
this.var(name, (0, code_1._)`${arr}[${i}]`);
forBody(name);
});
}
return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
}
// `for-in` statement.
// With option `ownProperties` replaced with a `for-of` loop for object keys
forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {
if (this.opts.ownProperties) {
return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody);
}
const name = this._scope.toName(nameOrPrefix);
return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
}
// end `for` loop
endFor() {
return this._endBlockNode(For);
}
// `label` statement
label(label) {
return this._leafNode(new Label(label));
}
// `break` statement
break(label) {
return this._leafNode(new Break(label));
}
// `return` statement
return(value) {
const node = new Return();
this._blockNode(node);
this.code(value);
if (node.nodes.length !== 1)
throw new Error('CodeGen: "return" should have one node');
return this._endBlockNode(Return);
}
// `try` statement
try(tryBody, catchCode, finallyCode) {
if (!catchCode && !finallyCode)
throw new Error('CodeGen: "try" without "catch" and "finally"');
const node = new Try();
this._blockNode(node);
this.code(tryBody);
if (catchCode) {
const error = this.name("e");
this._currNode = node.catch = new Catch(error);
catchCode(error);
}
if (finallyCode) {
this._currNode = node.finally = new Finally();
this.code(finallyCode);
}
return this._endBlockNode(Catch, Finally);
}
// `throw` statement
throw(error) {
return this._leafNode(new Throw(error));
}
// start self-balancing block
block(body, nodeCount) {
this._blockStarts.push(this._nodes.length);
if (body)
this.code(body).endBlock(nodeCount);
return this;
}
// end the current self-balancing block
endBlock(nodeCount) {
const len = this._blockStarts.pop();
if (len === void 0)
throw new Error("CodeGen: not in self-balancing block");
const toClose = this._nodes.length - len;
if (toClose < 0 || nodeCount !== void 0 && toClose !== nodeCount) {
throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
}
this._nodes.length = len;
return this;
}
// `function` heading (or definition if funcBody is passed)
func(name, args = code_1.nil, async, funcBody) {
this._blockNode(new Func(name, args, async));
if (funcBody)
this.code(funcBody).endFunc();
return this;
}
// end function definition
endFunc() {
return this._endBlockNode(Func);
}
optimize(n = 1) {
while (n-- > 0) {
this._root.optimizeNodes();
this._root.optimizeNames(this._root.names, this._constants);
}
}
_leafNode(node) {
this._currNode.nodes.push(node);
return this;
}
_blockNode(node) {
this._currNode.nodes.push(node);
this._nodes.push(node);
}
_endBlockNode(N1, N2) {
const n = this._currNode;
if (n instanceof N1 || N2 && n instanceof N2) {
this._nodes.pop();
return this;
}
throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
}
_elseNode(node) {
const n = this._currNode;
if (!(n instanceof If)) {
throw new Error('CodeGen: "else" without "if"');
}
this._currNode = n.else = node;
return this;
}
get _root() {
return this._nodes[0];
}
get _currNode() {
const ns = this._nodes;
return ns[ns.length - 1];
}
set _currNode(node) {
const ns = this._nodes;
ns[ns.length - 1] = node;
}
};
exports.CodeGen = CodeGen;
function addNames(names, from) {
for (const n in from)
names[n] = (names[n] || 0) + (from[n] || 0);
return names;
}
function addExprNames(names, from) {
return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
}
function optimizeExpr(expr, names, constants2) {
if (expr instanceof code_1.Name)
return replaceName(expr);
if (!canOptimize(expr))
return expr;
return new code_1._Code(expr._items.reduce((items, c) => {
if (c instanceof code_1.Name)
c = replaceName(c);
if (c instanceof code_1._Code)
items.push(...c._items);
else
items.push(c);
return items;
}, []));
function replaceName(n) {
const c = constants2[n.str];
if (c === void 0 || names[n.str] !== 1)
return n;
delete names[n.str];
return c;
}
function canOptimize(e) {
return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants2[c.str] !== void 0);
}
}
function subtractNames(names, from) {
for (const n in from)
names[n] = (names[n] || 0) - (from[n] || 0);
}
function not(x) {
return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._)`!${par(x)}`;
}
exports.not = not;
var andCode = mappend(exports.operators.AND);
function and(...args) {
return args.reduce(andCode);
}
exports.and = and;
var orCode = mappend(exports.operators.OR);
function or(...args) {
return args.reduce(orCode);
}
exports.or = or;
function mappend(op) {
return (x, y) => x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
}
function par(x) {
return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`;
}
}
});
// packages/core/node_modules/ajv/dist/compile/util.js
var require_util = __commonJS({
"packages/core/node_modules/ajv/dist/compile/util.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
var codegen_1 = require_codegen();
var code_1 = require_code();
function toHash(arr) {
const hash = {};
for (const item of arr)
hash[item] = true;
return hash;
}
exports.toHash = toHash;
function alwaysValidSchema(it, schema) {
if (typeof schema == "boolean")
return schema;
if (Object.keys(schema).length === 0)
return true;
checkUnknownRules(it, schema);
return !schemaHasRules(schema, it.self.RULES.all);
}
exports.alwaysValidSchema = alwaysValidSchema;
function checkUnknownRules(it, schema = it.schema) {
const { opts, self: self2 } = it;
if (!opts.strictSchema)
return;
if (typeof schema === "boolean")
return;
const rules = self2.RULES.keywords;
for (const key in schema) {
if (!rules[key])
checkStrictMode(it, `unknown keyword: "${key}"`);
}
}
exports.checkUnknownRules = checkUnknownRules;
function schemaHasRules(schema, rules) {
if (typeof schema == "boolean")
return !schema;
for (const key in schema)
if (rules[key])
return true;
return false;
}
exports.schemaHasRules = schemaHasRules;
function schemaHasRulesButRef(schema, RULES) {
if (typeof schema == "boolean")
return !schema;
for (const key in schema)
if (key !== "$ref" && RULES.all[key])
return true;
return false;
}
exports.schemaHasRulesButRef = schemaHasRulesButRef;
function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
if (!$data) {
if (typeof schema == "number" || typeof schema == "boolean")
return schema;
if (typeof schema == "string")
return (0, codegen_1._)`${schema}`;
}
return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
}
exports.schemaRefOrVal = schemaRefOrVal;
function unescapeFragment(str) {
return unescapeJsonPointer(decodeURIComponent(str));
}
exports.unescapeFragment = unescapeFragment;
function escapeFragment(str) {
return encodeURIComponent(escapeJsonPointer(str));
}
exports.escapeFragment = escapeFragment;
function escapeJsonPointer(str) {
if (typeof str == "number")
return `${str}`;
return str.replace(/~/g, "~0").replace(/\//g, "~1");
}
exports.escapeJsonPointer = escapeJsonPointer;
function unescapeJsonPointer(str) {
return str.replace(/~1/g, "/").replace(/~0/g, "~");
}
exports.unescapeJsonPointer = unescapeJsonPointer;
function eachItem(xs, f) {
if (Array.isArray(xs)) {
for (const x of xs)
f(x);
} else {
f(xs);
}
}
exports.eachItem = eachItem;
function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues2, resultToName }) {
return (gen, from, to, toName) => {
const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues2(from, to);
return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
};
}
exports.mergeEvaluated = {
props: makeMergeEvaluated({
mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => {
gen.if((0, codegen_1._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._)`${to} || {}`).code((0, codegen_1._)`Object.assign(${to}, ${from})`));
}),
mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => {
if (from === true) {
gen.assign(to, true);
} else {
gen.assign(to, (0, codegen_1._)`${to} || {}`);
setEvaluated(gen, to, from);
}
}),
mergeValues: (from, to) => from === true ? true : { ...from, ...to },
resultToName: evaluatedPropsToName
}),
items: makeMergeEvaluated({
mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)),
mergeValues: (from, to) => from === true ? true : Math.max(from, to),
resultToName: (gen, items) => gen.var("items", items)
})
};
function evaluatedPropsToName(gen, ps) {
if (ps === true)
return gen.var("props", true);
const props = gen.var("props", (0, codegen_1._)`{}`);
if (ps !== void 0)
setEvaluated(gen, props, ps);
return props;
}
exports.evaluatedPropsToName = evaluatedPropsToName;
function setEvaluated(gen, props, ps) {
Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true));
}
exports.setEvaluated = setEvaluated;
var snippets = {};
function useFunc(gen, f) {
return gen.scopeValue("func", {
ref: f,
code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code))
});
}
exports.useFunc = useFunc;
var Type2;
(function(Type3) {
Type3[Type3["Num"] = 0] = "Num";
Type3[Type3["Str"] = 1] = "Str";
})(Type2 || (exports.Type = Type2 = {}));
function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
if (dataProp instanceof codegen_1.Name) {
const isNumber = dataPropType === Type2.Num;
return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
}
return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
}
exports.getErrorPath = getErrorPath;
function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
if (!mode)
return;
msg = `strict mode: ${msg}`;
if (mode === true)
throw new Error(msg);
it.self.logger.warn(msg);
}
exports.checkStrictMode = checkStrictMode;
}
});
// packages/core/node_modules/ajv/dist/compile/names.js
var require_names = __commonJS({
"packages/core/node_modules/ajv/dist/compile/names.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var names = {
// validation function arguments
data: new codegen_1.Name("data"),
// data passed to validation function
// args passed from referencing schema
valCxt: new codegen_1.Name("valCxt"),
// validation/data context - should not be used directly, it is destructured to the names below
instancePath: new codegen_1.Name("instancePath"),
parentData: new codegen_1.Name("parentData"),
parentDataProperty: new codegen_1.Name("parentDataProperty"),
rootData: new codegen_1.Name("rootData"),
// root data - same as the data passed to the first/top validation function
dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
// used to support recursiveRef and dynamicRef
// function scoped variables
vErrors: new codegen_1.Name("vErrors"),
// null or array of validation errors
errors: new codegen_1.Name("errors"),
// counter of validation errors
this: new codegen_1.Name("this"),
// "globals"
self: new codegen_1.Name("self"),
scope: new codegen_1.Name("scope"),
// JTD serialize/parse name for JSON string and position
json: new codegen_1.Name("json"),
jsonPos: new codegen_1.Name("jsonPos"),
jsonLen: new codegen_1.Name("jsonLen"),
jsonPart: new codegen_1.Name("jsonPart")
};
exports.default = names;
}
});
// packages/core/node_modules/ajv/dist/compile/errors.js
var require_errors = __commonJS({
"packages/core/node_modules/ajv/dist/compile/errors.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
var codegen_1 = require_codegen();
var util_1 = require_util();
var names_1 = require_names();
exports.keywordError = {
message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation`
};
exports.keyword$DataError = {
message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)`
};
function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
const errObj = errorObjectCode(cxt, error, errorPaths);
if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule || allErrors) {
addError(gen, errObj);
} else {
returnErrors(it, (0, codegen_1._)`[${errObj}]`);
}
}
exports.reportError = reportError;
function reportExtraError(cxt, error = exports.keywordError, errorPaths) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
const errObj = errorObjectCode(cxt, error, errorPaths);
addError(gen, errObj);
if (!(compositeRule || allErrors)) {
returnErrors(it, names_1.default.vErrors);
}
}
exports.reportExtraError = reportExtraError;
function resetErrorsCount(gen, errsCount) {
gen.assign(names_1.default.errors, errsCount);
gen.if((0, codegen_1._)`${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._)`${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null)));
}
exports.resetErrorsCount = resetErrorsCount;
function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
if (errsCount === void 0)
throw new Error("ajv implementation error");
const err = gen.name("err");
gen.forRange("i", errsCount, names_1.default.errors, (i) => {
gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
if (it.opts.verbose) {
gen.assign((0, codegen_1._)`${err}.schema`, schemaValue);
gen.assign((0, codegen_1._)`${err}.data`, data);
}
});
}
exports.extendErrors = extendErrors;
function addError(gen, errObj) {
const err = gen.const("err", errObj);
gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`);
gen.code((0, codegen_1._)`${names_1.default.errors}++`);
}
function returnErrors(it, errs) {
const { gen, validateName, schemaEnv } = it;
if (schemaEnv.$async) {
gen.throw((0, codegen_1._)`new ${it.ValidationError}(${errs})`);
} else {
gen.assign((0, codegen_1._)`${validateName}.errors`, errs);
gen.return(false);
}
}
var E = {
keyword: new codegen_1.Name("keyword"),
schemaPath: new codegen_1.Name("schemaPath"),
// also used in JTD errors
params: new codegen_1.Name("params"),
propertyName: new codegen_1.Name("propertyName"),
message: new codegen_1.Name("message"),
schema: new codegen_1.Name("schema"),
parentSchema: new codegen_1.Name("parentSchema")
};
function errorObjectCode(cxt, error, errorPaths) {
const { createErrors } = cxt.it;
if (createErrors === false)
return (0, codegen_1._)`{}`;
return errorObject(cxt, error, errorPaths);
}
function errorObject(cxt, error, errorPaths = {}) {
const { gen, it } = cxt;
const keyValues = [
errorInstancePath(it, errorPaths),
errorSchemaPath(cxt, errorPaths)
];
extraErrorProps(cxt, error, keyValues);
return gen.object(...keyValues);
}
function errorInstancePath({ errorPath }, { instancePath }) {
const instPath = instancePath ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : errorPath;
return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];
}
function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
if (schemaPath) {
schPath = (0, codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
}
return [E.schemaPath, schPath];
}
function extraErrorProps(cxt, { params, message }, keyValues) {
const { keyword, data, schemaValue, it } = cxt;
const { opts, propertyName, topSchemaRef, schemaPath } = it;
keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._)`{}`]);
if (opts.messages) {
keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
}
if (opts.verbose) {
keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);
}
if (propertyName)
keyValues.push([E.propertyName, propertyName]);
}
}
});
// packages/core/node_modules/ajv/dist/compile/validate/boolSchema.js
var require_boolSchema = __commonJS({
"packages/core/node_modules/ajv/dist/compile/validate/boolSchema.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
var errors_1 = require_errors();
var codegen_1 = require_codegen();
var names_1 = require_names();
var boolError = {
message: "boolean schema is false"
};
function topBoolOrEmptySchema(it) {
const { gen, schema, validateName } = it;
if (schema === false) {
falseSchemaError(it, false);
} else if (typeof schema == "object" && schema.$async === true) {
gen.return(names_1.default.data);
} else {
gen.assign((0, codegen_1._)`${validateName}.errors`, null);
gen.return(true);
}
}
exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
function boolOrEmptySchema(it, valid) {
const { gen, schema } = it;
if (schema === false) {
gen.var(valid, false);
falseSchemaError(it);
} else {
gen.var(valid, true);
}
}
exports.boolOrEmptySchema = boolOrEmptySchema;
function falseSchemaError(it, overrideAllErrors) {
const { gen, data } = it;
const cxt = {
gen,
keyword: "false schema",
data,
schema: false,
schemaCode: false,
schemaValue: false,
params: {},
it
};
(0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors);
}
}
});
// packages/core/node_modules/ajv/dist/compile/rules.js
var require_rules = __commonJS({
"packages/core/node_modules/ajv/dist/compile/rules.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getRules = exports.isJSONType = void 0;
var _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"];
var jsonTypes = new Set(_jsonTypes);
function isJSONType(x) {
return typeof x == "string" && jsonTypes.has(x);
}
exports.isJSONType = isJSONType;
function getRules() {
const groups = {
number: { type: "number", rules: [] },
string: { type: "string", rules: [] },
array: { type: "array", rules: [] },
object: { type: "object", rules: [] }
};
return {
types: { ...groups, integer: true, boolean: true, null: true },
rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object],
post: { rules: [] },
all: {},
keywords: {}
};
}
exports.getRules = getRules;
}
});
// packages/core/node_modules/ajv/dist/compile/validate/applicability.js
var require_applicability = __commonJS({
"packages/core/node_modules/ajv/dist/compile/validate/applicability.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
function schemaHasRulesForType({ schema, self: self2 }, type) {
const group = self2.RULES.types[type];
return group && group !== true && shouldUseGroup(schema, group);
}
exports.schemaHasRulesForType = schemaHasRulesForType;
function shouldUseGroup(schema, group) {
return group.rules.some((rule) => shouldUseRule(schema, rule));
}
exports.shouldUseGroup = shouldUseGroup;
function shouldUseRule(schema, rule) {
var _a;
return schema[rule.keyword] !== void 0 || ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== void 0));
}
exports.shouldUseRule = shouldUseRule;
}
});
// packages/core/node_modules/ajv/dist/compile/validate/dataType.js
var require_dataType = __commonJS({
"packages/core/node_modules/ajv/dist/compile/validate/dataType.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
var rules_1 = require_rules();
var applicability_1 = require_applicability();
var errors_1 = require_errors();
var codegen_1 = require_codegen();
var util_1 = require_util();
var DataType;
(function(DataType2) {
DataType2[DataType2["Correct"] = 0] = "Correct";
DataType2[DataType2["Wrong"] = 1] = "Wrong";
})(DataType || (exports.DataType = DataType = {}));
function getSchemaTypes(schema) {
const types = getJSONTypes(schema.type);
const hasNull = types.includes("null");
if (hasNull) {
if (schema.nullable === false)
throw new Error("type: null contradicts nullable: false");
} else {
if (!types.length && schema.nullable !== void 0) {
throw new Error('"nullable" cannot be used without "type"');
}
if (schema.nullable === true)
types.push("null");
}
return types;
}
exports.getSchemaTypes = getSchemaTypes;
function getJSONTypes(ts) {
const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
if (types.every(rules_1.isJSONType))
return types;
throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
}
exports.getJSONTypes = getJSONTypes;
function coerceAndCheckDataType(it, types) {
const { gen, data, opts } = it;
const coerceTo = coerceToTypes(types, opts.coerceTypes);
const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
if (checkTypes) {
const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
gen.if(wrongType, () => {
if (coerceTo.length)
coerceData(it, types, coerceTo);
else
reportTypeError(it);
});
}
return checkTypes;
}
exports.coerceAndCheckDataType = coerceAndCheckDataType;
var COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
function coerceToTypes(types, coerceTypes) {
return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
}
function coerceData(it, types, coerceTo) {
const { gen, data, opts } = it;
const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
if (opts.coerceTypes === "array") {
gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
}
gen.if((0, codegen_1._)`${coerced} !== undefined`);
for (const t of coerceTo) {
if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") {
coerceSpecificType(t);
}
}
gen.else();
reportTypeError(it);
gen.endIf();
gen.if((0, codegen_1._)`${coerced} !== undefined`, () => {
gen.assign(data, coerced);
assignParentData(it, coerced);
});
function coerceSpecificType(t) {
switch (t) {
case "string":
gen.elseIf((0, codegen_1._)`${dataType} == "number" || ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`);
return;
case "number":
gen.elseIf((0, codegen_1._)`${dataType} == "boolean" || ${data} === null
|| (${dataType} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1._)`+${data}`);
return;
case "integer":
gen.elseIf((0, codegen_1._)`${dataType} === "boolean" || ${data} === null
|| (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1._)`+${data}`);
return;
case "boolean":
gen.elseIf((0, codegen_1._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1._)`${data} === "true" || ${data} === 1`).assign(coerced, true);
return;
case "null":
gen.elseIf((0, codegen_1._)`${data} === "" || ${data} === 0 || ${data} === false`);
gen.assign(coerced, null);
return;
case "array":
gen.elseIf((0, codegen_1._)`${dataType} === "string" || ${dataType} === "number"
|| ${dataType} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1._)`[${data}]`);
}
}
}
function assignParentData({ gen, parentData, parentDataProperty }, expr) {
gen.if((0, codegen_1._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, expr));
}
function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;
let cond;
switch (dataType) {
case "null":
return (0, codegen_1._)`${data} ${EQ} null`;
case "array":
cond = (0, codegen_1._)`Array.isArray(${data})`;
break;
case "object":
cond = (0, codegen_1._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
break;
case "integer":
cond = numCond((0, codegen_1._)`!(${data} % 1) && !isNaN(${data})`);
break;
case "number":
cond = numCond();
break;
default:
return (0, codegen_1._)`typeof ${data} ${EQ} ${dataType}`;
}
return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);
function numCond(_cond = codegen_1.nil) {
return (0, codegen_1.and)((0, codegen_1._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._)`isFinite(${data})` : codegen_1.nil);
}
}
exports.checkDataType = checkDataType;
function checkDataTypes(dataTypes, data, strictNums, correct) {
if (dataTypes.length === 1) {
return checkDataType(dataTypes[0], data, strictNums, correct);
}
let cond;
const types = (0, util_1.toHash)(dataTypes);
if (types.array && types.object) {
const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
delete types.null;
delete types.array;
delete types.object;
} else {
cond = codegen_1.nil;
}
if (types.number)
delete types.integer;
for (const t in types)
cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
return cond;
}
exports.checkDataTypes = checkDataTypes;
var typeError = {
message: ({ schema }) => `must be ${schema}`,
params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}`
};
function reportTypeError(it) {
const cxt = getTypeErrorContext(it);
(0, errors_1.reportError)(cxt, typeError);
}
exports.reportTypeError = reportTypeError;
function getTypeErrorContext(it) {
const { gen, data, schema } = it;
const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
return {
gen,
keyword: "type",
data,
schema: schema.type,
schemaCode,
schemaValue: schemaCode,
parentSchema: schema,
params: {},
it
};
}
}
});
// packages/core/node_modules/ajv/dist/compile/validate/defaults.js
var require_defaults = __commonJS({
"packages/core/node_modules/ajv/dist/compile/validate/defaults.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.assignDefaults = void 0;
var codegen_1 = require_codegen();
var util_1 = require_util();
function assignDefaults(it, ty) {
const { properties, items } = it.schema;
if (ty === "object" && properties) {
for (const key in properties) {
assignDefault(it, key, properties[key].default);
}
} else if (ty === "array" && Array.isArray(items)) {
items.forEach((sch, i) => assignDefault(it, i, sch.default));
}
}
exports.assignDefaults = assignDefaults;
function assignDefault(it, prop, defaultValue) {
const { gen, compositeRule, data, opts } = it;
if (defaultValue === void 0)
return;
const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
if (compositeRule) {
(0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
return;
}
let condition = (0, codegen_1._)`${childData} === undefined`;
if (opts.useDefaults === "empty") {
condition = (0, codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
}
gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
}
}
});
// packages/core/node_modules/ajv/dist/vocabularies/code.js
var require_code2 = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/code.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0;
var codegen_1 = require_codegen();
var util_1 = require_util();
var names_1 = require_names();
var util_2 = require_util();
function checkReportMissingProp(cxt, prop) {
const { gen, data, it } = cxt;
gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true);
cxt.error();
});
}
exports.checkReportMissingProp = checkReportMissingProp;
function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`)));
}
exports.checkMissingProp = checkMissingProp;
function reportMissingProp(cxt, missing) {
cxt.setParams({ missingProperty: missing }, true);
cxt.error();
}
exports.reportMissingProp = reportMissingProp;
function hasPropFunc(gen) {
return gen.scopeValue("func", {
// eslint-disable-next-line @typescript-eslint/unbound-method
ref: Object.prototype.hasOwnProperty,
code: (0, codegen_1._)`Object.prototype.hasOwnProperty`
});
}
exports.hasPropFunc = hasPropFunc;
function isOwnProperty(gen, data, property) {
return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
}
exports.isOwnProperty = isOwnProperty;
function propertyInData(gen, data, property, ownProperties) {
const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
return ownProperties ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond;
}
exports.propertyInData = propertyInData;
function noPropertyInData(gen, data, property, ownProperties) {
const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;
}
exports.noPropertyInData = noPropertyInData;
function allSchemaProperties(schemaMap) {
return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
}
exports.allSchemaProperties = allSchemaProperties;
function schemaProperties(it, schemaMap) {
return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
}
exports.schemaProperties = schemaProperties;
function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
const valCxt = [
[names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
[names_1.default.parentData, it.parentData],
[names_1.default.parentDataProperty, it.parentDataProperty],
[names_1.default.rootData, names_1.default.rootData]
];
if (it.opts.dynamicRef)
valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`;
}
exports.callValidateCode = callValidateCode;
var newRegExp = (0, codegen_1._)`new RegExp`;
function usePattern({ gen, it: { opts } }, pattern) {
const u = opts.unicodeRegExp ? "u" : "";
const { regExp } = opts.code;
const rx = regExp(pattern, u);
return gen.scopeValue("pattern", {
key: rx.toString(),
ref: rx,
code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`
});
}
exports.usePattern = usePattern;
function validateArray(cxt) {
const { gen, data, keyword, it } = cxt;
const valid = gen.name("valid");
if (it.allErrors) {
const validArr = gen.let("valid", true);
validateItems(() => gen.assign(validArr, false));
return validArr;
}
gen.var(valid, true);
validateItems(() => gen.break());
return valid;
function validateItems(notValid) {
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
gen.forRange("i", 0, len, (i) => {
cxt.subschema({
keyword,
dataProp: i,
dataPropType: util_1.Type.Num
}, valid);
gen.if((0, codegen_1.not)(valid), notValid);
});
}
}
exports.validateArray = validateArray;
function validateUnion(cxt) {
const { gen, schema, keyword, it } = cxt;
if (!Array.isArray(schema))
throw new Error("ajv implementation error");
const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
if (alwaysValid && !it.opts.unevaluated)
return;
const valid = gen.let("valid", false);
const schValid = gen.name("_valid");
gen.block(() => schema.forEach((_sch, i) => {
const schCxt = cxt.subschema({
keyword,
schemaProp: i,
compositeRule: true
}, schValid);
gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`);
const merged = cxt.mergeValidEvaluated(schCxt, schValid);
if (!merged)
gen.if((0, codegen_1.not)(valid));
}));
cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
}
exports.validateUnion = validateUnion;
}
});
// packages/core/node_modules/ajv/dist/compile/validate/keyword.js
var require_keyword = __commonJS({
"packages/core/node_modules/ajv/dist/compile/validate/keyword.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0;
var codegen_1 = require_codegen();
var names_1 = require_names();
var code_1 = require_code2();
var errors_1 = require_errors();
function macroKeywordCode(cxt, def) {
const { gen, keyword, schema, parentSchema, it } = cxt;
const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
const schemaRef = useKeyword(gen, keyword, macroSchema);
if (it.opts.validateSchema !== false)
it.self.validateSchema(macroSchema, true);
const valid = gen.name("valid");
cxt.subschema({
schema: macroSchema,
schemaPath: codegen_1.nil,
errSchemaPath: `${it.errSchemaPath}/${keyword}`,
topSchemaRef: schemaRef,
compositeRule: true
}, valid);
cxt.pass(valid, () => cxt.error(true));
}
exports.macroKeywordCode = macroKeywordCode;
function funcKeywordCode(cxt, def) {
var _a;
const { gen, keyword, schema, parentSchema, $data, it } = cxt;
checkAsyncKeyword(it, def);
const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate;
const validateRef = useKeyword(gen, keyword, validate);
const valid = gen.let("valid");
cxt.block$data(valid, validateKeyword);
cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid);
function validateKeyword() {
if (def.errors === false) {
assignValid();
if (def.modifying)
modifyData(cxt);
reportErrs(() => cxt.error());
} else {
const ruleErrs = def.async ? validateAsync() : validateSync();
if (def.modifying)
modifyData(cxt);
reportErrs(() => addErrs(cxt, ruleErrs));
}
}
function validateAsync() {
const ruleErrs = gen.let("ruleErrs", null);
gen.try(() => assignValid((0, codegen_1._)`await `), (e) => gen.assign(valid, false).if((0, codegen_1._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`), () => gen.throw(e)));
return ruleErrs;
}
function validateSync() {
const validateErrs = (0, codegen_1._)`${validateRef}.errors`;
gen.assign(validateErrs, null);
assignValid(codegen_1.nil);
return validateErrs;
}
function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) {
const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self;
const passSchema = !("compile" in def && !$data || def.schema === false);
gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying);
}
function reportErrs(errors) {
var _a2;
gen.if((0, codegen_1.not)((_a2 = def.valid) !== null && _a2 !== void 0 ? _a2 : valid), errors);
}
}
exports.funcKeywordCode = funcKeywordCode;
function modifyData(cxt) {
const { gen, data, it } = cxt;
gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`));
}
function addErrs(cxt, errs) {
const { gen } = cxt;
gen.if((0, codegen_1._)`Array.isArray(${errs})`, () => {
gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`).assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
(0, errors_1.extendErrors)(cxt);
}, () => cxt.error());
}
function checkAsyncKeyword({ schemaEnv }, def) {
if (def.async && !schemaEnv.$async)
throw new Error("async keyword in sync schema");
}
function useKeyword(gen, keyword, result) {
if (result === void 0)
throw new Error(`keyword "${keyword}" failed to compile`);
return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) });
}
function validSchemaType(schema, schemaType, allowUndefined = false) {
return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
}
exports.validSchemaType = validSchemaType;
function validateKeywordUsage({ schema, opts, self: self2, errSchemaPath }, def, keyword) {
if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
throw new Error("ajv implementation error");
}
const deps = def.dependencies;
if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {
throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
}
if (def.validateSchema) {
const valid = def.validateSchema(schema[keyword]);
if (!valid) {
const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def.validateSchema.errors);
if (opts.validateSchema === "log")
self2.logger.error(msg);
else
throw new Error(msg);
}
}
}
exports.validateKeywordUsage = validateKeywordUsage;
}
});
// packages/core/node_modules/ajv/dist/compile/validate/subschema.js
var require_subschema = __commonJS({
"packages/core/node_modules/ajv/dist/compile/validate/subschema.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
var codegen_1 = require_codegen();
var util_1 = require_util();
function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
if (keyword !== void 0 && schema !== void 0) {
throw new Error('both "keyword" and "schema" passed, only one allowed');
}
if (keyword !== void 0) {
const sch = it.schema[keyword];
return schemaProp === void 0 ? {
schema: sch,
schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
errSchemaPath: `${it.errSchemaPath}/${keyword}`
} : {
schema: sch[schemaProp],
schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
};
}
if (schema !== void 0) {
if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) {
throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
}
return {
schema,
schemaPath,
topSchemaRef,
errSchemaPath
};
}
throw new Error('either "keyword" or "schema" must be passed');
}
exports.getSubschema = getSubschema;
function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
if (data !== void 0 && dataProp !== void 0) {
throw new Error('both "data" and "dataProp" passed, only one allowed');
}
const { gen } = it;
if (dataProp !== void 0) {
const { errorPath, dataPathArr, opts } = it;
const nextData = gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true);
dataContextProps(nextData);
subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`;
subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
}
if (data !== void 0) {
const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true);
dataContextProps(nextData);
if (propertyName !== void 0)
subschema.propertyName = propertyName;
}
if (dataTypes)
subschema.dataTypes = dataTypes;
function dataContextProps(_nextData) {
subschema.data = _nextData;
subschema.dataLevel = it.dataLevel + 1;
subschema.dataTypes = [];
it.definedProperties = /* @__PURE__ */ new Set();
subschema.parentData = it.data;
subschema.dataNames = [...it.dataNames, _nextData];
}
}
exports.extendSubschemaData = extendSubschemaData;
function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
if (compositeRule !== void 0)
subschema.compositeRule = compositeRule;
if (createErrors !== void 0)
subschema.createErrors = createErrors;
if (allErrors !== void 0)
subschema.allErrors = allErrors;
subschema.jtdDiscriminator = jtdDiscriminator;
subschema.jtdMetadata = jtdMetadata;
}
exports.extendSubschemaMode = extendSubschemaMode;
}
});
// node_modules/fast-deep-equal/index.js
var require_fast_deep_equal = __commonJS({
"node_modules/fast-deep-equal/index.js"(exports, module) {
"use strict";
module.exports = function equal(a, b) {
if (a === b) return true;
if (a && b && typeof a == "object" && typeof b == "object") {
if (a.constructor !== b.constructor) return false;
var length, i, keys;
if (Array.isArray(a)) {
length = a.length;
if (length != b.length) return false;
for (i = length; i-- !== 0; )
if (!equal(a[i], b[i])) return false;
return true;
}
if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
keys = Object.keys(a);
length = keys.length;
if (length !== Object.keys(b).length) return false;
for (i = length; i-- !== 0; )
if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
for (i = length; i-- !== 0; ) {
var key = keys[i];
if (!equal(a[key], b[key])) return false;
}
return true;
}
return a !== a && b !== b;
};
}
});
// packages/core/node_modules/json-schema-traverse/index.js
var require_json_schema_traverse = __commonJS({
"packages/core/node_modules/json-schema-traverse/index.js"(exports, module) {
"use strict";
var traverse = module.exports = function(schema, opts, cb) {
if (typeof opts == "function") {
cb = opts;
opts = {};
}
cb = opts.cb || cb;
var pre = typeof cb == "function" ? cb : cb.pre || function() {
};
var post = cb.post || function() {
};
_traverse(opts, pre, post, schema, "", schema);
};
traverse.keywords = {
additionalItems: true,
items: true,
contains: true,
additionalProperties: true,
propertyNames: true,
not: true,
if: true,
then: true,
else: true
};
traverse.arrayKeywords = {
items: true,
allOf: true,
anyOf: true,
oneOf: true
};
traverse.propsKeywords = {
$defs: true,
definitions: true,
properties: true,
patternProperties: true,
dependencies: true
};
traverse.skipKeywords = {
default: true,
enum: true,
const: true,
required: true,
maximum: true,
minimum: true,
exclusiveMaximum: true,
exclusiveMinimum: true,
multipleOf: true,
maxLength: true,
minLength: true,
pattern: true,
format: true,
maxItems: true,
minItems: true,
uniqueItems: true,
maxProperties: true,
minProperties: true
};
function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
if (schema && typeof schema == "object" && !Array.isArray(schema)) {
pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
for (var key in schema) {
var sch = schema[key];
if (Array.isArray(sch)) {
if (key in traverse.arrayKeywords) {
for (var i = 0; i < sch.length; i++)
_traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
}
} else if (key in traverse.propsKeywords) {
if (sch && typeof sch == "object") {
for (var prop in sch)
_traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
}
} else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
_traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
}
}
post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
}
}
function escapeJsonPtr(str) {
return str.replace(/~/g, "~0").replace(/\//g, "~1");
}
}
});
// packages/core/node_modules/ajv/dist/compile/resolve.js
var require_resolve = __commonJS({
"packages/core/node_modules/ajv/dist/compile/resolve.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
var util_1 = require_util();
var equal = require_fast_deep_equal();
var traverse = require_json_schema_traverse();
var SIMPLE_INLINED = /* @__PURE__ */ new Set([
"type",
"format",
"pattern",
"maxLength",
"minLength",
"maxProperties",
"minProperties",
"maxItems",
"minItems",
"maximum",
"minimum",
"uniqueItems",
"multipleOf",
"required",
"enum",
"const"
]);
function inlineRef(schema, limit = true) {
if (typeof schema == "boolean")
return true;
if (limit === true)
return !hasRef(schema);
if (!limit)
return false;
return countKeys(schema) <= limit;
}
exports.inlineRef = inlineRef;
var REF_KEYWORDS = /* @__PURE__ */ new Set([
"$ref",
"$recursiveRef",
"$recursiveAnchor",
"$dynamicRef",
"$dynamicAnchor"
]);
function hasRef(schema) {
for (const key in schema) {
if (REF_KEYWORDS.has(key))
return true;
const sch = schema[key];
if (Array.isArray(sch) && sch.some(hasRef))
return true;
if (typeof sch == "object" && hasRef(sch))
return true;
}
return false;
}
function countKeys(schema) {
let count = 0;
for (const key in schema) {
if (key === "$ref")
return Infinity;
count++;
if (SIMPLE_INLINED.has(key))
continue;
if (typeof schema[key] == "object") {
(0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
}
if (count === Infinity)
return Infinity;
}
return count;
}
function getFullPath(resolver, id = "", normalize2) {
if (normalize2 !== false)
id = normalizeId(id);
const p = resolver.parse(id);
return _getFullPath(resolver, p);
}
exports.getFullPath = getFullPath;
function _getFullPath(resolver, p) {
const serialized = resolver.serialize(p);
return serialized.split("#")[0] + "#";
}
exports._getFullPath = _getFullPath;
var TRAILING_SLASH_HASH = /#\/?$/;
function normalizeId(id) {
return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
}
exports.normalizeId = normalizeId;
function resolveUrl(resolver, baseId, id) {
id = normalizeId(id);
return resolver.resolve(baseId, id);
}
exports.resolveUrl = resolveUrl;
var ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
function getSchemaRefs(schema, baseId) {
if (typeof schema == "boolean")
return {};
const { schemaId, uriResolver } = this.opts;
const schId = normalizeId(schema[schemaId] || baseId);
const baseIds = { "": schId };
const pathPrefix = getFullPath(uriResolver, schId, false);
const localRefs = {};
const schemaRefs = /* @__PURE__ */ new Set();
traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
if (parentJsonPtr === void 0)
return;
const fullPath = pathPrefix + jsonPtr;
let innerBaseId = baseIds[parentJsonPtr];
if (typeof sch[schemaId] == "string")
innerBaseId = addRef.call(this, sch[schemaId]);
addAnchor.call(this, sch.$anchor);
addAnchor.call(this, sch.$dynamicAnchor);
baseIds[jsonPtr] = innerBaseId;
function addRef(ref) {
const _resolve = this.opts.uriResolver.resolve;
ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
if (schemaRefs.has(ref))
throw ambiguos(ref);
schemaRefs.add(ref);
let schOrRef = this.refs[ref];
if (typeof schOrRef == "string")
schOrRef = this.refs[schOrRef];
if (typeof schOrRef == "object") {
checkAmbiguosRef(sch, schOrRef.schema, ref);
} else if (ref !== normalizeId(fullPath)) {
if (ref[0] === "#") {
checkAmbiguosRef(sch, localRefs[ref], ref);
localRefs[ref] = sch;
} else {
this.refs[ref] = fullPath;
}
}
return ref;
}
function addAnchor(anchor) {
if (typeof anchor == "string") {
if (!ANCHOR.test(anchor))
throw new Error(`invalid anchor "${anchor}"`);
addRef.call(this, `#${anchor}`);
}
}
});
return localRefs;
function checkAmbiguosRef(sch1, sch2, ref) {
if (sch2 !== void 0 && !equal(sch1, sch2))
throw ambiguos(ref);
}
function ambiguos(ref) {
return new Error(`reference "${ref}" resolves to more than one schema`);
}
}
exports.getSchemaRefs = getSchemaRefs;
}
});
// packages/core/node_modules/ajv/dist/compile/validate/index.js
var require_validate = __commonJS({
"packages/core/node_modules/ajv/dist/compile/validate/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
var boolSchema_1 = require_boolSchema();
var dataType_1 = require_dataType();
var applicability_1 = require_applicability();
var dataType_2 = require_dataType();
var defaults_1 = require_defaults();
var keyword_1 = require_keyword();
var subschema_1 = require_subschema();
var codegen_1 = require_codegen();
var names_1 = require_names();
var resolve_1 = require_resolve();
var util_1 = require_util();
var errors_1 = require_errors();
function validateFunctionCode(it) {
if (isSchemaObj(it)) {
checkKeywords(it);
if (schemaCxtHasRules(it)) {
topSchemaObjCode(it);
return;
}
}
validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
}
exports.validateFunctionCode = validateFunctionCode;
function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
if (opts.code.es5) {
gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
destructureValCxtES5(gen, opts);
gen.code(body);
});
} else {
gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
}
}
function destructureValCxt(opts) {
return (0, codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
}
function destructureValCxtES5(gen, opts) {
gen.if(names_1.default.valCxt, () => {
gen.var(names_1.default.instancePath, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`);
gen.var(names_1.default.parentData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`);
gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`);
gen.var(names_1.default.rootData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`);
if (opts.dynamicRef)
gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`);
}, () => {
gen.var(names_1.default.instancePath, (0, codegen_1._)`""`);
gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`);
gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`);
gen.var(names_1.default.rootData, names_1.default.data);
if (opts.dynamicRef)
gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`);
});
}
function topSchemaObjCode(it) {
const { schema, opts, gen } = it;
validateFunction(it, () => {
if (opts.$comment && schema.$comment)
commentKeyword(it);
checkNoDefault(it);
gen.let(names_1.default.vErrors, null);
gen.let(names_1.default.errors, 0);
if (opts.unevaluated)
resetEvaluated(it);
typeAndKeywords(it);
returnResults(it);
});
return;
}
function resetEvaluated(it) {
const { gen, validateName } = it;
it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`);
gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
}
function funcSourceUrl(schema, opts) {
const schId = typeof schema == "object" && schema[opts.schemaId];
return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
}
function subschemaCode(it, valid) {
if (isSchemaObj(it)) {
checkKeywords(it);
if (schemaCxtHasRules(it)) {
subSchemaObjCode(it, valid);
return;
}
}
(0, boolSchema_1.boolOrEmptySchema)(it, valid);
}
function schemaCxtHasRules({ schema, self: self2 }) {
if (typeof schema == "boolean")
return !schema;
for (const key in schema)
if (self2.RULES.all[key])
return true;
return false;
}
function isSchemaObj(it) {
return typeof it.schema != "boolean";
}
function subSchemaObjCode(it, valid) {
const { schema, gen, opts } = it;
if (opts.$comment && schema.$comment)
commentKeyword(it);
updateContext(it);
checkAsyncSchema(it);
const errsCount = gen.const("_errs", names_1.default.errors);
typeAndKeywords(it, errsCount);
gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
}
function checkKeywords(it) {
(0, util_1.checkUnknownRules)(it);
checkRefsAndKeywords(it);
}
function typeAndKeywords(it, errsCount) {
if (it.opts.jtd)
return schemaKeywords(it, [], false, errsCount);
const types = (0, dataType_1.getSchemaTypes)(it.schema);
const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types);
schemaKeywords(it, types, !checkedTypes, errsCount);
}
function checkRefsAndKeywords(it) {
const { schema, errSchemaPath, opts, self: self2 } = it;
if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self2.RULES)) {
self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
}
}
function checkNoDefault(it) {
const { schema, opts } = it;
if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) {
(0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
}
}
function updateContext(it) {
const schId = it.schema[it.opts.schemaId];
if (schId)
it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
}
function checkAsyncSchema(it) {
if (it.schema.$async && !it.schemaEnv.$async)
throw new Error("async schema in sync schema");
}
function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
const msg = schema.$comment;
if (opts.$comment === true) {
gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
} else if (typeof opts.$comment == "function") {
const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`;
const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
gen.code((0, codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
}
}
function returnResults(it) {
const { gen, schemaEnv, validateName, ValidationError, opts } = it;
if (schemaEnv.$async) {
gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
} else {
gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
if (opts.unevaluated)
assignEvaluated(it);
gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
}
}
function assignEvaluated({ gen, evaluated, props, items }) {
if (props instanceof codegen_1.Name)
gen.assign((0, codegen_1._)`${evaluated}.props`, props);
if (items instanceof codegen_1.Name)
gen.assign((0, codegen_1._)`${evaluated}.items`, items);
}
function schemaKeywords(it, types, typeErrors, errsCount) {
const { gen, schema, data, allErrors, opts, self: self2 } = it;
const { RULES } = self2;
if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
return;
}
if (!opts.jtd)
checkStrictTypes(it, types);
gen.block(() => {
for (const group of RULES.rules)
groupKeywords(group);
groupKeywords(RULES.post);
});
function groupKeywords(group) {
if (!(0, applicability_1.shouldUseGroup)(schema, group))
return;
if (group.type) {
gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
iterateKeywords(it, group);
if (types.length === 1 && types[0] === group.type && typeErrors) {
gen.else();
(0, dataType_2.reportTypeError)(it);
}
gen.endIf();
} else {
iterateKeywords(it, group);
}
if (!allErrors)
gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`);
}
}
function iterateKeywords(it, group) {
const { gen, schema, opts: { useDefaults } } = it;
if (useDefaults)
(0, defaults_1.assignDefaults)(it, group.type);
gen.block(() => {
for (const rule of group.rules) {
if ((0, applicability_1.shouldUseRule)(schema, rule)) {
keywordCode(it, rule.keyword, rule.definition, group.type);
}
}
});
}
function checkStrictTypes(it, types) {
if (it.schemaEnv.meta || !it.opts.strictTypes)
return;
checkContextTypes(it, types);
if (!it.opts.allowUnionTypes)
checkMultipleTypes(it, types);
checkKeywordTypes(it, it.dataTypes);
}
function checkContextTypes(it, types) {
if (!types.length)
return;
if (!it.dataTypes.length) {
it.dataTypes = types;
return;
}
types.forEach((t) => {
if (!includesType(it.dataTypes, t)) {
strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
}
});
narrowSchemaTypes(it, types);
}
function checkMultipleTypes(it, ts) {
if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
strictTypesError(it, "use allowUnionTypes to allow union type keyword");
}
}
function checkKeywordTypes(it, ts) {
const rules = it.self.RULES.all;
for (const keyword in rules) {
const rule = rules[keyword];
if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
const { type } = rule.definition;
if (type.length && !type.some((t) => hasApplicableType(ts, t))) {
strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`);
}
}
}
}
function hasApplicableType(schTs, kwdT) {
return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
}
function includesType(ts, t) {
return ts.includes(t) || t === "integer" && ts.includes("number");
}
function narrowSchemaTypes(it, withTypes) {
const ts = [];
for (const t of it.dataTypes) {
if (includesType(withTypes, t))
ts.push(t);
else if (withTypes.includes("integer") && t === "number")
ts.push("integer");
}
it.dataTypes = ts;
}
function strictTypesError(it, msg) {
const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
msg += ` at "${schemaPath}" (strictTypes)`;
(0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);
}
var KeywordCxt = class {
constructor(it, def, keyword) {
(0, keyword_1.validateKeywordUsage)(it, def, keyword);
this.gen = it.gen;
this.allErrors = it.allErrors;
this.keyword = keyword;
this.data = it.data;
this.schema = it.schema[keyword];
this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data;
this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data);
this.schemaType = def.schemaType;
this.parentSchema = it.schema;
this.params = {};
this.it = it;
this.def = def;
if (this.$data) {
this.schemaCode = it.gen.const("vSchema", getData(this.$data, it));
} else {
this.schemaCode = this.schemaValue;
if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) {
throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`);
}
}
if ("code" in def ? def.trackErrors : def.errors !== false) {
this.errsCount = it.gen.const("_errs", names_1.default.errors);
}
}
result(condition, successAction, failAction) {
this.failResult((0, codegen_1.not)(condition), successAction, failAction);
}
failResult(condition, successAction, failAction) {
this.gen.if(condition);
if (failAction)
failAction();
else
this.error();
if (successAction) {
this.gen.else();
successAction();
if (this.allErrors)
this.gen.endIf();
} else {
if (this.allErrors)
this.gen.endIf();
else
this.gen.else();
}
}
pass(condition, failAction) {
this.failResult((0, codegen_1.not)(condition), void 0, failAction);
}
fail(condition) {
if (condition === void 0) {
this.error();
if (!this.allErrors)
this.gen.if(false);
return;
}
this.gen.if(condition);
this.error();
if (this.allErrors)
this.gen.endIf();
else
this.gen.else();
}
fail$data(condition) {
if (!this.$data)
return this.fail(condition);
const { schemaCode } = this;
this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);
}
error(append, errorParams, errorPaths) {
if (errorParams) {
this.setParams(errorParams);
this._error(append, errorPaths);
this.setParams({});
return;
}
this._error(append, errorPaths);
}
_error(append, errorPaths) {
;
(append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
}
$dataError() {
(0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
}
reset() {
if (this.errsCount === void 0)
throw new Error('add "trackErrors" to keyword definition');
(0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
}
ok(cond) {
if (!this.allErrors)
this.gen.if(cond);
}
setParams(obj, assign) {
if (assign)
Object.assign(this.params, obj);
else
this.params = obj;
}
block$data(valid, codeBlock, $dataValid = codegen_1.nil) {
this.gen.block(() => {
this.check$data(valid, $dataValid);
codeBlock();
});
}
check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
if (!this.$data)
return;
const { gen, schemaCode, schemaType, def } = this;
gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid));
if (valid !== codegen_1.nil)
gen.assign(valid, true);
if (schemaType.length || def.validateSchema) {
gen.elseIf(this.invalid$data());
this.$dataError();
if (valid !== codegen_1.nil)
gen.assign(valid, false);
}
gen.else();
}
invalid$data() {
const { gen, schemaCode, schemaType, def, it } = this;
return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
function wrong$DataType() {
if (schemaType.length) {
if (!(schemaCode instanceof codegen_1.Name))
throw new Error("ajv implementation error");
const st = Array.isArray(schemaType) ? schemaType : [schemaType];
return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
}
return codegen_1.nil;
}
function invalid$DataSchema() {
if (def.validateSchema) {
const validateSchemaRef = gen.scopeValue("validate$data", { ref: def.validateSchema });
return (0, codegen_1._)`!${validateSchemaRef}(${schemaCode})`;
}
return codegen_1.nil;
}
}
subschema(appl, valid) {
const subschema = (0, subschema_1.getSubschema)(this.it, appl);
(0, subschema_1.extendSubschemaData)(subschema, this.it, appl);
(0, subschema_1.extendSubschemaMode)(subschema, appl);
const nextContext = { ...this.it, ...subschema, items: void 0, props: void 0 };
subschemaCode(nextContext, valid);
return nextContext;
}
mergeEvaluated(schemaCxt, toName) {
const { it, gen } = this;
if (!it.opts.unevaluated)
return;
if (it.props !== true && schemaCxt.props !== void 0) {
it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
}
if (it.items !== true && schemaCxt.items !== void 0) {
it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
}
}
mergeValidEvaluated(schemaCxt, valid) {
const { it, gen } = this;
if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {
gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name));
return true;
}
}
};
exports.KeywordCxt = KeywordCxt;
function keywordCode(it, keyword, def, ruleType) {
const cxt = new KeywordCxt(it, def, keyword);
if ("code" in def) {
def.code(cxt, ruleType);
} else if (cxt.$data && def.validate) {
(0, keyword_1.funcKeywordCode)(cxt, def);
} else if ("macro" in def) {
(0, keyword_1.macroKeywordCode)(cxt, def);
} else if (def.compile || def.validate) {
(0, keyword_1.funcKeywordCode)(cxt, def);
}
}
var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
function getData($data, { dataLevel, dataNames, dataPathArr }) {
let jsonPointer;
let data;
if ($data === "")
return names_1.default.rootData;
if ($data[0] === "/") {
if (!JSON_POINTER.test($data))
throw new Error(`Invalid JSON-pointer: ${$data}`);
jsonPointer = $data;
data = names_1.default.rootData;
} else {
const matches = RELATIVE_JSON_POINTER.exec($data);
if (!matches)
throw new Error(`Invalid JSON-pointer: ${$data}`);
const up = +matches[1];
jsonPointer = matches[2];
if (jsonPointer === "#") {
if (up >= dataLevel)
throw new Error(errorMsg("property/index", up));
return dataPathArr[dataLevel - up];
}
if (up > dataLevel)
throw new Error(errorMsg("data", up));
data = dataNames[dataLevel - up];
if (!jsonPointer)
return data;
}
let expr = data;
const segments = jsonPointer.split("/");
for (const segment of segments) {
if (segment) {
data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;
expr = (0, codegen_1._)`${expr} && ${data}`;
}
}
return expr;
function errorMsg(pointerType, up) {
return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
}
}
exports.getData = getData;
}
});
// packages/core/node_modules/ajv/dist/runtime/validation_error.js
var require_validation_error = __commonJS({
"packages/core/node_modules/ajv/dist/runtime/validation_error.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ValidationError = class extends Error {
constructor(errors) {
super("validation failed");
this.errors = errors;
this.ajv = this.validation = true;
}
};
exports.default = ValidationError;
}
});
// packages/core/node_modules/ajv/dist/compile/ref_error.js
var require_ref_error = __commonJS({
"packages/core/node_modules/ajv/dist/compile/ref_error.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var resolve_1 = require_resolve();
var MissingRefError = class extends Error {
constructor(resolver, baseId, ref, msg) {
super(msg || `can't resolve reference ${ref} from id ${baseId}`);
this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));
}
};
exports.default = MissingRefError;
}
});
// packages/core/node_modules/ajv/dist/compile/index.js
var require_compile = __commonJS({
"packages/core/node_modules/ajv/dist/compile/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
var codegen_1 = require_codegen();
var validation_error_1 = require_validation_error();
var names_1 = require_names();
var resolve_1 = require_resolve();
var util_1 = require_util();
var validate_1 = require_validate();
var SchemaEnv = class {
constructor(env) {
var _a;
this.refs = {};
this.dynamicAnchors = {};
let schema;
if (typeof env.schema == "object")
schema = env.schema;
this.schema = env.schema;
this.schemaId = env.schemaId;
this.root = env.root || this;
this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
this.schemaPath = env.schemaPath;
this.localRefs = env.localRefs;
this.meta = env.meta;
this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
this.refs = {};
}
};
exports.SchemaEnv = SchemaEnv;
function compileSchema(sch) {
const _sch = getCompilingSchema.call(this, sch);
if (_sch)
return _sch;
const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId);
const { es5, lines } = this.opts.code;
const { ownProperties } = this.opts;
const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
let _ValidationError;
if (sch.$async) {
_ValidationError = gen.scopeValue("Error", {
ref: validation_error_1.default,
code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`
});
}
const validateName = gen.scopeName("validate");
sch.validateName = validateName;
const schemaCxt = {
gen,
allErrors: this.opts.allErrors,
data: names_1.default.data,
parentData: names_1.default.parentData,
parentDataProperty: names_1.default.parentDataProperty,
dataNames: [names_1.default.data],
dataPathArr: [codegen_1.nil],
// TODO can its length be used as dataLevel if nil is removed?
dataLevel: 0,
dataTypes: [],
definedProperties: /* @__PURE__ */ new Set(),
topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) } : { ref: sch.schema }),
validateName,
ValidationError: _ValidationError,
schema: sch.schema,
schemaEnv: sch,
rootId,
baseId: sch.baseId || rootId,
schemaPath: codegen_1.nil,
errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
errorPath: (0, codegen_1._)`""`,
opts: this.opts,
self: this
};
let sourceCode;
try {
this._compilations.add(sch);
(0, validate_1.validateFunctionCode)(schemaCxt);
gen.optimize(this.opts.code.optimize);
const validateCode = gen.toString();
sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
if (this.opts.code.process)
sourceCode = this.opts.code.process(sourceCode, sch);
const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
const validate = makeValidate(this, this.scope.get());
this.scope.value(validateName, { ref: validate });
validate.errors = null;
validate.schema = sch.schema;
validate.schemaEnv = sch;
if (sch.$async)
validate.$async = true;
if (this.opts.code.source === true) {
validate.source = { validateName, validateCode, scopeValues: gen._values };
}
if (this.opts.unevaluated) {
const { props, items } = schemaCxt;
validate.evaluated = {
props: props instanceof codegen_1.Name ? void 0 : props,
items: items instanceof codegen_1.Name ? void 0 : items,
dynamicProps: props instanceof codegen_1.Name,
dynamicItems: items instanceof codegen_1.Name
};
if (validate.source)
validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
}
sch.validate = validate;
return sch;
} catch (e) {
delete sch.validate;
delete sch.validateName;
if (sourceCode)
this.logger.error("Error compiling schema, function code:", sourceCode);
throw e;
} finally {
this._compilations.delete(sch);
}
}
exports.compileSchema = compileSchema;
function resolveRef(root, baseId, ref) {
var _a;
ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
const schOrFunc = root.refs[ref];
if (schOrFunc)
return schOrFunc;
let _sch = resolve5.call(this, root, ref);
if (_sch === void 0) {
const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
const { schemaId } = this.opts;
if (schema)
_sch = new SchemaEnv({ schema, schemaId, root, baseId });
}
if (_sch === void 0)
return;
return root.refs[ref] = inlineOrCompile.call(this, _sch);
}
exports.resolveRef = resolveRef;
function inlineOrCompile(sch) {
if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
return sch.schema;
return sch.validate ? sch : compileSchema.call(this, sch);
}
function getCompilingSchema(schEnv) {
for (const sch of this._compilations) {
if (sameSchemaEnv(sch, schEnv))
return sch;
}
}
exports.getCompilingSchema = getCompilingSchema;
function sameSchemaEnv(s1, s2) {
return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
}
function resolve5(root, ref) {
let sch;
while (typeof (sch = this.refs[ref]) == "string")
ref = sch;
return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
}
function resolveSchema(root, ref) {
const p = this.opts.uriResolver.parse(ref);
const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0);
if (Object.keys(root.schema).length > 0 && refPath === baseId) {
return getJsonPointer.call(this, p, root);
}
const id = (0, resolve_1.normalizeId)(refPath);
const schOrRef = this.refs[id] || this.schemas[id];
if (typeof schOrRef == "string") {
const sch = resolveSchema.call(this, root, schOrRef);
if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
return;
return getJsonPointer.call(this, p, sch);
}
if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object")
return;
if (!schOrRef.validate)
compileSchema.call(this, schOrRef);
if (id === (0, resolve_1.normalizeId)(ref)) {
const { schema } = schOrRef;
const { schemaId } = this.opts;
const schId = schema[schemaId];
if (schId)
baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
return new SchemaEnv({ schema, schemaId, root, baseId });
}
return getJsonPointer.call(this, p, schOrRef);
}
exports.resolveSchema = resolveSchema;
var PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([
"properties",
"patternProperties",
"enum",
"dependencies",
"definitions"
]);
function getJsonPointer(parsedRef, { baseId, schema, root }) {
var _a;
if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/")
return;
for (const part of parsedRef.fragment.slice(1).split("/")) {
if (typeof schema === "boolean")
return;
const partSchema = schema[(0, util_1.unescapeFragment)(part)];
if (partSchema === void 0)
return;
schema = partSchema;
const schId = typeof schema === "object" && schema[this.opts.schemaId];
if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
}
}
let env;
if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
env = resolveSchema.call(this, root, $ref);
}
const { schemaId } = this.opts;
env = env || new SchemaEnv({ schema, schemaId, root, baseId });
if (env.schema !== env.root.schema)
return env;
return void 0;
}
}
});
// packages/core/node_modules/ajv/dist/refs/data.json
var require_data = __commonJS({
"packages/core/node_modules/ajv/dist/refs/data.json"(exports, module) {
module.exports = {
$id: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
description: "Meta-schema for $data reference (JSON AnySchema extension proposal)",
type: "object",
required: ["$data"],
properties: {
$data: {
type: "string",
anyOf: [{ format: "relative-json-pointer" }, { format: "json-pointer" }]
}
},
additionalProperties: false
};
}
});
// node_modules/fast-uri/lib/scopedChars.js
var require_scopedChars = __commonJS({
"node_modules/fast-uri/lib/scopedChars.js"(exports, module) {
"use strict";
var HEX = {
0: 0,
1: 1,
2: 2,
3: 3,
4: 4,
5: 5,
6: 6,
7: 7,
8: 8,
9: 9,
a: 10,
A: 10,
b: 11,
B: 11,
c: 12,
C: 12,
d: 13,
D: 13,
e: 14,
E: 14,
f: 15,
F: 15
};
module.exports = {
HEX
};
}
});
// node_modules/fast-uri/lib/utils.js
var require_utils = __commonJS({
"node_modules/fast-uri/lib/utils.js"(exports, module) {
"use strict";
var { HEX } = require_scopedChars();
var IPV4_REG = /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u;
function normalizeIPv4(host) {
if (findToken(host, ".") < 3) {
return { host, isIPV4: false };
}
const matches = host.match(IPV4_REG) || [];
const [address] = matches;
if (address) {
return { host: stripLeadingZeros(address, "."), isIPV4: true };
} else {
return { host, isIPV4: false };
}
}
function stringArrayToHexStripped(input, keepZero = false) {
let acc = "";
let strip = true;
for (const c of input) {
if (HEX[c] === void 0) return void 0;
if (c !== "0" && strip === true) strip = false;
if (!strip) acc += c;
}
if (keepZero && acc.length === 0) acc = "0";
return acc;
}
function getIPV6(input) {
let tokenCount = 0;
const output = { error: false, address: "", zone: "" };
const address = [];
const buffer = [];
let isZone = false;
let endipv6Encountered = false;
let endIpv6 = false;
function consume() {
if (buffer.length) {
if (isZone === false) {
const hex = stringArrayToHexStripped(buffer);
if (hex !== void 0) {
address.push(hex);
} else {
output.error = true;
return false;
}
}
buffer.length = 0;
}
return true;
}
for (let i = 0; i < input.length; i++) {
const cursor = input[i];
if (cursor === "[" || cursor === "]") {
continue;
}
if (cursor === ":") {
if (endipv6Encountered === true) {
endIpv6 = true;
}
if (!consume()) {
break;
}
tokenCount++;
address.push(":");
if (tokenCount > 7) {
output.error = true;
break;
}
if (i - 1 >= 0 && input[i - 1] === ":") {
endipv6Encountered = true;
}
continue;
} else if (cursor === "%") {
if (!consume()) {
break;
}
isZone = true;
} else {
buffer.push(cursor);
continue;
}
}
if (buffer.length) {
if (isZone) {
output.zone = buffer.join("");
} else if (endIpv6) {
address.push(buffer.join(""));
} else {
address.push(stringArrayToHexStripped(buffer));
}
}
output.address = address.join("");
return output;
}
function normalizeIPv6(host) {
if (findToken(host, ":") < 2) {
return { host, isIPV6: false };
}
const ipv6 = getIPV6(host);
if (!ipv6.error) {
let newHost = ipv6.address;
let escapedHost = ipv6.address;
if (ipv6.zone) {
newHost += "%" + ipv6.zone;
escapedHost += "%25" + ipv6.zone;
}
return { host: newHost, escapedHost, isIPV6: true };
} else {
return { host, isIPV6: false };
}
}
function stripLeadingZeros(str, token) {
let out = "";
let skip = true;
const l = str.length;
for (let i = 0; i < l; i++) {
const c = str[i];
if (c === "0" && skip) {
if (i + 1 <= l && str[i + 1] === token || i + 1 === l) {
out += c;
skip = false;
}
} else {
if (c === token) {
skip = true;
} else {
skip = false;
}
out += c;
}
}
return out;
}
function findToken(str, token) {
let ind = 0;
for (let i = 0; i < str.length; i++) {
if (str[i] === token) ind++;
}
return ind;
}
var RDS1 = /^\.\.?\//u;
var RDS2 = /^\/\.(?:\/|$)/u;
var RDS3 = /^\/\.\.(?:\/|$)/u;
var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/u;
function removeDotSegments(input) {
const output = [];
while (input.length) {
if (input.match(RDS1)) {
input = input.replace(RDS1, "");
} else if (input.match(RDS2)) {
input = input.replace(RDS2, "/");
} else if (input.match(RDS3)) {
input = input.replace(RDS3, "/");
output.pop();
} else if (input === "." || input === "..") {
input = "";
} else {
const im = input.match(RDS5);
if (im) {
const s = im[0];
input = input.slice(s.length);
output.push(s);
} else {
throw new Error("Unexpected dot segment condition");
}
}
}
return output.join("");
}
function normalizeComponentEncoding(components, esc) {
const func = esc !== true ? escape : unescape;
if (components.scheme !== void 0) {
components.scheme = func(components.scheme);
}
if (components.userinfo !== void 0) {
components.userinfo = func(components.userinfo);
}
if (components.host !== void 0) {
components.host = func(components.host);
}
if (components.path !== void 0) {
components.path = func(components.path);
}
if (components.query !== void 0) {
components.query = func(components.query);
}
if (components.fragment !== void 0) {
components.fragment = func(components.fragment);
}
return components;
}
function recomposeAuthority(components) {
const uriTokens = [];
if (components.userinfo !== void 0) {
uriTokens.push(components.userinfo);
uriTokens.push("@");
}
if (components.host !== void 0) {
let host = unescape(components.host);
const ipV4res = normalizeIPv4(host);
if (ipV4res.isIPV4) {
host = ipV4res.host;
} else {
const ipV6res = normalizeIPv6(ipV4res.host);
if (ipV6res.isIPV6 === true) {
host = `[${ipV6res.escapedHost}]`;
} else {
host = components.host;
}
}
uriTokens.push(host);
}
if (typeof components.port === "number" || typeof components.port === "string") {
uriTokens.push(":");
uriTokens.push(String(components.port));
}
return uriTokens.length ? uriTokens.join("") : void 0;
}
module.exports = {
recomposeAuthority,
normalizeComponentEncoding,
removeDotSegments,
normalizeIPv4,
normalizeIPv6,
stringArrayToHexStripped
};
}
});
// node_modules/fast-uri/lib/schemes.js
var require_schemes = __commonJS({
"node_modules/fast-uri/lib/schemes.js"(exports, module) {
"use strict";
var UUID_REG = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu;
var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
function isSecure(wsComponents) {
return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
}
function httpParse(components) {
if (!components.host) {
components.error = components.error || "HTTP URIs must have a host.";
}
return components;
}
function httpSerialize(components) {
const secure = String(components.scheme).toLowerCase() === "https";
if (components.port === (secure ? 443 : 80) || components.port === "") {
components.port = void 0;
}
if (!components.path) {
components.path = "/";
}
return components;
}
function wsParse(wsComponents) {
wsComponents.secure = isSecure(wsComponents);
wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : "");
wsComponents.path = void 0;
wsComponents.query = void 0;
return wsComponents;
}
function wsSerialize(wsComponents) {
if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
wsComponents.port = void 0;
}
if (typeof wsComponents.secure === "boolean") {
wsComponents.scheme = wsComponents.secure ? "wss" : "ws";
wsComponents.secure = void 0;
}
if (wsComponents.resourceName) {
const [path10, query] = wsComponents.resourceName.split("?");
wsComponents.path = path10 && path10 !== "/" ? path10 : void 0;
wsComponents.query = query;
wsComponents.resourceName = void 0;
}
wsComponents.fragment = void 0;
return wsComponents;
}
function urnParse(urnComponents, options) {
if (!urnComponents.path) {
urnComponents.error = "URN can not be parsed";
return urnComponents;
}
const matches = urnComponents.path.match(URN_REG);
if (matches) {
const scheme = options.scheme || urnComponents.scheme || "urn";
urnComponents.nid = matches[1].toLowerCase();
urnComponents.nss = matches[2];
const urnScheme = `${scheme}:${options.nid || urnComponents.nid}`;
const schemeHandler = SCHEMES[urnScheme];
urnComponents.path = void 0;
if (schemeHandler) {
urnComponents = schemeHandler.parse(urnComponents, options);
}
} else {
urnComponents.error = urnComponents.error || "URN can not be parsed.";
}
return urnComponents;
}
function urnSerialize(urnComponents, options) {
const scheme = options.scheme || urnComponents.scheme || "urn";
const nid = urnComponents.nid.toLowerCase();
const urnScheme = `${scheme}:${options.nid || nid}`;
const schemeHandler = SCHEMES[urnScheme];
if (schemeHandler) {
urnComponents = schemeHandler.serialize(urnComponents, options);
}
const uriComponents = urnComponents;
const nss = urnComponents.nss;
uriComponents.path = `${nid || options.nid}:${nss}`;
options.skipEscape = true;
return uriComponents;
}
function urnuuidParse(urnComponents, options) {
const uuidComponents = urnComponents;
uuidComponents.uuid = uuidComponents.nss;
uuidComponents.nss = void 0;
if (!options.tolerant && (!uuidComponents.uuid || !UUID_REG.test(uuidComponents.uuid))) {
uuidComponents.error = uuidComponents.error || "UUID is not valid.";
}
return uuidComponents;
}
function urnuuidSerialize(uuidComponents) {
const urnComponents = uuidComponents;
urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
return urnComponents;
}
var http = {
scheme: "http",
domainHost: true,
parse: httpParse,
serialize: httpSerialize
};
var https = {
scheme: "https",
domainHost: http.domainHost,
parse: httpParse,
serialize: httpSerialize
};
var ws = {
scheme: "ws",
domainHost: true,
parse: wsParse,
serialize: wsSerialize
};
var wss = {
scheme: "wss",
domainHost: ws.domainHost,
parse: ws.parse,
serialize: ws.serialize
};
var urn = {
scheme: "urn",
parse: urnParse,
serialize: urnSerialize,
skipNormalize: true
};
var urnuuid = {
scheme: "urn:uuid",
parse: urnuuidParse,
serialize: urnuuidSerialize,
skipNormalize: true
};
var SCHEMES = {
http,
https,
ws,
wss,
urn,
"urn:uuid": urnuuid
};
module.exports = SCHEMES;
}
});
// node_modules/fast-uri/index.js
var require_fast_uri = __commonJS({
"node_modules/fast-uri/index.js"(exports, module) {
"use strict";
var { normalizeIPv6, normalizeIPv4, removeDotSegments, recomposeAuthority, normalizeComponentEncoding } = require_utils();
var SCHEMES = require_schemes();
function normalize2(uri, options) {
if (typeof uri === "string") {
uri = serialize(parse(uri, options), options);
} else if (typeof uri === "object") {
uri = parse(serialize(uri, options), options);
}
return uri;
}
function resolve5(baseURI, relativeURI, options) {
const schemelessOptions = Object.assign({ scheme: "null" }, options);
const resolved = resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
return serialize(resolved, { ...schemelessOptions, skipEscape: true });
}
function resolveComponents(base, relative, options, skipNormalization) {
const target = {};
if (!skipNormalization) {
base = parse(serialize(base, options), options);
relative = parse(serialize(relative, options), options);
}
options = options || {};
if (!options.tolerant && relative.scheme) {
target.scheme = relative.scheme;
target.userinfo = relative.userinfo;
target.host = relative.host;
target.port = relative.port;
target.path = removeDotSegments(relative.path || "");
target.query = relative.query;
} else {
if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
target.userinfo = relative.userinfo;
target.host = relative.host;
target.port = relative.port;
target.path = removeDotSegments(relative.path || "");
target.query = relative.query;
} else {
if (!relative.path) {
target.path = base.path;
if (relative.query !== void 0) {
target.query = relative.query;
} else {
target.query = base.query;
}
} else {
if (relative.path.charAt(0) === "/") {
target.path = removeDotSegments(relative.path);
} else {
if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
target.path = "/" + relative.path;
} else if (!base.path) {
target.path = relative.path;
} else {
target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
}
target.path = removeDotSegments(target.path);
}
target.query = relative.query;
}
target.userinfo = base.userinfo;
target.host = base.host;
target.port = base.port;
}
target.scheme = base.scheme;
}
target.fragment = relative.fragment;
return target;
}
function equal(uriA, uriB, options) {
if (typeof uriA === "string") {
uriA = unescape(uriA);
uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), { ...options, skipEscape: true });
} else if (typeof uriA === "object") {
uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
}
if (typeof uriB === "string") {
uriB = unescape(uriB);
uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), { ...options, skipEscape: true });
} else if (typeof uriB === "object") {
uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
}
return uriA.toLowerCase() === uriB.toLowerCase();
}
function serialize(cmpts, opts) {
const components = {
host: cmpts.host,
scheme: cmpts.scheme,
userinfo: cmpts.userinfo,
port: cmpts.port,
path: cmpts.path,
query: cmpts.query,
nid: cmpts.nid,
nss: cmpts.nss,
uuid: cmpts.uuid,
fragment: cmpts.fragment,
reference: cmpts.reference,
resourceName: cmpts.resourceName,
secure: cmpts.secure,
error: ""
};
const options = Object.assign({}, opts);
const uriTokens = [];
const schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);
if (components.path !== void 0) {
if (!options.skipEscape) {
components.path = escape(components.path);
if (components.scheme !== void 0) {
components.path = components.path.split("%3A").join(":");
}
} else {
components.path = unescape(components.path);
}
}
if (options.reference !== "suffix" && components.scheme) {
uriTokens.push(components.scheme, ":");
}
const authority = recomposeAuthority(components);
if (authority !== void 0) {
if (options.reference !== "suffix") {
uriTokens.push("//");
}
uriTokens.push(authority);
if (components.path && components.path.charAt(0) !== "/") {
uriTokens.push("/");
}
}
if (components.path !== void 0) {
let s = components.path;
if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
s = removeDotSegments(s);
}
if (authority === void 0) {
s = s.replace(/^\/\//u, "/%2F");
}
uriTokens.push(s);
}
if (components.query !== void 0) {
uriTokens.push("?", components.query);
}
if (components.fragment !== void 0) {
uriTokens.push("#", components.fragment);
}
return uriTokens.join("");
}
var hexLookUp = Array.from({ length: 127 }, (_v, k) => /[^!"$&'()*+,\-.;=_`a-z{}~]/u.test(String.fromCharCode(k)));
function nonSimpleDomain(value) {
let code = 0;
for (let i = 0, len = value.length; i < len; ++i) {
code = value.charCodeAt(i);
if (code > 126 || hexLookUp[code]) {
return true;
}
}
return false;
}
var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
function parse(uri, opts) {
const options = Object.assign({}, opts);
const parsed = {
scheme: void 0,
userinfo: void 0,
host: "",
port: void 0,
path: "",
query: void 0,
fragment: void 0
};
const gotEncoding = uri.indexOf("%") !== -1;
let isIP = false;
if (options.reference === "suffix") uri = (options.scheme ? options.scheme + ":" : "") + "//" + uri;
const matches = uri.match(URI_PARSE);
if (matches) {
parsed.scheme = matches[1];
parsed.userinfo = matches[3];
parsed.host = matches[4];
parsed.port = parseInt(matches[5], 10);
parsed.path = matches[6] || "";
parsed.query = matches[7];
parsed.fragment = matches[8];
if (isNaN(parsed.port)) {
parsed.port = matches[5];
}
if (parsed.host) {
const ipv4result = normalizeIPv4(parsed.host);
if (ipv4result.isIPV4 === false) {
const ipv6result = normalizeIPv6(ipv4result.host);
parsed.host = ipv6result.host.toLowerCase();
isIP = ipv6result.isIPV6;
} else {
parsed.host = ipv4result.host;
isIP = true;
}
}
if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) {
parsed.reference = "same-document";
} else if (parsed.scheme === void 0) {
parsed.reference = "relative";
} else if (parsed.fragment === void 0) {
parsed.reference = "absolute";
} else {
parsed.reference = "uri";
}
if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) {
parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
}
const schemeHandler = SCHEMES[(options.scheme || parsed.scheme || "").toLowerCase()];
if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
try {
parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
} catch (e) {
parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
}
}
}
if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
if (gotEncoding && parsed.scheme !== void 0) {
parsed.scheme = unescape(parsed.scheme);
}
if (gotEncoding && parsed.host !== void 0) {
parsed.host = unescape(parsed.host);
}
if (parsed.path) {
parsed.path = escape(unescape(parsed.path));
}
if (parsed.fragment) {
parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
}
}
if (schemeHandler && schemeHandler.parse) {
schemeHandler.parse(parsed, options);
}
} else {
parsed.error = parsed.error || "URI can not be parsed.";
}
return parsed;
}
var fastUri = {
SCHEMES,
normalize: normalize2,
resolve: resolve5,
resolveComponents,
equal,
serialize,
parse
};
module.exports = fastUri;
module.exports.default = fastUri;
module.exports.fastUri = fastUri;
}
});
// packages/core/node_modules/ajv/dist/runtime/uri.js
var require_uri = __commonJS({
"packages/core/node_modules/ajv/dist/runtime/uri.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var uri = require_fast_uri();
uri.code = 'require("ajv/dist/runtime/uri").default';
exports.default = uri;
}
});
// packages/core/node_modules/ajv/dist/core.js
var require_core = __commonJS({
"packages/core/node_modules/ajv/dist/core.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
var validate_1 = require_validate();
Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
return validate_1.KeywordCxt;
} });
var codegen_1 = require_codegen();
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
return codegen_1._;
} });
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
return codegen_1.str;
} });
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
return codegen_1.stringify;
} });
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
return codegen_1.nil;
} });
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
return codegen_1.Name;
} });
Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
return codegen_1.CodeGen;
} });
var validation_error_1 = require_validation_error();
var ref_error_1 = require_ref_error();
var rules_1 = require_rules();
var compile_1 = require_compile();
var codegen_2 = require_codegen();
var resolve_1 = require_resolve();
var dataType_1 = require_dataType();
var util_1 = require_util();
var $dataRefSchema = require_data();
var uri_1 = require_uri();
var defaultRegExp = (str, flags) => new RegExp(str, flags);
defaultRegExp.code = "new RegExp";
var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
"validate",
"serialize",
"parse",
"wrapper",
"root",
"schema",
"keyword",
"pattern",
"formats",
"validate$data",
"func",
"obj",
"Error"
]);
var removedOptions = {
errorDataPath: "",
format: "`validateFormats: false` can be used instead.",
nullable: '"nullable" keyword is supported by default.',
jsonPointers: "Deprecated jsPropertySyntax can be used instead.",
extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",
missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",
processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",
sourceCode: "Use option `code: {source: true}`",
strictDefaults: "It is default now, see option `strict`.",
strictKeywords: "It is default now, see option `strict`.",
uniqueItems: '"uniqueItems" keyword is always validated.',
unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",
cache: "Map is used as cache, schema object as key.",
serialize: "Map is used as cache, schema object as key.",
ajvErrors: "It is default now."
};
var deprecatedOptions = {
ignoreKeywordsWithRef: "",
jsPropertySyntax: "",
unicode: '"minLength"/"maxLength" account for unicode characters by default.'
};
var MAX_EXPRESSION = 200;
function requiredOptions(o) {
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
const s = o.strict;
const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;
const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0;
const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;
const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
return {
strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,
strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,
strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log",
strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log",
strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,
code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },
loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
uriResolver
};
}
var Ajv = class {
constructor(opts = {}) {
this.schemas = {};
this.refs = {};
this.formats = {};
this._compilations = /* @__PURE__ */ new Set();
this._loading = {};
this._cache = /* @__PURE__ */ new Map();
opts = this.opts = { ...opts, ...requiredOptions(opts) };
const { es5, lines } = this.opts.code;
this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines });
this.logger = getLogger(opts.logger);
const formatOpt = opts.validateFormats;
opts.validateFormats = false;
this.RULES = (0, rules_1.getRules)();
checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
this._metaOpts = getMetaSchemaOptions.call(this);
if (opts.formats)
addInitialFormats.call(this);
this._addVocabularies();
this._addDefaultMetaSchema();
if (opts.keywords)
addInitialKeywords.call(this, opts.keywords);
if (typeof opts.meta == "object")
this.addMetaSchema(opts.meta);
addInitialSchemas.call(this);
opts.validateFormats = formatOpt;
}
_addVocabularies() {
this.addKeyword("$async");
}
_addDefaultMetaSchema() {
const { $data, meta, schemaId } = this.opts;
let _dataRefSchema = $dataRefSchema;
if (schemaId === "id") {
_dataRefSchema = { ...$dataRefSchema };
_dataRefSchema.id = _dataRefSchema.$id;
delete _dataRefSchema.$id;
}
if (meta && $data)
this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
}
defaultMeta() {
const { meta, schemaId } = this.opts;
return this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : void 0;
}
validate(schemaKeyRef, data) {
let v;
if (typeof schemaKeyRef == "string") {
v = this.getSchema(schemaKeyRef);
if (!v)
throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
} else {
v = this.compile(schemaKeyRef);
}
const valid = v(data);
if (!("$async" in v))
this.errors = v.errors;
return valid;
}
compile(schema, _meta) {
const sch = this._addSchema(schema, _meta);
return sch.validate || this._compileSchemaEnv(sch);
}
compileAsync(schema, meta) {
if (typeof this.opts.loadSchema != "function") {
throw new Error("options.loadSchema should be a function");
}
const { loadSchema } = this.opts;
return runCompileAsync.call(this, schema, meta);
async function runCompileAsync(_schema, _meta) {
await loadMetaSchema.call(this, _schema.$schema);
const sch = this._addSchema(_schema, _meta);
return sch.validate || _compileAsync.call(this, sch);
}
async function loadMetaSchema($ref) {
if ($ref && !this.getSchema($ref)) {
await runCompileAsync.call(this, { $ref }, true);
}
}
async function _compileAsync(sch) {
try {
return this._compileSchemaEnv(sch);
} catch (e) {
if (!(e instanceof ref_error_1.default))
throw e;
checkLoaded.call(this, e);
await loadMissingSchema.call(this, e.missingSchema);
return _compileAsync.call(this, sch);
}
}
function checkLoaded({ missingSchema: ref, missingRef }) {
if (this.refs[ref]) {
throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);
}
}
async function loadMissingSchema(ref) {
const _schema = await _loadSchema.call(this, ref);
if (!this.refs[ref])
await loadMetaSchema.call(this, _schema.$schema);
if (!this.refs[ref])
this.addSchema(_schema, ref, meta);
}
async function _loadSchema(ref) {
const p = this._loading[ref];
if (p)
return p;
try {
return await (this._loading[ref] = loadSchema(ref));
} finally {
delete this._loading[ref];
}
}
}
// Adds schema to the instance
addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
if (Array.isArray(schema)) {
for (const sch of schema)
this.addSchema(sch, void 0, _meta, _validateSchema);
return this;
}
let id;
if (typeof schema === "object") {
const { schemaId } = this.opts;
id = schema[schemaId];
if (id !== void 0 && typeof id != "string") {
throw new Error(`schema ${schemaId} must be string`);
}
}
key = (0, resolve_1.normalizeId)(key || id);
this._checkUnique(key);
this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
return this;
}
// Add schema that will be used to validate other schemas
// options in META_IGNORE_OPTIONS are alway set to false
addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
this.addSchema(schema, key, true, _validateSchema);
return this;
}
// Validate schema against its meta-schema
validateSchema(schema, throwOrLogError) {
if (typeof schema == "boolean")
return true;
let $schema;
$schema = schema.$schema;
if ($schema !== void 0 && typeof $schema != "string") {
throw new Error("$schema must be a string");
}
$schema = $schema || this.opts.defaultMeta || this.defaultMeta();
if (!$schema) {
this.logger.warn("meta-schema not available");
this.errors = null;
return true;
}
const valid = this.validate($schema, schema);
if (!valid && throwOrLogError) {
const message = "schema is invalid: " + this.errorsText();
if (this.opts.validateSchema === "log")
this.logger.error(message);
else
throw new Error(message);
}
return valid;
}
// Get compiled schema by `key` or `ref`.
// (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)
getSchema(keyRef) {
let sch;
while (typeof (sch = getSchEnv.call(this, keyRef)) == "string")
keyRef = sch;
if (sch === void 0) {
const { schemaId } = this.opts;
const root = new compile_1.SchemaEnv({ schema: {}, schemaId });
sch = compile_1.resolveSchema.call(this, root, keyRef);
if (!sch)
return;
this.refs[keyRef] = sch;
}
return sch.validate || this._compileSchemaEnv(sch);
}
// Remove cached schema(s).
// If no parameter is passed all schemas but meta-schemas are removed.
// If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.
// Even if schema is referenced by other schemas it still can be removed as other schemas have local references.
removeSchema(schemaKeyRef) {
if (schemaKeyRef instanceof RegExp) {
this._removeAllSchemas(this.schemas, schemaKeyRef);
this._removeAllSchemas(this.refs, schemaKeyRef);
return this;
}
switch (typeof schemaKeyRef) {
case "undefined":
this._removeAllSchemas(this.schemas);
this._removeAllSchemas(this.refs);
this._cache.clear();
return this;
case "string": {
const sch = getSchEnv.call(this, schemaKeyRef);
if (typeof sch == "object")
this._cache.delete(sch.schema);
delete this.schemas[schemaKeyRef];
delete this.refs[schemaKeyRef];
return this;
}
case "object": {
const cacheKey = schemaKeyRef;
this._cache.delete(cacheKey);
let id = schemaKeyRef[this.opts.schemaId];
if (id) {
id = (0, resolve_1.normalizeId)(id);
delete this.schemas[id];
delete this.refs[id];
}
return this;
}
default:
throw new Error("ajv.removeSchema: invalid parameter");
}
}
// add "vocabulary" - a collection of keywords
addVocabulary(definitions) {
for (const def of definitions)
this.addKeyword(def);
return this;
}
addKeyword(kwdOrDef, def) {
let keyword;
if (typeof kwdOrDef == "string") {
keyword = kwdOrDef;
if (typeof def == "object") {
this.logger.warn("these parameters are deprecated, see docs for addKeyword");
def.keyword = keyword;
}
} else if (typeof kwdOrDef == "object" && def === void 0) {
def = kwdOrDef;
keyword = def.keyword;
if (Array.isArray(keyword) && !keyword.length) {
throw new Error("addKeywords: keyword must be string or non-empty array");
}
} else {
throw new Error("invalid addKeywords parameters");
}
checkKeyword.call(this, keyword, def);
if (!def) {
(0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
return this;
}
keywordMetaschema.call(this, def);
const definition = {
...def,
type: (0, dataType_1.getJSONTypes)(def.type),
schemaType: (0, dataType_1.getJSONTypes)(def.schemaType)
};
(0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
return this;
}
getKeyword(keyword) {
const rule = this.RULES.all[keyword];
return typeof rule == "object" ? rule.definition : !!rule;
}
// Remove keyword
removeKeyword(keyword) {
const { RULES } = this;
delete RULES.keywords[keyword];
delete RULES.all[keyword];
for (const group of RULES.rules) {
const i = group.rules.findIndex((rule) => rule.keyword === keyword);
if (i >= 0)
group.rules.splice(i, 1);
}
return this;
}
// Add format
addFormat(name, format2) {
if (typeof format2 == "string")
format2 = new RegExp(format2);
this.formats[name] = format2;
return this;
}
errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
if (!errors || errors.length === 0)
return "No errors";
return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
}
$dataMetaSchema(metaSchema, keywordsJsonPointers) {
const rules = this.RULES.all;
metaSchema = JSON.parse(JSON.stringify(metaSchema));
for (const jsonPointer of keywordsJsonPointers) {
const segments = jsonPointer.split("/").slice(1);
let keywords = metaSchema;
for (const seg of segments)
keywords = keywords[seg];
for (const key in rules) {
const rule = rules[key];
if (typeof rule != "object")
continue;
const { $data } = rule.definition;
const schema = keywords[key];
if ($data && schema)
keywords[key] = schemaOrData(schema);
}
}
return metaSchema;
}
_removeAllSchemas(schemas, regex) {
for (const keyRef in schemas) {
const sch = schemas[keyRef];
if (!regex || regex.test(keyRef)) {
if (typeof sch == "string") {
delete schemas[keyRef];
} else if (sch && !sch.meta) {
this._cache.delete(sch.schema);
delete schemas[keyRef];
}
}
}
}
_addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
let id;
const { schemaId } = this.opts;
if (typeof schema == "object") {
id = schema[schemaId];
} else {
if (this.opts.jtd)
throw new Error("schema must be object");
else if (typeof schema != "boolean")
throw new Error("schema must be object or boolean");
}
let sch = this._cache.get(schema);
if (sch !== void 0)
return sch;
baseId = (0, resolve_1.normalizeId)(id || baseId);
const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });
this._cache.set(sch.schema, sch);
if (addSchema && !baseId.startsWith("#")) {
if (baseId)
this._checkUnique(baseId);
this.refs[baseId] = sch;
}
if (validateSchema)
this.validateSchema(schema, true);
return sch;
}
_checkUnique(id) {
if (this.schemas[id] || this.refs[id]) {
throw new Error(`schema with key or id "${id}" already exists`);
}
}
_compileSchemaEnv(sch) {
if (sch.meta)
this._compileMetaSchema(sch);
else
compile_1.compileSchema.call(this, sch);
if (!sch.validate)
throw new Error("ajv implementation error");
return sch.validate;
}
_compileMetaSchema(sch) {
const currentOpts = this.opts;
this.opts = this._metaOpts;
try {
compile_1.compileSchema.call(this, sch);
} finally {
this.opts = currentOpts;
}
}
};
Ajv.ValidationError = validation_error_1.default;
Ajv.MissingRefError = ref_error_1.default;
exports.default = Ajv;
function checkOptions(checkOpts, options, msg, log = "error") {
for (const key in checkOpts) {
const opt = key;
if (opt in options)
this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
}
}
function getSchEnv(keyRef) {
keyRef = (0, resolve_1.normalizeId)(keyRef);
return this.schemas[keyRef] || this.refs[keyRef];
}
function addInitialSchemas() {
const optsSchemas = this.opts.schemas;
if (!optsSchemas)
return;
if (Array.isArray(optsSchemas))
this.addSchema(optsSchemas);
else
for (const key in optsSchemas)
this.addSchema(optsSchemas[key], key);
}
function addInitialFormats() {
for (const name in this.opts.formats) {
const format2 = this.opts.formats[name];
if (format2)
this.addFormat(name, format2);
}
}
function addInitialKeywords(defs) {
if (Array.isArray(defs)) {
this.addVocabulary(defs);
return;
}
this.logger.warn("keywords option as map is deprecated, pass array");
for (const keyword in defs) {
const def = defs[keyword];
if (!def.keyword)
def.keyword = keyword;
this.addKeyword(def);
}
}
function getMetaSchemaOptions() {
const metaOpts = { ...this.opts };
for (const opt of META_IGNORE_OPTIONS)
delete metaOpts[opt];
return metaOpts;
}
var noLogs = { log() {
}, warn() {
}, error() {
} };
function getLogger(logger4) {
if (logger4 === false)
return noLogs;
if (logger4 === void 0)
return console;
if (logger4.log && logger4.warn && logger4.error)
return logger4;
throw new Error("logger must implement log, warn and error methods");
}
var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
function checkKeyword(keyword, def) {
const { RULES } = this;
(0, util_1.eachItem)(keyword, (kwd) => {
if (RULES.keywords[kwd])
throw new Error(`Keyword ${kwd} is already defined`);
if (!KEYWORD_NAME.test(kwd))
throw new Error(`Keyword ${kwd} has invalid name`);
});
if (!def)
return;
if (def.$data && !("code" in def || "validate" in def)) {
throw new Error('$data keyword must have "code" or "validate" function');
}
}
function addRule(keyword, definition, dataType) {
var _a;
const post = definition === null || definition === void 0 ? void 0 : definition.post;
if (dataType && post)
throw new Error('keyword with "post" flag cannot have "type"');
const { RULES } = this;
let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
if (!ruleGroup) {
ruleGroup = { type: dataType, rules: [] };
RULES.rules.push(ruleGroup);
}
RULES.keywords[keyword] = true;
if (!definition)
return;
const rule = {
keyword,
definition: {
...definition,
type: (0, dataType_1.getJSONTypes)(definition.type),
schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType)
}
};
if (definition.before)
addBeforeRule.call(this, ruleGroup, rule, definition.before);
else
ruleGroup.rules.push(rule);
RULES.all[keyword] = rule;
(_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd));
}
function addBeforeRule(ruleGroup, rule, before) {
const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
if (i >= 0) {
ruleGroup.rules.splice(i, 0, rule);
} else {
ruleGroup.rules.push(rule);
this.logger.warn(`rule ${before} is not defined`);
}
}
function keywordMetaschema(def) {
let { metaSchema } = def;
if (metaSchema === void 0)
return;
if (def.$data && this.opts.$data)
metaSchema = schemaOrData(metaSchema);
def.validateSchema = this.compile(metaSchema, true);
}
var $dataRef = {
$ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
};
function schemaOrData(schema) {
return { anyOf: [schema, $dataRef] };
}
}
});
// packages/core/node_modules/ajv/dist/vocabularies/core/id.js
var require_id = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/core/id.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var def = {
keyword: "id",
code() {
throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/core/ref.js
var require_ref = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/core/ref.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.callRef = exports.getValidate = void 0;
var ref_error_1 = require_ref_error();
var code_1 = require_code2();
var codegen_1 = require_codegen();
var names_1 = require_names();
var compile_1 = require_compile();
var util_1 = require_util();
var def = {
keyword: "$ref",
schemaType: "string",
code(cxt) {
const { gen, schema: $ref, it } = cxt;
const { baseId, schemaEnv: env, validateName, opts, self: self2 } = it;
const { root } = env;
if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
return callRootRef();
const schOrEnv = compile_1.resolveRef.call(self2, root, baseId, $ref);
if (schOrEnv === void 0)
throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
if (schOrEnv instanceof compile_1.SchemaEnv)
return callValidate(schOrEnv);
return inlineRefSchema(schOrEnv);
function callRootRef() {
if (env === root)
return callRef(cxt, validateName, env, env.$async);
const rootName = gen.scopeValue("root", { ref: root });
return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
}
function callValidate(sch) {
const v = getValidate(cxt, sch);
callRef(cxt, v, sch, sch.$async);
}
function inlineRefSchema(sch) {
const schName = gen.scopeValue("schema", opts.code.source === true ? { ref: sch, code: (0, codegen_1.stringify)(sch) } : { ref: sch });
const valid = gen.name("valid");
const schCxt = cxt.subschema({
schema: sch,
dataTypes: [],
schemaPath: codegen_1.nil,
topSchemaRef: schName,
errSchemaPath: $ref
}, valid);
cxt.mergeEvaluated(schCxt);
cxt.ok(valid);
}
}
};
function getValidate(cxt, sch) {
const { gen } = cxt;
return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
}
exports.getValidate = getValidate;
function callRef(cxt, v, sch, $async) {
const { gen, it } = cxt;
const { allErrors, schemaEnv: env, opts } = it;
const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
if ($async)
callAsyncRef();
else
callSyncRef();
function callAsyncRef() {
if (!env.$async)
throw new Error("async schema referenced by sync schema");
const valid = gen.let("valid");
gen.try(() => {
gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
addEvaluatedFrom(v);
if (!allErrors)
gen.assign(valid, true);
}, (e) => {
gen.if((0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
addErrorsFrom(e);
if (!allErrors)
gen.assign(valid, false);
});
cxt.ok(valid);
}
function callSyncRef() {
cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
}
function addErrorsFrom(source) {
const errs = (0, codegen_1._)`${source}.errors`;
gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`);
gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
}
function addEvaluatedFrom(source) {
var _a;
if (!it.opts.unevaluated)
return;
const schEvaluated = (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated;
if (it.props !== true) {
if (schEvaluated && !schEvaluated.dynamicProps) {
if (schEvaluated.props !== void 0) {
it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
}
} else {
const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`);
it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
}
}
if (it.items !== true) {
if (schEvaluated && !schEvaluated.dynamicItems) {
if (schEvaluated.items !== void 0) {
it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
}
} else {
const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`);
it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
}
}
}
}
exports.callRef = callRef;
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/core/index.js
var require_core2 = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/core/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var id_1 = require_id();
var ref_1 = require_ref();
var core = [
"$schema",
"$id",
"$defs",
"$vocabulary",
{ keyword: "$comment" },
"definitions",
id_1.default,
ref_1.default
];
exports.default = core;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
var require_limitNumber = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/limitNumber.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var ops = codegen_1.operators;
var KWDs = {
maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
minimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
exclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
exclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
};
var error = {
message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
};
var def = {
keyword: Object.keys(KWDs),
type: "number",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { keyword, data, schemaCode } = cxt;
cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`);
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
var require_multipleOf = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/multipleOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error = {
message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`
};
var def = {
keyword: "multipleOf",
type: "number",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { gen, data, schemaCode, it } = cxt;
const prec = it.opts.multipleOfPrecision;
const res = gen.let("res");
const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/runtime/ucs2length.js
var require_ucs2length = __commonJS({
"packages/core/node_modules/ajv/dist/runtime/ucs2length.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function ucs2length(str) {
const len = str.length;
let length = 0;
let pos = 0;
let value;
while (pos < len) {
length++;
value = str.charCodeAt(pos++);
if (value >= 55296 && value <= 56319 && pos < len) {
value = str.charCodeAt(pos);
if ((value & 64512) === 56320)
pos++;
}
}
return length;
}
exports.default = ucs2length;
ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/limitLength.js
var require_limitLength = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/limitLength.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var ucs2length_1 = require_ucs2length();
var error = {
message({ keyword, schemaCode }) {
const comp = keyword === "maxLength" ? "more" : "fewer";
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
},
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
};
var def = {
keyword: ["maxLength", "minLength"],
type: "string",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { keyword, data, schemaCode, it } = cxt;
const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT;
const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`);
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/pattern.js
var require_pattern = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/pattern.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code2();
var util_1 = require_util();
var codegen_1 = require_codegen();
var error = {
message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
};
var def = {
keyword: "pattern",
type: "string",
schemaType: "string",
$data: true,
error,
code(cxt) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
const u = it.opts.unicodeRegExp ? "u" : "";
if ($data) {
const { regExp } = it.opts.code;
const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
const valid = gen.let("valid");
gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
cxt.fail$data((0, codegen_1._)`!${valid}`);
} else {
const regExp = (0, code_1.usePattern)(cxt, schema);
cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
var require_limitProperties = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/limitProperties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error = {
message({ keyword, schemaCode }) {
const comp = keyword === "maxProperties" ? "more" : "fewer";
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
},
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
};
var def = {
keyword: ["maxProperties", "minProperties"],
type: "object",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { keyword, data, schemaCode } = cxt;
const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT;
cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`);
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/required.js
var require_required = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/required.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code2();
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
};
var def = {
keyword: "required",
type: "object",
schemaType: "array",
$data: true,
error,
code(cxt) {
const { gen, schema, schemaCode, data, $data, it } = cxt;
const { opts } = it;
if (!$data && schema.length === 0)
return;
const useLoop = schema.length >= opts.loopRequired;
if (it.allErrors)
allErrorsMode();
else
exitOnErrorMode();
if (opts.strictRequired) {
const props = cxt.parentSchema.properties;
const { definedProperties } = cxt.it;
for (const requiredKey of schema) {
if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) {
const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`;
(0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
}
}
}
function allErrorsMode() {
if (useLoop || $data) {
cxt.block$data(codegen_1.nil, loopAllRequired);
} else {
for (const prop of schema) {
(0, code_1.checkReportMissingProp)(cxt, prop);
}
}
}
function exitOnErrorMode() {
const missing = gen.let("missing");
if (useLoop || $data) {
const valid = gen.let("valid", true);
cxt.block$data(valid, () => loopUntilMissing(missing, valid));
cxt.ok(valid);
} else {
gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
(0, code_1.reportMissingProp)(cxt, missing);
gen.else();
}
}
function loopAllRequired() {
gen.forOf("prop", schemaCode, (prop) => {
cxt.setParams({ missingProperty: prop });
gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());
});
}
function loopUntilMissing(missing, valid) {
cxt.setParams({ missingProperty: missing });
gen.forOf(missing, schemaCode, () => {
gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
gen.if((0, codegen_1.not)(valid), () => {
cxt.error();
gen.break();
});
}, codegen_1.nil);
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/limitItems.js
var require_limitItems = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/limitItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error = {
message({ keyword, schemaCode }) {
const comp = keyword === "maxItems" ? "more" : "fewer";
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
},
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
};
var def = {
keyword: ["maxItems", "minItems"],
type: "array",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { keyword, data, schemaCode } = cxt;
const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT;
cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`);
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/runtime/equal.js
var require_equal = __commonJS({
"packages/core/node_modules/ajv/dist/runtime/equal.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var equal = require_fast_deep_equal();
equal.code = 'require("ajv/dist/runtime/equal").default';
exports.default = equal;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
var require_uniqueItems = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dataType_1 = require_dataType();
var codegen_1 = require_codegen();
var util_1 = require_util();
var equal_1 = require_equal();
var error = {
message: ({ params: { i, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`
};
var def = {
keyword: "uniqueItems",
type: "array",
schemaType: "boolean",
$data: true,
error,
code(cxt) {
const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
if (!$data && !schema)
return;
const valid = gen.let("valid");
const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`);
cxt.ok(valid);
function validateUniqueItems() {
const i = gen.let("i", (0, codegen_1._)`${data}.length`);
const j = gen.let("j");
cxt.setParams({ i, j });
gen.assign(valid, true);
gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
}
function canOptimize() {
return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array");
}
function loopN(i, j) {
const item = gen.name("item");
const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
const indices = gen.const("indices", (0, codegen_1._)`{}`);
gen.for((0, codegen_1._)`;${i}--;`, () => {
gen.let(item, (0, codegen_1._)`${data}[${i}]`);
gen.if(wrongType, (0, codegen_1._)`continue`);
if (itemTypes.length > 1)
gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`);
gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => {
gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
cxt.error();
gen.assign(valid, false).break();
}).code((0, codegen_1._)`${indices}[${item}] = ${i}`);
});
}
function loopN2(i, j) {
const eql = (0, util_1.useFunc)(gen, equal_1.default);
const outer = gen.name("outer");
gen.label(outer).for((0, codegen_1._)`;${i}--;`, () => gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => {
cxt.error();
gen.assign(valid, false).break(outer);
})));
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/const.js
var require_const = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/const.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var equal_1 = require_equal();
var error = {
message: "must be equal to constant",
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
};
var def = {
keyword: "const",
$data: true,
error,
code(cxt) {
const { gen, data, $data, schemaCode, schema } = cxt;
if ($data || schema && typeof schema == "object") {
cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
} else {
cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/enum.js
var require_enum = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/enum.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var equal_1 = require_equal();
var error = {
message: "must be equal to one of the allowed values",
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}`
};
var def = {
keyword: "enum",
schemaType: "array",
$data: true,
error,
code(cxt) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
if (!$data && schema.length === 0)
throw new Error("enum must have non-empty array");
const useLoop = schema.length >= it.opts.loopEnum;
let eql;
const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
let valid;
if (useLoop || $data) {
valid = gen.let("valid");
cxt.block$data(valid, loopEnum);
} else {
if (!Array.isArray(schema))
throw new Error("ajv implementation error");
const vSchema = gen.const("vSchema", schemaCode);
valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
}
cxt.pass(valid);
function loopEnum() {
gen.assign(valid, false);
gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
}
function equalCode(vSchema, i) {
const sch = schema[i];
return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/index.js
var require_validation = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var limitNumber_1 = require_limitNumber();
var multipleOf_1 = require_multipleOf();
var limitLength_1 = require_limitLength();
var pattern_1 = require_pattern();
var limitProperties_1 = require_limitProperties();
var required_1 = require_required();
var limitItems_1 = require_limitItems();
var uniqueItems_1 = require_uniqueItems();
var const_1 = require_const();
var enum_1 = require_enum();
var validation = [
// number
limitNumber_1.default,
multipleOf_1.default,
// string
limitLength_1.default,
pattern_1.default,
// object
limitProperties_1.default,
required_1.default,
// array
limitItems_1.default,
uniqueItems_1.default,
// any
{ keyword: "type", schemaType: ["string", "array"] },
{ keyword: "nullable", schemaType: "boolean" },
const_1.default,
enum_1.default
];
exports.default = validation;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
var require_additionalItems = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAdditionalItems = void 0;
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
};
var def = {
keyword: "additionalItems",
type: "array",
schemaType: ["boolean", "object"],
before: "uniqueItems",
error,
code(cxt) {
const { parentSchema, it } = cxt;
const { items } = parentSchema;
if (!Array.isArray(items)) {
(0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas');
return;
}
validateAdditionalItems(cxt, items);
}
};
function validateAdditionalItems(cxt, items) {
const { gen, schema, data, keyword, it } = cxt;
it.items = true;
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
if (schema === false) {
cxt.setParams({ len: items.length });
cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
cxt.ok(valid);
}
function validateItems(valid) {
gen.forRange("i", items.length, len, (i) => {
cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid);
if (!it.allErrors)
gen.if((0, codegen_1.not)(valid), () => gen.break());
});
}
}
exports.validateAdditionalItems = validateAdditionalItems;
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/items.js
var require_items = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/items.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateTuple = void 0;
var codegen_1 = require_codegen();
var util_1 = require_util();
var code_1 = require_code2();
var def = {
keyword: "items",
type: "array",
schemaType: ["object", "array", "boolean"],
before: "uniqueItems",
code(cxt) {
const { schema, it } = cxt;
if (Array.isArray(schema))
return validateTuple(cxt, "additionalItems", schema);
it.items = true;
if ((0, util_1.alwaysValidSchema)(it, schema))
return;
cxt.ok((0, code_1.validateArray)(cxt));
}
};
function validateTuple(cxt, extraItems, schArr = cxt.schema) {
const { gen, parentSchema, data, keyword, it } = cxt;
checkStrictTuple(parentSchema);
if (it.opts.unevaluated && schArr.length && it.items !== true) {
it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
}
const valid = gen.name("valid");
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
schArr.forEach((sch, i) => {
if ((0, util_1.alwaysValidSchema)(it, sch))
return;
gen.if((0, codegen_1._)`${len} > ${i}`, () => cxt.subschema({
keyword,
schemaProp: i,
dataProp: i
}, valid));
cxt.ok(valid);
});
function checkStrictTuple(sch) {
const { opts, errSchemaPath } = it;
const l = schArr.length;
const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
if (opts.strictTuples && !fullTuple) {
const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
(0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
}
}
}
exports.validateTuple = validateTuple;
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
var require_prefixItems = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var items_1 = require_items();
var def = {
keyword: "prefixItems",
type: "array",
schemaType: ["array"],
before: "uniqueItems",
code: (cxt) => (0, items_1.validateTuple)(cxt, "items")
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/items2020.js
var require_items2020 = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/items2020.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var code_1 = require_code2();
var additionalItems_1 = require_additionalItems();
var error = {
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
};
var def = {
keyword: "items",
type: "array",
schemaType: ["object", "boolean"],
before: "uniqueItems",
error,
code(cxt) {
const { schema, parentSchema, it } = cxt;
const { prefixItems } = parentSchema;
it.items = true;
if ((0, util_1.alwaysValidSchema)(it, schema))
return;
if (prefixItems)
(0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
else
cxt.ok((0, code_1.validateArray)(cxt));
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/contains.js
var require_contains = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/contains.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
};
var def = {
keyword: "contains",
type: "array",
schemaType: ["object", "boolean"],
before: "uniqueItems",
trackErrors: true,
error,
code(cxt) {
const { gen, schema, parentSchema, data, it } = cxt;
let min;
let max;
const { minContains, maxContains } = parentSchema;
if (it.opts.next) {
min = minContains === void 0 ? 1 : minContains;
max = maxContains;
} else {
min = 1;
}
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
cxt.setParams({ min, max });
if (max === void 0 && min === 0) {
(0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
return;
}
if (max !== void 0 && min > max) {
(0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
cxt.fail();
return;
}
if ((0, util_1.alwaysValidSchema)(it, schema)) {
let cond = (0, codegen_1._)`${len} >= ${min}`;
if (max !== void 0)
cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
cxt.pass(cond);
return;
}
it.items = true;
const valid = gen.name("valid");
if (max === void 0 && min === 1) {
validateItems(valid, () => gen.if(valid, () => gen.break()));
} else if (min === 0) {
gen.let(valid, true);
if (max !== void 0)
gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
} else {
gen.let(valid, false);
validateItemsWithCount();
}
cxt.result(valid, () => cxt.reset());
function validateItemsWithCount() {
const schValid = gen.name("_valid");
const count = gen.let("count", 0);
validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
}
function validateItems(_valid, block) {
gen.forRange("i", 0, len, (i) => {
cxt.subschema({
keyword: "contains",
dataProp: i,
dataPropType: util_1.Type.Num,
compositeRule: true
}, _valid);
block();
});
}
function checkLimits(count) {
gen.code((0, codegen_1._)`${count}++`);
if (max === void 0) {
gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
} else {
gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
if (min === 1)
gen.assign(valid, true);
else
gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
}
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
var require_dependencies = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/dependencies.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
var codegen_1 = require_codegen();
var util_1 = require_util();
var code_1 = require_code2();
exports.error = {
message: ({ params: { property, depsCount, deps } }) => {
const property_ies = depsCount === 1 ? "property" : "properties";
return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
},
params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property},
missingProperty: ${missingProperty},
depsCount: ${depsCount},
deps: ${deps}}`
// TODO change to reference
};
var def = {
keyword: "dependencies",
type: "object",
schemaType: "object",
error: exports.error,
code(cxt) {
const [propDeps, schDeps] = splitDependencies(cxt);
validatePropertyDeps(cxt, propDeps);
validateSchemaDeps(cxt, schDeps);
}
};
function splitDependencies({ schema }) {
const propertyDeps = {};
const schemaDeps = {};
for (const key in schema) {
if (key === "__proto__")
continue;
const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
deps[key] = schema[key];
}
return [propertyDeps, schemaDeps];
}
function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
const { gen, data, it } = cxt;
if (Object.keys(propertyDeps).length === 0)
return;
const missing = gen.let("missing");
for (const prop in propertyDeps) {
const deps = propertyDeps[prop];
if (deps.length === 0)
continue;
const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
cxt.setParams({
property: prop,
depsCount: deps.length,
deps: deps.join(", ")
});
if (it.allErrors) {
gen.if(hasProperty, () => {
for (const depProp of deps) {
(0, code_1.checkReportMissingProp)(cxt, depProp);
}
});
} else {
gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
(0, code_1.reportMissingProp)(cxt, missing);
gen.else();
}
}
}
exports.validatePropertyDeps = validatePropertyDeps;
function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
const { gen, data, keyword, it } = cxt;
const valid = gen.name("valid");
for (const prop in schemaDeps) {
if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop]))
continue;
gen.if(
(0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties),
() => {
const schCxt = cxt.subschema({ keyword, schemaProp: prop }, valid);
cxt.mergeValidEvaluated(schCxt, valid);
},
() => gen.var(valid, true)
// TODO var
);
cxt.ok(valid);
}
}
exports.validateSchemaDeps = validateSchemaDeps;
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
var require_propertyNames = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
message: "property name must be valid",
params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
};
var def = {
keyword: "propertyNames",
type: "object",
schemaType: ["object", "boolean"],
error,
code(cxt) {
const { gen, schema, data, it } = cxt;
if ((0, util_1.alwaysValidSchema)(it, schema))
return;
const valid = gen.name("valid");
gen.forIn("key", data, (key) => {
cxt.setParams({ propertyName: key });
cxt.subschema({
keyword: "propertyNames",
data: key,
dataTypes: ["string"],
propertyName: key,
compositeRule: true
}, valid);
gen.if((0, codegen_1.not)(valid), () => {
cxt.error(true);
if (!it.allErrors)
gen.break();
});
});
cxt.ok(valid);
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
var require_additionalProperties = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code2();
var codegen_1 = require_codegen();
var names_1 = require_names();
var util_1 = require_util();
var error = {
message: "must NOT have additional properties",
params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
};
var def = {
keyword: "additionalProperties",
type: ["object"],
schemaType: ["boolean", "object"],
allowUndefined: true,
trackErrors: true,
error,
code(cxt) {
const { gen, schema, parentSchema, data, errsCount, it } = cxt;
if (!errsCount)
throw new Error("ajv implementation error");
const { allErrors, opts } = it;
it.props = true;
if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema))
return;
const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
checkAdditionalProperties();
cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
function checkAdditionalProperties() {
gen.forIn("key", data, (key) => {
if (!props.length && !patProps.length)
additionalPropertyCode(key);
else
gen.if(isAdditional(key), () => additionalPropertyCode(key));
});
}
function isAdditional(key) {
let definedProp;
if (props.length > 8) {
const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
} else if (props.length) {
definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
} else {
definedProp = codegen_1.nil;
}
if (patProps.length) {
definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
}
return (0, codegen_1.not)(definedProp);
}
function deleteAdditional(key) {
gen.code((0, codegen_1._)`delete ${data}[${key}]`);
}
function additionalPropertyCode(key) {
if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
deleteAdditional(key);
return;
}
if (schema === false) {
cxt.setParams({ additionalProperty: key });
cxt.error();
if (!allErrors)
gen.break();
return;
}
if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.name("valid");
if (opts.removeAdditional === "failing") {
applyAdditionalSchema(key, valid, false);
gen.if((0, codegen_1.not)(valid), () => {
cxt.reset();
deleteAdditional(key);
});
} else {
applyAdditionalSchema(key, valid);
if (!allErrors)
gen.if((0, codegen_1.not)(valid), () => gen.break());
}
}
}
function applyAdditionalSchema(key, valid, errors) {
const subschema = {
keyword: "additionalProperties",
dataProp: key,
dataPropType: util_1.Type.Str
};
if (errors === false) {
Object.assign(subschema, {
compositeRule: true,
createErrors: false,
allErrors: false
});
}
cxt.subschema(subschema, valid);
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/properties.js
var require_properties = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/properties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var validate_1 = require_validate();
var code_1 = require_code2();
var util_1 = require_util();
var additionalProperties_1 = require_additionalProperties();
var def = {
keyword: "properties",
type: "object",
schemaType: "object",
code(cxt) {
const { gen, schema, parentSchema, data, it } = cxt;
if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) {
additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
}
const allProps = (0, code_1.allSchemaProperties)(schema);
for (const prop of allProps) {
it.definedProperties.add(prop);
}
if (it.opts.unevaluated && allProps.length && it.props !== true) {
it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
}
const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
if (properties.length === 0)
return;
const valid = gen.name("valid");
for (const prop of properties) {
if (hasDefault(prop)) {
applyPropertySchema(prop);
} else {
gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));
applyPropertySchema(prop);
if (!it.allErrors)
gen.else().var(valid, true);
gen.endIf();
}
cxt.it.definedProperties.add(prop);
cxt.ok(valid);
}
function hasDefault(prop) {
return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0;
}
function applyPropertySchema(prop) {
cxt.subschema({
keyword: "properties",
schemaProp: prop,
dataProp: prop
}, valid);
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
var require_patternProperties = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code2();
var codegen_1 = require_codegen();
var util_1 = require_util();
var util_2 = require_util();
var def = {
keyword: "patternProperties",
type: "object",
schemaType: "object",
code(cxt) {
const { gen, schema, data, parentSchema, it } = cxt;
const { opts } = it;
const patterns = (0, code_1.allSchemaProperties)(schema);
const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) {
return;
}
const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;
const valid = gen.name("valid");
if (it.props !== true && !(it.props instanceof codegen_1.Name)) {
it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
}
const { props } = it;
validatePatternProperties();
function validatePatternProperties() {
for (const pat of patterns) {
if (checkProperties)
checkMatchingProperties(pat);
if (it.allErrors) {
validateProperties(pat);
} else {
gen.var(valid, true);
validateProperties(pat);
gen.if(valid);
}
}
}
function checkMatchingProperties(pat) {
for (const prop in checkProperties) {
if (new RegExp(pat).test(prop)) {
(0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`);
}
}
}
function validateProperties(pat) {
gen.forIn("key", data, (key) => {
gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
const alwaysValid = alwaysValidPatterns.includes(pat);
if (!alwaysValid) {
cxt.subschema({
keyword: "patternProperties",
schemaProp: pat,
dataProp: key,
dataPropType: util_2.Type.Str
}, valid);
}
if (it.opts.unevaluated && props !== true) {
gen.assign((0, codegen_1._)`${props}[${key}]`, true);
} else if (!alwaysValid && !it.allErrors) {
gen.if((0, codegen_1.not)(valid), () => gen.break());
}
});
});
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/not.js
var require_not = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/not.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require_util();
var def = {
keyword: "not",
schemaType: ["object", "boolean"],
trackErrors: true,
code(cxt) {
const { gen, schema, it } = cxt;
if ((0, util_1.alwaysValidSchema)(it, schema)) {
cxt.fail();
return;
}
const valid = gen.name("valid");
cxt.subschema({
keyword: "not",
compositeRule: true,
createErrors: false,
allErrors: false
}, valid);
cxt.failResult(valid, () => cxt.reset(), () => cxt.error());
},
error: { message: "must NOT be valid" }
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
var require_anyOf = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/anyOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code2();
var def = {
keyword: "anyOf",
schemaType: "array",
trackErrors: true,
code: code_1.validateUnion,
error: { message: "must match a schema in anyOf" }
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
var require_oneOf = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/oneOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
message: "must match exactly one schema in oneOf",
params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`
};
var def = {
keyword: "oneOf",
schemaType: "array",
trackErrors: true,
error,
code(cxt) {
const { gen, schema, parentSchema, it } = cxt;
if (!Array.isArray(schema))
throw new Error("ajv implementation error");
if (it.opts.discriminator && parentSchema.discriminator)
return;
const schArr = schema;
const valid = gen.let("valid", false);
const passing = gen.let("passing", null);
const schValid = gen.name("_valid");
cxt.setParams({ passing });
gen.block(validateOneOf);
cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
function validateOneOf() {
schArr.forEach((sch, i) => {
let schCxt;
if ((0, util_1.alwaysValidSchema)(it, sch)) {
gen.var(schValid, true);
} else {
schCxt = cxt.subschema({
keyword: "oneOf",
schemaProp: i,
compositeRule: true
}, schValid);
}
if (i > 0) {
gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i}]`).else();
}
gen.if(schValid, () => {
gen.assign(valid, true);
gen.assign(passing, i);
if (schCxt)
cxt.mergeEvaluated(schCxt, codegen_1.Name);
});
});
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/allOf.js
var require_allOf = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/allOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require_util();
var def = {
keyword: "allOf",
schemaType: "array",
code(cxt) {
const { gen, schema, it } = cxt;
if (!Array.isArray(schema))
throw new Error("ajv implementation error");
const valid = gen.name("valid");
schema.forEach((sch, i) => {
if ((0, util_1.alwaysValidSchema)(it, sch))
return;
const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid);
cxt.ok(valid);
cxt.mergeEvaluated(schCxt);
});
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/if.js
var require_if = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/if.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
};
var def = {
keyword: "if",
schemaType: ["object", "boolean"],
trackErrors: true,
error,
code(cxt) {
const { gen, parentSchema, it } = cxt;
if (parentSchema.then === void 0 && parentSchema.else === void 0) {
(0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored');
}
const hasThen = hasSchema(it, "then");
const hasElse = hasSchema(it, "else");
if (!hasThen && !hasElse)
return;
const valid = gen.let("valid", true);
const schValid = gen.name("_valid");
validateIf();
cxt.reset();
if (hasThen && hasElse) {
const ifClause = gen.let("ifClause");
cxt.setParams({ ifClause });
gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
} else if (hasThen) {
gen.if(schValid, validateClause("then"));
} else {
gen.if((0, codegen_1.not)(schValid), validateClause("else"));
}
cxt.pass(valid, () => cxt.error(true));
function validateIf() {
const schCxt = cxt.subschema({
keyword: "if",
compositeRule: true,
createErrors: false,
allErrors: false
}, schValid);
cxt.mergeEvaluated(schCxt);
}
function validateClause(keyword, ifClause) {
return () => {
const schCxt = cxt.subschema({ keyword }, schValid);
gen.assign(valid, schValid);
cxt.mergeValidEvaluated(schCxt, valid);
if (ifClause)
gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
else
cxt.setParams({ ifClause: keyword });
};
}
}
};
function hasSchema(it, keyword) {
const schema = it.schema[keyword];
return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
}
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
var require_thenElse = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/thenElse.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require_util();
var def = {
keyword: ["then", "else"],
schemaType: ["object", "boolean"],
code({ keyword, parentSchema, it }) {
if (parentSchema.if === void 0)
(0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/index.js
var require_applicator = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var additionalItems_1 = require_additionalItems();
var prefixItems_1 = require_prefixItems();
var items_1 = require_items();
var items2020_1 = require_items2020();
var contains_1 = require_contains();
var dependencies_1 = require_dependencies();
var propertyNames_1 = require_propertyNames();
var additionalProperties_1 = require_additionalProperties();
var properties_1 = require_properties();
var patternProperties_1 = require_patternProperties();
var not_1 = require_not();
var anyOf_1 = require_anyOf();
var oneOf_1 = require_oneOf();
var allOf_1 = require_allOf();
var if_1 = require_if();
var thenElse_1 = require_thenElse();
function getApplicator(draft2020 = false) {
const applicator = [
// any
not_1.default,
anyOf_1.default,
oneOf_1.default,
allOf_1.default,
if_1.default,
thenElse_1.default,
// object
propertyNames_1.default,
additionalProperties_1.default,
dependencies_1.default,
properties_1.default,
patternProperties_1.default
];
if (draft2020)
applicator.push(prefixItems_1.default, items2020_1.default);
else
applicator.push(additionalItems_1.default, items_1.default);
applicator.push(contains_1.default);
return applicator;
}
exports.default = getApplicator;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/format/format.js
var require_format = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/format/format.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error = {
message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`,
params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`
};
var def = {
keyword: "format",
type: ["number", "string"],
schemaType: "string",
$data: true,
error,
code(cxt, ruleType) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
const { opts, errSchemaPath, schemaEnv, self: self2 } = it;
if (!opts.validateFormats)
return;
if ($data)
validate$DataFormat();
else
validateFormat();
function validate$DataFormat() {
const fmts = gen.scopeValue("formats", {
ref: self2.formats,
code: opts.code.formats
});
const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
const fType = gen.let("fType");
const format2 = gen.let("format");
gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format2, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format2, fDef));
cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
function unknownFmt() {
if (opts.strictSchema === false)
return codegen_1.nil;
return (0, codegen_1._)`${schemaCode} && !${format2}`;
}
function invalidFmt() {
const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format2}(${data}) : ${format2}(${data}))` : (0, codegen_1._)`${format2}(${data})`;
const validData = (0, codegen_1._)`(typeof ${format2} == "function" ? ${callFormat} : ${format2}.test(${data}))`;
return (0, codegen_1._)`${format2} && ${format2} !== true && ${fType} === ${ruleType} && !${validData}`;
}
}
function validateFormat() {
const formatDef = self2.formats[schema];
if (!formatDef) {
unknownFormat();
return;
}
if (formatDef === true)
return;
const [fmtType, format2, fmtRef] = getFormat(formatDef);
if (fmtType === ruleType)
cxt.pass(validCondition());
function unknownFormat() {
if (opts.strictSchema === false) {
self2.logger.warn(unknownMsg());
return;
}
throw new Error(unknownMsg());
function unknownMsg() {
return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
}
}
function getFormat(fmtDef) {
const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : void 0;
const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code });
if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
}
return ["string", fmtDef, fmt];
}
function validCondition() {
if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
if (!schemaEnv.$async)
throw new Error("async format in sync schema");
return (0, codegen_1._)`await ${fmtRef}(${data})`;
}
return typeof format2 == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
}
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/format/index.js
var require_format2 = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/format/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var format_1 = require_format();
var format2 = [format_1.default];
exports.default = format2;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/metadata.js
var require_metadata = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/metadata.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.contentVocabulary = exports.metadataVocabulary = void 0;
exports.metadataVocabulary = [
"title",
"description",
"default",
"deprecated",
"readOnly",
"writeOnly",
"examples"
];
exports.contentVocabulary = [
"contentMediaType",
"contentEncoding",
"contentSchema"
];
}
});
// packages/core/node_modules/ajv/dist/vocabularies/draft7.js
var require_draft7 = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/draft7.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = require_core2();
var validation_1 = require_validation();
var applicator_1 = require_applicator();
var format_1 = require_format2();
var metadata_1 = require_metadata();
var draft7Vocabularies = [
core_1.default,
validation_1.default,
(0, applicator_1.default)(),
format_1.default,
metadata_1.metadataVocabulary,
metadata_1.contentVocabulary
];
exports.default = draft7Vocabularies;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/discriminator/types.js
var require_types = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/discriminator/types.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DiscrError = void 0;
var DiscrError;
(function(DiscrError2) {
DiscrError2["Tag"] = "tag";
DiscrError2["Mapping"] = "mapping";
})(DiscrError || (exports.DiscrError = DiscrError = {}));
}
});
// packages/core/node_modules/ajv/dist/vocabularies/discriminator/index.js
var require_discriminator = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/discriminator/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var types_1 = require_types();
var compile_1 = require_compile();
var ref_error_1 = require_ref_error();
var util_1 = require_util();
var error = {
message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
};
var def = {
keyword: "discriminator",
type: "object",
schemaType: "object",
error,
code(cxt) {
const { gen, data, schema, parentSchema, it } = cxt;
const { oneOf } = parentSchema;
if (!it.opts.discriminator) {
throw new Error("discriminator: requires discriminator option");
}
const tagName = schema.propertyName;
if (typeof tagName != "string")
throw new Error("discriminator: requires propertyName");
if (schema.mapping)
throw new Error("discriminator: mapping is not supported");
if (!oneOf)
throw new Error("discriminator: requires oneOf keyword");
const valid = gen.let("valid", false);
const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, { discrError: types_1.DiscrError.Tag, tag, tagName }));
cxt.ok(valid);
function validateMapping() {
const mapping = getMapping();
gen.if(false);
for (const tagValue in mapping) {
gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
gen.assign(valid, applyTagSchema(mapping[tagValue]));
}
gen.else();
cxt.error(false, { discrError: types_1.DiscrError.Mapping, tag, tagName });
gen.endIf();
}
function applyTagSchema(schemaProp) {
const _valid = gen.name("valid");
const schCxt = cxt.subschema({ keyword: "oneOf", schemaProp }, _valid);
cxt.mergeEvaluated(schCxt, codegen_1.Name);
return _valid;
}
function getMapping() {
var _a;
const oneOfMapping = {};
const topRequired = hasRequired(parentSchema);
let tagRequired = true;
for (let i = 0; i < oneOf.length; i++) {
let sch = oneOf[i];
if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
const ref = sch.$ref;
sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
if (sch instanceof compile_1.SchemaEnv)
sch = sch.schema;
if (sch === void 0)
throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
}
const propSch = (_a = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a === void 0 ? void 0 : _a[tagName];
if (typeof propSch != "object") {
throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
}
tagRequired = tagRequired && (topRequired || hasRequired(sch));
addMappings(propSch, i);
}
if (!tagRequired)
throw new Error(`discriminator: "${tagName}" must be required`);
return oneOfMapping;
function hasRequired({ required }) {
return Array.isArray(required) && required.includes(tagName);
}
function addMappings(sch, i) {
if (sch.const) {
addMapping(sch.const, i);
} else if (sch.enum) {
for (const tagValue of sch.enum) {
addMapping(tagValue, i);
}
} else {
throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
}
}
function addMapping(tagValue, i) {
if (typeof tagValue != "string" || tagValue in oneOfMapping) {
throw new Error(`discriminator: "${tagName}" values must be unique strings`);
}
oneOfMapping[tagValue] = i;
}
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-draft-07.json
var require_json_schema_draft_07 = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-draft-07.json"(exports, module) {
module.exports = {
$schema: "http://json-schema.org/draft-07/schema#",
$id: "http://json-schema.org/draft-07/schema#",
title: "Core schema meta-schema",
definitions: {
schemaArray: {
type: "array",
minItems: 1,
items: { $ref: "#" }
},
nonNegativeInteger: {
type: "integer",
minimum: 0
},
nonNegativeIntegerDefault0: {
allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }]
},
simpleTypes: {
enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
},
stringArray: {
type: "array",
items: { type: "string" },
uniqueItems: true,
default: []
}
},
type: ["object", "boolean"],
properties: {
$id: {
type: "string",
format: "uri-reference"
},
$schema: {
type: "string",
format: "uri"
},
$ref: {
type: "string",
format: "uri-reference"
},
$comment: {
type: "string"
},
title: {
type: "string"
},
description: {
type: "string"
},
default: true,
readOnly: {
type: "boolean",
default: false
},
examples: {
type: "array",
items: true
},
multipleOf: {
type: "number",
exclusiveMinimum: 0
},
maximum: {
type: "number"
},
exclusiveMaximum: {
type: "number"
},
minimum: {
type: "number"
},
exclusiveMinimum: {
type: "number"
},
maxLength: { $ref: "#/definitions/nonNegativeInteger" },
minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
pattern: {
type: "string",
format: "regex"
},
additionalItems: { $ref: "#" },
items: {
anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
default: true
},
maxItems: { $ref: "#/definitions/nonNegativeInteger" },
minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
uniqueItems: {
type: "boolean",
default: false
},
contains: { $ref: "#" },
maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
required: { $ref: "#/definitions/stringArray" },
additionalProperties: { $ref: "#" },
definitions: {
type: "object",
additionalProperties: { $ref: "#" },
default: {}
},
properties: {
type: "object",
additionalProperties: { $ref: "#" },
default: {}
},
patternProperties: {
type: "object",
additionalProperties: { $ref: "#" },
propertyNames: { format: "regex" },
default: {}
},
dependencies: {
type: "object",
additionalProperties: {
anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }]
}
},
propertyNames: { $ref: "#" },
const: true,
enum: {
type: "array",
items: true,
minItems: 1,
uniqueItems: true
},
type: {
anyOf: [
{ $ref: "#/definitions/simpleTypes" },
{
type: "array",
items: { $ref: "#/definitions/simpleTypes" },
minItems: 1,
uniqueItems: true
}
]
},
format: { type: "string" },
contentMediaType: { type: "string" },
contentEncoding: { type: "string" },
if: { $ref: "#" },
then: { $ref: "#" },
else: { $ref: "#" },
allOf: { $ref: "#/definitions/schemaArray" },
anyOf: { $ref: "#/definitions/schemaArray" },
oneOf: { $ref: "#/definitions/schemaArray" },
not: { $ref: "#" }
},
default: true
};
}
});
// packages/core/node_modules/ajv/dist/ajv.js
var require_ajv = __commonJS({
"packages/core/node_modules/ajv/dist/ajv.js"(exports, module) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
var core_1 = require_core();
var draft7_1 = require_draft7();
var discriminator_1 = require_discriminator();
var draft7MetaSchema = require_json_schema_draft_07();
var META_SUPPORT_DATA = ["/properties"];
var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
var Ajv = class extends core_1.default {
_addVocabularies() {
super._addVocabularies();
draft7_1.default.forEach((v) => this.addVocabulary(v));
if (this.opts.discriminator)
this.addKeyword(discriminator_1.default);
}
_addDefaultMetaSchema() {
super._addDefaultMetaSchema();
if (!this.opts.meta)
return;
const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema;
this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
}
defaultMeta() {
return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
}
};
exports.Ajv = Ajv;
module.exports = exports = Ajv;
module.exports.Ajv = Ajv;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = Ajv;
var validate_1 = require_validate();
Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
return validate_1.KeywordCxt;
} });
var codegen_1 = require_codegen();
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
return codegen_1._;
} });
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
return codegen_1.str;
} });
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
return codegen_1.stringify;
} });
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
return codegen_1.nil;
} });
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
return codegen_1.Name;
} });
Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
return codegen_1.CodeGen;
} });
var validation_error_1 = require_validation_error();
Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
return validation_error_1.default;
} });
var ref_error_1 = require_ref_error();
Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
return ref_error_1.default;
} });
}
});
// packages/core/node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js
var require_dynamicAnchor = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.dynamicAnchor = void 0;
var codegen_1 = require_codegen();
var names_1 = require_names();
var compile_1 = require_compile();
var ref_1 = require_ref();
var def = {
keyword: "$dynamicAnchor",
schemaType: "string",
code: (cxt) => dynamicAnchor(cxt, cxt.schema)
};
function dynamicAnchor(cxt, anchor) {
const { gen, it } = cxt;
it.schemaEnv.root.dynamicAnchors[anchor] = true;
const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate));
}
exports.dynamicAnchor = dynamicAnchor;
function _getValidate(cxt) {
const { schemaEnv, schema, self: self2 } = cxt.it;
const { root, baseId, localRefs, meta } = schemaEnv.root;
const { schemaId } = self2.opts;
const sch = new compile_1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta });
compile_1.compileSchema.call(self2, sch);
return (0, ref_1.getValidate)(cxt, sch);
}
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js
var require_dynamicRef = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.dynamicRef = void 0;
var codegen_1 = require_codegen();
var names_1 = require_names();
var ref_1 = require_ref();
var def = {
keyword: "$dynamicRef",
schemaType: "string",
code: (cxt) => dynamicRef(cxt, cxt.schema)
};
function dynamicRef(cxt, ref) {
const { gen, keyword, it } = cxt;
if (ref[0] !== "#")
throw new Error(`"${keyword}" only supports hash fragment reference`);
const anchor = ref.slice(1);
if (it.allErrors) {
_dynamicRef();
} else {
const valid = gen.let("valid", false);
_dynamicRef(valid);
cxt.ok(valid);
}
function _dynamicRef(valid) {
if (it.schemaEnv.root.dynamicAnchors[anchor]) {
const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
} else {
_callRef(it.validateName, valid)();
}
}
function _callRef(validate, valid) {
return valid ? () => gen.block(() => {
(0, ref_1.callRef)(cxt, validate);
gen.let(valid, true);
}) : () => (0, ref_1.callRef)(cxt, validate);
}
}
exports.dynamicRef = dynamicRef;
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js
var require_recursiveAnchor = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dynamicAnchor_1 = require_dynamicAnchor();
var util_1 = require_util();
var def = {
keyword: "$recursiveAnchor",
schemaType: "boolean",
code(cxt) {
if (cxt.schema)
(0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
else
(0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js
var require_recursiveRef = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dynamicRef_1 = require_dynamicRef();
var def = {
keyword: "$recursiveRef",
schemaType: "string",
code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/dynamic/index.js
var require_dynamic = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/dynamic/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dynamicAnchor_1 = require_dynamicAnchor();
var dynamicRef_1 = require_dynamicRef();
var recursiveAnchor_1 = require_recursiveAnchor();
var recursiveRef_1 = require_recursiveRef();
var dynamic = [dynamicAnchor_1.default, dynamicRef_1.default, recursiveAnchor_1.default, recursiveRef_1.default];
exports.default = dynamic;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/dependentRequired.js
var require_dependentRequired = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/dependentRequired.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dependencies_1 = require_dependencies();
var def = {
keyword: "dependentRequired",
type: "object",
schemaType: "object",
error: dependencies_1.error,
code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js
var require_dependentSchemas = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dependencies_1 = require_dependencies();
var def = {
keyword: "dependentSchemas",
type: "object",
schemaType: "object",
code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/validation/limitContains.js
var require_limitContains = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/validation/limitContains.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require_util();
var def = {
keyword: ["maxContains", "minContains"],
type: "array",
schemaType: "number",
code({ keyword, parentSchema, it }) {
if (parentSchema.contains === void 0) {
(0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/next.js
var require_next = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/next.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dependentRequired_1 = require_dependentRequired();
var dependentSchemas_1 = require_dependentSchemas();
var limitContains_1 = require_limitContains();
var next = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default];
exports.default = next;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js
var require_unevaluatedProperties = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var names_1 = require_names();
var error = {
message: "must NOT have unevaluated properties",
params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
};
var def = {
keyword: "unevaluatedProperties",
type: "object",
schemaType: ["boolean", "object"],
trackErrors: true,
error,
code(cxt) {
const { gen, schema, data, errsCount, it } = cxt;
if (!errsCount)
throw new Error("ajv implementation error");
const { allErrors, props } = it;
if (props instanceof codegen_1.Name) {
gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
} else if (props !== true) {
gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
}
it.props = true;
cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
function unevaluatedPropCode(key) {
if (schema === false) {
cxt.setParams({ unevaluatedProperty: key });
cxt.error();
if (!allErrors)
gen.break();
return;
}
if (!(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.name("valid");
cxt.subschema({
keyword: "unevaluatedProperties",
dataProp: key,
dataPropType: util_1.Type.Str
}, valid);
if (!allErrors)
gen.if((0, codegen_1.not)(valid), () => gen.break());
}
}
function unevaluatedDynamic(evaluatedProps, key) {
return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
}
function unevaluatedStatic(evaluatedProps, key) {
const ps = [];
for (const p in evaluatedProps) {
if (evaluatedProps[p] === true)
ps.push((0, codegen_1._)`${key} !== ${p}`);
}
return (0, codegen_1.and)(...ps);
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js
var require_unevaluatedItems = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
};
var def = {
keyword: "unevaluatedItems",
type: "array",
schemaType: ["boolean", "object"],
error,
code(cxt) {
const { gen, schema, data, it } = cxt;
const items = it.items || 0;
if (items === true)
return;
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
if (schema === false) {
cxt.setParams({ len: items });
cxt.fail((0, codegen_1._)`${len} > ${items}`);
} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
cxt.ok(valid);
}
it.items = true;
function validateItems(valid, from) {
gen.forRange("i", from, len, (i) => {
cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1.Type.Num }, valid);
if (!it.allErrors)
gen.if((0, codegen_1.not)(valid), () => gen.break());
});
}
}
};
exports.default = def;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/unevaluated/index.js
var require_unevaluated = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/unevaluated/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var unevaluatedProperties_1 = require_unevaluatedProperties();
var unevaluatedItems_1 = require_unevaluatedItems();
var unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
exports.default = unevaluated;
}
});
// packages/core/node_modules/ajv/dist/vocabularies/draft2020.js
var require_draft2020 = __commonJS({
"packages/core/node_modules/ajv/dist/vocabularies/draft2020.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = require_core2();
var validation_1 = require_validation();
var applicator_1 = require_applicator();
var dynamic_1 = require_dynamic();
var next_1 = require_next();
var unevaluated_1 = require_unevaluated();
var format_1 = require_format2();
var metadata_1 = require_metadata();
var draft2020Vocabularies = [
dynamic_1.default,
core_1.default,
validation_1.default,
(0, applicator_1.default)(true),
format_1.default,
metadata_1.metadataVocabulary,
metadata_1.contentVocabulary,
next_1.default,
unevaluated_1.default
];
exports.default = draft2020Vocabularies;
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/schema.json
var require_schema = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/schema.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/schema",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/core": true,
"https://json-schema.org/draft/2020-12/vocab/applicator": true,
"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
"https://json-schema.org/draft/2020-12/vocab/validation": true,
"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
"https://json-schema.org/draft/2020-12/vocab/content": true
},
$dynamicAnchor: "meta",
title: "Core and Validation specifications meta-schema",
allOf: [
{ $ref: "meta/core" },
{ $ref: "meta/applicator" },
{ $ref: "meta/unevaluated" },
{ $ref: "meta/validation" },
{ $ref: "meta/meta-data" },
{ $ref: "meta/format-annotation" },
{ $ref: "meta/content" }
],
type: ["object", "boolean"],
$comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
properties: {
definitions: {
$comment: '"definitions" has been replaced by "$defs".',
type: "object",
additionalProperties: { $dynamicRef: "#meta" },
deprecated: true,
default: {}
},
dependencies: {
$comment: '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.',
type: "object",
additionalProperties: {
anyOf: [{ $dynamicRef: "#meta" }, { $ref: "meta/validation#/$defs/stringArray" }]
},
deprecated: true,
default: {}
},
$recursiveAnchor: {
$comment: '"$recursiveAnchor" has been replaced by "$dynamicAnchor".',
$ref: "meta/core#/$defs/anchorString",
deprecated: true
},
$recursiveRef: {
$comment: '"$recursiveRef" has been replaced by "$dynamicRef".',
$ref: "meta/core#/$defs/uriReferenceString",
deprecated: true
}
}
};
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json
var require_applicator2 = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/applicator",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/applicator": true
},
$dynamicAnchor: "meta",
title: "Applicator vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
prefixItems: { $ref: "#/$defs/schemaArray" },
items: { $dynamicRef: "#meta" },
contains: { $dynamicRef: "#meta" },
additionalProperties: { $dynamicRef: "#meta" },
properties: {
type: "object",
additionalProperties: { $dynamicRef: "#meta" },
default: {}
},
patternProperties: {
type: "object",
additionalProperties: { $dynamicRef: "#meta" },
propertyNames: { format: "regex" },
default: {}
},
dependentSchemas: {
type: "object",
additionalProperties: { $dynamicRef: "#meta" },
default: {}
},
propertyNames: { $dynamicRef: "#meta" },
if: { $dynamicRef: "#meta" },
then: { $dynamicRef: "#meta" },
else: { $dynamicRef: "#meta" },
allOf: { $ref: "#/$defs/schemaArray" },
anyOf: { $ref: "#/$defs/schemaArray" },
oneOf: { $ref: "#/$defs/schemaArray" },
not: { $dynamicRef: "#meta" }
},
$defs: {
schemaArray: {
type: "array",
minItems: 1,
items: { $dynamicRef: "#meta" }
}
}
};
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json
var require_unevaluated2 = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/unevaluated": true
},
$dynamicAnchor: "meta",
title: "Unevaluated applicator vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
unevaluatedItems: { $dynamicRef: "#meta" },
unevaluatedProperties: { $dynamicRef: "#meta" }
}
};
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json
var require_content = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/content",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/content": true
},
$dynamicAnchor: "meta",
title: "Content vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
contentEncoding: { type: "string" },
contentMediaType: { type: "string" },
contentSchema: { $dynamicRef: "#meta" }
}
};
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json
var require_core3 = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/core",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/core": true
},
$dynamicAnchor: "meta",
title: "Core vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
$id: {
$ref: "#/$defs/uriReferenceString",
$comment: "Non-empty fragments not allowed.",
pattern: "^[^#]*#?$"
},
$schema: { $ref: "#/$defs/uriString" },
$ref: { $ref: "#/$defs/uriReferenceString" },
$anchor: { $ref: "#/$defs/anchorString" },
$dynamicRef: { $ref: "#/$defs/uriReferenceString" },
$dynamicAnchor: { $ref: "#/$defs/anchorString" },
$vocabulary: {
type: "object",
propertyNames: { $ref: "#/$defs/uriString" },
additionalProperties: {
type: "boolean"
}
},
$comment: {
type: "string"
},
$defs: {
type: "object",
additionalProperties: { $dynamicRef: "#meta" }
}
},
$defs: {
anchorString: {
type: "string",
pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
},
uriString: {
type: "string",
format: "uri"
},
uriReferenceString: {
type: "string",
format: "uri-reference"
}
}
};
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json
var require_format_annotation = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/format-annotation": true
},
$dynamicAnchor: "meta",
title: "Format vocabulary meta-schema for annotation results",
type: ["object", "boolean"],
properties: {
format: { type: "string" }
}
};
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json
var require_meta_data = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/meta-data",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/meta-data": true
},
$dynamicAnchor: "meta",
title: "Meta-data vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
title: {
type: "string"
},
description: {
type: "string"
},
default: true,
deprecated: {
type: "boolean",
default: false
},
readOnly: {
type: "boolean",
default: false
},
writeOnly: {
type: "boolean",
default: false
},
examples: {
type: "array",
items: true
}
}
};
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
var require_validation2 = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/validation",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/validation": true
},
$dynamicAnchor: "meta",
title: "Validation vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
type: {
anyOf: [
{ $ref: "#/$defs/simpleTypes" },
{
type: "array",
items: { $ref: "#/$defs/simpleTypes" },
minItems: 1,
uniqueItems: true
}
]
},
const: true,
enum: {
type: "array",
items: true
},
multipleOf: {
type: "number",
exclusiveMinimum: 0
},
maximum: {
type: "number"
},
exclusiveMaximum: {
type: "number"
},
minimum: {
type: "number"
},
exclusiveMinimum: {
type: "number"
},
maxLength: { $ref: "#/$defs/nonNegativeInteger" },
minLength: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
pattern: {
type: "string",
format: "regex"
},
maxItems: { $ref: "#/$defs/nonNegativeInteger" },
minItems: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
uniqueItems: {
type: "boolean",
default: false
},
maxContains: { $ref: "#/$defs/nonNegativeInteger" },
minContains: {
$ref: "#/$defs/nonNegativeInteger",
default: 1
},
maxProperties: { $ref: "#/$defs/nonNegativeInteger" },
minProperties: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
required: { $ref: "#/$defs/stringArray" },
dependentRequired: {
type: "object",
additionalProperties: {
$ref: "#/$defs/stringArray"
}
}
},
$defs: {
nonNegativeInteger: {
type: "integer",
minimum: 0
},
nonNegativeIntegerDefault0: {
$ref: "#/$defs/nonNegativeInteger",
default: 0
},
simpleTypes: {
enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
},
stringArray: {
type: "array",
items: { type: "string" },
uniqueItems: true,
default: []
}
}
};
}
});
// packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/index.js
var require_json_schema_2020_12 = __commonJS({
"packages/core/node_modules/ajv/dist/refs/json-schema-2020-12/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var metaSchema = require_schema();
var applicator = require_applicator2();
var unevaluated = require_unevaluated2();
var content = require_content();
var core = require_core3();
var format2 = require_format_annotation();
var metadata = require_meta_data();
var validation = require_validation2();
var META_SUPPORT_DATA = ["/properties"];
function addMetaSchema2020($data) {
;
[
metaSchema,
applicator,
unevaluated,
content,
core,
with$data(this, format2),
metadata,
with$data(this, validation)
].forEach((sch) => this.addMetaSchema(sch, void 0, false));
return this;
function with$data(ajv, sch) {
return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
}
}
exports.default = addMetaSchema2020;
}
});
// packages/core/node_modules/ajv/dist/2020.js
var require__ = __commonJS({
"packages/core/node_modules/ajv/dist/2020.js"(exports, module) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
var core_1 = require_core();
var draft2020_1 = require_draft2020();
var discriminator_1 = require_discriminator();
var json_schema_2020_12_1 = require_json_schema_2020_12();
var META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
var Ajv2020 = class extends core_1.default {
constructor(opts = {}) {
super({
...opts,
dynamicRef: true,
next: true,
unevaluated: true
});
}
_addVocabularies() {
super._addVocabularies();
draft2020_1.default.forEach((v) => this.addVocabulary(v));
if (this.opts.discriminator)
this.addKeyword(discriminator_1.default);
}
_addDefaultMetaSchema() {
super._addDefaultMetaSchema();
const { $data, meta } = this.opts;
if (!meta)
return;
json_schema_2020_12_1.default.call(this, $data);
this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
}
defaultMeta() {
return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
}
};
exports.Ajv2020 = Ajv2020;
module.exports = exports = Ajv2020;
module.exports.Ajv2020 = Ajv2020;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = Ajv2020;
var validate_1 = require_validate();
Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
return validate_1.KeywordCxt;
} });
var codegen_1 = require_codegen();
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
return codegen_1._;
} });
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
return codegen_1.str;
} });
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
return codegen_1.stringify;
} });
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
return codegen_1.nil;
} });
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
return codegen_1.Name;
} });
Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
return codegen_1.CodeGen;
} });
var validation_error_1 = require_validation_error();
Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
return validation_error_1.default;
} });
var ref_error_1 = require_ref_error();
Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
return ref_error_1.default;
} });
}
});
// node_modules/ajv-formats/dist/formats.js
var require_formats = __commonJS({
"node_modules/ajv-formats/dist/formats.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
function fmtDef(validate, compare) {
return { validate, compare };
}
exports.fullFormats = {
// date: http://tools.ietf.org/html/rfc3339#section-5.6
date: fmtDef(date, compareDate),
// date-time: http://tools.ietf.org/html/rfc3339#section-5.6
time: fmtDef(getTime(true), compareTime),
"date-time": fmtDef(getDateTime(true), compareDateTime),
"iso-time": fmtDef(getTime(), compareIsoTime),
"iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
// duration: https://tools.ietf.org/html/rfc3339#appendix-A
duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
uri,
"uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
// uri-template: https://tools.ietf.org/html/rfc6570
"uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
// For the source: https://gist.github.com/dperini/729294
// For test cases: https://mathiasbynens.be/demo/url-regex
url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
// optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
regex,
// uuid: http://tools.ietf.org/html/rfc4122
uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
// JSON-pointer: https://tools.ietf.org/html/rfc6901
// uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
"json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
"json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
// relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00
"relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
// the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types
// byte: https://github.com/miguelmota/is-base64
byte,
// signed 32 bit integer
int32: { type: "number", validate: validateInt32 },
// signed 64 bit integer
int64: { type: "number", validate: validateInt64 },
// C-type float
float: { type: "number", validate: validateNumber },
// C-type double
double: { type: "number", validate: validateNumber },
// hint to the UI to hide input strings
password: true,
// unchecked string payload
binary: true
};
exports.fastFormats = {
...exports.fullFormats,
date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime),
"date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime),
"iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime),
"iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime),
// uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js
uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
"uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
// email (sources from jsen validator):
// http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363
// http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'wilful violation')
email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
};
exports.formatNames = Object.keys(exports.fullFormats);
function isLeapYear(year) {
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
}
var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
function date(str) {
const matches = DATE.exec(str);
if (!matches)
return false;
const year = +matches[1];
const month = +matches[2];
const day = +matches[3];
return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
}
function compareDate(d1, d2) {
if (!(d1 && d2))
return void 0;
if (d1 > d2)
return 1;
if (d1 < d2)
return -1;
return 0;
}
var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
function getTime(strictTimeZone) {
return function time(str) {
const matches = TIME.exec(str);
if (!matches)
return false;
const hr = +matches[1];
const min = +matches[2];
const sec = +matches[3];
const tz = matches[4];
const tzSign = matches[5] === "-" ? -1 : 1;
const tzH = +(matches[6] || 0);
const tzM = +(matches[7] || 0);
if (tzH > 23 || tzM > 59 || strictTimeZone && !tz)
return false;
if (hr <= 23 && min <= 59 && sec < 60)
return true;
const utcMin = min - tzM * tzSign;
const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
};
}
function compareTime(s1, s2) {
if (!(s1 && s2))
return void 0;
const t1 = (/* @__PURE__ */ new Date("2020-01-01T" + s1)).valueOf();
const t2 = (/* @__PURE__ */ new Date("2020-01-01T" + s2)).valueOf();
if (!(t1 && t2))
return void 0;
return t1 - t2;
}
function compareIsoTime(t1, t2) {
if (!(t1 && t2))
return void 0;
const a1 = TIME.exec(t1);
const a2 = TIME.exec(t2);
if (!(a1 && a2))
return void 0;
t1 = a1[1] + a1[2] + a1[3];
t2 = a2[1] + a2[2] + a2[3];
if (t1 > t2)
return 1;
if (t1 < t2)
return -1;
return 0;
}
var DATE_TIME_SEPARATOR = /t|\s/i;
function getDateTime(strictTimeZone) {
const time = getTime(strictTimeZone);
return function date_time(str) {
const dateTime = str.split(DATE_TIME_SEPARATOR);
return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1]);
};
}
function compareDateTime(dt1, dt2) {
if (!(dt1 && dt2))
return void 0;
const d1 = new Date(dt1).valueOf();
const d2 = new Date(dt2).valueOf();
if (!(d1 && d2))
return void 0;
return d1 - d2;
}
function compareIsoDateTime(dt1, dt2) {
if (!(dt1 && dt2))
return void 0;
const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
const res = compareDate(d1, d2);
if (res === void 0)
return void 0;
return res || compareTime(t1, t2);
}
var NOT_URI_FRAGMENT = /\/|:/;
var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
function uri(str) {
return NOT_URI_FRAGMENT.test(str) && URI.test(str);
}
var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
function byte(str) {
BYTE.lastIndex = 0;
return BYTE.test(str);
}
var MIN_INT32 = -(2 ** 31);
var MAX_INT32 = 2 ** 31 - 1;
function validateInt32(value) {
return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
}
function validateInt64(value) {
return Number.isInteger(value);
}
function validateNumber() {
return true;
}
var Z_ANCHOR = /[^\\]\\Z/;
function regex(str) {
if (Z_ANCHOR.test(str))
return false;
try {
new RegExp(str);
return true;
} catch (e) {
return false;
}
}
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/codegen/code.js
var require_code3 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/codegen/code.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
var _CodeOrName = class {
};
exports._CodeOrName = _CodeOrName;
exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
var Name = class extends _CodeOrName {
constructor(s) {
super();
if (!exports.IDENTIFIER.test(s))
throw new Error("CodeGen: name must be a valid identifier");
this.str = s;
}
toString() {
return this.str;
}
emptyStr() {
return false;
}
get names() {
return { [this.str]: 1 };
}
};
exports.Name = Name;
var _Code = class extends _CodeOrName {
constructor(code) {
super();
this._items = typeof code === "string" ? [code] : code;
}
toString() {
return this.str;
}
emptyStr() {
if (this._items.length > 1)
return false;
const item = this._items[0];
return item === "" || item === '""';
}
get str() {
var _a;
return (_a = this._str) !== null && _a !== void 0 ? _a : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
}
get names() {
var _a;
return (_a = this._names) !== null && _a !== void 0 ? _a : this._names = this._items.reduce((names, c) => {
if (c instanceof Name)
names[c.str] = (names[c.str] || 0) + 1;
return names;
}, {});
}
};
exports._Code = _Code;
exports.nil = new _Code("");
function _(strs, ...args) {
const code = [strs[0]];
let i = 0;
while (i < args.length) {
addCodeArg(code, args[i]);
code.push(strs[++i]);
}
return new _Code(code);
}
exports._ = _;
var plus = new _Code("+");
function str(strs, ...args) {
const expr = [safeStringify(strs[0])];
let i = 0;
while (i < args.length) {
expr.push(plus);
addCodeArg(expr, args[i]);
expr.push(plus, safeStringify(strs[++i]));
}
optimize(expr);
return new _Code(expr);
}
exports.str = str;
function addCodeArg(code, arg) {
if (arg instanceof _Code)
code.push(...arg._items);
else if (arg instanceof Name)
code.push(arg);
else
code.push(interpolate(arg));
}
exports.addCodeArg = addCodeArg;
function optimize(expr) {
let i = 1;
while (i < expr.length - 1) {
if (expr[i] === plus) {
const res = mergeExprItems(expr[i - 1], expr[i + 1]);
if (res !== void 0) {
expr.splice(i - 1, 3, res);
continue;
}
expr[i++] = "+";
}
i++;
}
}
function mergeExprItems(a, b) {
if (b === '""')
return a;
if (a === '""')
return b;
if (typeof a == "string") {
if (b instanceof Name || a[a.length - 1] !== '"')
return;
if (typeof b != "string")
return `${a.slice(0, -1)}${b}"`;
if (b[0] === '"')
return a.slice(0, -1) + b.slice(1);
return;
}
if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
return `"${a}${b.slice(1)}`;
return;
}
function strConcat(c1, c2) {
return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
}
exports.strConcat = strConcat;
function interpolate(x) {
return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
}
function stringify(x) {
return new _Code(safeStringify(x));
}
exports.stringify = stringify;
function safeStringify(x) {
return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
}
exports.safeStringify = safeStringify;
function getProperty(key) {
return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
}
exports.getProperty = getProperty;
function getEsmExportName(key) {
if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
return new _Code(`${key}`);
}
throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
}
exports.getEsmExportName = getEsmExportName;
function regexpCode(rx) {
return new _Code(rx.toString());
}
exports.regexpCode = regexpCode;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/codegen/scope.js
var require_scope2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/codegen/scope.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
var code_1 = require_code3();
var ValueError = class extends Error {
constructor(name) {
super(`CodeGen: "code" for ${name} not defined`);
this.value = name.value;
}
};
var UsedValueState;
(function(UsedValueState2) {
UsedValueState2[UsedValueState2["Started"] = 0] = "Started";
UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed";
})(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
exports.varKinds = {
const: new code_1.Name("const"),
let: new code_1.Name("let"),
var: new code_1.Name("var")
};
var Scope = class {
constructor({ prefixes, parent } = {}) {
this._names = {};
this._prefixes = prefixes;
this._parent = parent;
}
toName(nameOrPrefix) {
return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
}
name(prefix) {
return new code_1.Name(this._newName(prefix));
}
_newName(prefix) {
const ng = this._names[prefix] || this._nameGroup(prefix);
return `${prefix}${ng.index++}`;
}
_nameGroup(prefix) {
var _a, _b;
if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) {
throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
}
return this._names[prefix] = { prefix, index: 0 };
}
};
exports.Scope = Scope;
var ValueScopeName = class extends code_1.Name {
constructor(prefix, nameStr) {
super(nameStr);
this.prefix = prefix;
}
setValue(value, { property, itemIndex }) {
this.value = value;
this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
}
};
exports.ValueScopeName = ValueScopeName;
var line = (0, code_1._)`\n`;
var ValueScope = class extends Scope {
constructor(opts) {
super(opts);
this._values = {};
this._scope = opts.scope;
this.opts = { ...opts, _n: opts.lines ? line : code_1.nil };
}
get() {
return this._scope;
}
name(prefix) {
return new ValueScopeName(prefix, this._newName(prefix));
}
value(nameOrPrefix, value) {
var _a;
if (value.ref === void 0)
throw new Error("CodeGen: ref must be passed in value");
const name = this.toName(nameOrPrefix);
const { prefix } = name;
const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
let vs = this._values[prefix];
if (vs) {
const _name = vs.get(valueKey);
if (_name)
return _name;
} else {
vs = this._values[prefix] = /* @__PURE__ */ new Map();
}
vs.set(valueKey, name);
const s = this._scope[prefix] || (this._scope[prefix] = []);
const itemIndex = s.length;
s[itemIndex] = value.ref;
name.setValue(value, { property: prefix, itemIndex });
return name;
}
getValue(prefix, keyOrRef) {
const vs = this._values[prefix];
if (!vs)
return;
return vs.get(keyOrRef);
}
scopeRefs(scopeName, values = this._values) {
return this._reduceValues(values, (name) => {
if (name.scopePath === void 0)
throw new Error(`CodeGen: name "${name}" has no value`);
return (0, code_1._)`${scopeName}${name.scopePath}`;
});
}
scopeCode(values = this._values, usedValues, getCode) {
return this._reduceValues(values, (name) => {
if (name.value === void 0)
throw new Error(`CodeGen: name "${name}" has no value`);
return name.value.code;
}, usedValues, getCode);
}
_reduceValues(values, valueCode, usedValues = {}, getCode) {
let code = code_1.nil;
for (const prefix in values) {
const vs = values[prefix];
if (!vs)
continue;
const nameSet = usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map();
vs.forEach((name) => {
if (nameSet.has(name))
return;
nameSet.set(name, UsedValueState.Started);
let c = valueCode(name);
if (c) {
const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
} else if (c = getCode === null || getCode === void 0 ? void 0 : getCode(name)) {
code = (0, code_1._)`${code}${c}${this.opts._n}`;
} else {
throw new ValueError(name);
}
nameSet.set(name, UsedValueState.Completed);
});
}
return code;
}
};
exports.ValueScope = ValueScope;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/codegen/index.js
var require_codegen2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/codegen/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
var code_1 = require_code3();
var scope_1 = require_scope2();
var code_2 = require_code3();
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
return code_2._;
} });
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
return code_2.str;
} });
Object.defineProperty(exports, "strConcat", { enumerable: true, get: function() {
return code_2.strConcat;
} });
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
return code_2.nil;
} });
Object.defineProperty(exports, "getProperty", { enumerable: true, get: function() {
return code_2.getProperty;
} });
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
return code_2.stringify;
} });
Object.defineProperty(exports, "regexpCode", { enumerable: true, get: function() {
return code_2.regexpCode;
} });
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
return code_2.Name;
} });
var scope_2 = require_scope2();
Object.defineProperty(exports, "Scope", { enumerable: true, get: function() {
return scope_2.Scope;
} });
Object.defineProperty(exports, "ValueScope", { enumerable: true, get: function() {
return scope_2.ValueScope;
} });
Object.defineProperty(exports, "ValueScopeName", { enumerable: true, get: function() {
return scope_2.ValueScopeName;
} });
Object.defineProperty(exports, "varKinds", { enumerable: true, get: function() {
return scope_2.varKinds;
} });
exports.operators = {
GT: new code_1._Code(">"),
GTE: new code_1._Code(">="),
LT: new code_1._Code("<"),
LTE: new code_1._Code("<="),
EQ: new code_1._Code("==="),
NEQ: new code_1._Code("!=="),
NOT: new code_1._Code("!"),
OR: new code_1._Code("||"),
AND: new code_1._Code("&&"),
ADD: new code_1._Code("+")
};
var Node = class {
optimizeNodes() {
return this;
}
optimizeNames(_names, _constants) {
return this;
}
};
var Def = class extends Node {
constructor(varKind, name, rhs) {
super();
this.varKind = varKind;
this.name = name;
this.rhs = rhs;
}
render({ es5, _n }) {
const varKind = es5 ? scope_1.varKinds.var : this.varKind;
const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
return `${varKind} ${this.name}${rhs};` + _n;
}
optimizeNames(names, constants2) {
if (!names[this.name.str])
return;
if (this.rhs)
this.rhs = optimizeExpr(this.rhs, names, constants2);
return this;
}
get names() {
return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
}
};
var Assign = class extends Node {
constructor(lhs, rhs, sideEffects) {
super();
this.lhs = lhs;
this.rhs = rhs;
this.sideEffects = sideEffects;
}
render({ _n }) {
return `${this.lhs} = ${this.rhs};` + _n;
}
optimizeNames(names, constants2) {
if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
return;
this.rhs = optimizeExpr(this.rhs, names, constants2);
return this;
}
get names() {
const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };
return addExprNames(names, this.rhs);
}
};
var AssignOp = class extends Assign {
constructor(lhs, op, rhs, sideEffects) {
super(lhs, rhs, sideEffects);
this.op = op;
}
render({ _n }) {
return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
}
};
var Label = class extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
return `${this.label}:` + _n;
}
};
var Break = class extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
const label = this.label ? ` ${this.label}` : "";
return `break${label};` + _n;
}
};
var Throw = class extends Node {
constructor(error) {
super();
this.error = error;
}
render({ _n }) {
return `throw ${this.error};` + _n;
}
get names() {
return this.error.names;
}
};
var AnyCode = class extends Node {
constructor(code) {
super();
this.code = code;
}
render({ _n }) {
return `${this.code};` + _n;
}
optimizeNodes() {
return `${this.code}` ? this : void 0;
}
optimizeNames(names, constants2) {
this.code = optimizeExpr(this.code, names, constants2);
return this;
}
get names() {
return this.code instanceof code_1._CodeOrName ? this.code.names : {};
}
};
var ParentNode = class extends Node {
constructor(nodes = []) {
super();
this.nodes = nodes;
}
render(opts) {
return this.nodes.reduce((code, n) => code + n.render(opts), "");
}
optimizeNodes() {
const { nodes } = this;
let i = nodes.length;
while (i--) {
const n = nodes[i].optimizeNodes();
if (Array.isArray(n))
nodes.splice(i, 1, ...n);
else if (n)
nodes[i] = n;
else
nodes.splice(i, 1);
}
return nodes.length > 0 ? this : void 0;
}
optimizeNames(names, constants2) {
const { nodes } = this;
let i = nodes.length;
while (i--) {
const n = nodes[i];
if (n.optimizeNames(names, constants2))
continue;
subtractNames(names, n.names);
nodes.splice(i, 1);
}
return nodes.length > 0 ? this : void 0;
}
get names() {
return this.nodes.reduce((names, n) => addNames(names, n.names), {});
}
};
var BlockNode = class extends ParentNode {
render(opts) {
return "{" + opts._n + super.render(opts) + "}" + opts._n;
}
};
var Root = class extends ParentNode {
};
var Else = class extends BlockNode {
};
Else.kind = "else";
var If = class _If extends BlockNode {
constructor(condition, nodes) {
super(nodes);
this.condition = condition;
}
render(opts) {
let code = `if(${this.condition})` + super.render(opts);
if (this.else)
code += "else " + this.else.render(opts);
return code;
}
optimizeNodes() {
super.optimizeNodes();
const cond = this.condition;
if (cond === true)
return this.nodes;
let e = this.else;
if (e) {
const ns = e.optimizeNodes();
e = this.else = Array.isArray(ns) ? new Else(ns) : ns;
}
if (e) {
if (cond === false)
return e instanceof _If ? e : e.nodes;
if (this.nodes.length)
return this;
return new _If(not(cond), e instanceof _If ? [e] : e.nodes);
}
if (cond === false || !this.nodes.length)
return void 0;
return this;
}
optimizeNames(names, constants2) {
var _a;
this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants2);
if (!(super.optimizeNames(names, constants2) || this.else))
return;
this.condition = optimizeExpr(this.condition, names, constants2);
return this;
}
get names() {
const names = super.names;
addExprNames(names, this.condition);
if (this.else)
addNames(names, this.else.names);
return names;
}
};
If.kind = "if";
var For = class extends BlockNode {
};
For.kind = "for";
var ForLoop = class extends For {
constructor(iteration) {
super();
this.iteration = iteration;
}
render(opts) {
return `for(${this.iteration})` + super.render(opts);
}
optimizeNames(names, constants2) {
if (!super.optimizeNames(names, constants2))
return;
this.iteration = optimizeExpr(this.iteration, names, constants2);
return this;
}
get names() {
return addNames(super.names, this.iteration.names);
}
};
var ForRange = class extends For {
constructor(varKind, name, from, to) {
super();
this.varKind = varKind;
this.name = name;
this.from = from;
this.to = to;
}
render(opts) {
const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;
const { name, from, to } = this;
return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);
}
get names() {
const names = addExprNames(super.names, this.from);
return addExprNames(names, this.to);
}
};
var ForIter = class extends For {
constructor(loop, varKind, name, iterable) {
super();
this.loop = loop;
this.varKind = varKind;
this.name = name;
this.iterable = iterable;
}
render(opts) {
return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
}
optimizeNames(names, constants2) {
if (!super.optimizeNames(names, constants2))
return;
this.iterable = optimizeExpr(this.iterable, names, constants2);
return this;
}
get names() {
return addNames(super.names, this.iterable.names);
}
};
var Func = class extends BlockNode {
constructor(name, args, async) {
super();
this.name = name;
this.args = args;
this.async = async;
}
render(opts) {
const _async = this.async ? "async " : "";
return `${_async}function ${this.name}(${this.args})` + super.render(opts);
}
};
Func.kind = "func";
var Return = class extends ParentNode {
render(opts) {
return "return " + super.render(opts);
}
};
Return.kind = "return";
var Try = class extends BlockNode {
render(opts) {
let code = "try" + super.render(opts);
if (this.catch)
code += this.catch.render(opts);
if (this.finally)
code += this.finally.render(opts);
return code;
}
optimizeNodes() {
var _a, _b;
super.optimizeNodes();
(_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes();
(_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
return this;
}
optimizeNames(names, constants2) {
var _a, _b;
super.optimizeNames(names, constants2);
(_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants2);
(_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants2);
return this;
}
get names() {
const names = super.names;
if (this.catch)
addNames(names, this.catch.names);
if (this.finally)
addNames(names, this.finally.names);
return names;
}
};
var Catch = class extends BlockNode {
constructor(error) {
super();
this.error = error;
}
render(opts) {
return `catch(${this.error})` + super.render(opts);
}
};
Catch.kind = "catch";
var Finally = class extends BlockNode {
render(opts) {
return "finally" + super.render(opts);
}
};
Finally.kind = "finally";
var CodeGen = class {
constructor(extScope, opts = {}) {
this._values = {};
this._blockStarts = [];
this._constants = {};
this.opts = { ...opts, _n: opts.lines ? "\n" : "" };
this._extScope = extScope;
this._scope = new scope_1.Scope({ parent: extScope });
this._nodes = [new Root()];
}
toString() {
return this._root.render(this.opts);
}
// returns unique name in the internal scope
name(prefix) {
return this._scope.name(prefix);
}
// reserves unique name in the external scope
scopeName(prefix) {
return this._extScope.name(prefix);
}
// reserves unique name in the external scope and assigns value to it
scopeValue(prefixOrName, value) {
const name = this._extScope.value(prefixOrName, value);
const vs = this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set());
vs.add(name);
return name;
}
getScopeValue(prefix, keyOrRef) {
return this._extScope.getValue(prefix, keyOrRef);
}
// return code that assigns values in the external scope to the names that are used internally
// (same names that were returned by gen.scopeName or gen.scopeValue)
scopeRefs(scopeName) {
return this._extScope.scopeRefs(scopeName, this._values);
}
scopeCode() {
return this._extScope.scopeCode(this._values);
}
_def(varKind, nameOrPrefix, rhs, constant) {
const name = this._scope.toName(nameOrPrefix);
if (rhs !== void 0 && constant)
this._constants[name.str] = rhs;
this._leafNode(new Def(varKind, name, rhs));
return name;
}
// `const` declaration (`var` in es5 mode)
const(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
}
// `let` declaration with optional assignment (`var` in es5 mode)
let(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
}
// `var` declaration with optional assignment
var(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
}
// assignment code
assign(lhs, rhs, sideEffects) {
return this._leafNode(new Assign(lhs, rhs, sideEffects));
}
// `+=` code
add(lhs, rhs) {
return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
}
// appends passed SafeExpr to code or executes Block
code(c) {
if (typeof c == "function")
c();
else if (c !== code_1.nil)
this._leafNode(new AnyCode(c));
return this;
}
// returns code for object literal for the passed argument list of key-value pairs
object(...keyValues) {
const code = ["{"];
for (const [key, value] of keyValues) {
if (code.length > 1)
code.push(",");
code.push(key);
if (key !== value || this.opts.es5) {
code.push(":");
(0, code_1.addCodeArg)(code, value);
}
}
code.push("}");
return new code_1._Code(code);
}
// `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
if(condition, thenBody, elseBody) {
this._blockNode(new If(condition));
if (thenBody && elseBody) {
this.code(thenBody).else().code(elseBody).endIf();
} else if (thenBody) {
this.code(thenBody).endIf();
} else if (elseBody) {
throw new Error('CodeGen: "else" body without "then" body');
}
return this;
}
// `else if` clause - invalid without `if` or after `else` clauses
elseIf(condition) {
return this._elseNode(new If(condition));
}
// `else` clause - only valid after `if` or `else if` clauses
else() {
return this._elseNode(new Else());
}
// end `if` statement (needed if gen.if was used only with condition)
endIf() {
return this._endBlockNode(If, Else);
}
_for(node, forBody) {
this._blockNode(node);
if (forBody)
this.code(forBody).endFor();
return this;
}
// a generic `for` clause (or statement if `forBody` is passed)
for(iteration, forBody) {
return this._for(new ForLoop(iteration), forBody);
}
// `for` statement for a range of values
forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {
const name = this._scope.toName(nameOrPrefix);
return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
}
// `for-of` statement (in es5 mode replace with a normal for loop)
forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
const name = this._scope.toName(nameOrPrefix);
if (this.opts.es5) {
const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => {
this.var(name, (0, code_1._)`${arr}[${i}]`);
forBody(name);
});
}
return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
}
// `for-in` statement.
// With option `ownProperties` replaced with a `for-of` loop for object keys
forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {
if (this.opts.ownProperties) {
return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody);
}
const name = this._scope.toName(nameOrPrefix);
return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
}
// end `for` loop
endFor() {
return this._endBlockNode(For);
}
// `label` statement
label(label) {
return this._leafNode(new Label(label));
}
// `break` statement
break(label) {
return this._leafNode(new Break(label));
}
// `return` statement
return(value) {
const node = new Return();
this._blockNode(node);
this.code(value);
if (node.nodes.length !== 1)
throw new Error('CodeGen: "return" should have one node');
return this._endBlockNode(Return);
}
// `try` statement
try(tryBody, catchCode, finallyCode) {
if (!catchCode && !finallyCode)
throw new Error('CodeGen: "try" without "catch" and "finally"');
const node = new Try();
this._blockNode(node);
this.code(tryBody);
if (catchCode) {
const error = this.name("e");
this._currNode = node.catch = new Catch(error);
catchCode(error);
}
if (finallyCode) {
this._currNode = node.finally = new Finally();
this.code(finallyCode);
}
return this._endBlockNode(Catch, Finally);
}
// `throw` statement
throw(error) {
return this._leafNode(new Throw(error));
}
// start self-balancing block
block(body, nodeCount) {
this._blockStarts.push(this._nodes.length);
if (body)
this.code(body).endBlock(nodeCount);
return this;
}
// end the current self-balancing block
endBlock(nodeCount) {
const len = this._blockStarts.pop();
if (len === void 0)
throw new Error("CodeGen: not in self-balancing block");
const toClose = this._nodes.length - len;
if (toClose < 0 || nodeCount !== void 0 && toClose !== nodeCount) {
throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
}
this._nodes.length = len;
return this;
}
// `function` heading (or definition if funcBody is passed)
func(name, args = code_1.nil, async, funcBody) {
this._blockNode(new Func(name, args, async));
if (funcBody)
this.code(funcBody).endFunc();
return this;
}
// end function definition
endFunc() {
return this._endBlockNode(Func);
}
optimize(n = 1) {
while (n-- > 0) {
this._root.optimizeNodes();
this._root.optimizeNames(this._root.names, this._constants);
}
}
_leafNode(node) {
this._currNode.nodes.push(node);
return this;
}
_blockNode(node) {
this._currNode.nodes.push(node);
this._nodes.push(node);
}
_endBlockNode(N1, N2) {
const n = this._currNode;
if (n instanceof N1 || N2 && n instanceof N2) {
this._nodes.pop();
return this;
}
throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
}
_elseNode(node) {
const n = this._currNode;
if (!(n instanceof If)) {
throw new Error('CodeGen: "else" without "if"');
}
this._currNode = n.else = node;
return this;
}
get _root() {
return this._nodes[0];
}
get _currNode() {
const ns = this._nodes;
return ns[ns.length - 1];
}
set _currNode(node) {
const ns = this._nodes;
ns[ns.length - 1] = node;
}
};
exports.CodeGen = CodeGen;
function addNames(names, from) {
for (const n in from)
names[n] = (names[n] || 0) + (from[n] || 0);
return names;
}
function addExprNames(names, from) {
return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
}
function optimizeExpr(expr, names, constants2) {
if (expr instanceof code_1.Name)
return replaceName(expr);
if (!canOptimize(expr))
return expr;
return new code_1._Code(expr._items.reduce((items, c) => {
if (c instanceof code_1.Name)
c = replaceName(c);
if (c instanceof code_1._Code)
items.push(...c._items);
else
items.push(c);
return items;
}, []));
function replaceName(n) {
const c = constants2[n.str];
if (c === void 0 || names[n.str] !== 1)
return n;
delete names[n.str];
return c;
}
function canOptimize(e) {
return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants2[c.str] !== void 0);
}
}
function subtractNames(names, from) {
for (const n in from)
names[n] = (names[n] || 0) - (from[n] || 0);
}
function not(x) {
return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._)`!${par(x)}`;
}
exports.not = not;
var andCode = mappend(exports.operators.AND);
function and(...args) {
return args.reduce(andCode);
}
exports.and = and;
var orCode = mappend(exports.operators.OR);
function or(...args) {
return args.reduce(orCode);
}
exports.or = or;
function mappend(op) {
return (x, y) => x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
}
function par(x) {
return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`;
}
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/util.js
var require_util2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/util.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
var codegen_1 = require_codegen2();
var code_1 = require_code3();
function toHash(arr) {
const hash = {};
for (const item of arr)
hash[item] = true;
return hash;
}
exports.toHash = toHash;
function alwaysValidSchema(it, schema) {
if (typeof schema == "boolean")
return schema;
if (Object.keys(schema).length === 0)
return true;
checkUnknownRules(it, schema);
return !schemaHasRules(schema, it.self.RULES.all);
}
exports.alwaysValidSchema = alwaysValidSchema;
function checkUnknownRules(it, schema = it.schema) {
const { opts, self: self2 } = it;
if (!opts.strictSchema)
return;
if (typeof schema === "boolean")
return;
const rules = self2.RULES.keywords;
for (const key in schema) {
if (!rules[key])
checkStrictMode(it, `unknown keyword: "${key}"`);
}
}
exports.checkUnknownRules = checkUnknownRules;
function schemaHasRules(schema, rules) {
if (typeof schema == "boolean")
return !schema;
for (const key in schema)
if (rules[key])
return true;
return false;
}
exports.schemaHasRules = schemaHasRules;
function schemaHasRulesButRef(schema, RULES) {
if (typeof schema == "boolean")
return !schema;
for (const key in schema)
if (key !== "$ref" && RULES.all[key])
return true;
return false;
}
exports.schemaHasRulesButRef = schemaHasRulesButRef;
function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
if (!$data) {
if (typeof schema == "number" || typeof schema == "boolean")
return schema;
if (typeof schema == "string")
return (0, codegen_1._)`${schema}`;
}
return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
}
exports.schemaRefOrVal = schemaRefOrVal;
function unescapeFragment(str) {
return unescapeJsonPointer(decodeURIComponent(str));
}
exports.unescapeFragment = unescapeFragment;
function escapeFragment(str) {
return encodeURIComponent(escapeJsonPointer(str));
}
exports.escapeFragment = escapeFragment;
function escapeJsonPointer(str) {
if (typeof str == "number")
return `${str}`;
return str.replace(/~/g, "~0").replace(/\//g, "~1");
}
exports.escapeJsonPointer = escapeJsonPointer;
function unescapeJsonPointer(str) {
return str.replace(/~1/g, "/").replace(/~0/g, "~");
}
exports.unescapeJsonPointer = unescapeJsonPointer;
function eachItem(xs, f) {
if (Array.isArray(xs)) {
for (const x of xs)
f(x);
} else {
f(xs);
}
}
exports.eachItem = eachItem;
function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues2, resultToName }) {
return (gen, from, to, toName) => {
const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues2(from, to);
return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
};
}
exports.mergeEvaluated = {
props: makeMergeEvaluated({
mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => {
gen.if((0, codegen_1._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._)`${to} || {}`).code((0, codegen_1._)`Object.assign(${to}, ${from})`));
}),
mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => {
if (from === true) {
gen.assign(to, true);
} else {
gen.assign(to, (0, codegen_1._)`${to} || {}`);
setEvaluated(gen, to, from);
}
}),
mergeValues: (from, to) => from === true ? true : { ...from, ...to },
resultToName: evaluatedPropsToName
}),
items: makeMergeEvaluated({
mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)),
mergeValues: (from, to) => from === true ? true : Math.max(from, to),
resultToName: (gen, items) => gen.var("items", items)
})
};
function evaluatedPropsToName(gen, ps) {
if (ps === true)
return gen.var("props", true);
const props = gen.var("props", (0, codegen_1._)`{}`);
if (ps !== void 0)
setEvaluated(gen, props, ps);
return props;
}
exports.evaluatedPropsToName = evaluatedPropsToName;
function setEvaluated(gen, props, ps) {
Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true));
}
exports.setEvaluated = setEvaluated;
var snippets = {};
function useFunc(gen, f) {
return gen.scopeValue("func", {
ref: f,
code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code))
});
}
exports.useFunc = useFunc;
var Type2;
(function(Type3) {
Type3[Type3["Num"] = 0] = "Num";
Type3[Type3["Str"] = 1] = "Str";
})(Type2 || (exports.Type = Type2 = {}));
function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
if (dataProp instanceof codegen_1.Name) {
const isNumber = dataPropType === Type2.Num;
return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
}
return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
}
exports.getErrorPath = getErrorPath;
function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
if (!mode)
return;
msg = `strict mode: ${msg}`;
if (mode === true)
throw new Error(msg);
it.self.logger.warn(msg);
}
exports.checkStrictMode = checkStrictMode;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/names.js
var require_names2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/names.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var names = {
// validation function arguments
data: new codegen_1.Name("data"),
// data passed to validation function
// args passed from referencing schema
valCxt: new codegen_1.Name("valCxt"),
// validation/data context - should not be used directly, it is destructured to the names below
instancePath: new codegen_1.Name("instancePath"),
parentData: new codegen_1.Name("parentData"),
parentDataProperty: new codegen_1.Name("parentDataProperty"),
rootData: new codegen_1.Name("rootData"),
// root data - same as the data passed to the first/top validation function
dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
// used to support recursiveRef and dynamicRef
// function scoped variables
vErrors: new codegen_1.Name("vErrors"),
// null or array of validation errors
errors: new codegen_1.Name("errors"),
// counter of validation errors
this: new codegen_1.Name("this"),
// "globals"
self: new codegen_1.Name("self"),
scope: new codegen_1.Name("scope"),
// JTD serialize/parse name for JSON string and position
json: new codegen_1.Name("json"),
jsonPos: new codegen_1.Name("jsonPos"),
jsonLen: new codegen_1.Name("jsonLen"),
jsonPart: new codegen_1.Name("jsonPart")
};
exports.default = names;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/errors.js
var require_errors2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/errors.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var names_1 = require_names2();
exports.keywordError = {
message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation`
};
exports.keyword$DataError = {
message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)`
};
function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
const errObj = errorObjectCode(cxt, error, errorPaths);
if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule || allErrors) {
addError(gen, errObj);
} else {
returnErrors(it, (0, codegen_1._)`[${errObj}]`);
}
}
exports.reportError = reportError;
function reportExtraError(cxt, error = exports.keywordError, errorPaths) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
const errObj = errorObjectCode(cxt, error, errorPaths);
addError(gen, errObj);
if (!(compositeRule || allErrors)) {
returnErrors(it, names_1.default.vErrors);
}
}
exports.reportExtraError = reportExtraError;
function resetErrorsCount(gen, errsCount) {
gen.assign(names_1.default.errors, errsCount);
gen.if((0, codegen_1._)`${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._)`${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null)));
}
exports.resetErrorsCount = resetErrorsCount;
function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
if (errsCount === void 0)
throw new Error("ajv implementation error");
const err = gen.name("err");
gen.forRange("i", errsCount, names_1.default.errors, (i) => {
gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
if (it.opts.verbose) {
gen.assign((0, codegen_1._)`${err}.schema`, schemaValue);
gen.assign((0, codegen_1._)`${err}.data`, data);
}
});
}
exports.extendErrors = extendErrors;
function addError(gen, errObj) {
const err = gen.const("err", errObj);
gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`);
gen.code((0, codegen_1._)`${names_1.default.errors}++`);
}
function returnErrors(it, errs) {
const { gen, validateName, schemaEnv } = it;
if (schemaEnv.$async) {
gen.throw((0, codegen_1._)`new ${it.ValidationError}(${errs})`);
} else {
gen.assign((0, codegen_1._)`${validateName}.errors`, errs);
gen.return(false);
}
}
var E = {
keyword: new codegen_1.Name("keyword"),
schemaPath: new codegen_1.Name("schemaPath"),
// also used in JTD errors
params: new codegen_1.Name("params"),
propertyName: new codegen_1.Name("propertyName"),
message: new codegen_1.Name("message"),
schema: new codegen_1.Name("schema"),
parentSchema: new codegen_1.Name("parentSchema")
};
function errorObjectCode(cxt, error, errorPaths) {
const { createErrors } = cxt.it;
if (createErrors === false)
return (0, codegen_1._)`{}`;
return errorObject(cxt, error, errorPaths);
}
function errorObject(cxt, error, errorPaths = {}) {
const { gen, it } = cxt;
const keyValues = [
errorInstancePath(it, errorPaths),
errorSchemaPath(cxt, errorPaths)
];
extraErrorProps(cxt, error, keyValues);
return gen.object(...keyValues);
}
function errorInstancePath({ errorPath }, { instancePath }) {
const instPath = instancePath ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : errorPath;
return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];
}
function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
if (schemaPath) {
schPath = (0, codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
}
return [E.schemaPath, schPath];
}
function extraErrorProps(cxt, { params, message }, keyValues) {
const { keyword, data, schemaValue, it } = cxt;
const { opts, propertyName, topSchemaRef, schemaPath } = it;
keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._)`{}`]);
if (opts.messages) {
keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
}
if (opts.verbose) {
keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);
}
if (propertyName)
keyValues.push([E.propertyName, propertyName]);
}
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/boolSchema.js
var require_boolSchema2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/boolSchema.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
var errors_1 = require_errors2();
var codegen_1 = require_codegen2();
var names_1 = require_names2();
var boolError = {
message: "boolean schema is false"
};
function topBoolOrEmptySchema(it) {
const { gen, schema, validateName } = it;
if (schema === false) {
falseSchemaError(it, false);
} else if (typeof schema == "object" && schema.$async === true) {
gen.return(names_1.default.data);
} else {
gen.assign((0, codegen_1._)`${validateName}.errors`, null);
gen.return(true);
}
}
exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
function boolOrEmptySchema(it, valid) {
const { gen, schema } = it;
if (schema === false) {
gen.var(valid, false);
falseSchemaError(it);
} else {
gen.var(valid, true);
}
}
exports.boolOrEmptySchema = boolOrEmptySchema;
function falseSchemaError(it, overrideAllErrors) {
const { gen, data } = it;
const cxt = {
gen,
keyword: "false schema",
data,
schema: false,
schemaCode: false,
schemaValue: false,
params: {},
it
};
(0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors);
}
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/rules.js
var require_rules2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/rules.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getRules = exports.isJSONType = void 0;
var _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"];
var jsonTypes = new Set(_jsonTypes);
function isJSONType(x) {
return typeof x == "string" && jsonTypes.has(x);
}
exports.isJSONType = isJSONType;
function getRules() {
const groups = {
number: { type: "number", rules: [] },
string: { type: "string", rules: [] },
array: { type: "array", rules: [] },
object: { type: "object", rules: [] }
};
return {
types: { ...groups, integer: true, boolean: true, null: true },
rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object],
post: { rules: [] },
all: {},
keywords: {}
};
}
exports.getRules = getRules;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/applicability.js
var require_applicability2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/applicability.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
function schemaHasRulesForType({ schema, self: self2 }, type) {
const group = self2.RULES.types[type];
return group && group !== true && shouldUseGroup(schema, group);
}
exports.schemaHasRulesForType = schemaHasRulesForType;
function shouldUseGroup(schema, group) {
return group.rules.some((rule) => shouldUseRule(schema, rule));
}
exports.shouldUseGroup = shouldUseGroup;
function shouldUseRule(schema, rule) {
var _a;
return schema[rule.keyword] !== void 0 || ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== void 0));
}
exports.shouldUseRule = shouldUseRule;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/dataType.js
var require_dataType2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/dataType.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
var rules_1 = require_rules2();
var applicability_1 = require_applicability2();
var errors_1 = require_errors2();
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var DataType;
(function(DataType2) {
DataType2[DataType2["Correct"] = 0] = "Correct";
DataType2[DataType2["Wrong"] = 1] = "Wrong";
})(DataType || (exports.DataType = DataType = {}));
function getSchemaTypes(schema) {
const types = getJSONTypes(schema.type);
const hasNull = types.includes("null");
if (hasNull) {
if (schema.nullable === false)
throw new Error("type: null contradicts nullable: false");
} else {
if (!types.length && schema.nullable !== void 0) {
throw new Error('"nullable" cannot be used without "type"');
}
if (schema.nullable === true)
types.push("null");
}
return types;
}
exports.getSchemaTypes = getSchemaTypes;
function getJSONTypes(ts) {
const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
if (types.every(rules_1.isJSONType))
return types;
throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
}
exports.getJSONTypes = getJSONTypes;
function coerceAndCheckDataType(it, types) {
const { gen, data, opts } = it;
const coerceTo = coerceToTypes(types, opts.coerceTypes);
const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
if (checkTypes) {
const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
gen.if(wrongType, () => {
if (coerceTo.length)
coerceData(it, types, coerceTo);
else
reportTypeError(it);
});
}
return checkTypes;
}
exports.coerceAndCheckDataType = coerceAndCheckDataType;
var COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
function coerceToTypes(types, coerceTypes) {
return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
}
function coerceData(it, types, coerceTo) {
const { gen, data, opts } = it;
const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
if (opts.coerceTypes === "array") {
gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
}
gen.if((0, codegen_1._)`${coerced} !== undefined`);
for (const t of coerceTo) {
if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") {
coerceSpecificType(t);
}
}
gen.else();
reportTypeError(it);
gen.endIf();
gen.if((0, codegen_1._)`${coerced} !== undefined`, () => {
gen.assign(data, coerced);
assignParentData(it, coerced);
});
function coerceSpecificType(t) {
switch (t) {
case "string":
gen.elseIf((0, codegen_1._)`${dataType} == "number" || ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`);
return;
case "number":
gen.elseIf((0, codegen_1._)`${dataType} == "boolean" || ${data} === null
|| (${dataType} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1._)`+${data}`);
return;
case "integer":
gen.elseIf((0, codegen_1._)`${dataType} === "boolean" || ${data} === null
|| (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1._)`+${data}`);
return;
case "boolean":
gen.elseIf((0, codegen_1._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1._)`${data} === "true" || ${data} === 1`).assign(coerced, true);
return;
case "null":
gen.elseIf((0, codegen_1._)`${data} === "" || ${data} === 0 || ${data} === false`);
gen.assign(coerced, null);
return;
case "array":
gen.elseIf((0, codegen_1._)`${dataType} === "string" || ${dataType} === "number"
|| ${dataType} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1._)`[${data}]`);
}
}
}
function assignParentData({ gen, parentData, parentDataProperty }, expr) {
gen.if((0, codegen_1._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, expr));
}
function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;
let cond;
switch (dataType) {
case "null":
return (0, codegen_1._)`${data} ${EQ} null`;
case "array":
cond = (0, codegen_1._)`Array.isArray(${data})`;
break;
case "object":
cond = (0, codegen_1._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
break;
case "integer":
cond = numCond((0, codegen_1._)`!(${data} % 1) && !isNaN(${data})`);
break;
case "number":
cond = numCond();
break;
default:
return (0, codegen_1._)`typeof ${data} ${EQ} ${dataType}`;
}
return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);
function numCond(_cond = codegen_1.nil) {
return (0, codegen_1.and)((0, codegen_1._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._)`isFinite(${data})` : codegen_1.nil);
}
}
exports.checkDataType = checkDataType;
function checkDataTypes(dataTypes, data, strictNums, correct) {
if (dataTypes.length === 1) {
return checkDataType(dataTypes[0], data, strictNums, correct);
}
let cond;
const types = (0, util_1.toHash)(dataTypes);
if (types.array && types.object) {
const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
delete types.null;
delete types.array;
delete types.object;
} else {
cond = codegen_1.nil;
}
if (types.number)
delete types.integer;
for (const t in types)
cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
return cond;
}
exports.checkDataTypes = checkDataTypes;
var typeError = {
message: ({ schema }) => `must be ${schema}`,
params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}`
};
function reportTypeError(it) {
const cxt = getTypeErrorContext(it);
(0, errors_1.reportError)(cxt, typeError);
}
exports.reportTypeError = reportTypeError;
function getTypeErrorContext(it) {
const { gen, data, schema } = it;
const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
return {
gen,
keyword: "type",
data,
schema: schema.type,
schemaCode,
schemaValue: schemaCode,
parentSchema: schema,
params: {},
it
};
}
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/defaults.js
var require_defaults2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/defaults.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.assignDefaults = void 0;
var codegen_1 = require_codegen2();
var util_1 = require_util2();
function assignDefaults(it, ty) {
const { properties, items } = it.schema;
if (ty === "object" && properties) {
for (const key in properties) {
assignDefault(it, key, properties[key].default);
}
} else if (ty === "array" && Array.isArray(items)) {
items.forEach((sch, i) => assignDefault(it, i, sch.default));
}
}
exports.assignDefaults = assignDefaults;
function assignDefault(it, prop, defaultValue) {
const { gen, compositeRule, data, opts } = it;
if (defaultValue === void 0)
return;
const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
if (compositeRule) {
(0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
return;
}
let condition = (0, codegen_1._)`${childData} === undefined`;
if (opts.useDefaults === "empty") {
condition = (0, codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
}
gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
}
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/code.js
var require_code4 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/code.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0;
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var names_1 = require_names2();
var util_2 = require_util2();
function checkReportMissingProp(cxt, prop) {
const { gen, data, it } = cxt;
gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true);
cxt.error();
});
}
exports.checkReportMissingProp = checkReportMissingProp;
function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`)));
}
exports.checkMissingProp = checkMissingProp;
function reportMissingProp(cxt, missing) {
cxt.setParams({ missingProperty: missing }, true);
cxt.error();
}
exports.reportMissingProp = reportMissingProp;
function hasPropFunc(gen) {
return gen.scopeValue("func", {
// eslint-disable-next-line @typescript-eslint/unbound-method
ref: Object.prototype.hasOwnProperty,
code: (0, codegen_1._)`Object.prototype.hasOwnProperty`
});
}
exports.hasPropFunc = hasPropFunc;
function isOwnProperty(gen, data, property) {
return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
}
exports.isOwnProperty = isOwnProperty;
function propertyInData(gen, data, property, ownProperties) {
const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
return ownProperties ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond;
}
exports.propertyInData = propertyInData;
function noPropertyInData(gen, data, property, ownProperties) {
const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;
}
exports.noPropertyInData = noPropertyInData;
function allSchemaProperties(schemaMap) {
return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
}
exports.allSchemaProperties = allSchemaProperties;
function schemaProperties(it, schemaMap) {
return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
}
exports.schemaProperties = schemaProperties;
function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
const valCxt = [
[names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
[names_1.default.parentData, it.parentData],
[names_1.default.parentDataProperty, it.parentDataProperty],
[names_1.default.rootData, names_1.default.rootData]
];
if (it.opts.dynamicRef)
valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`;
}
exports.callValidateCode = callValidateCode;
var newRegExp = (0, codegen_1._)`new RegExp`;
function usePattern({ gen, it: { opts } }, pattern) {
const u = opts.unicodeRegExp ? "u" : "";
const { regExp } = opts.code;
const rx = regExp(pattern, u);
return gen.scopeValue("pattern", {
key: rx.toString(),
ref: rx,
code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`
});
}
exports.usePattern = usePattern;
function validateArray(cxt) {
const { gen, data, keyword, it } = cxt;
const valid = gen.name("valid");
if (it.allErrors) {
const validArr = gen.let("valid", true);
validateItems(() => gen.assign(validArr, false));
return validArr;
}
gen.var(valid, true);
validateItems(() => gen.break());
return valid;
function validateItems(notValid) {
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
gen.forRange("i", 0, len, (i) => {
cxt.subschema({
keyword,
dataProp: i,
dataPropType: util_1.Type.Num
}, valid);
gen.if((0, codegen_1.not)(valid), notValid);
});
}
}
exports.validateArray = validateArray;
function validateUnion(cxt) {
const { gen, schema, keyword, it } = cxt;
if (!Array.isArray(schema))
throw new Error("ajv implementation error");
const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
if (alwaysValid && !it.opts.unevaluated)
return;
const valid = gen.let("valid", false);
const schValid = gen.name("_valid");
gen.block(() => schema.forEach((_sch, i) => {
const schCxt = cxt.subschema({
keyword,
schemaProp: i,
compositeRule: true
}, schValid);
gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`);
const merged = cxt.mergeValidEvaluated(schCxt, schValid);
if (!merged)
gen.if((0, codegen_1.not)(valid));
}));
cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
}
exports.validateUnion = validateUnion;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/keyword.js
var require_keyword2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/keyword.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0;
var codegen_1 = require_codegen2();
var names_1 = require_names2();
var code_1 = require_code4();
var errors_1 = require_errors2();
function macroKeywordCode(cxt, def) {
const { gen, keyword, schema, parentSchema, it } = cxt;
const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
const schemaRef = useKeyword(gen, keyword, macroSchema);
if (it.opts.validateSchema !== false)
it.self.validateSchema(macroSchema, true);
const valid = gen.name("valid");
cxt.subschema({
schema: macroSchema,
schemaPath: codegen_1.nil,
errSchemaPath: `${it.errSchemaPath}/${keyword}`,
topSchemaRef: schemaRef,
compositeRule: true
}, valid);
cxt.pass(valid, () => cxt.error(true));
}
exports.macroKeywordCode = macroKeywordCode;
function funcKeywordCode(cxt, def) {
var _a;
const { gen, keyword, schema, parentSchema, $data, it } = cxt;
checkAsyncKeyword(it, def);
const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate;
const validateRef = useKeyword(gen, keyword, validate);
const valid = gen.let("valid");
cxt.block$data(valid, validateKeyword);
cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid);
function validateKeyword() {
if (def.errors === false) {
assignValid();
if (def.modifying)
modifyData(cxt);
reportErrs(() => cxt.error());
} else {
const ruleErrs = def.async ? validateAsync() : validateSync();
if (def.modifying)
modifyData(cxt);
reportErrs(() => addErrs(cxt, ruleErrs));
}
}
function validateAsync() {
const ruleErrs = gen.let("ruleErrs", null);
gen.try(() => assignValid((0, codegen_1._)`await `), (e) => gen.assign(valid, false).if((0, codegen_1._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`), () => gen.throw(e)));
return ruleErrs;
}
function validateSync() {
const validateErrs = (0, codegen_1._)`${validateRef}.errors`;
gen.assign(validateErrs, null);
assignValid(codegen_1.nil);
return validateErrs;
}
function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) {
const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self;
const passSchema = !("compile" in def && !$data || def.schema === false);
gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying);
}
function reportErrs(errors) {
var _a2;
gen.if((0, codegen_1.not)((_a2 = def.valid) !== null && _a2 !== void 0 ? _a2 : valid), errors);
}
}
exports.funcKeywordCode = funcKeywordCode;
function modifyData(cxt) {
const { gen, data, it } = cxt;
gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`));
}
function addErrs(cxt, errs) {
const { gen } = cxt;
gen.if((0, codegen_1._)`Array.isArray(${errs})`, () => {
gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`).assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
(0, errors_1.extendErrors)(cxt);
}, () => cxt.error());
}
function checkAsyncKeyword({ schemaEnv }, def) {
if (def.async && !schemaEnv.$async)
throw new Error("async keyword in sync schema");
}
function useKeyword(gen, keyword, result) {
if (result === void 0)
throw new Error(`keyword "${keyword}" failed to compile`);
return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) });
}
function validSchemaType(schema, schemaType, allowUndefined = false) {
return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
}
exports.validSchemaType = validSchemaType;
function validateKeywordUsage({ schema, opts, self: self2, errSchemaPath }, def, keyword) {
if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
throw new Error("ajv implementation error");
}
const deps = def.dependencies;
if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {
throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
}
if (def.validateSchema) {
const valid = def.validateSchema(schema[keyword]);
if (!valid) {
const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def.validateSchema.errors);
if (opts.validateSchema === "log")
self2.logger.error(msg);
else
throw new Error(msg);
}
}
}
exports.validateKeywordUsage = validateKeywordUsage;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/subschema.js
var require_subschema2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/subschema.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
var codegen_1 = require_codegen2();
var util_1 = require_util2();
function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
if (keyword !== void 0 && schema !== void 0) {
throw new Error('both "keyword" and "schema" passed, only one allowed');
}
if (keyword !== void 0) {
const sch = it.schema[keyword];
return schemaProp === void 0 ? {
schema: sch,
schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
errSchemaPath: `${it.errSchemaPath}/${keyword}`
} : {
schema: sch[schemaProp],
schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
};
}
if (schema !== void 0) {
if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) {
throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
}
return {
schema,
schemaPath,
topSchemaRef,
errSchemaPath
};
}
throw new Error('either "keyword" or "schema" must be passed');
}
exports.getSubschema = getSubschema;
function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
if (data !== void 0 && dataProp !== void 0) {
throw new Error('both "data" and "dataProp" passed, only one allowed');
}
const { gen } = it;
if (dataProp !== void 0) {
const { errorPath, dataPathArr, opts } = it;
const nextData = gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true);
dataContextProps(nextData);
subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`;
subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
}
if (data !== void 0) {
const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true);
dataContextProps(nextData);
if (propertyName !== void 0)
subschema.propertyName = propertyName;
}
if (dataTypes)
subschema.dataTypes = dataTypes;
function dataContextProps(_nextData) {
subschema.data = _nextData;
subschema.dataLevel = it.dataLevel + 1;
subschema.dataTypes = [];
it.definedProperties = /* @__PURE__ */ new Set();
subschema.parentData = it.data;
subschema.dataNames = [...it.dataNames, _nextData];
}
}
exports.extendSubschemaData = extendSubschemaData;
function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
if (compositeRule !== void 0)
subschema.compositeRule = compositeRule;
if (createErrors !== void 0)
subschema.createErrors = createErrors;
if (allErrors !== void 0)
subschema.allErrors = allErrors;
subschema.jtdDiscriminator = jtdDiscriminator;
subschema.jtdMetadata = jtdMetadata;
}
exports.extendSubschemaMode = extendSubschemaMode;
}
});
// node_modules/ajv-formats/node_modules/json-schema-traverse/index.js
var require_json_schema_traverse2 = __commonJS({
"node_modules/ajv-formats/node_modules/json-schema-traverse/index.js"(exports, module) {
"use strict";
var traverse = module.exports = function(schema, opts, cb) {
if (typeof opts == "function") {
cb = opts;
opts = {};
}
cb = opts.cb || cb;
var pre = typeof cb == "function" ? cb : cb.pre || function() {
};
var post = cb.post || function() {
};
_traverse(opts, pre, post, schema, "", schema);
};
traverse.keywords = {
additionalItems: true,
items: true,
contains: true,
additionalProperties: true,
propertyNames: true,
not: true,
if: true,
then: true,
else: true
};
traverse.arrayKeywords = {
items: true,
allOf: true,
anyOf: true,
oneOf: true
};
traverse.propsKeywords = {
$defs: true,
definitions: true,
properties: true,
patternProperties: true,
dependencies: true
};
traverse.skipKeywords = {
default: true,
enum: true,
const: true,
required: true,
maximum: true,
minimum: true,
exclusiveMaximum: true,
exclusiveMinimum: true,
multipleOf: true,
maxLength: true,
minLength: true,
pattern: true,
format: true,
maxItems: true,
minItems: true,
uniqueItems: true,
maxProperties: true,
minProperties: true
};
function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
if (schema && typeof schema == "object" && !Array.isArray(schema)) {
pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
for (var key in schema) {
var sch = schema[key];
if (Array.isArray(sch)) {
if (key in traverse.arrayKeywords) {
for (var i = 0; i < sch.length; i++)
_traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
}
} else if (key in traverse.propsKeywords) {
if (sch && typeof sch == "object") {
for (var prop in sch)
_traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
}
} else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
_traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
}
}
post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
}
}
function escapeJsonPtr(str) {
return str.replace(/~/g, "~0").replace(/\//g, "~1");
}
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/resolve.js
var require_resolve2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/resolve.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
var util_1 = require_util2();
var equal = require_fast_deep_equal();
var traverse = require_json_schema_traverse2();
var SIMPLE_INLINED = /* @__PURE__ */ new Set([
"type",
"format",
"pattern",
"maxLength",
"minLength",
"maxProperties",
"minProperties",
"maxItems",
"minItems",
"maximum",
"minimum",
"uniqueItems",
"multipleOf",
"required",
"enum",
"const"
]);
function inlineRef(schema, limit = true) {
if (typeof schema == "boolean")
return true;
if (limit === true)
return !hasRef(schema);
if (!limit)
return false;
return countKeys(schema) <= limit;
}
exports.inlineRef = inlineRef;
var REF_KEYWORDS = /* @__PURE__ */ new Set([
"$ref",
"$recursiveRef",
"$recursiveAnchor",
"$dynamicRef",
"$dynamicAnchor"
]);
function hasRef(schema) {
for (const key in schema) {
if (REF_KEYWORDS.has(key))
return true;
const sch = schema[key];
if (Array.isArray(sch) && sch.some(hasRef))
return true;
if (typeof sch == "object" && hasRef(sch))
return true;
}
return false;
}
function countKeys(schema) {
let count = 0;
for (const key in schema) {
if (key === "$ref")
return Infinity;
count++;
if (SIMPLE_INLINED.has(key))
continue;
if (typeof schema[key] == "object") {
(0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
}
if (count === Infinity)
return Infinity;
}
return count;
}
function getFullPath(resolver, id = "", normalize2) {
if (normalize2 !== false)
id = normalizeId(id);
const p = resolver.parse(id);
return _getFullPath(resolver, p);
}
exports.getFullPath = getFullPath;
function _getFullPath(resolver, p) {
const serialized = resolver.serialize(p);
return serialized.split("#")[0] + "#";
}
exports._getFullPath = _getFullPath;
var TRAILING_SLASH_HASH = /#\/?$/;
function normalizeId(id) {
return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
}
exports.normalizeId = normalizeId;
function resolveUrl(resolver, baseId, id) {
id = normalizeId(id);
return resolver.resolve(baseId, id);
}
exports.resolveUrl = resolveUrl;
var ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
function getSchemaRefs(schema, baseId) {
if (typeof schema == "boolean")
return {};
const { schemaId, uriResolver } = this.opts;
const schId = normalizeId(schema[schemaId] || baseId);
const baseIds = { "": schId };
const pathPrefix = getFullPath(uriResolver, schId, false);
const localRefs = {};
const schemaRefs = /* @__PURE__ */ new Set();
traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
if (parentJsonPtr === void 0)
return;
const fullPath = pathPrefix + jsonPtr;
let innerBaseId = baseIds[parentJsonPtr];
if (typeof sch[schemaId] == "string")
innerBaseId = addRef.call(this, sch[schemaId]);
addAnchor.call(this, sch.$anchor);
addAnchor.call(this, sch.$dynamicAnchor);
baseIds[jsonPtr] = innerBaseId;
function addRef(ref) {
const _resolve = this.opts.uriResolver.resolve;
ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
if (schemaRefs.has(ref))
throw ambiguos(ref);
schemaRefs.add(ref);
let schOrRef = this.refs[ref];
if (typeof schOrRef == "string")
schOrRef = this.refs[schOrRef];
if (typeof schOrRef == "object") {
checkAmbiguosRef(sch, schOrRef.schema, ref);
} else if (ref !== normalizeId(fullPath)) {
if (ref[0] === "#") {
checkAmbiguosRef(sch, localRefs[ref], ref);
localRefs[ref] = sch;
} else {
this.refs[ref] = fullPath;
}
}
return ref;
}
function addAnchor(anchor) {
if (typeof anchor == "string") {
if (!ANCHOR.test(anchor))
throw new Error(`invalid anchor "${anchor}"`);
addRef.call(this, `#${anchor}`);
}
}
});
return localRefs;
function checkAmbiguosRef(sch1, sch2, ref) {
if (sch2 !== void 0 && !equal(sch1, sch2))
throw ambiguos(ref);
}
function ambiguos(ref) {
return new Error(`reference "${ref}" resolves to more than one schema`);
}
}
exports.getSchemaRefs = getSchemaRefs;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/index.js
var require_validate2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/validate/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
var boolSchema_1 = require_boolSchema2();
var dataType_1 = require_dataType2();
var applicability_1 = require_applicability2();
var dataType_2 = require_dataType2();
var defaults_1 = require_defaults2();
var keyword_1 = require_keyword2();
var subschema_1 = require_subschema2();
var codegen_1 = require_codegen2();
var names_1 = require_names2();
var resolve_1 = require_resolve2();
var util_1 = require_util2();
var errors_1 = require_errors2();
function validateFunctionCode(it) {
if (isSchemaObj(it)) {
checkKeywords(it);
if (schemaCxtHasRules(it)) {
topSchemaObjCode(it);
return;
}
}
validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
}
exports.validateFunctionCode = validateFunctionCode;
function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
if (opts.code.es5) {
gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
destructureValCxtES5(gen, opts);
gen.code(body);
});
} else {
gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
}
}
function destructureValCxt(opts) {
return (0, codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
}
function destructureValCxtES5(gen, opts) {
gen.if(names_1.default.valCxt, () => {
gen.var(names_1.default.instancePath, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`);
gen.var(names_1.default.parentData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`);
gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`);
gen.var(names_1.default.rootData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`);
if (opts.dynamicRef)
gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`);
}, () => {
gen.var(names_1.default.instancePath, (0, codegen_1._)`""`);
gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`);
gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`);
gen.var(names_1.default.rootData, names_1.default.data);
if (opts.dynamicRef)
gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`);
});
}
function topSchemaObjCode(it) {
const { schema, opts, gen } = it;
validateFunction(it, () => {
if (opts.$comment && schema.$comment)
commentKeyword(it);
checkNoDefault(it);
gen.let(names_1.default.vErrors, null);
gen.let(names_1.default.errors, 0);
if (opts.unevaluated)
resetEvaluated(it);
typeAndKeywords(it);
returnResults(it);
});
return;
}
function resetEvaluated(it) {
const { gen, validateName } = it;
it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`);
gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
}
function funcSourceUrl(schema, opts) {
const schId = typeof schema == "object" && schema[opts.schemaId];
return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
}
function subschemaCode(it, valid) {
if (isSchemaObj(it)) {
checkKeywords(it);
if (schemaCxtHasRules(it)) {
subSchemaObjCode(it, valid);
return;
}
}
(0, boolSchema_1.boolOrEmptySchema)(it, valid);
}
function schemaCxtHasRules({ schema, self: self2 }) {
if (typeof schema == "boolean")
return !schema;
for (const key in schema)
if (self2.RULES.all[key])
return true;
return false;
}
function isSchemaObj(it) {
return typeof it.schema != "boolean";
}
function subSchemaObjCode(it, valid) {
const { schema, gen, opts } = it;
if (opts.$comment && schema.$comment)
commentKeyword(it);
updateContext(it);
checkAsyncSchema(it);
const errsCount = gen.const("_errs", names_1.default.errors);
typeAndKeywords(it, errsCount);
gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
}
function checkKeywords(it) {
(0, util_1.checkUnknownRules)(it);
checkRefsAndKeywords(it);
}
function typeAndKeywords(it, errsCount) {
if (it.opts.jtd)
return schemaKeywords(it, [], false, errsCount);
const types = (0, dataType_1.getSchemaTypes)(it.schema);
const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types);
schemaKeywords(it, types, !checkedTypes, errsCount);
}
function checkRefsAndKeywords(it) {
const { schema, errSchemaPath, opts, self: self2 } = it;
if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self2.RULES)) {
self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
}
}
function checkNoDefault(it) {
const { schema, opts } = it;
if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) {
(0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
}
}
function updateContext(it) {
const schId = it.schema[it.opts.schemaId];
if (schId)
it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
}
function checkAsyncSchema(it) {
if (it.schema.$async && !it.schemaEnv.$async)
throw new Error("async schema in sync schema");
}
function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
const msg = schema.$comment;
if (opts.$comment === true) {
gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
} else if (typeof opts.$comment == "function") {
const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`;
const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
gen.code((0, codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
}
}
function returnResults(it) {
const { gen, schemaEnv, validateName, ValidationError, opts } = it;
if (schemaEnv.$async) {
gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
} else {
gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
if (opts.unevaluated)
assignEvaluated(it);
gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
}
}
function assignEvaluated({ gen, evaluated, props, items }) {
if (props instanceof codegen_1.Name)
gen.assign((0, codegen_1._)`${evaluated}.props`, props);
if (items instanceof codegen_1.Name)
gen.assign((0, codegen_1._)`${evaluated}.items`, items);
}
function schemaKeywords(it, types, typeErrors, errsCount) {
const { gen, schema, data, allErrors, opts, self: self2 } = it;
const { RULES } = self2;
if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
return;
}
if (!opts.jtd)
checkStrictTypes(it, types);
gen.block(() => {
for (const group of RULES.rules)
groupKeywords(group);
groupKeywords(RULES.post);
});
function groupKeywords(group) {
if (!(0, applicability_1.shouldUseGroup)(schema, group))
return;
if (group.type) {
gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
iterateKeywords(it, group);
if (types.length === 1 && types[0] === group.type && typeErrors) {
gen.else();
(0, dataType_2.reportTypeError)(it);
}
gen.endIf();
} else {
iterateKeywords(it, group);
}
if (!allErrors)
gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`);
}
}
function iterateKeywords(it, group) {
const { gen, schema, opts: { useDefaults } } = it;
if (useDefaults)
(0, defaults_1.assignDefaults)(it, group.type);
gen.block(() => {
for (const rule of group.rules) {
if ((0, applicability_1.shouldUseRule)(schema, rule)) {
keywordCode(it, rule.keyword, rule.definition, group.type);
}
}
});
}
function checkStrictTypes(it, types) {
if (it.schemaEnv.meta || !it.opts.strictTypes)
return;
checkContextTypes(it, types);
if (!it.opts.allowUnionTypes)
checkMultipleTypes(it, types);
checkKeywordTypes(it, it.dataTypes);
}
function checkContextTypes(it, types) {
if (!types.length)
return;
if (!it.dataTypes.length) {
it.dataTypes = types;
return;
}
types.forEach((t) => {
if (!includesType(it.dataTypes, t)) {
strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
}
});
narrowSchemaTypes(it, types);
}
function checkMultipleTypes(it, ts) {
if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
strictTypesError(it, "use allowUnionTypes to allow union type keyword");
}
}
function checkKeywordTypes(it, ts) {
const rules = it.self.RULES.all;
for (const keyword in rules) {
const rule = rules[keyword];
if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
const { type } = rule.definition;
if (type.length && !type.some((t) => hasApplicableType(ts, t))) {
strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`);
}
}
}
}
function hasApplicableType(schTs, kwdT) {
return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
}
function includesType(ts, t) {
return ts.includes(t) || t === "integer" && ts.includes("number");
}
function narrowSchemaTypes(it, withTypes) {
const ts = [];
for (const t of it.dataTypes) {
if (includesType(withTypes, t))
ts.push(t);
else if (withTypes.includes("integer") && t === "number")
ts.push("integer");
}
it.dataTypes = ts;
}
function strictTypesError(it, msg) {
const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
msg += ` at "${schemaPath}" (strictTypes)`;
(0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);
}
var KeywordCxt = class {
constructor(it, def, keyword) {
(0, keyword_1.validateKeywordUsage)(it, def, keyword);
this.gen = it.gen;
this.allErrors = it.allErrors;
this.keyword = keyword;
this.data = it.data;
this.schema = it.schema[keyword];
this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data;
this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data);
this.schemaType = def.schemaType;
this.parentSchema = it.schema;
this.params = {};
this.it = it;
this.def = def;
if (this.$data) {
this.schemaCode = it.gen.const("vSchema", getData(this.$data, it));
} else {
this.schemaCode = this.schemaValue;
if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) {
throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`);
}
}
if ("code" in def ? def.trackErrors : def.errors !== false) {
this.errsCount = it.gen.const("_errs", names_1.default.errors);
}
}
result(condition, successAction, failAction) {
this.failResult((0, codegen_1.not)(condition), successAction, failAction);
}
failResult(condition, successAction, failAction) {
this.gen.if(condition);
if (failAction)
failAction();
else
this.error();
if (successAction) {
this.gen.else();
successAction();
if (this.allErrors)
this.gen.endIf();
} else {
if (this.allErrors)
this.gen.endIf();
else
this.gen.else();
}
}
pass(condition, failAction) {
this.failResult((0, codegen_1.not)(condition), void 0, failAction);
}
fail(condition) {
if (condition === void 0) {
this.error();
if (!this.allErrors)
this.gen.if(false);
return;
}
this.gen.if(condition);
this.error();
if (this.allErrors)
this.gen.endIf();
else
this.gen.else();
}
fail$data(condition) {
if (!this.$data)
return this.fail(condition);
const { schemaCode } = this;
this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);
}
error(append, errorParams, errorPaths) {
if (errorParams) {
this.setParams(errorParams);
this._error(append, errorPaths);
this.setParams({});
return;
}
this._error(append, errorPaths);
}
_error(append, errorPaths) {
;
(append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
}
$dataError() {
(0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
}
reset() {
if (this.errsCount === void 0)
throw new Error('add "trackErrors" to keyword definition');
(0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
}
ok(cond) {
if (!this.allErrors)
this.gen.if(cond);
}
setParams(obj, assign) {
if (assign)
Object.assign(this.params, obj);
else
this.params = obj;
}
block$data(valid, codeBlock, $dataValid = codegen_1.nil) {
this.gen.block(() => {
this.check$data(valid, $dataValid);
codeBlock();
});
}
check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
if (!this.$data)
return;
const { gen, schemaCode, schemaType, def } = this;
gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid));
if (valid !== codegen_1.nil)
gen.assign(valid, true);
if (schemaType.length || def.validateSchema) {
gen.elseIf(this.invalid$data());
this.$dataError();
if (valid !== codegen_1.nil)
gen.assign(valid, false);
}
gen.else();
}
invalid$data() {
const { gen, schemaCode, schemaType, def, it } = this;
return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
function wrong$DataType() {
if (schemaType.length) {
if (!(schemaCode instanceof codegen_1.Name))
throw new Error("ajv implementation error");
const st = Array.isArray(schemaType) ? schemaType : [schemaType];
return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
}
return codegen_1.nil;
}
function invalid$DataSchema() {
if (def.validateSchema) {
const validateSchemaRef = gen.scopeValue("validate$data", { ref: def.validateSchema });
return (0, codegen_1._)`!${validateSchemaRef}(${schemaCode})`;
}
return codegen_1.nil;
}
}
subschema(appl, valid) {
const subschema = (0, subschema_1.getSubschema)(this.it, appl);
(0, subschema_1.extendSubschemaData)(subschema, this.it, appl);
(0, subschema_1.extendSubschemaMode)(subschema, appl);
const nextContext = { ...this.it, ...subschema, items: void 0, props: void 0 };
subschemaCode(nextContext, valid);
return nextContext;
}
mergeEvaluated(schemaCxt, toName) {
const { it, gen } = this;
if (!it.opts.unevaluated)
return;
if (it.props !== true && schemaCxt.props !== void 0) {
it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
}
if (it.items !== true && schemaCxt.items !== void 0) {
it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
}
}
mergeValidEvaluated(schemaCxt, valid) {
const { it, gen } = this;
if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {
gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name));
return true;
}
}
};
exports.KeywordCxt = KeywordCxt;
function keywordCode(it, keyword, def, ruleType) {
const cxt = new KeywordCxt(it, def, keyword);
if ("code" in def) {
def.code(cxt, ruleType);
} else if (cxt.$data && def.validate) {
(0, keyword_1.funcKeywordCode)(cxt, def);
} else if ("macro" in def) {
(0, keyword_1.macroKeywordCode)(cxt, def);
} else if (def.compile || def.validate) {
(0, keyword_1.funcKeywordCode)(cxt, def);
}
}
var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
function getData($data, { dataLevel, dataNames, dataPathArr }) {
let jsonPointer;
let data;
if ($data === "")
return names_1.default.rootData;
if ($data[0] === "/") {
if (!JSON_POINTER.test($data))
throw new Error(`Invalid JSON-pointer: ${$data}`);
jsonPointer = $data;
data = names_1.default.rootData;
} else {
const matches = RELATIVE_JSON_POINTER.exec($data);
if (!matches)
throw new Error(`Invalid JSON-pointer: ${$data}`);
const up = +matches[1];
jsonPointer = matches[2];
if (jsonPointer === "#") {
if (up >= dataLevel)
throw new Error(errorMsg("property/index", up));
return dataPathArr[dataLevel - up];
}
if (up > dataLevel)
throw new Error(errorMsg("data", up));
data = dataNames[dataLevel - up];
if (!jsonPointer)
return data;
}
let expr = data;
const segments = jsonPointer.split("/");
for (const segment of segments) {
if (segment) {
data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;
expr = (0, codegen_1._)`${expr} && ${data}`;
}
}
return expr;
function errorMsg(pointerType, up) {
return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
}
}
exports.getData = getData;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/runtime/validation_error.js
var require_validation_error2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/runtime/validation_error.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ValidationError = class extends Error {
constructor(errors) {
super("validation failed");
this.errors = errors;
this.ajv = this.validation = true;
}
};
exports.default = ValidationError;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/ref_error.js
var require_ref_error2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/ref_error.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var resolve_1 = require_resolve2();
var MissingRefError = class extends Error {
constructor(resolver, baseId, ref, msg) {
super(msg || `can't resolve reference ${ref} from id ${baseId}`);
this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));
}
};
exports.default = MissingRefError;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/compile/index.js
var require_compile2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/compile/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
var codegen_1 = require_codegen2();
var validation_error_1 = require_validation_error2();
var names_1 = require_names2();
var resolve_1 = require_resolve2();
var util_1 = require_util2();
var validate_1 = require_validate2();
var SchemaEnv = class {
constructor(env) {
var _a;
this.refs = {};
this.dynamicAnchors = {};
let schema;
if (typeof env.schema == "object")
schema = env.schema;
this.schema = env.schema;
this.schemaId = env.schemaId;
this.root = env.root || this;
this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
this.schemaPath = env.schemaPath;
this.localRefs = env.localRefs;
this.meta = env.meta;
this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
this.refs = {};
}
};
exports.SchemaEnv = SchemaEnv;
function compileSchema(sch) {
const _sch = getCompilingSchema.call(this, sch);
if (_sch)
return _sch;
const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId);
const { es5, lines } = this.opts.code;
const { ownProperties } = this.opts;
const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
let _ValidationError;
if (sch.$async) {
_ValidationError = gen.scopeValue("Error", {
ref: validation_error_1.default,
code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`
});
}
const validateName = gen.scopeName("validate");
sch.validateName = validateName;
const schemaCxt = {
gen,
allErrors: this.opts.allErrors,
data: names_1.default.data,
parentData: names_1.default.parentData,
parentDataProperty: names_1.default.parentDataProperty,
dataNames: [names_1.default.data],
dataPathArr: [codegen_1.nil],
// TODO can its length be used as dataLevel if nil is removed?
dataLevel: 0,
dataTypes: [],
definedProperties: /* @__PURE__ */ new Set(),
topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) } : { ref: sch.schema }),
validateName,
ValidationError: _ValidationError,
schema: sch.schema,
schemaEnv: sch,
rootId,
baseId: sch.baseId || rootId,
schemaPath: codegen_1.nil,
errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
errorPath: (0, codegen_1._)`""`,
opts: this.opts,
self: this
};
let sourceCode;
try {
this._compilations.add(sch);
(0, validate_1.validateFunctionCode)(schemaCxt);
gen.optimize(this.opts.code.optimize);
const validateCode = gen.toString();
sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
if (this.opts.code.process)
sourceCode = this.opts.code.process(sourceCode, sch);
const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
const validate = makeValidate(this, this.scope.get());
this.scope.value(validateName, { ref: validate });
validate.errors = null;
validate.schema = sch.schema;
validate.schemaEnv = sch;
if (sch.$async)
validate.$async = true;
if (this.opts.code.source === true) {
validate.source = { validateName, validateCode, scopeValues: gen._values };
}
if (this.opts.unevaluated) {
const { props, items } = schemaCxt;
validate.evaluated = {
props: props instanceof codegen_1.Name ? void 0 : props,
items: items instanceof codegen_1.Name ? void 0 : items,
dynamicProps: props instanceof codegen_1.Name,
dynamicItems: items instanceof codegen_1.Name
};
if (validate.source)
validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
}
sch.validate = validate;
return sch;
} catch (e) {
delete sch.validate;
delete sch.validateName;
if (sourceCode)
this.logger.error("Error compiling schema, function code:", sourceCode);
throw e;
} finally {
this._compilations.delete(sch);
}
}
exports.compileSchema = compileSchema;
function resolveRef(root, baseId, ref) {
var _a;
ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
const schOrFunc = root.refs[ref];
if (schOrFunc)
return schOrFunc;
let _sch = resolve5.call(this, root, ref);
if (_sch === void 0) {
const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
const { schemaId } = this.opts;
if (schema)
_sch = new SchemaEnv({ schema, schemaId, root, baseId });
}
if (_sch === void 0)
return;
return root.refs[ref] = inlineOrCompile.call(this, _sch);
}
exports.resolveRef = resolveRef;
function inlineOrCompile(sch) {
if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
return sch.schema;
return sch.validate ? sch : compileSchema.call(this, sch);
}
function getCompilingSchema(schEnv) {
for (const sch of this._compilations) {
if (sameSchemaEnv(sch, schEnv))
return sch;
}
}
exports.getCompilingSchema = getCompilingSchema;
function sameSchemaEnv(s1, s2) {
return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
}
function resolve5(root, ref) {
let sch;
while (typeof (sch = this.refs[ref]) == "string")
ref = sch;
return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
}
function resolveSchema(root, ref) {
const p = this.opts.uriResolver.parse(ref);
const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0);
if (Object.keys(root.schema).length > 0 && refPath === baseId) {
return getJsonPointer.call(this, p, root);
}
const id = (0, resolve_1.normalizeId)(refPath);
const schOrRef = this.refs[id] || this.schemas[id];
if (typeof schOrRef == "string") {
const sch = resolveSchema.call(this, root, schOrRef);
if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
return;
return getJsonPointer.call(this, p, sch);
}
if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object")
return;
if (!schOrRef.validate)
compileSchema.call(this, schOrRef);
if (id === (0, resolve_1.normalizeId)(ref)) {
const { schema } = schOrRef;
const { schemaId } = this.opts;
const schId = schema[schemaId];
if (schId)
baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
return new SchemaEnv({ schema, schemaId, root, baseId });
}
return getJsonPointer.call(this, p, schOrRef);
}
exports.resolveSchema = resolveSchema;
var PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([
"properties",
"patternProperties",
"enum",
"dependencies",
"definitions"
]);
function getJsonPointer(parsedRef, { baseId, schema, root }) {
var _a;
if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/")
return;
for (const part of parsedRef.fragment.slice(1).split("/")) {
if (typeof schema === "boolean")
return;
const partSchema = schema[(0, util_1.unescapeFragment)(part)];
if (partSchema === void 0)
return;
schema = partSchema;
const schId = typeof schema === "object" && schema[this.opts.schemaId];
if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
}
}
let env;
if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
env = resolveSchema.call(this, root, $ref);
}
const { schemaId } = this.opts;
env = env || new SchemaEnv({ schema, schemaId, root, baseId });
if (env.schema !== env.root.schema)
return env;
return void 0;
}
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/refs/data.json
var require_data2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/refs/data.json"(exports, module) {
module.exports = {
$id: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
description: "Meta-schema for $data reference (JSON AnySchema extension proposal)",
type: "object",
required: ["$data"],
properties: {
$data: {
type: "string",
anyOf: [{ format: "relative-json-pointer" }, { format: "json-pointer" }]
}
},
additionalProperties: false
};
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/runtime/uri.js
var require_uri2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/runtime/uri.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var uri = require_fast_uri();
uri.code = 'require("ajv/dist/runtime/uri").default';
exports.default = uri;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/core.js
var require_core4 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/core.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
var validate_1 = require_validate2();
Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
return validate_1.KeywordCxt;
} });
var codegen_1 = require_codegen2();
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
return codegen_1._;
} });
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
return codegen_1.str;
} });
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
return codegen_1.stringify;
} });
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
return codegen_1.nil;
} });
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
return codegen_1.Name;
} });
Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
return codegen_1.CodeGen;
} });
var validation_error_1 = require_validation_error2();
var ref_error_1 = require_ref_error2();
var rules_1 = require_rules2();
var compile_1 = require_compile2();
var codegen_2 = require_codegen2();
var resolve_1 = require_resolve2();
var dataType_1 = require_dataType2();
var util_1 = require_util2();
var $dataRefSchema = require_data2();
var uri_1 = require_uri2();
var defaultRegExp = (str, flags) => new RegExp(str, flags);
defaultRegExp.code = "new RegExp";
var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
"validate",
"serialize",
"parse",
"wrapper",
"root",
"schema",
"keyword",
"pattern",
"formats",
"validate$data",
"func",
"obj",
"Error"
]);
var removedOptions = {
errorDataPath: "",
format: "`validateFormats: false` can be used instead.",
nullable: '"nullable" keyword is supported by default.',
jsonPointers: "Deprecated jsPropertySyntax can be used instead.",
extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",
missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",
processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",
sourceCode: "Use option `code: {source: true}`",
strictDefaults: "It is default now, see option `strict`.",
strictKeywords: "It is default now, see option `strict`.",
uniqueItems: '"uniqueItems" keyword is always validated.',
unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",
cache: "Map is used as cache, schema object as key.",
serialize: "Map is used as cache, schema object as key.",
ajvErrors: "It is default now."
};
var deprecatedOptions = {
ignoreKeywordsWithRef: "",
jsPropertySyntax: "",
unicode: '"minLength"/"maxLength" account for unicode characters by default.'
};
var MAX_EXPRESSION = 200;
function requiredOptions(o) {
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
const s = o.strict;
const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;
const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0;
const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;
const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
return {
strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,
strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,
strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log",
strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log",
strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,
code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },
loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
uriResolver
};
}
var Ajv = class {
constructor(opts = {}) {
this.schemas = {};
this.refs = {};
this.formats = {};
this._compilations = /* @__PURE__ */ new Set();
this._loading = {};
this._cache = /* @__PURE__ */ new Map();
opts = this.opts = { ...opts, ...requiredOptions(opts) };
const { es5, lines } = this.opts.code;
this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines });
this.logger = getLogger(opts.logger);
const formatOpt = opts.validateFormats;
opts.validateFormats = false;
this.RULES = (0, rules_1.getRules)();
checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
this._metaOpts = getMetaSchemaOptions.call(this);
if (opts.formats)
addInitialFormats.call(this);
this._addVocabularies();
this._addDefaultMetaSchema();
if (opts.keywords)
addInitialKeywords.call(this, opts.keywords);
if (typeof opts.meta == "object")
this.addMetaSchema(opts.meta);
addInitialSchemas.call(this);
opts.validateFormats = formatOpt;
}
_addVocabularies() {
this.addKeyword("$async");
}
_addDefaultMetaSchema() {
const { $data, meta, schemaId } = this.opts;
let _dataRefSchema = $dataRefSchema;
if (schemaId === "id") {
_dataRefSchema = { ...$dataRefSchema };
_dataRefSchema.id = _dataRefSchema.$id;
delete _dataRefSchema.$id;
}
if (meta && $data)
this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
}
defaultMeta() {
const { meta, schemaId } = this.opts;
return this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : void 0;
}
validate(schemaKeyRef, data) {
let v;
if (typeof schemaKeyRef == "string") {
v = this.getSchema(schemaKeyRef);
if (!v)
throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
} else {
v = this.compile(schemaKeyRef);
}
const valid = v(data);
if (!("$async" in v))
this.errors = v.errors;
return valid;
}
compile(schema, _meta) {
const sch = this._addSchema(schema, _meta);
return sch.validate || this._compileSchemaEnv(sch);
}
compileAsync(schema, meta) {
if (typeof this.opts.loadSchema != "function") {
throw new Error("options.loadSchema should be a function");
}
const { loadSchema } = this.opts;
return runCompileAsync.call(this, schema, meta);
async function runCompileAsync(_schema, _meta) {
await loadMetaSchema.call(this, _schema.$schema);
const sch = this._addSchema(_schema, _meta);
return sch.validate || _compileAsync.call(this, sch);
}
async function loadMetaSchema($ref) {
if ($ref && !this.getSchema($ref)) {
await runCompileAsync.call(this, { $ref }, true);
}
}
async function _compileAsync(sch) {
try {
return this._compileSchemaEnv(sch);
} catch (e) {
if (!(e instanceof ref_error_1.default))
throw e;
checkLoaded.call(this, e);
await loadMissingSchema.call(this, e.missingSchema);
return _compileAsync.call(this, sch);
}
}
function checkLoaded({ missingSchema: ref, missingRef }) {
if (this.refs[ref]) {
throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);
}
}
async function loadMissingSchema(ref) {
const _schema = await _loadSchema.call(this, ref);
if (!this.refs[ref])
await loadMetaSchema.call(this, _schema.$schema);
if (!this.refs[ref])
this.addSchema(_schema, ref, meta);
}
async function _loadSchema(ref) {
const p = this._loading[ref];
if (p)
return p;
try {
return await (this._loading[ref] = loadSchema(ref));
} finally {
delete this._loading[ref];
}
}
}
// Adds schema to the instance
addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
if (Array.isArray(schema)) {
for (const sch of schema)
this.addSchema(sch, void 0, _meta, _validateSchema);
return this;
}
let id;
if (typeof schema === "object") {
const { schemaId } = this.opts;
id = schema[schemaId];
if (id !== void 0 && typeof id != "string") {
throw new Error(`schema ${schemaId} must be string`);
}
}
key = (0, resolve_1.normalizeId)(key || id);
this._checkUnique(key);
this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
return this;
}
// Add schema that will be used to validate other schemas
// options in META_IGNORE_OPTIONS are alway set to false
addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
this.addSchema(schema, key, true, _validateSchema);
return this;
}
// Validate schema against its meta-schema
validateSchema(schema, throwOrLogError) {
if (typeof schema == "boolean")
return true;
let $schema;
$schema = schema.$schema;
if ($schema !== void 0 && typeof $schema != "string") {
throw new Error("$schema must be a string");
}
$schema = $schema || this.opts.defaultMeta || this.defaultMeta();
if (!$schema) {
this.logger.warn("meta-schema not available");
this.errors = null;
return true;
}
const valid = this.validate($schema, schema);
if (!valid && throwOrLogError) {
const message = "schema is invalid: " + this.errorsText();
if (this.opts.validateSchema === "log")
this.logger.error(message);
else
throw new Error(message);
}
return valid;
}
// Get compiled schema by `key` or `ref`.
// (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)
getSchema(keyRef) {
let sch;
while (typeof (sch = getSchEnv.call(this, keyRef)) == "string")
keyRef = sch;
if (sch === void 0) {
const { schemaId } = this.opts;
const root = new compile_1.SchemaEnv({ schema: {}, schemaId });
sch = compile_1.resolveSchema.call(this, root, keyRef);
if (!sch)
return;
this.refs[keyRef] = sch;
}
return sch.validate || this._compileSchemaEnv(sch);
}
// Remove cached schema(s).
// If no parameter is passed all schemas but meta-schemas are removed.
// If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.
// Even if schema is referenced by other schemas it still can be removed as other schemas have local references.
removeSchema(schemaKeyRef) {
if (schemaKeyRef instanceof RegExp) {
this._removeAllSchemas(this.schemas, schemaKeyRef);
this._removeAllSchemas(this.refs, schemaKeyRef);
return this;
}
switch (typeof schemaKeyRef) {
case "undefined":
this._removeAllSchemas(this.schemas);
this._removeAllSchemas(this.refs);
this._cache.clear();
return this;
case "string": {
const sch = getSchEnv.call(this, schemaKeyRef);
if (typeof sch == "object")
this._cache.delete(sch.schema);
delete this.schemas[schemaKeyRef];
delete this.refs[schemaKeyRef];
return this;
}
case "object": {
const cacheKey = schemaKeyRef;
this._cache.delete(cacheKey);
let id = schemaKeyRef[this.opts.schemaId];
if (id) {
id = (0, resolve_1.normalizeId)(id);
delete this.schemas[id];
delete this.refs[id];
}
return this;
}
default:
throw new Error("ajv.removeSchema: invalid parameter");
}
}
// add "vocabulary" - a collection of keywords
addVocabulary(definitions) {
for (const def of definitions)
this.addKeyword(def);
return this;
}
addKeyword(kwdOrDef, def) {
let keyword;
if (typeof kwdOrDef == "string") {
keyword = kwdOrDef;
if (typeof def == "object") {
this.logger.warn("these parameters are deprecated, see docs for addKeyword");
def.keyword = keyword;
}
} else if (typeof kwdOrDef == "object" && def === void 0) {
def = kwdOrDef;
keyword = def.keyword;
if (Array.isArray(keyword) && !keyword.length) {
throw new Error("addKeywords: keyword must be string or non-empty array");
}
} else {
throw new Error("invalid addKeywords parameters");
}
checkKeyword.call(this, keyword, def);
if (!def) {
(0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
return this;
}
keywordMetaschema.call(this, def);
const definition = {
...def,
type: (0, dataType_1.getJSONTypes)(def.type),
schemaType: (0, dataType_1.getJSONTypes)(def.schemaType)
};
(0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
return this;
}
getKeyword(keyword) {
const rule = this.RULES.all[keyword];
return typeof rule == "object" ? rule.definition : !!rule;
}
// Remove keyword
removeKeyword(keyword) {
const { RULES } = this;
delete RULES.keywords[keyword];
delete RULES.all[keyword];
for (const group of RULES.rules) {
const i = group.rules.findIndex((rule) => rule.keyword === keyword);
if (i >= 0)
group.rules.splice(i, 1);
}
return this;
}
// Add format
addFormat(name, format2) {
if (typeof format2 == "string")
format2 = new RegExp(format2);
this.formats[name] = format2;
return this;
}
errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
if (!errors || errors.length === 0)
return "No errors";
return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
}
$dataMetaSchema(metaSchema, keywordsJsonPointers) {
const rules = this.RULES.all;
metaSchema = JSON.parse(JSON.stringify(metaSchema));
for (const jsonPointer of keywordsJsonPointers) {
const segments = jsonPointer.split("/").slice(1);
let keywords = metaSchema;
for (const seg of segments)
keywords = keywords[seg];
for (const key in rules) {
const rule = rules[key];
if (typeof rule != "object")
continue;
const { $data } = rule.definition;
const schema = keywords[key];
if ($data && schema)
keywords[key] = schemaOrData(schema);
}
}
return metaSchema;
}
_removeAllSchemas(schemas, regex) {
for (const keyRef in schemas) {
const sch = schemas[keyRef];
if (!regex || regex.test(keyRef)) {
if (typeof sch == "string") {
delete schemas[keyRef];
} else if (sch && !sch.meta) {
this._cache.delete(sch.schema);
delete schemas[keyRef];
}
}
}
}
_addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
let id;
const { schemaId } = this.opts;
if (typeof schema == "object") {
id = schema[schemaId];
} else {
if (this.opts.jtd)
throw new Error("schema must be object");
else if (typeof schema != "boolean")
throw new Error("schema must be object or boolean");
}
let sch = this._cache.get(schema);
if (sch !== void 0)
return sch;
baseId = (0, resolve_1.normalizeId)(id || baseId);
const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });
this._cache.set(sch.schema, sch);
if (addSchema && !baseId.startsWith("#")) {
if (baseId)
this._checkUnique(baseId);
this.refs[baseId] = sch;
}
if (validateSchema)
this.validateSchema(schema, true);
return sch;
}
_checkUnique(id) {
if (this.schemas[id] || this.refs[id]) {
throw new Error(`schema with key or id "${id}" already exists`);
}
}
_compileSchemaEnv(sch) {
if (sch.meta)
this._compileMetaSchema(sch);
else
compile_1.compileSchema.call(this, sch);
if (!sch.validate)
throw new Error("ajv implementation error");
return sch.validate;
}
_compileMetaSchema(sch) {
const currentOpts = this.opts;
this.opts = this._metaOpts;
try {
compile_1.compileSchema.call(this, sch);
} finally {
this.opts = currentOpts;
}
}
};
Ajv.ValidationError = validation_error_1.default;
Ajv.MissingRefError = ref_error_1.default;
exports.default = Ajv;
function checkOptions(checkOpts, options, msg, log = "error") {
for (const key in checkOpts) {
const opt = key;
if (opt in options)
this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
}
}
function getSchEnv(keyRef) {
keyRef = (0, resolve_1.normalizeId)(keyRef);
return this.schemas[keyRef] || this.refs[keyRef];
}
function addInitialSchemas() {
const optsSchemas = this.opts.schemas;
if (!optsSchemas)
return;
if (Array.isArray(optsSchemas))
this.addSchema(optsSchemas);
else
for (const key in optsSchemas)
this.addSchema(optsSchemas[key], key);
}
function addInitialFormats() {
for (const name in this.opts.formats) {
const format2 = this.opts.formats[name];
if (format2)
this.addFormat(name, format2);
}
}
function addInitialKeywords(defs) {
if (Array.isArray(defs)) {
this.addVocabulary(defs);
return;
}
this.logger.warn("keywords option as map is deprecated, pass array");
for (const keyword in defs) {
const def = defs[keyword];
if (!def.keyword)
def.keyword = keyword;
this.addKeyword(def);
}
}
function getMetaSchemaOptions() {
const metaOpts = { ...this.opts };
for (const opt of META_IGNORE_OPTIONS)
delete metaOpts[opt];
return metaOpts;
}
var noLogs = { log() {
}, warn() {
}, error() {
} };
function getLogger(logger4) {
if (logger4 === false)
return noLogs;
if (logger4 === void 0)
return console;
if (logger4.log && logger4.warn && logger4.error)
return logger4;
throw new Error("logger must implement log, warn and error methods");
}
var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
function checkKeyword(keyword, def) {
const { RULES } = this;
(0, util_1.eachItem)(keyword, (kwd) => {
if (RULES.keywords[kwd])
throw new Error(`Keyword ${kwd} is already defined`);
if (!KEYWORD_NAME.test(kwd))
throw new Error(`Keyword ${kwd} has invalid name`);
});
if (!def)
return;
if (def.$data && !("code" in def || "validate" in def)) {
throw new Error('$data keyword must have "code" or "validate" function');
}
}
function addRule(keyword, definition, dataType) {
var _a;
const post = definition === null || definition === void 0 ? void 0 : definition.post;
if (dataType && post)
throw new Error('keyword with "post" flag cannot have "type"');
const { RULES } = this;
let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
if (!ruleGroup) {
ruleGroup = { type: dataType, rules: [] };
RULES.rules.push(ruleGroup);
}
RULES.keywords[keyword] = true;
if (!definition)
return;
const rule = {
keyword,
definition: {
...definition,
type: (0, dataType_1.getJSONTypes)(definition.type),
schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType)
}
};
if (definition.before)
addBeforeRule.call(this, ruleGroup, rule, definition.before);
else
ruleGroup.rules.push(rule);
RULES.all[keyword] = rule;
(_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd));
}
function addBeforeRule(ruleGroup, rule, before) {
const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
if (i >= 0) {
ruleGroup.rules.splice(i, 0, rule);
} else {
ruleGroup.rules.push(rule);
this.logger.warn(`rule ${before} is not defined`);
}
}
function keywordMetaschema(def) {
let { metaSchema } = def;
if (metaSchema === void 0)
return;
if (def.$data && this.opts.$data)
metaSchema = schemaOrData(metaSchema);
def.validateSchema = this.compile(metaSchema, true);
}
var $dataRef = {
$ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
};
function schemaOrData(schema) {
return { anyOf: [schema, $dataRef] };
}
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/core/id.js
var require_id2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/core/id.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var def = {
keyword: "id",
code() {
throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/core/ref.js
var require_ref2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/core/ref.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.callRef = exports.getValidate = void 0;
var ref_error_1 = require_ref_error2();
var code_1 = require_code4();
var codegen_1 = require_codegen2();
var names_1 = require_names2();
var compile_1 = require_compile2();
var util_1 = require_util2();
var def = {
keyword: "$ref",
schemaType: "string",
code(cxt) {
const { gen, schema: $ref, it } = cxt;
const { baseId, schemaEnv: env, validateName, opts, self: self2 } = it;
const { root } = env;
if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
return callRootRef();
const schOrEnv = compile_1.resolveRef.call(self2, root, baseId, $ref);
if (schOrEnv === void 0)
throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
if (schOrEnv instanceof compile_1.SchemaEnv)
return callValidate(schOrEnv);
return inlineRefSchema(schOrEnv);
function callRootRef() {
if (env === root)
return callRef(cxt, validateName, env, env.$async);
const rootName = gen.scopeValue("root", { ref: root });
return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
}
function callValidate(sch) {
const v = getValidate(cxt, sch);
callRef(cxt, v, sch, sch.$async);
}
function inlineRefSchema(sch) {
const schName = gen.scopeValue("schema", opts.code.source === true ? { ref: sch, code: (0, codegen_1.stringify)(sch) } : { ref: sch });
const valid = gen.name("valid");
const schCxt = cxt.subschema({
schema: sch,
dataTypes: [],
schemaPath: codegen_1.nil,
topSchemaRef: schName,
errSchemaPath: $ref
}, valid);
cxt.mergeEvaluated(schCxt);
cxt.ok(valid);
}
}
};
function getValidate(cxt, sch) {
const { gen } = cxt;
return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
}
exports.getValidate = getValidate;
function callRef(cxt, v, sch, $async) {
const { gen, it } = cxt;
const { allErrors, schemaEnv: env, opts } = it;
const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
if ($async)
callAsyncRef();
else
callSyncRef();
function callAsyncRef() {
if (!env.$async)
throw new Error("async schema referenced by sync schema");
const valid = gen.let("valid");
gen.try(() => {
gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
addEvaluatedFrom(v);
if (!allErrors)
gen.assign(valid, true);
}, (e) => {
gen.if((0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
addErrorsFrom(e);
if (!allErrors)
gen.assign(valid, false);
});
cxt.ok(valid);
}
function callSyncRef() {
cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
}
function addErrorsFrom(source) {
const errs = (0, codegen_1._)`${source}.errors`;
gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`);
gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
}
function addEvaluatedFrom(source) {
var _a;
if (!it.opts.unevaluated)
return;
const schEvaluated = (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated;
if (it.props !== true) {
if (schEvaluated && !schEvaluated.dynamicProps) {
if (schEvaluated.props !== void 0) {
it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
}
} else {
const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`);
it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
}
}
if (it.items !== true) {
if (schEvaluated && !schEvaluated.dynamicItems) {
if (schEvaluated.items !== void 0) {
it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
}
} else {
const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`);
it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
}
}
}
}
exports.callRef = callRef;
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/core/index.js
var require_core5 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/core/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var id_1 = require_id2();
var ref_1 = require_ref2();
var core = [
"$schema",
"$id",
"$defs",
"$vocabulary",
{ keyword: "$comment" },
"definitions",
id_1.default,
ref_1.default
];
exports.default = core;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
var require_limitNumber2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/limitNumber.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var ops = codegen_1.operators;
var KWDs = {
maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
minimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
exclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
exclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
};
var error = {
message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
};
var def = {
keyword: Object.keys(KWDs),
type: "number",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { keyword, data, schemaCode } = cxt;
cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`);
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
var require_multipleOf2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/multipleOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var error = {
message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`
};
var def = {
keyword: "multipleOf",
type: "number",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { gen, data, schemaCode, it } = cxt;
const prec = it.opts.multipleOfPrecision;
const res = gen.let("res");
const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/runtime/ucs2length.js
var require_ucs2length2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/runtime/ucs2length.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function ucs2length(str) {
const len = str.length;
let length = 0;
let pos = 0;
let value;
while (pos < len) {
length++;
value = str.charCodeAt(pos++);
if (value >= 55296 && value <= 56319 && pos < len) {
value = str.charCodeAt(pos);
if ((value & 64512) === 56320)
pos++;
}
}
return length;
}
exports.default = ucs2length;
ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/limitLength.js
var require_limitLength2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/limitLength.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var ucs2length_1 = require_ucs2length2();
var error = {
message({ keyword, schemaCode }) {
const comp = keyword === "maxLength" ? "more" : "fewer";
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
},
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
};
var def = {
keyword: ["maxLength", "minLength"],
type: "string",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { keyword, data, schemaCode, it } = cxt;
const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT;
const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`);
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/pattern.js
var require_pattern2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/pattern.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code4();
var util_1 = require_util2();
var codegen_1 = require_codegen2();
var error = {
message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
};
var def = {
keyword: "pattern",
type: "string",
schemaType: "string",
$data: true,
error,
code(cxt) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
const u = it.opts.unicodeRegExp ? "u" : "";
if ($data) {
const { regExp } = it.opts.code;
const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
const valid = gen.let("valid");
gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
cxt.fail$data((0, codegen_1._)`!${valid}`);
} else {
const regExp = (0, code_1.usePattern)(cxt, schema);
cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
var require_limitProperties2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/limitProperties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var error = {
message({ keyword, schemaCode }) {
const comp = keyword === "maxProperties" ? "more" : "fewer";
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
},
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
};
var def = {
keyword: ["maxProperties", "minProperties"],
type: "object",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { keyword, data, schemaCode } = cxt;
const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT;
cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`);
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/required.js
var require_required2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/required.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code4();
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var error = {
message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
};
var def = {
keyword: "required",
type: "object",
schemaType: "array",
$data: true,
error,
code(cxt) {
const { gen, schema, schemaCode, data, $data, it } = cxt;
const { opts } = it;
if (!$data && schema.length === 0)
return;
const useLoop = schema.length >= opts.loopRequired;
if (it.allErrors)
allErrorsMode();
else
exitOnErrorMode();
if (opts.strictRequired) {
const props = cxt.parentSchema.properties;
const { definedProperties } = cxt.it;
for (const requiredKey of schema) {
if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) {
const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`;
(0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
}
}
}
function allErrorsMode() {
if (useLoop || $data) {
cxt.block$data(codegen_1.nil, loopAllRequired);
} else {
for (const prop of schema) {
(0, code_1.checkReportMissingProp)(cxt, prop);
}
}
}
function exitOnErrorMode() {
const missing = gen.let("missing");
if (useLoop || $data) {
const valid = gen.let("valid", true);
cxt.block$data(valid, () => loopUntilMissing(missing, valid));
cxt.ok(valid);
} else {
gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
(0, code_1.reportMissingProp)(cxt, missing);
gen.else();
}
}
function loopAllRequired() {
gen.forOf("prop", schemaCode, (prop) => {
cxt.setParams({ missingProperty: prop });
gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());
});
}
function loopUntilMissing(missing, valid) {
cxt.setParams({ missingProperty: missing });
gen.forOf(missing, schemaCode, () => {
gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
gen.if((0, codegen_1.not)(valid), () => {
cxt.error();
gen.break();
});
}, codegen_1.nil);
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/limitItems.js
var require_limitItems2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/limitItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var error = {
message({ keyword, schemaCode }) {
const comp = keyword === "maxItems" ? "more" : "fewer";
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
},
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
};
var def = {
keyword: ["maxItems", "minItems"],
type: "array",
schemaType: "number",
$data: true,
error,
code(cxt) {
const { keyword, data, schemaCode } = cxt;
const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT;
cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`);
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/runtime/equal.js
var require_equal2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/runtime/equal.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var equal = require_fast_deep_equal();
equal.code = 'require("ajv/dist/runtime/equal").default';
exports.default = equal;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
var require_uniqueItems2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dataType_1 = require_dataType2();
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var equal_1 = require_equal2();
var error = {
message: ({ params: { i, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`
};
var def = {
keyword: "uniqueItems",
type: "array",
schemaType: "boolean",
$data: true,
error,
code(cxt) {
const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
if (!$data && !schema)
return;
const valid = gen.let("valid");
const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`);
cxt.ok(valid);
function validateUniqueItems() {
const i = gen.let("i", (0, codegen_1._)`${data}.length`);
const j = gen.let("j");
cxt.setParams({ i, j });
gen.assign(valid, true);
gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
}
function canOptimize() {
return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array");
}
function loopN(i, j) {
const item = gen.name("item");
const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
const indices = gen.const("indices", (0, codegen_1._)`{}`);
gen.for((0, codegen_1._)`;${i}--;`, () => {
gen.let(item, (0, codegen_1._)`${data}[${i}]`);
gen.if(wrongType, (0, codegen_1._)`continue`);
if (itemTypes.length > 1)
gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`);
gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => {
gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
cxt.error();
gen.assign(valid, false).break();
}).code((0, codegen_1._)`${indices}[${item}] = ${i}`);
});
}
function loopN2(i, j) {
const eql = (0, util_1.useFunc)(gen, equal_1.default);
const outer = gen.name("outer");
gen.label(outer).for((0, codegen_1._)`;${i}--;`, () => gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => {
cxt.error();
gen.assign(valid, false).break(outer);
})));
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/const.js
var require_const2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/const.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var equal_1 = require_equal2();
var error = {
message: "must be equal to constant",
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
};
var def = {
keyword: "const",
$data: true,
error,
code(cxt) {
const { gen, data, $data, schemaCode, schema } = cxt;
if ($data || schema && typeof schema == "object") {
cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
} else {
cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/enum.js
var require_enum2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/enum.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var equal_1 = require_equal2();
var error = {
message: "must be equal to one of the allowed values",
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}`
};
var def = {
keyword: "enum",
schemaType: "array",
$data: true,
error,
code(cxt) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
if (!$data && schema.length === 0)
throw new Error("enum must have non-empty array");
const useLoop = schema.length >= it.opts.loopEnum;
let eql;
const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
let valid;
if (useLoop || $data) {
valid = gen.let("valid");
cxt.block$data(valid, loopEnum);
} else {
if (!Array.isArray(schema))
throw new Error("ajv implementation error");
const vSchema = gen.const("vSchema", schemaCode);
valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
}
cxt.pass(valid);
function loopEnum() {
gen.assign(valid, false);
gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
}
function equalCode(vSchema, i) {
const sch = schema[i];
return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/index.js
var require_validation3 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/validation/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var limitNumber_1 = require_limitNumber2();
var multipleOf_1 = require_multipleOf2();
var limitLength_1 = require_limitLength2();
var pattern_1 = require_pattern2();
var limitProperties_1 = require_limitProperties2();
var required_1 = require_required2();
var limitItems_1 = require_limitItems2();
var uniqueItems_1 = require_uniqueItems2();
var const_1 = require_const2();
var enum_1 = require_enum2();
var validation = [
// number
limitNumber_1.default,
multipleOf_1.default,
// string
limitLength_1.default,
pattern_1.default,
// object
limitProperties_1.default,
required_1.default,
// array
limitItems_1.default,
uniqueItems_1.default,
// any
{ keyword: "type", schemaType: ["string", "array"] },
{ keyword: "nullable", schemaType: "boolean" },
const_1.default,
enum_1.default
];
exports.default = validation;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
var require_additionalItems2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAdditionalItems = void 0;
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var error = {
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
};
var def = {
keyword: "additionalItems",
type: "array",
schemaType: ["boolean", "object"],
before: "uniqueItems",
error,
code(cxt) {
const { parentSchema, it } = cxt;
const { items } = parentSchema;
if (!Array.isArray(items)) {
(0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas');
return;
}
validateAdditionalItems(cxt, items);
}
};
function validateAdditionalItems(cxt, items) {
const { gen, schema, data, keyword, it } = cxt;
it.items = true;
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
if (schema === false) {
cxt.setParams({ len: items.length });
cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
cxt.ok(valid);
}
function validateItems(valid) {
gen.forRange("i", items.length, len, (i) => {
cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid);
if (!it.allErrors)
gen.if((0, codegen_1.not)(valid), () => gen.break());
});
}
}
exports.validateAdditionalItems = validateAdditionalItems;
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/items.js
var require_items2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/items.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateTuple = void 0;
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var code_1 = require_code4();
var def = {
keyword: "items",
type: "array",
schemaType: ["object", "array", "boolean"],
before: "uniqueItems",
code(cxt) {
const { schema, it } = cxt;
if (Array.isArray(schema))
return validateTuple(cxt, "additionalItems", schema);
it.items = true;
if ((0, util_1.alwaysValidSchema)(it, schema))
return;
cxt.ok((0, code_1.validateArray)(cxt));
}
};
function validateTuple(cxt, extraItems, schArr = cxt.schema) {
const { gen, parentSchema, data, keyword, it } = cxt;
checkStrictTuple(parentSchema);
if (it.opts.unevaluated && schArr.length && it.items !== true) {
it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
}
const valid = gen.name("valid");
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
schArr.forEach((sch, i) => {
if ((0, util_1.alwaysValidSchema)(it, sch))
return;
gen.if((0, codegen_1._)`${len} > ${i}`, () => cxt.subschema({
keyword,
schemaProp: i,
dataProp: i
}, valid));
cxt.ok(valid);
});
function checkStrictTuple(sch) {
const { opts, errSchemaPath } = it;
const l = schArr.length;
const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
if (opts.strictTuples && !fullTuple) {
const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
(0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
}
}
}
exports.validateTuple = validateTuple;
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
var require_prefixItems2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var items_1 = require_items2();
var def = {
keyword: "prefixItems",
type: "array",
schemaType: ["array"],
before: "uniqueItems",
code: (cxt) => (0, items_1.validateTuple)(cxt, "items")
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/items2020.js
var require_items20202 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/items2020.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var code_1 = require_code4();
var additionalItems_1 = require_additionalItems2();
var error = {
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
};
var def = {
keyword: "items",
type: "array",
schemaType: ["object", "boolean"],
before: "uniqueItems",
error,
code(cxt) {
const { schema, parentSchema, it } = cxt;
const { prefixItems } = parentSchema;
it.items = true;
if ((0, util_1.alwaysValidSchema)(it, schema))
return;
if (prefixItems)
(0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
else
cxt.ok((0, code_1.validateArray)(cxt));
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/contains.js
var require_contains2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/contains.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var error = {
message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
};
var def = {
keyword: "contains",
type: "array",
schemaType: ["object", "boolean"],
before: "uniqueItems",
trackErrors: true,
error,
code(cxt) {
const { gen, schema, parentSchema, data, it } = cxt;
let min;
let max;
const { minContains, maxContains } = parentSchema;
if (it.opts.next) {
min = minContains === void 0 ? 1 : minContains;
max = maxContains;
} else {
min = 1;
}
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
cxt.setParams({ min, max });
if (max === void 0 && min === 0) {
(0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
return;
}
if (max !== void 0 && min > max) {
(0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
cxt.fail();
return;
}
if ((0, util_1.alwaysValidSchema)(it, schema)) {
let cond = (0, codegen_1._)`${len} >= ${min}`;
if (max !== void 0)
cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
cxt.pass(cond);
return;
}
it.items = true;
const valid = gen.name("valid");
if (max === void 0 && min === 1) {
validateItems(valid, () => gen.if(valid, () => gen.break()));
} else if (min === 0) {
gen.let(valid, true);
if (max !== void 0)
gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
} else {
gen.let(valid, false);
validateItemsWithCount();
}
cxt.result(valid, () => cxt.reset());
function validateItemsWithCount() {
const schValid = gen.name("_valid");
const count = gen.let("count", 0);
validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
}
function validateItems(_valid, block) {
gen.forRange("i", 0, len, (i) => {
cxt.subschema({
keyword: "contains",
dataProp: i,
dataPropType: util_1.Type.Num,
compositeRule: true
}, _valid);
block();
});
}
function checkLimits(count) {
gen.code((0, codegen_1._)`${count}++`);
if (max === void 0) {
gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
} else {
gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
if (min === 1)
gen.assign(valid, true);
else
gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
}
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
var require_dependencies2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/dependencies.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var code_1 = require_code4();
exports.error = {
message: ({ params: { property, depsCount, deps } }) => {
const property_ies = depsCount === 1 ? "property" : "properties";
return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
},
params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property},
missingProperty: ${missingProperty},
depsCount: ${depsCount},
deps: ${deps}}`
// TODO change to reference
};
var def = {
keyword: "dependencies",
type: "object",
schemaType: "object",
error: exports.error,
code(cxt) {
const [propDeps, schDeps] = splitDependencies(cxt);
validatePropertyDeps(cxt, propDeps);
validateSchemaDeps(cxt, schDeps);
}
};
function splitDependencies({ schema }) {
const propertyDeps = {};
const schemaDeps = {};
for (const key in schema) {
if (key === "__proto__")
continue;
const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
deps[key] = schema[key];
}
return [propertyDeps, schemaDeps];
}
function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
const { gen, data, it } = cxt;
if (Object.keys(propertyDeps).length === 0)
return;
const missing = gen.let("missing");
for (const prop in propertyDeps) {
const deps = propertyDeps[prop];
if (deps.length === 0)
continue;
const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
cxt.setParams({
property: prop,
depsCount: deps.length,
deps: deps.join(", ")
});
if (it.allErrors) {
gen.if(hasProperty, () => {
for (const depProp of deps) {
(0, code_1.checkReportMissingProp)(cxt, depProp);
}
});
} else {
gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
(0, code_1.reportMissingProp)(cxt, missing);
gen.else();
}
}
}
exports.validatePropertyDeps = validatePropertyDeps;
function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
const { gen, data, keyword, it } = cxt;
const valid = gen.name("valid");
for (const prop in schemaDeps) {
if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop]))
continue;
gen.if(
(0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties),
() => {
const schCxt = cxt.subschema({ keyword, schemaProp: prop }, valid);
cxt.mergeValidEvaluated(schCxt, valid);
},
() => gen.var(valid, true)
// TODO var
);
cxt.ok(valid);
}
}
exports.validateSchemaDeps = validateSchemaDeps;
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
var require_propertyNames2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var error = {
message: "property name must be valid",
params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
};
var def = {
keyword: "propertyNames",
type: "object",
schemaType: ["object", "boolean"],
error,
code(cxt) {
const { gen, schema, data, it } = cxt;
if ((0, util_1.alwaysValidSchema)(it, schema))
return;
const valid = gen.name("valid");
gen.forIn("key", data, (key) => {
cxt.setParams({ propertyName: key });
cxt.subschema({
keyword: "propertyNames",
data: key,
dataTypes: ["string"],
propertyName: key,
compositeRule: true
}, valid);
gen.if((0, codegen_1.not)(valid), () => {
cxt.error(true);
if (!it.allErrors)
gen.break();
});
});
cxt.ok(valid);
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
var require_additionalProperties2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code4();
var codegen_1 = require_codegen2();
var names_1 = require_names2();
var util_1 = require_util2();
var error = {
message: "must NOT have additional properties",
params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
};
var def = {
keyword: "additionalProperties",
type: ["object"],
schemaType: ["boolean", "object"],
allowUndefined: true,
trackErrors: true,
error,
code(cxt) {
const { gen, schema, parentSchema, data, errsCount, it } = cxt;
if (!errsCount)
throw new Error("ajv implementation error");
const { allErrors, opts } = it;
it.props = true;
if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema))
return;
const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
checkAdditionalProperties();
cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
function checkAdditionalProperties() {
gen.forIn("key", data, (key) => {
if (!props.length && !patProps.length)
additionalPropertyCode(key);
else
gen.if(isAdditional(key), () => additionalPropertyCode(key));
});
}
function isAdditional(key) {
let definedProp;
if (props.length > 8) {
const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
} else if (props.length) {
definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
} else {
definedProp = codegen_1.nil;
}
if (patProps.length) {
definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
}
return (0, codegen_1.not)(definedProp);
}
function deleteAdditional(key) {
gen.code((0, codegen_1._)`delete ${data}[${key}]`);
}
function additionalPropertyCode(key) {
if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
deleteAdditional(key);
return;
}
if (schema === false) {
cxt.setParams({ additionalProperty: key });
cxt.error();
if (!allErrors)
gen.break();
return;
}
if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.name("valid");
if (opts.removeAdditional === "failing") {
applyAdditionalSchema(key, valid, false);
gen.if((0, codegen_1.not)(valid), () => {
cxt.reset();
deleteAdditional(key);
});
} else {
applyAdditionalSchema(key, valid);
if (!allErrors)
gen.if((0, codegen_1.not)(valid), () => gen.break());
}
}
}
function applyAdditionalSchema(key, valid, errors) {
const subschema = {
keyword: "additionalProperties",
dataProp: key,
dataPropType: util_1.Type.Str
};
if (errors === false) {
Object.assign(subschema, {
compositeRule: true,
createErrors: false,
allErrors: false
});
}
cxt.subschema(subschema, valid);
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/properties.js
var require_properties2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/properties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var validate_1 = require_validate2();
var code_1 = require_code4();
var util_1 = require_util2();
var additionalProperties_1 = require_additionalProperties2();
var def = {
keyword: "properties",
type: "object",
schemaType: "object",
code(cxt) {
const { gen, schema, parentSchema, data, it } = cxt;
if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) {
additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
}
const allProps = (0, code_1.allSchemaProperties)(schema);
for (const prop of allProps) {
it.definedProperties.add(prop);
}
if (it.opts.unevaluated && allProps.length && it.props !== true) {
it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
}
const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
if (properties.length === 0)
return;
const valid = gen.name("valid");
for (const prop of properties) {
if (hasDefault(prop)) {
applyPropertySchema(prop);
} else {
gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));
applyPropertySchema(prop);
if (!it.allErrors)
gen.else().var(valid, true);
gen.endIf();
}
cxt.it.definedProperties.add(prop);
cxt.ok(valid);
}
function hasDefault(prop) {
return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0;
}
function applyPropertySchema(prop) {
cxt.subschema({
keyword: "properties",
schemaProp: prop,
dataProp: prop
}, valid);
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
var require_patternProperties2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code4();
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var util_2 = require_util2();
var def = {
keyword: "patternProperties",
type: "object",
schemaType: "object",
code(cxt) {
const { gen, schema, data, parentSchema, it } = cxt;
const { opts } = it;
const patterns = (0, code_1.allSchemaProperties)(schema);
const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) {
return;
}
const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;
const valid = gen.name("valid");
if (it.props !== true && !(it.props instanceof codegen_1.Name)) {
it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
}
const { props } = it;
validatePatternProperties();
function validatePatternProperties() {
for (const pat of patterns) {
if (checkProperties)
checkMatchingProperties(pat);
if (it.allErrors) {
validateProperties(pat);
} else {
gen.var(valid, true);
validateProperties(pat);
gen.if(valid);
}
}
}
function checkMatchingProperties(pat) {
for (const prop in checkProperties) {
if (new RegExp(pat).test(prop)) {
(0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`);
}
}
}
function validateProperties(pat) {
gen.forIn("key", data, (key) => {
gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
const alwaysValid = alwaysValidPatterns.includes(pat);
if (!alwaysValid) {
cxt.subschema({
keyword: "patternProperties",
schemaProp: pat,
dataProp: key,
dataPropType: util_2.Type.Str
}, valid);
}
if (it.opts.unevaluated && props !== true) {
gen.assign((0, codegen_1._)`${props}[${key}]`, true);
} else if (!alwaysValid && !it.allErrors) {
gen.if((0, codegen_1.not)(valid), () => gen.break());
}
});
});
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/not.js
var require_not2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/not.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require_util2();
var def = {
keyword: "not",
schemaType: ["object", "boolean"],
trackErrors: true,
code(cxt) {
const { gen, schema, it } = cxt;
if ((0, util_1.alwaysValidSchema)(it, schema)) {
cxt.fail();
return;
}
const valid = gen.name("valid");
cxt.subschema({
keyword: "not",
compositeRule: true,
createErrors: false,
allErrors: false
}, valid);
cxt.failResult(valid, () => cxt.reset(), () => cxt.error());
},
error: { message: "must NOT be valid" }
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
var require_anyOf2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/anyOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code4();
var def = {
keyword: "anyOf",
schemaType: "array",
trackErrors: true,
code: code_1.validateUnion,
error: { message: "must match a schema in anyOf" }
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
var require_oneOf2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/oneOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var error = {
message: "must match exactly one schema in oneOf",
params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`
};
var def = {
keyword: "oneOf",
schemaType: "array",
trackErrors: true,
error,
code(cxt) {
const { gen, schema, parentSchema, it } = cxt;
if (!Array.isArray(schema))
throw new Error("ajv implementation error");
if (it.opts.discriminator && parentSchema.discriminator)
return;
const schArr = schema;
const valid = gen.let("valid", false);
const passing = gen.let("passing", null);
const schValid = gen.name("_valid");
cxt.setParams({ passing });
gen.block(validateOneOf);
cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
function validateOneOf() {
schArr.forEach((sch, i) => {
let schCxt;
if ((0, util_1.alwaysValidSchema)(it, sch)) {
gen.var(schValid, true);
} else {
schCxt = cxt.subschema({
keyword: "oneOf",
schemaProp: i,
compositeRule: true
}, schValid);
}
if (i > 0) {
gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i}]`).else();
}
gen.if(schValid, () => {
gen.assign(valid, true);
gen.assign(passing, i);
if (schCxt)
cxt.mergeEvaluated(schCxt, codegen_1.Name);
});
});
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/allOf.js
var require_allOf2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/allOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require_util2();
var def = {
keyword: "allOf",
schemaType: "array",
code(cxt) {
const { gen, schema, it } = cxt;
if (!Array.isArray(schema))
throw new Error("ajv implementation error");
const valid = gen.name("valid");
schema.forEach((sch, i) => {
if ((0, util_1.alwaysValidSchema)(it, sch))
return;
const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid);
cxt.ok(valid);
cxt.mergeEvaluated(schCxt);
});
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/if.js
var require_if2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/if.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var util_1 = require_util2();
var error = {
message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
};
var def = {
keyword: "if",
schemaType: ["object", "boolean"],
trackErrors: true,
error,
code(cxt) {
const { gen, parentSchema, it } = cxt;
if (parentSchema.then === void 0 && parentSchema.else === void 0) {
(0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored');
}
const hasThen = hasSchema(it, "then");
const hasElse = hasSchema(it, "else");
if (!hasThen && !hasElse)
return;
const valid = gen.let("valid", true);
const schValid = gen.name("_valid");
validateIf();
cxt.reset();
if (hasThen && hasElse) {
const ifClause = gen.let("ifClause");
cxt.setParams({ ifClause });
gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
} else if (hasThen) {
gen.if(schValid, validateClause("then"));
} else {
gen.if((0, codegen_1.not)(schValid), validateClause("else"));
}
cxt.pass(valid, () => cxt.error(true));
function validateIf() {
const schCxt = cxt.subschema({
keyword: "if",
compositeRule: true,
createErrors: false,
allErrors: false
}, schValid);
cxt.mergeEvaluated(schCxt);
}
function validateClause(keyword, ifClause) {
return () => {
const schCxt = cxt.subschema({ keyword }, schValid);
gen.assign(valid, schValid);
cxt.mergeValidEvaluated(schCxt, valid);
if (ifClause)
gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
else
cxt.setParams({ ifClause: keyword });
};
}
}
};
function hasSchema(it, keyword) {
const schema = it.schema[keyword];
return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
}
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
var require_thenElse2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/thenElse.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require_util2();
var def = {
keyword: ["then", "else"],
schemaType: ["object", "boolean"],
code({ keyword, parentSchema, it }) {
if (parentSchema.if === void 0)
(0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/index.js
var require_applicator3 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var additionalItems_1 = require_additionalItems2();
var prefixItems_1 = require_prefixItems2();
var items_1 = require_items2();
var items2020_1 = require_items20202();
var contains_1 = require_contains2();
var dependencies_1 = require_dependencies2();
var propertyNames_1 = require_propertyNames2();
var additionalProperties_1 = require_additionalProperties2();
var properties_1 = require_properties2();
var patternProperties_1 = require_patternProperties2();
var not_1 = require_not2();
var anyOf_1 = require_anyOf2();
var oneOf_1 = require_oneOf2();
var allOf_1 = require_allOf2();
var if_1 = require_if2();
var thenElse_1 = require_thenElse2();
function getApplicator(draft2020 = false) {
const applicator = [
// any
not_1.default,
anyOf_1.default,
oneOf_1.default,
allOf_1.default,
if_1.default,
thenElse_1.default,
// object
propertyNames_1.default,
additionalProperties_1.default,
dependencies_1.default,
properties_1.default,
patternProperties_1.default
];
if (draft2020)
applicator.push(prefixItems_1.default, items2020_1.default);
else
applicator.push(additionalItems_1.default, items_1.default);
applicator.push(contains_1.default);
return applicator;
}
exports.default = getApplicator;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/format/format.js
var require_format3 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/format/format.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var error = {
message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`,
params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`
};
var def = {
keyword: "format",
type: ["number", "string"],
schemaType: "string",
$data: true,
error,
code(cxt, ruleType) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
const { opts, errSchemaPath, schemaEnv, self: self2 } = it;
if (!opts.validateFormats)
return;
if ($data)
validate$DataFormat();
else
validateFormat();
function validate$DataFormat() {
const fmts = gen.scopeValue("formats", {
ref: self2.formats,
code: opts.code.formats
});
const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
const fType = gen.let("fType");
const format2 = gen.let("format");
gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format2, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format2, fDef));
cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
function unknownFmt() {
if (opts.strictSchema === false)
return codegen_1.nil;
return (0, codegen_1._)`${schemaCode} && !${format2}`;
}
function invalidFmt() {
const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format2}(${data}) : ${format2}(${data}))` : (0, codegen_1._)`${format2}(${data})`;
const validData = (0, codegen_1._)`(typeof ${format2} == "function" ? ${callFormat} : ${format2}.test(${data}))`;
return (0, codegen_1._)`${format2} && ${format2} !== true && ${fType} === ${ruleType} && !${validData}`;
}
}
function validateFormat() {
const formatDef = self2.formats[schema];
if (!formatDef) {
unknownFormat();
return;
}
if (formatDef === true)
return;
const [fmtType, format2, fmtRef] = getFormat(formatDef);
if (fmtType === ruleType)
cxt.pass(validCondition());
function unknownFormat() {
if (opts.strictSchema === false) {
self2.logger.warn(unknownMsg());
return;
}
throw new Error(unknownMsg());
function unknownMsg() {
return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
}
}
function getFormat(fmtDef) {
const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : void 0;
const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code });
if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
}
return ["string", fmtDef, fmt];
}
function validCondition() {
if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
if (!schemaEnv.$async)
throw new Error("async format in sync schema");
return (0, codegen_1._)`await ${fmtRef}(${data})`;
}
return typeof format2 == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
}
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/format/index.js
var require_format4 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/format/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var format_1 = require_format3();
var format2 = [format_1.default];
exports.default = format2;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/metadata.js
var require_metadata2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/metadata.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.contentVocabulary = exports.metadataVocabulary = void 0;
exports.metadataVocabulary = [
"title",
"description",
"default",
"deprecated",
"readOnly",
"writeOnly",
"examples"
];
exports.contentVocabulary = [
"contentMediaType",
"contentEncoding",
"contentSchema"
];
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/draft7.js
var require_draft72 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/draft7.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = require_core5();
var validation_1 = require_validation3();
var applicator_1 = require_applicator3();
var format_1 = require_format4();
var metadata_1 = require_metadata2();
var draft7Vocabularies = [
core_1.default,
validation_1.default,
(0, applicator_1.default)(),
format_1.default,
metadata_1.metadataVocabulary,
metadata_1.contentVocabulary
];
exports.default = draft7Vocabularies;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/discriminator/types.js
var require_types2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/discriminator/types.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DiscrError = void 0;
var DiscrError;
(function(DiscrError2) {
DiscrError2["Tag"] = "tag";
DiscrError2["Mapping"] = "mapping";
})(DiscrError || (exports.DiscrError = DiscrError = {}));
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/discriminator/index.js
var require_discriminator2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/discriminator/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen2();
var types_1 = require_types2();
var compile_1 = require_compile2();
var ref_error_1 = require_ref_error2();
var util_1 = require_util2();
var error = {
message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
};
var def = {
keyword: "discriminator",
type: "object",
schemaType: "object",
error,
code(cxt) {
const { gen, data, schema, parentSchema, it } = cxt;
const { oneOf } = parentSchema;
if (!it.opts.discriminator) {
throw new Error("discriminator: requires discriminator option");
}
const tagName = schema.propertyName;
if (typeof tagName != "string")
throw new Error("discriminator: requires propertyName");
if (schema.mapping)
throw new Error("discriminator: mapping is not supported");
if (!oneOf)
throw new Error("discriminator: requires oneOf keyword");
const valid = gen.let("valid", false);
const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, { discrError: types_1.DiscrError.Tag, tag, tagName }));
cxt.ok(valid);
function validateMapping() {
const mapping = getMapping();
gen.if(false);
for (const tagValue in mapping) {
gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
gen.assign(valid, applyTagSchema(mapping[tagValue]));
}
gen.else();
cxt.error(false, { discrError: types_1.DiscrError.Mapping, tag, tagName });
gen.endIf();
}
function applyTagSchema(schemaProp) {
const _valid = gen.name("valid");
const schCxt = cxt.subschema({ keyword: "oneOf", schemaProp }, _valid);
cxt.mergeEvaluated(schCxt, codegen_1.Name);
return _valid;
}
function getMapping() {
var _a;
const oneOfMapping = {};
const topRequired = hasRequired(parentSchema);
let tagRequired = true;
for (let i = 0; i < oneOf.length; i++) {
let sch = oneOf[i];
if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
const ref = sch.$ref;
sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
if (sch instanceof compile_1.SchemaEnv)
sch = sch.schema;
if (sch === void 0)
throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
}
const propSch = (_a = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a === void 0 ? void 0 : _a[tagName];
if (typeof propSch != "object") {
throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
}
tagRequired = tagRequired && (topRequired || hasRequired(sch));
addMappings(propSch, i);
}
if (!tagRequired)
throw new Error(`discriminator: "${tagName}" must be required`);
return oneOfMapping;
function hasRequired({ required }) {
return Array.isArray(required) && required.includes(tagName);
}
function addMappings(sch, i) {
if (sch.const) {
addMapping(sch.const, i);
} else if (sch.enum) {
for (const tagValue of sch.enum) {
addMapping(tagValue, i);
}
} else {
throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
}
}
function addMapping(tagValue, i) {
if (typeof tagValue != "string" || tagValue in oneOfMapping) {
throw new Error(`discriminator: "${tagName}" values must be unique strings`);
}
oneOfMapping[tagValue] = i;
}
}
}
};
exports.default = def;
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/refs/json-schema-draft-07.json
var require_json_schema_draft_072 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/refs/json-schema-draft-07.json"(exports, module) {
module.exports = {
$schema: "http://json-schema.org/draft-07/schema#",
$id: "http://json-schema.org/draft-07/schema#",
title: "Core schema meta-schema",
definitions: {
schemaArray: {
type: "array",
minItems: 1,
items: { $ref: "#" }
},
nonNegativeInteger: {
type: "integer",
minimum: 0
},
nonNegativeIntegerDefault0: {
allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }]
},
simpleTypes: {
enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
},
stringArray: {
type: "array",
items: { type: "string" },
uniqueItems: true,
default: []
}
},
type: ["object", "boolean"],
properties: {
$id: {
type: "string",
format: "uri-reference"
},
$schema: {
type: "string",
format: "uri"
},
$ref: {
type: "string",
format: "uri-reference"
},
$comment: {
type: "string"
},
title: {
type: "string"
},
description: {
type: "string"
},
default: true,
readOnly: {
type: "boolean",
default: false
},
examples: {
type: "array",
items: true
},
multipleOf: {
type: "number",
exclusiveMinimum: 0
},
maximum: {
type: "number"
},
exclusiveMaximum: {
type: "number"
},
minimum: {
type: "number"
},
exclusiveMinimum: {
type: "number"
},
maxLength: { $ref: "#/definitions/nonNegativeInteger" },
minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
pattern: {
type: "string",
format: "regex"
},
additionalItems: { $ref: "#" },
items: {
anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
default: true
},
maxItems: { $ref: "#/definitions/nonNegativeInteger" },
minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
uniqueItems: {
type: "boolean",
default: false
},
contains: { $ref: "#" },
maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
required: { $ref: "#/definitions/stringArray" },
additionalProperties: { $ref: "#" },
definitions: {
type: "object",
additionalProperties: { $ref: "#" },
default: {}
},
properties: {
type: "object",
additionalProperties: { $ref: "#" },
default: {}
},
patternProperties: {
type: "object",
additionalProperties: { $ref: "#" },
propertyNames: { format: "regex" },
default: {}
},
dependencies: {
type: "object",
additionalProperties: {
anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }]
}
},
propertyNames: { $ref: "#" },
const: true,
enum: {
type: "array",
items: true,
minItems: 1,
uniqueItems: true
},
type: {
anyOf: [
{ $ref: "#/definitions/simpleTypes" },
{
type: "array",
items: { $ref: "#/definitions/simpleTypes" },
minItems: 1,
uniqueItems: true
}
]
},
format: { type: "string" },
contentMediaType: { type: "string" },
contentEncoding: { type: "string" },
if: { $ref: "#" },
then: { $ref: "#" },
else: { $ref: "#" },
allOf: { $ref: "#/definitions/schemaArray" },
anyOf: { $ref: "#/definitions/schemaArray" },
oneOf: { $ref: "#/definitions/schemaArray" },
not: { $ref: "#" }
},
default: true
};
}
});
// node_modules/ajv-formats/node_modules/ajv/dist/ajv.js
var require_ajv2 = __commonJS({
"node_modules/ajv-formats/node_modules/ajv/dist/ajv.js"(exports, module) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
var core_1 = require_core4();
var draft7_1 = require_draft72();
var discriminator_1 = require_discriminator2();
var draft7MetaSchema = require_json_schema_draft_072();
var META_SUPPORT_DATA = ["/properties"];
var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
var Ajv = class extends core_1.default {
_addVocabularies() {
super._addVocabularies();
draft7_1.default.forEach((v) => this.addVocabulary(v));
if (this.opts.discriminator)
this.addKeyword(discriminator_1.default);
}
_addDefaultMetaSchema() {
super._addDefaultMetaSchema();
if (!this.opts.meta)
return;
const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema;
this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
}
defaultMeta() {
return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
}
};
exports.Ajv = Ajv;
module.exports = exports = Ajv;
module.exports.Ajv = Ajv;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = Ajv;
var validate_1 = require_validate2();
Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
return validate_1.KeywordCxt;
} });
var codegen_1 = require_codegen2();
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
return codegen_1._;
} });
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
return codegen_1.str;
} });
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
return codegen_1.stringify;
} });
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
return codegen_1.nil;
} });
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
return codegen_1.Name;
} });
Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
return codegen_1.CodeGen;
} });
var validation_error_1 = require_validation_error2();
Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
return validation_error_1.default;
} });
var ref_error_1 = require_ref_error2();
Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
return ref_error_1.default;
} });
}
});
// node_modules/ajv-formats/dist/limit.js
var require_limit = __commonJS({
"node_modules/ajv-formats/dist/limit.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatLimitDefinition = void 0;
var ajv_1 = require_ajv2();
var codegen_1 = require_codegen2();
var ops = codegen_1.operators;
var KWDs = {
formatMaximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
formatMinimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
formatExclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
formatExclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
};
var error = {
message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
};
exports.formatLimitDefinition = {
keyword: Object.keys(KWDs),
type: "string",
schemaType: "string",
$data: true,
error,
code(cxt) {
const { gen, data, schemaCode, keyword, it } = cxt;
const { opts, self: self2 } = it;
if (!opts.validateFormats)
return;
const fCxt = new ajv_1.KeywordCxt(it, self2.RULES.all.format.definition, "format");
if (fCxt.$data)
validate$DataFormat();
else
validateFormat();
function validate$DataFormat() {
const fmts = gen.scopeValue("formats", {
ref: self2.formats,
code: opts.code.formats
});
const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
}
function validateFormat() {
const format2 = fCxt.schema;
const fmtDef = self2.formats[format2];
if (!fmtDef || fmtDef === true)
return;
if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
throw new Error(`"${keyword}": format "${format2}" does not define "compare" function`);
}
const fmt = gen.scopeValue("formats", {
key: format2,
ref: fmtDef,
code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format2)}` : void 0
});
cxt.fail$data(compareCode(fmt));
}
function compareCode(fmt) {
return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
}
},
dependencies: ["format"]
};
var formatLimitPlugin = (ajv) => {
ajv.addKeyword(exports.formatLimitDefinition);
return ajv;
};
exports.default = formatLimitPlugin;
}
});
// node_modules/ajv-formats/dist/index.js
var require_dist = __commonJS({
"node_modules/ajv-formats/dist/index.js"(exports, module) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var formats_1 = require_formats();
var limit_1 = require_limit();
var codegen_1 = require_codegen2();
var fullName = new codegen_1.Name("fullFormats");
var fastName = new codegen_1.Name("fastFormats");
var formatsPlugin = (ajv, opts = { keywords: true }) => {
if (Array.isArray(opts)) {
addFormats2(ajv, opts, formats_1.fullFormats, fullName);
return ajv;
}
const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
const list = opts.formats || formats_1.formatNames;
addFormats2(ajv, list, formats, exportName);
if (opts.keywords)
(0, limit_1.default)(ajv);
return ajv;
};
formatsPlugin.get = (name, mode = "full") => {
const formats = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats;
const f = formats[name];
if (!f)
throw new Error(`Unknown format "${name}"`);
return f;
};
function addFormats2(ajv, list, fs11, exportName) {
var _a;
var _b;
(_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
for (const f of list)
ajv.addFormat(f, fs11[f]);
}
module.exports = exports = formatsPlugin;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = formatsPlugin;
}
});
// node_modules/extend/index.js
var require_extend = __commonJS({
"node_modules/extend/index.js"(exports, module) {
"use strict";
var hasOwn = Object.prototype.hasOwnProperty;
var toStr = Object.prototype.toString;
var defineProperty = Object.defineProperty;
var gOPD = Object.getOwnPropertyDescriptor;
var isArray = function isArray2(arr) {
if (typeof Array.isArray === "function") {
return Array.isArray(arr);
}
return toStr.call(arr) === "[object Array]";
};
var isPlainObject = function isPlainObject2(obj) {
if (!obj || toStr.call(obj) !== "[object Object]") {
return false;
}
var hasOwnConstructor = hasOwn.call(obj, "constructor");
var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf");
if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
return false;
}
var key;
for (key in obj) {
}
return typeof key === "undefined" || hasOwn.call(obj, key);
};
var setProperty = function setProperty2(target, options) {
if (defineProperty && options.name === "__proto__") {
defineProperty(target, options.name, {
enumerable: true,
configurable: true,
value: options.newValue,
writable: true
});
} else {
target[options.name] = options.newValue;
}
};
var getProperty = function getProperty2(obj, name) {
if (name === "__proto__") {
if (!hasOwn.call(obj, name)) {
return void 0;
} else if (gOPD) {
return gOPD(obj, name).value;
}
}
return obj[name];
};
module.exports = function extend() {
var options, name, src, copy, copyIsArray, clone;
var target = arguments[0];
var i = 1;
var length = arguments.length;
var deep = false;
if (typeof target === "boolean") {
deep = target;
target = arguments[1] || {};
i = 2;
}
if (target == null || typeof target !== "object" && typeof target !== "function") {
target = {};
}
for (; i < length; ++i) {
options = arguments[i];
if (options != null) {
for (name in options) {
src = getProperty(target, name);
copy = getProperty(options, name);
if (target !== copy) {
if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
if (copyIsArray) {
copyIsArray = false;
clone = src && isArray(src) ? src : [];
} else {
clone = src && isPlainObject(src) ? src : {};
}
setProperty(target, { name, newValue: extend(deep, clone, copy) });
} else if (typeof copy !== "undefined") {
setProperty(target, { name, newValue: copy });
}
}
}
}
}
return target;
};
}
});
// node_modules/@google/genai/node_modules/gaxios/package.json
var require_package = __commonJS({
"node_modules/@google/genai/node_modules/gaxios/package.json"(exports, module) {
module.exports = {
name: "gaxios",
version: "7.1.3",
description: "A simple common HTTP client specifically for Google APIs and services.",
main: "build/cjs/src/index.js",
types: "build/cjs/src/index.d.ts",
files: [
"build/"
],
exports: {
".": {
import: {
types: "./build/esm/src/index.d.ts",
default: "./build/esm/src/index.js"
},
require: {
types: "./build/cjs/src/index.d.ts",
default: "./build/cjs/src/index.js"
}
}
},
scripts: {
lint: "gts check --no-inline-config",
test: "c8 mocha build/esm/test",
"presystem-test": "npm run compile",
"system-test": "mocha build/esm/system-test --timeout 80000",
compile: "tsc -b ./tsconfig.json ./tsconfig.cjs.json && node utils/enable-esm.mjs",
fix: "gts fix",
prepare: "npm run compile",
pretest: "npm run compile",
webpack: "webpack",
"prebrowser-test": "npm run compile",
"browser-test": "node build/browser-test/browser-test-runner.js",
docs: "jsdoc -c .jsdoc.js",
"docs-test": "linkinator docs",
"predocs-test": "npm run docs",
"samples-test": "cd samples/ && npm link ../ && npm test && cd ../",
prelint: "cd samples; npm link ../; npm install",
clean: "gts clean"
},
repository: {
type: "git",
directory: "packages/gaxios",
url: "https://github.com/googleapis/google-cloud-node-core.git"
},
keywords: [
"google"
],
engines: {
node: ">=18"
},
author: "Google, LLC",
license: "Apache-2.0",
devDependencies: {
"@babel/plugin-proposal-private-methods": "^7.18.6",
"@types/cors": "^2.8.6",
"@types/express": "^5.0.0",
"@types/extend": "^3.0.1",
"@types/mocha": "^10.0.10",
"@types/multiparty": "4.2.1",
"@types/mv": "^2.1.0",
"@types/ncp": "^2.0.1",
"@types/node": "^22.0.0",
"@types/sinon": "^17.0.0",
"@types/tmp": "0.2.6",
assert: "^2.0.0",
browserify: "^17.0.0",
c8: "^10.0.0",
cors: "^2.8.5",
express: "^5.0.0",
gts: "^6.0.0",
"is-docker": "^3.0.0",
jsdoc: "^4.0.0",
"jsdoc-fresh": "^5.0.0",
"jsdoc-region-tag": "^4.0.0",
karma: "^6.0.0",
"karma-chrome-launcher": "^3.0.0",
"karma-coverage": "^2.0.0",
"karma-firefox-launcher": "^2.0.0",
"karma-mocha": "^2.0.0",
"karma-remap-coverage": "^0.1.5",
"karma-sourcemap-loader": "^0.4.0",
"karma-webpack": "^5.0.1",
linkinator: "^6.1.2",
mocha: "^11.1.0",
multiparty: "^4.2.1",
mv: "^2.1.1",
ncp: "^2.0.0",
nock: "^14.0.0-beta.13",
"null-loader": "^4.0.0",
"pack-n-play": "^4.0.0",
puppeteer: "^24.0.0",
sinon: "^21.0.0",
"stream-browserify": "^3.0.0",
tmp: "0.2.5",
"ts-loader": "^9.5.2",
typescript: "^5.8.3",
webpack: "^5.35.0",
"webpack-cli": "^6.0.1"
},
dependencies: {
extend: "^3.0.2",
"https-proxy-agent": "^7.0.1",
"node-fetch": "^3.3.2",
rimraf: "^5.0.1"
},
homepage: "https://github.com/googleapis/google-cloud-node-core/tree/main/packages/gaxios"
};
}
});
// node_modules/@google/genai/node_modules/gaxios/build/cjs/src/util.cjs
var require_util3 = __commonJS({
"node_modules/@google/genai/node_modules/gaxios/build/cjs/src/util.cjs"(exports, module) {
"use strict";
var pkg = require_package();
module.exports = { pkg };
}
});
// node_modules/@google/genai/node_modules/gaxios/build/cjs/src/common.js
var require_common = __commonJS({
"node_modules/@google/genai/node_modules/gaxios/build/cjs/src/common.js"(exports) {
"use strict";
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.GaxiosError = exports.GAXIOS_ERROR_SYMBOL = void 0;
exports.defaultErrorRedactor = defaultErrorRedactor;
var extend_1 = __importDefault(require_extend());
var util_cjs_1 = __importDefault(require_util3());
var pkg = util_cjs_1.default.pkg;
exports.GAXIOS_ERROR_SYMBOL = Symbol.for(`${pkg.name}-gaxios-error`);
var GaxiosError = class _GaxiosError extends Error {
config;
response;
/**
* An error code.
* Can be a system error code, DOMException error name, or any error's 'code' property where it is a `string`.
*
* It is only a `number` when the cause is sourced from an API-level error (AIP-193).
*
* @see {@link https://nodejs.org/api/errors.html#errorcode error.code}
* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMException#error_names DOMException#error_names}
* @see {@link https://google.aip.dev/193#http11json-representation AIP-193}
*
* @example
* 'ECONNRESET'
*
* @example
* 'TimeoutError'
*
* @example
* 500
*/
code;
/**
* An HTTP Status code.
* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Response/status Response#status}
*
* @example
* 500
*/
status;
/**
* @deprecated use {@link GaxiosError.cause} instead.
*
* @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause Error#cause}
*
* @privateRemarks
*
* We will want to remove this property later as the modern `cause` property is better suited
* for displaying and relaying nested errors. Keeping this here makes the resulting
* error log larger than it needs to be.
*
*/
error;
/**
* Support `instanceof` operator for `GaxiosError` across builds/duplicated files.
*
* @see {@link GAXIOS_ERROR_SYMBOL}
* @see {@link GaxiosError[Symbol.hasInstance]}
* @see {@link https://github.com/microsoft/TypeScript/issues/13965#issuecomment-278570200}
* @see {@link https://stackoverflow.com/questions/46618852/require-and-instanceof}
* @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/@@hasInstance#reverting_to_default_instanceof_behavior}
*/
[exports.GAXIOS_ERROR_SYMBOL] = pkg.version;
/**
* Support `instanceof` operator for `GaxiosError` across builds/duplicated files.
*
* @see {@link GAXIOS_ERROR_SYMBOL}
* @see {@link GaxiosError[GAXIOS_ERROR_SYMBOL]}
*/
static [Symbol.hasInstance](instance) {
if (instance && typeof instance === "object" && exports.GAXIOS_ERROR_SYMBOL in instance && instance[exports.GAXIOS_ERROR_SYMBOL] === pkg.version) {
return true;
}
return Function.prototype[Symbol.hasInstance].call(_GaxiosError, instance);
}
constructor(message, config, response, cause) {
super(message, { cause });
this.config = config;
this.response = response;
this.error = cause instanceof Error ? cause : void 0;
this.config = (0, extend_1.default)(true, {}, config);
if (this.response) {
this.response.config = (0, extend_1.default)(true, {}, this.response.config);
}
if (this.response) {
try {
this.response.data = translateData(
this.config.responseType,
// workaround for `node-fetch`'s `.data` deprecation...
this.response?.bodyUsed ? this.response?.data : void 0
);
} catch {
}
this.status = this.response.status;
}
if (cause instanceof DOMException) {
this.code = cause.name;
} else if (cause && typeof cause === "object" && "code" in cause && (typeof cause.code === "string" || typeof cause.code === "number")) {
this.code = cause.code;
}
}
/**
* An AIP-193 conforming error extractor.
*
* @see {@link https://google.aip.dev/193#http11json-representation AIP-193}
*
* @internal
* @expiremental
*
* @param res the response object
* @returns the extracted error information
*/
static extractAPIErrorFromResponse(res, defaultErrorMessage = "The request failed") {
let message = defaultErrorMessage;
if (typeof res.data === "string") {
message = res.data;
}
if (res.data && typeof res.data === "object" && "error" in res.data && res.data.error && !res.ok) {
if (typeof res.data.error === "string") {
return {
message: res.data.error,
code: res.status,
status: res.statusText
};
}
if (typeof res.data.error === "object") {
message = "message" in res.data.error && typeof res.data.error.message === "string" ? res.data.error.message : message;
const status = "status" in res.data.error && typeof res.data.error.status === "string" ? res.data.error.status : res.statusText;
const code = "code" in res.data.error && typeof res.data.error.code === "number" ? res.data.error.code : res.status;
if ("errors" in res.data.error && Array.isArray(res.data.error.errors)) {
const errorMessages = [];
for (const e of res.data.error.errors) {
if (typeof e === "object" && "message" in e && typeof e.message === "string") {
errorMessages.push(e.message);
}
}
return Object.assign({
message: errorMessages.join("\n") || message,
code,
status
}, res.data.error);
}
return Object.assign({
message,
code,
status
}, res.data.error);
}
}
return {
message,
code: res.status,
status: res.statusText
};
}
};
exports.GaxiosError = GaxiosError;
function translateData(responseType, data) {
switch (responseType) {
case "stream":
return data;
case "json":
return JSON.parse(JSON.stringify(data));
case "arraybuffer":
return JSON.parse(Buffer.from(data).toString("utf8"));
case "blob":
return JSON.parse(data.text());
default:
return data;
}
}
function defaultErrorRedactor(data) {
const REDACT = "<<REDACTED> - See `errorRedactor` option in `gaxios` for configuration>.";
function redactHeaders(headers) {
if (!headers)
return;
headers.forEach((_, key) => {
if (/^authentication$/i.test(key) || /^authorization$/i.test(key) || /secret/i.test(key))
headers.set(key, REDACT);
});
}
function redactString(obj, key) {
if (typeof obj === "object" && obj !== null && typeof obj[key] === "string") {
const text = obj[key];
if (/grant_type=/i.test(text) || /assertion=/i.test(text) || /secret/i.test(text)) {
obj[key] = REDACT;
}
}
}
function redactObject(obj) {
if (!obj || typeof obj !== "object") {
return;
} else if (obj instanceof FormData || obj instanceof URLSearchParams || // support `node-fetch` FormData/URLSearchParams
"forEach" in obj && "set" in obj) {
obj.forEach((_, key) => {
if (["grant_type", "assertion"].includes(key) || /secret/.test(key)) {
obj.set(key, REDACT);
}
});
} else {
if ("grant_type" in obj) {
obj["grant_type"] = REDACT;
}
if ("assertion" in obj) {
obj["assertion"] = REDACT;
}
if ("client_secret" in obj) {
obj["client_secret"] = REDACT;
}
}
}
if (data.config) {
redactHeaders(data.config.headers);
redactString(data.config, "data");
redactObject(data.config.data);
redactString(data.config, "body");
redactObject(data.config.body);
if (data.config.url.searchParams.has("token")) {
data.config.url.searchParams.set("token", REDACT);
}
if (data.config.url.searchParams.has("client_secret")) {
data.config.url.searchParams.set("client_secret", REDACT);
}
}
if (data.response) {
defaultErrorRedactor({ config: data.response.config });
redactHeaders(data.response.headers);
if (data.response.bodyUsed) {
redactString(data.response, "data");
redactObject(data.response.data);
}
}
return data;
}
}
});
// node_modules/@google/genai/node_modules/gaxios/build/cjs/src/retry.js
var require_retry = __commonJS({
"node_modules/@google/genai/node_modules/gaxios/build/cjs/src/retry.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getRetryConfig = getRetryConfig;
async function getRetryConfig(err) {
let config = getConfig(err);
if (!err || !err.config || !config && !err.config.retry) {
return { shouldRetry: false };
}
config = config || {};
config.currentRetryAttempt = config.currentRetryAttempt || 0;
config.retry = config.retry === void 0 || config.retry === null ? 3 : config.retry;
config.httpMethodsToRetry = config.httpMethodsToRetry || [
"GET",
"HEAD",
"PUT",
"OPTIONS",
"DELETE"
];
config.noResponseRetries = config.noResponseRetries === void 0 || config.noResponseRetries === null ? 2 : config.noResponseRetries;
config.retryDelayMultiplier = config.retryDelayMultiplier ? config.retryDelayMultiplier : 2;
config.timeOfFirstRequest = config.timeOfFirstRequest ? config.timeOfFirstRequest : Date.now();
config.totalTimeout = config.totalTimeout ? config.totalTimeout : Number.MAX_SAFE_INTEGER;
config.maxRetryDelay = config.maxRetryDelay ? config.maxRetryDelay : Number.MAX_SAFE_INTEGER;
const retryRanges = [
// https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
// 1xx - Retry (Informational, request still processing)
// 2xx - Do not retry (Success)
// 3xx - Do not retry (Redirect)
// 4xx - Do not retry (Client errors)
// 408 - Retry ("Request Timeout")
// 429 - Retry ("Too Many Requests")
// 5xx - Retry (Server errors)
[100, 199],
[408, 408],
[429, 429],
[500, 599]
];
config.statusCodesToRetry = config.statusCodesToRetry || retryRanges;
err.config.retryConfig = config;
const shouldRetryFn = config.shouldRetry || shouldRetryRequest;
if (!await shouldRetryFn(err)) {
return { shouldRetry: false, config: err.config };
}
const delay = getNextRetryDelay(config);
err.config.retryConfig.currentRetryAttempt += 1;
const backoff = config.retryBackoff ? config.retryBackoff(err, delay) : new Promise((resolve5) => {
setTimeout(resolve5, delay);
});
if (config.onRetryAttempt) {
await config.onRetryAttempt(err);
}
await backoff;
return { shouldRetry: true, config: err.config };
}
function shouldRetryRequest(err) {
const config = getConfig(err);
if (err.config.signal?.aborted && err.code !== "TimeoutError" || err.code === "AbortError") {
return false;
}
if (!config || config.retry === 0) {
return false;
}
if (!err.response && (config.currentRetryAttempt || 0) >= config.noResponseRetries) {
return false;
}
if (!config.httpMethodsToRetry || !config.httpMethodsToRetry.includes(err.config.method?.toUpperCase() || "GET")) {
return false;
}
if (err.response && err.response.status) {
let isInRange = false;
for (const [min, max] of config.statusCodesToRetry) {
const status = err.response.status;
if (status >= min && status <= max) {
isInRange = true;
break;
}
}
if (!isInRange) {
return false;
}
}
config.currentRetryAttempt = config.currentRetryAttempt || 0;
if (config.currentRetryAttempt >= config.retry) {
return false;
}
return true;
}
function getConfig(err) {
if (err && err.config && err.config.retryConfig) {
return err.config.retryConfig;
}
return;
}
function getNextRetryDelay(config) {
const retryDelay = config.currentRetryAttempt ? 0 : config.retryDelay ?? 100;
const calculatedDelay = retryDelay + (Math.pow(config.retryDelayMultiplier, config.currentRetryAttempt) - 1) / 2 * 1e3;
const maxAllowableDelay = config.totalTimeout - (Date.now() - config.timeOfFirstRequest);
return Math.min(calculatedDelay, maxAllowableDelay, config.maxRetryDelay);
}
}
});
// node_modules/@google/genai/node_modules/gaxios/build/cjs/src/interceptor.js
var require_interceptor = __commonJS({
"node_modules/@google/genai/node_modules/gaxios/build/cjs/src/interceptor.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GaxiosInterceptorManager = void 0;
var GaxiosInterceptorManager = class extends Set {
};
exports.GaxiosInterceptorManager = GaxiosInterceptorManager;
}
});
// node_modules/@google/genai/node_modules/gaxios/build/cjs/src/gaxios.js
var require_gaxios = __commonJS({
"node_modules/@google/genai/node_modules/gaxios/build/cjs/src/gaxios.js"(exports) {
"use strict";
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Gaxios = void 0;
var extend_1 = __importDefault(require_extend());
var https_1 = __require("https");
var common_js_1 = require_common();
var retry_js_1 = require_retry();
var stream_1 = __require("stream");
var interceptor_js_1 = require_interceptor();
var randomUUID3 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
var HTTP_STATUS_NO_CONTENT = 204;
var Gaxios = class {
agentCache = /* @__PURE__ */ new Map();
/**
* Default HTTP options that will be used for every HTTP request.
*/
defaults;
/**
* Interceptors
*/
interceptors;
/**
* The Gaxios class is responsible for making HTTP requests.
* @param defaults The default set of options to be used for this instance.
*/
constructor(defaults) {
this.defaults = defaults || {};
this.interceptors = {
request: new interceptor_js_1.GaxiosInterceptorManager(),
response: new interceptor_js_1.GaxiosInterceptorManager()
};
}
/**
* A {@link fetch `fetch`} compliant API for {@link Gaxios}.
*
* @remarks
*
* This is useful as a drop-in replacement for `fetch` API usage.
*
* @example
*
* ```ts
* const gaxios = new Gaxios();
* const myFetch: typeof fetch = (...args) => gaxios.fetch(...args);
* await myFetch('https://example.com');
* ```
*
* @param args `fetch` API or `Gaxios#request` parameters
* @returns the {@link Response} with Gaxios-added properties
*/
fetch(...args) {
const input = args[0];
const init = args[1];
let url = void 0;
const headers = new Headers();
if (typeof input === "string") {
url = new URL(input);
} else if (input instanceof URL) {
url = input;
} else if (input && input.url) {
url = new URL(input.url);
}
if (input && typeof input === "object" && "headers" in input) {
_a.mergeHeaders(headers, input.headers);
}
if (init) {
_a.mergeHeaders(headers, new Headers(init.headers));
}
if (typeof input === "object" && !(input instanceof URL)) {
return this.request({ ...init, ...input, headers, url });
} else {
return this.request({ ...init, headers, url });
}
}
/**
* Perform an HTTP request with the given options.
* @param opts Set of HTTP options that will be used for this HTTP request.
*/
async request(opts = {}) {
let prepared = await this.#prepareRequest(opts);
prepared = await this.#applyRequestInterceptors(prepared);
return this.#applyResponseInterceptors(this._request(prepared));
}
async _defaultAdapter(config) {
const fetchImpl = config.fetchImplementation || this.defaults.fetchImplementation || await _a.#getFetch();
const preparedOpts = { ...config };
delete preparedOpts.data;
const res = await fetchImpl(config.url, preparedOpts);
const data = await this.getResponseData(config, res);
if (!Object.getOwnPropertyDescriptor(res, "data")?.configurable) {
Object.defineProperties(res, {
data: {
configurable: true,
writable: true,
enumerable: true,
value: data
}
});
}
return Object.assign(res, { config, data });
}
/**
* Internal, retryable version of the `request` method.
* @param opts Set of HTTP options that will be used for this HTTP request.
*/
async _request(opts) {
try {
let translatedResponse;
if (opts.adapter) {
translatedResponse = await opts.adapter(opts, this._defaultAdapter.bind(this));
} else {
translatedResponse = await this._defaultAdapter(opts);
}
if (!opts.validateStatus(translatedResponse.status)) {
if (opts.responseType === "stream") {
const response = [];
for await (const chunk of translatedResponse.data) {
response.push(chunk);
}
translatedResponse.data = response.toString();
}
const errorInfo = common_js_1.GaxiosError.extractAPIErrorFromResponse(translatedResponse, `Request failed with status code ${translatedResponse.status}`);
throw new common_js_1.GaxiosError(errorInfo?.message, opts, translatedResponse, errorInfo);
}
return translatedResponse;
} catch (e) {
let err;
if (e instanceof common_js_1.GaxiosError) {
err = e;
} else if (e instanceof Error) {
err = new common_js_1.GaxiosError(e.message, opts, void 0, e);
} else {
err = new common_js_1.GaxiosError("Unexpected Gaxios Error", opts, void 0, e);
}
const { shouldRetry, config } = await (0, retry_js_1.getRetryConfig)(err);
if (shouldRetry && config) {
err.config.retryConfig.currentRetryAttempt = config.retryConfig.currentRetryAttempt;
opts.retryConfig = err.config?.retryConfig;
this.#appendTimeoutToSignal(opts);
return this._request(opts);
}
if (opts.errorRedactor) {
opts.errorRedactor(err);
}
throw err;
}
}
async getResponseData(opts, res) {
if (res.status === HTTP_STATUS_NO_CONTENT) {
return "";
}
if (opts.maxContentLength && res.headers.has("content-length") && opts.maxContentLength < Number.parseInt(res.headers?.get("content-length") || "")) {
throw new common_js_1.GaxiosError("Response's `Content-Length` is over the limit.", opts, Object.assign(res, { config: opts }));
}
switch (opts.responseType) {
case "stream":
return res.body;
case "json": {
const data = await res.text();
try {
return JSON.parse(data);
} catch {
return data;
}
}
case "arraybuffer":
return res.arrayBuffer();
case "blob":
return res.blob();
case "text":
return res.text();
default:
return this.getResponseDataFromContentType(res);
}
}
#urlMayUseProxy(url, noProxy = []) {
const candidate = new URL(url);
const noProxyList = [...noProxy];
const noProxyEnvList = (process.env.NO_PROXY ?? process.env.no_proxy)?.split(",") || [];
for (const rule of noProxyEnvList) {
noProxyList.push(rule.trim());
}
for (const rule of noProxyList) {
if (rule instanceof RegExp) {
if (rule.test(candidate.toString())) {
return false;
}
} else if (rule instanceof URL) {
if (rule.origin === candidate.origin) {
return false;
}
} else if (rule.startsWith("*.") || rule.startsWith(".")) {
const cleanedRule = rule.replace(/^\*\./, ".");
if (candidate.hostname.endsWith(cleanedRule)) {
return false;
}
} else if (rule === candidate.origin || rule === candidate.hostname || rule === candidate.href) {
return false;
}
}
return true;
}
/**
* Applies the request interceptors. The request interceptors are applied after the
* call to prepareRequest is completed.
*
* @param {GaxiosOptionsPrepared} options The current set of options.
*
* @returns {Promise<GaxiosOptionsPrepared>} Promise that resolves to the set of options or response after interceptors are applied.
*/
async #applyRequestInterceptors(options) {
let promiseChain = Promise.resolve(options);
for (const interceptor of this.interceptors.request.values()) {
if (interceptor) {
promiseChain = promiseChain.then(interceptor.resolved, interceptor.rejected);
}
}
return promiseChain;
}
/**
* Applies the response interceptors. The response interceptors are applied after the
* call to request is made.
*
* @param {GaxiosOptionsPrepared} options The current set of options.
*
* @returns {Promise<GaxiosOptionsPrepared>} Promise that resolves to the set of options or response after interceptors are applied.
*/
async #applyResponseInterceptors(response) {
let promiseChain = Promise.resolve(response);
for (const interceptor of this.interceptors.response.values()) {
if (interceptor) {
promiseChain = promiseChain.then(interceptor.resolved, interceptor.rejected);
}
}
return promiseChain;
}
/**
* Validates the options, merges them with defaults, and prepare request.
*
* @param options The original options passed from the client.
* @returns Prepared options, ready to make a request
*/
async #prepareRequest(options) {
const preparedHeaders = new Headers(this.defaults.headers);
_a.mergeHeaders(preparedHeaders, options.headers);
const opts = (0, extend_1.default)(true, {}, this.defaults, options);
if (!opts.url) {
throw new Error("URL is required.");
}
if (opts.baseURL) {
opts.url = new URL(opts.url, opts.baseURL);
}
opts.url = new URL(opts.url);
if (opts.params) {
if (opts.paramsSerializer) {
let additionalQueryParams = opts.paramsSerializer(opts.params);
if (additionalQueryParams.startsWith("?")) {
additionalQueryParams = additionalQueryParams.slice(1);
}
const prefix = opts.url.toString().includes("?") ? "&" : "?";
opts.url = opts.url + prefix + additionalQueryParams;
} else {
const url = opts.url instanceof URL ? opts.url : new URL(opts.url);
for (const [key, value] of new URLSearchParams(opts.params)) {
url.searchParams.append(key, value);
}
opts.url = url;
}
}
if (typeof options.maxContentLength === "number") {
opts.size = options.maxContentLength;
}
if (typeof options.maxRedirects === "number") {
opts.follow = options.maxRedirects;
}
const shouldDirectlyPassData = typeof opts.data === "string" || opts.data instanceof ArrayBuffer || opts.data instanceof Blob || // Node 18 does not have a global `File` object
globalThis.File && opts.data instanceof File || opts.data instanceof FormData || opts.data instanceof stream_1.Readable || opts.data instanceof ReadableStream || opts.data instanceof String || opts.data instanceof URLSearchParams || ArrayBuffer.isView(opts.data) || // `Buffer` (Node.js), `DataView`, `TypedArray`
/**
* @deprecated `node-fetch` or another third-party's request types
*/
["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
if (opts.multipart?.length) {
const boundary = await randomUUID3();
preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
} else if (shouldDirectlyPassData) {
opts.body = opts.data;
} else if (typeof opts.data === "object") {
if (preparedHeaders.get("Content-Type") === "application/x-www-form-urlencoded") {
opts.body = opts.paramsSerializer ? opts.paramsSerializer(opts.data) : new URLSearchParams(opts.data);
} else {
if (!preparedHeaders.has("content-type")) {
preparedHeaders.set("content-type", "application/json");
}
opts.body = JSON.stringify(opts.data);
}
} else if (opts.data) {
opts.body = opts.data;
}
opts.validateStatus = opts.validateStatus || this.validateStatus;
opts.responseType = opts.responseType || "unknown";
if (!preparedHeaders.has("accept") && opts.responseType === "json") {
preparedHeaders.set("accept", "application/json");
}
const proxy = opts.proxy || process?.env?.HTTPS_PROXY || process?.env?.https_proxy || process?.env?.HTTP_PROXY || process?.env?.http_proxy;
if (opts.agent) {
} else if (proxy && this.#urlMayUseProxy(opts.url, opts.noProxy)) {
const HttpsProxyAgent = await _a.#getProxyAgent();
if (this.agentCache.has(proxy)) {
opts.agent = this.agentCache.get(proxy);
} else {
opts.agent = new HttpsProxyAgent(proxy, {
cert: opts.cert,
key: opts.key
});
this.agentCache.set(proxy, opts.agent);
}
} else if (opts.cert && opts.key) {
if (this.agentCache.has(opts.key)) {
opts.agent = this.agentCache.get(opts.key);
} else {
opts.agent = new https_1.Agent({
cert: opts.cert,
key: opts.key
});
this.agentCache.set(opts.key, opts.agent);
}
}
if (typeof opts.errorRedactor !== "function" && opts.errorRedactor !== false) {
opts.errorRedactor = common_js_1.defaultErrorRedactor;
}
if (opts.body && !("duplex" in opts)) {
opts.duplex = "half";
}
this.#appendTimeoutToSignal(opts);
return Object.assign(opts, {
headers: preparedHeaders,
url: opts.url instanceof URL ? opts.url : new URL(opts.url)
});
}
#appendTimeoutToSignal(opts) {
if (opts.timeout) {
const timeoutSignal = AbortSignal.timeout(opts.timeout);
if (opts.signal && !opts.signal.aborted) {
opts.signal = AbortSignal.any([opts.signal, timeoutSignal]);
} else {
opts.signal = timeoutSignal;
}
}
}
/**
* By default, throw for any non-2xx status code
* @param status status code from the HTTP response
*/
validateStatus(status) {
return status >= 200 && status < 300;
}
/**
* Attempts to parse a response by looking at the Content-Type header.
* @param {Response} response the HTTP response.
* @returns a promise that resolves to the response data.
*/
async getResponseDataFromContentType(response) {
let contentType = response.headers.get("Content-Type");
if (contentType === null) {
return response.text();
}
contentType = contentType.toLowerCase();
if (contentType.includes("application/json")) {
let data = await response.text();
try {
data = JSON.parse(data);
} catch {
}
return data;
} else if (contentType.match(/^text\//)) {
return response.text();
} else {
return response.blob();
}
}
/**
* Creates an async generator that yields the pieces of a multipart/related request body.
* This implementation follows the spec: https://www.ietf.org/rfc/rfc2387.txt. However, recursive
* multipart/related requests are not currently supported.
*
* @param {GaxiosMultipartOptions[]} multipartOptions the pieces to turn into a multipart/related body.
* @param {string} boundary the boundary string to be placed between each part.
*/
async *getMultipartRequest(multipartOptions, boundary) {
const finale = `--${boundary}--`;
for (const currentPart of multipartOptions) {
const partContentType = currentPart.headers.get("Content-Type") || "application/octet-stream";
const preamble = `--${boundary}\r
Content-Type: ${partContentType}\r
\r
`;
yield preamble;
if (typeof currentPart.content === "string") {
yield currentPart.content;
} else {
yield* currentPart.content;
}
yield "\r\n";
}
yield finale;
}
/**
* A cache for the lazily-loaded proxy agent.
*
* Should use {@link Gaxios[#getProxyAgent]} to retrieve.
*/
// using `import` to dynamically import the types here
static #proxyAgent;
/**
* A cache for the lazily-loaded fetch library.
*
* Should use {@link Gaxios[#getFetch]} to retrieve.
*/
//
static #fetch;
/**
* Imports, caches, and returns a proxy agent - if not already imported
*
* @returns A proxy agent
*/
static async #getProxyAgent() {
this.#proxyAgent ||= (await import("./dist-T73EYRDX.js")).HttpsProxyAgent;
return this.#proxyAgent;
}
static async #getFetch() {
const hasWindow = typeof window !== "undefined" && !!window;
this.#fetch ||= hasWindow ? window.fetch : (await import("./src-QVCVGIUX.js")).default;
return this.#fetch;
}
/**
* Merges headers.
* If the base headers do not exist a new `Headers` object will be returned.
*
* @remarks
*
* Using this utility can be helpful when the headers are not known to exist:
* - if they exist as `Headers`, that instance will be used
* - it improves performance and allows users to use their existing references to their `Headers`
* - if they exist in another form (`HeadersInit`), they will be used to create a new `Headers` object
* - if the base headers do not exist a new `Headers` object will be created
*
* @param base headers to append/overwrite to
* @param append headers to append/overwrite with
* @returns the base headers instance with merged `Headers`
*/
static mergeHeaders(base, ...append) {
base = base instanceof Headers ? base : new Headers(base);
for (const headers of append) {
const add = headers instanceof Headers ? headers : new Headers(headers);
add.forEach((value, key) => {
key === "set-cookie" ? base.append(key, value) : base.set(key, value);
});
}
return base;
}
};
exports.Gaxios = Gaxios;
_a = Gaxios;
}
});
// node_modules/@google/genai/node_modules/gaxios/build/cjs/src/index.js
var require_src = __commonJS({
"node_modules/@google/genai/node_modules/gaxios/build/cjs/src/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: function() {
return m[k];
} };
}
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.instance = exports.Gaxios = exports.GaxiosError = void 0;
exports.request = request;
var gaxios_js_1 = require_gaxios();
Object.defineProperty(exports, "Gaxios", { enumerable: true, get: function() {
return gaxios_js_1.Gaxios;
} });
var common_js_1 = require_common();
Object.defineProperty(exports, "GaxiosError", { enumerable: true, get: function() {
return common_js_1.GaxiosError;
} });
__exportStar(require_interceptor(), exports);
exports.instance = new gaxios_js_1.Gaxios();
async function request(opts) {
return exports.instance.request(opts);
}
}
});
// node_modules/bignumber.js/bignumber.js
var require_bignumber = __commonJS({
"node_modules/bignumber.js/bignumber.js"(exports, module) {
(function(globalObject) {
"use strict";
var BigNumber, isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i, mathceil = Math.ceil, mathfloor = Math.floor, bignumberError = "[BigNumber Error] ", tooManyDigits = bignumberError + "Number primitive has more than 15 significant digits: ", BASE = 1e14, LOG_BASE = 14, MAX_SAFE_INTEGER = 9007199254740991, POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13], SQRT_BASE = 1e7, MAX = 1e9;
function clone(configObject) {
var div, convertBase, parseNumeric, P = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = false, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
prefix: "",
groupSize: 3,
secondaryGroupSize: 0,
groupSeparator: ",",
decimalSeparator: ".",
fractionGroupSize: 0,
fractionGroupSeparator: "\xA0",
// non-breaking space
suffix: ""
}, ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz", alphabetHasNormalDecimalDigits = true;
function BigNumber2(v, b) {
var alphabet, c, caseChanged, e, i, isNum, len, str, x = this;
if (!(x instanceof BigNumber2)) return new BigNumber2(v, b);
if (b == null) {
if (v && v._isBigNumber === true) {
x.s = v.s;
if (!v.c || v.e > MAX_EXP) {
x.c = x.e = null;
} else if (v.e < MIN_EXP) {
x.c = [x.e = 0];
} else {
x.e = v.e;
x.c = v.c.slice();
}
return;
}
if ((isNum = typeof v == "number") && v * 0 == 0) {
x.s = 1 / v < 0 ? (v = -v, -1) : 1;
if (v === ~~v) {
for (e = 0, i = v; i >= 10; i /= 10, e++) ;
if (e > MAX_EXP) {
x.c = x.e = null;
} else {
x.e = e;
x.c = [v];
}
return;
}
str = String(v);
} else {
if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);
x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;
}
if ((e = str.indexOf(".")) > -1) str = str.replace(".", "");
if ((i = str.search(/e/i)) > 0) {
if (e < 0) e = i;
e += +str.slice(i + 1);
str = str.substring(0, i);
} else if (e < 0) {
e = str.length;
}
} else {
intCheck(b, 2, ALPHABET.length, "Base");
if (b == 10 && alphabetHasNormalDecimalDigits) {
x = new BigNumber2(v);
return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
}
str = String(v);
if (isNum = typeof v == "number") {
if (v * 0 != 0) return parseNumeric(x, str, isNum, b);
x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;
if (BigNumber2.DEBUG && str.replace(/^0\.0*|\./, "").length > 15) {
throw Error(tooManyDigits + v);
}
} else {
x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
}
alphabet = ALPHABET.slice(0, b);
e = i = 0;
for (len = str.length; i < len; i++) {
if (alphabet.indexOf(c = str.charAt(i)) < 0) {
if (c == ".") {
if (i > e) {
e = len;
continue;
}
} else if (!caseChanged) {
if (str == str.toUpperCase() && (str = str.toLowerCase()) || str == str.toLowerCase() && (str = str.toUpperCase())) {
caseChanged = true;
i = -1;
e = 0;
continue;
}
}
return parseNumeric(x, String(v), isNum, b);
}
}
isNum = false;
str = convertBase(str, b, 10, x.s);
if ((e = str.indexOf(".")) > -1) str = str.replace(".", "");
else e = str.length;
}
for (i = 0; str.charCodeAt(i) === 48; i++) ;
for (len = str.length; str.charCodeAt(--len) === 48; ) ;
if (str = str.slice(i, ++len)) {
len -= i;
if (isNum && BigNumber2.DEBUG && len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {
throw Error(tooManyDigits + x.s * v);
}
if ((e = e - i - 1) > MAX_EXP) {
x.c = x.e = null;
} else if (e < MIN_EXP) {
x.c = [x.e = 0];
} else {
x.e = e;
x.c = [];
i = (e + 1) % LOG_BASE;
if (e < 0) i += LOG_BASE;
if (i < len) {
if (i) x.c.push(+str.slice(0, i));
for (len -= LOG_BASE; i < len; ) {
x.c.push(+str.slice(i, i += LOG_BASE));
}
i = LOG_BASE - (str = str.slice(i)).length;
} else {
i -= len;
}
for (; i--; str += "0") ;
x.c.push(+str);
}
} else {
x.c = [x.e = 0];
}
}
BigNumber2.clone = clone;
BigNumber2.ROUND_UP = 0;
BigNumber2.ROUND_DOWN = 1;
BigNumber2.ROUND_CEIL = 2;
BigNumber2.ROUND_FLOOR = 3;
BigNumber2.ROUND_HALF_UP = 4;
BigNumber2.ROUND_HALF_DOWN = 5;
BigNumber2.ROUND_HALF_EVEN = 6;
BigNumber2.ROUND_HALF_CEIL = 7;
BigNumber2.ROUND_HALF_FLOOR = 8;
BigNumber2.EUCLID = 9;
BigNumber2.config = BigNumber2.set = function(obj) {
var p, v;
if (obj != null) {
if (typeof obj == "object") {
if (obj.hasOwnProperty(p = "DECIMAL_PLACES")) {
v = obj[p];
intCheck(v, 0, MAX, p);
DECIMAL_PLACES = v;
}
if (obj.hasOwnProperty(p = "ROUNDING_MODE")) {
v = obj[p];
intCheck(v, 0, 8, p);
ROUNDING_MODE = v;
}
if (obj.hasOwnProperty(p = "EXPONENTIAL_AT")) {
v = obj[p];
if (v && v.pop) {
intCheck(v[0], -MAX, 0, p);
intCheck(v[1], 0, MAX, p);
TO_EXP_NEG = v[0];
TO_EXP_POS = v[1];
} else {
intCheck(v, -MAX, MAX, p);
TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);
}
}
if (obj.hasOwnProperty(p = "RANGE")) {
v = obj[p];
if (v && v.pop) {
intCheck(v[0], -MAX, -1, p);
intCheck(v[1], 1, MAX, p);
MIN_EXP = v[0];
MAX_EXP = v[1];
} else {
intCheck(v, -MAX, MAX, p);
if (v) {
MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);
} else {
throw Error(bignumberError + p + " cannot be zero: " + v);
}
}
}
if (obj.hasOwnProperty(p = "CRYPTO")) {
v = obj[p];
if (v === !!v) {
if (v) {
if (typeof crypto != "undefined" && crypto && (crypto.getRandomValues || crypto.randomBytes)) {
CRYPTO = v;
} else {
CRYPTO = !v;
throw Error(bignumberError + "crypto unavailable");
}
} else {
CRYPTO = v;
}
} else {
throw Error(bignumberError + p + " not true or false: " + v);
}
}
if (obj.hasOwnProperty(p = "MODULO_MODE")) {
v = obj[p];
intCheck(v, 0, 9, p);
MODULO_MODE = v;
}
if (obj.hasOwnProperty(p = "POW_PRECISION")) {
v = obj[p];
intCheck(v, 0, MAX, p);
POW_PRECISION = v;
}
if (obj.hasOwnProperty(p = "FORMAT")) {
v = obj[p];
if (typeof v == "object") FORMAT = v;
else throw Error(bignumberError + p + " not an object: " + v);
}
if (obj.hasOwnProperty(p = "ALPHABET")) {
v = obj[p];
if (typeof v == "string" && !/^.?$|[+\-.\s]|(.).*\1/.test(v)) {
alphabetHasNormalDecimalDigits = v.slice(0, 10) == "0123456789";
ALPHABET = v;
} else {
throw Error(bignumberError + p + " invalid: " + v);
}
}
} else {
throw Error(bignumberError + "Object expected: " + obj);
}
}
return {
DECIMAL_PLACES,
ROUNDING_MODE,
EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],
RANGE: [MIN_EXP, MAX_EXP],
CRYPTO,
MODULO_MODE,
POW_PRECISION,
FORMAT,
ALPHABET
};
};
BigNumber2.isBigNumber = function(v) {
if (!v || v._isBigNumber !== true) return false;
if (!BigNumber2.DEBUG) return true;
var i, n, c = v.c, e = v.e, s = v.s;
out: if ({}.toString.call(c) == "[object Array]") {
if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {
if (c[0] === 0) {
if (e === 0 && c.length === 1) return true;
break out;
}
i = (e + 1) % LOG_BASE;
if (i < 1) i += LOG_BASE;
if (String(c[0]).length == i) {
for (i = 0; i < c.length; i++) {
n = c[i];
if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;
}
if (n !== 0) return true;
}
}
} else if (c === null && e === null && (s === null || s === 1 || s === -1)) {
return true;
}
throw Error(bignumberError + "Invalid BigNumber: " + v);
};
BigNumber2.maximum = BigNumber2.max = function() {
return maxOrMin(arguments, -1);
};
BigNumber2.minimum = BigNumber2.min = function() {
return maxOrMin(arguments, 1);
};
BigNumber2.random = function() {
var pow2_53 = 9007199254740992;
var random53bitInt = Math.random() * pow2_53 & 2097151 ? function() {
return mathfloor(Math.random() * pow2_53);
} : function() {
return (Math.random() * 1073741824 | 0) * 8388608 + (Math.random() * 8388608 | 0);
};
return function(dp) {
var a, b, e, k, v, i = 0, c = [], rand = new BigNumber2(ONE);
if (dp == null) dp = DECIMAL_PLACES;
else intCheck(dp, 0, MAX);
k = mathceil(dp / LOG_BASE);
if (CRYPTO) {
if (crypto.getRandomValues) {
a = crypto.getRandomValues(new Uint32Array(k *= 2));
for (; i < k; ) {
v = a[i] * 131072 + (a[i + 1] >>> 11);
if (v >= 9e15) {
b = crypto.getRandomValues(new Uint32Array(2));
a[i] = b[0];
a[i + 1] = b[1];
} else {
c.push(v % 1e14);
i += 2;
}
}
i = k / 2;
} else if (crypto.randomBytes) {
a = crypto.randomBytes(k *= 7);
for (; i < k; ) {
v = (a[i] & 31) * 281474976710656 + a[i + 1] * 1099511627776 + a[i + 2] * 4294967296 + a[i + 3] * 16777216 + (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];
if (v >= 9e15) {
crypto.randomBytes(7).copy(a, i);
} else {
c.push(v % 1e14);
i += 7;
}
}
i = k / 7;
} else {
CRYPTO = false;
throw Error(bignumberError + "crypto unavailable");
}
}
if (!CRYPTO) {
for (; i < k; ) {
v = random53bitInt();
if (v < 9e15) c[i++] = v % 1e14;
}
}
k = c[--i];
dp %= LOG_BASE;
if (k && dp) {
v = POWS_TEN[LOG_BASE - dp];
c[i] = mathfloor(k / v) * v;
}
for (; c[i] === 0; c.pop(), i--) ;
if (i < 0) {
c = [e = 0];
} else {
for (e = -1; c[0] === 0; c.splice(0, 1), e -= LOG_BASE) ;
for (i = 1, v = c[0]; v >= 10; v /= 10, i++) ;
if (i < LOG_BASE) e -= LOG_BASE - i;
}
rand.e = e;
rand.c = c;
return rand;
};
}();
BigNumber2.sum = function() {
var i = 1, args = arguments, sum = new BigNumber2(args[0]);
for (; i < args.length; ) sum = sum.plus(args[i++]);
return sum;
};
convertBase = /* @__PURE__ */ function() {
var decimal = "0123456789";
function toBaseOut(str, baseIn, baseOut, alphabet) {
var j, arr = [0], arrL, i = 0, len = str.length;
for (; i < len; ) {
for (arrL = arr.length; arrL--; arr[arrL] *= baseIn) ;
arr[0] += alphabet.indexOf(str.charAt(i++));
for (j = 0; j < arr.length; j++) {
if (arr[j] > baseOut - 1) {
if (arr[j + 1] == null) arr[j + 1] = 0;
arr[j + 1] += arr[j] / baseOut | 0;
arr[j] %= baseOut;
}
}
}
return arr.reverse();
}
return function(str, baseIn, baseOut, sign, callerIsToString) {
var alphabet, d, e, k, r, x, xc, y, i = str.indexOf("."), dp = DECIMAL_PLACES, rm = ROUNDING_MODE;
if (i >= 0) {
k = POW_PRECISION;
POW_PRECISION = 0;
str = str.replace(".", "");
y = new BigNumber2(baseIn);
x = y.pow(str.length - i);
POW_PRECISION = k;
y.c = toBaseOut(
toFixedPoint(coeffToString(x.c), x.e, "0"),
10,
baseOut,
decimal
);
y.e = y.c.length;
}
xc = toBaseOut(str, baseIn, baseOut, callerIsToString ? (alphabet = ALPHABET, decimal) : (alphabet = decimal, ALPHABET));
e = k = xc.length;
for (; xc[--k] == 0; xc.pop()) ;
if (!xc[0]) return alphabet.charAt(0);
if (i < 0) {
--e;
} else {
x.c = xc;
x.e = e;
x.s = sign;
x = div(x, y, dp, rm, baseOut);
xc = x.c;
r = x.r;
e = x.e;
}
d = e + dp + 1;
i = xc[d];
k = baseOut / 2;
r = r || d < 0 || xc[d + 1] != null;
r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : i > k || i == k && (rm == 4 || r || rm == 6 && xc[d - 1] & 1 || rm == (x.s < 0 ? 8 : 7));
if (d < 1 || !xc[0]) {
str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);
} else {
xc.length = d;
if (r) {
for (--baseOut; ++xc[--d] > baseOut; ) {
xc[d] = 0;
if (!d) {
++e;
xc = [1].concat(xc);
}
}
}
for (k = xc.length; !xc[--k]; ) ;
for (i = 0, str = ""; i <= k; str += alphabet.charAt(xc[i++])) ;
str = toFixedPoint(str, e, alphabet.charAt(0));
}
return str;
};
}();
div = /* @__PURE__ */ function() {
function multiply(x, k, base) {
var m, temp, xlo, xhi, carry = 0, i = x.length, klo = k % SQRT_BASE, khi = k / SQRT_BASE | 0;
for (x = x.slice(); i--; ) {
xlo = x[i] % SQRT_BASE;
xhi = x[i] / SQRT_BASE | 0;
m = khi * xlo + xhi * klo;
temp = klo * xlo + m % SQRT_BASE * SQRT_BASE + carry;
carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;
x[i] = temp % base;
}
if (carry) x = [carry].concat(x);
return x;
}
function compare2(a, b, aL, bL) {
var i, cmp;
if (aL != bL) {
cmp = aL > bL ? 1 : -1;
} else {
for (i = cmp = 0; i < aL; i++) {
if (a[i] != b[i]) {
cmp = a[i] > b[i] ? 1 : -1;
break;
}
}
}
return cmp;
}
function subtract(a, b, aL, base) {
var i = 0;
for (; aL--; ) {
a[aL] -= i;
i = a[aL] < b[aL] ? 1 : 0;
a[aL] = i * base + a[aL] - b[aL];
}
for (; !a[0] && a.length > 1; a.splice(0, 1)) ;
}
return function(x, y, dp, rm, base) {
var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0, yL, yz, s = x.s == y.s ? 1 : -1, xc = x.c, yc = y.c;
if (!xc || !xc[0] || !yc || !yc[0]) {
return new BigNumber2(
// Return NaN if either NaN, or both Infinity or 0.
!x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN : (
// Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.
xc && xc[0] == 0 || !yc ? s * 0 : s / 0
)
);
}
q = new BigNumber2(s);
qc = q.c = [];
e = x.e - y.e;
s = dp + e + 1;
if (!base) {
base = BASE;
e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);
s = s / LOG_BASE | 0;
}
for (i = 0; yc[i] == (xc[i] || 0); i++) ;
if (yc[i] > (xc[i] || 0)) e--;
if (s < 0) {
qc.push(1);
more = true;
} else {
xL = xc.length;
yL = yc.length;
i = 0;
s += 2;
n = mathfloor(base / (yc[0] + 1));
if (n > 1) {
yc = multiply(yc, n, base);
xc = multiply(xc, n, base);
yL = yc.length;
xL = xc.length;
}
xi = yL;
rem = xc.slice(0, yL);
remL = rem.length;
for (; remL < yL; rem[remL++] = 0) ;
yz = yc.slice();
yz = [0].concat(yz);
yc0 = yc[0];
if (yc[1] >= base / 2) yc0++;
do {
n = 0;
cmp = compare2(yc, rem, yL, remL);
if (cmp < 0) {
rem0 = rem[0];
if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);
n = mathfloor(rem0 / yc0);
if (n > 1) {
if (n >= base) n = base - 1;
prod = multiply(yc, n, base);
prodL = prod.length;
remL = rem.length;
while (compare2(prod, rem, prodL, remL) == 1) {
n--;
subtract(prod, yL < prodL ? yz : yc, prodL, base);
prodL = prod.length;
cmp = 1;
}
} else {
if (n == 0) {
cmp = n = 1;
}
prod = yc.slice();
prodL = prod.length;
}
if (prodL < remL) prod = [0].concat(prod);
subtract(rem, prod, remL, base);
remL = rem.length;
if (cmp == -1) {
while (compare2(yc, rem, yL, remL) < 1) {
n++;
subtract(rem, yL < remL ? yz : yc, remL, base);
remL = rem.length;
}
}
} else if (cmp === 0) {
n++;
rem = [0];
}
qc[i++] = n;
if (rem[0]) {
rem[remL++] = xc[xi] || 0;
} else {
rem = [xc[xi]];
remL = 1;
}
} while ((xi++ < xL || rem[0] != null) && s--);
more = rem[0] != null;
if (!qc[0]) qc.splice(0, 1);
}
if (base == BASE) {
for (i = 1, s = qc[0]; s >= 10; s /= 10, i++) ;
round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);
} else {
q.e = e;
q.r = +more;
}
return q;
};
}();
function format2(n, i, rm, id) {
var c0, e, ne, len, str;
if (rm == null) rm = ROUNDING_MODE;
else intCheck(rm, 0, 8);
if (!n.c) return n.toString();
c0 = n.c[0];
ne = n.e;
if (i == null) {
str = coeffToString(n.c);
str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS) ? toExponential(str, ne) : toFixedPoint(str, ne, "0");
} else {
n = round(new BigNumber2(n), i, rm);
e = n.e;
str = coeffToString(n.c);
len = str.length;
if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {
for (; len < i; str += "0", len++) ;
str = toExponential(str, e);
} else {
i -= ne;
str = toFixedPoint(str, e, "0");
if (e + 1 > len) {
if (--i > 0) for (str += "."; i--; str += "0") ;
} else {
i += e - len;
if (i > 0) {
if (e + 1 == len) str += ".";
for (; i--; str += "0") ;
}
}
}
}
return n.s < 0 && c0 ? "-" + str : str;
}
function maxOrMin(args, n) {
var k, y, i = 1, x = new BigNumber2(args[0]);
for (; i < args.length; i++) {
y = new BigNumber2(args[i]);
if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {
x = y;
}
}
return x;
}
function normalise(n, c, e) {
var i = 1, j = c.length;
for (; !c[--j]; c.pop()) ;
for (j = c[0]; j >= 10; j /= 10, i++) ;
if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {
n.c = n.e = null;
} else if (e < MIN_EXP) {
n.c = [n.e = 0];
} else {
n.e = e;
n.c = c;
}
return n;
}
parseNumeric = /* @__PURE__ */ function() {
var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, dotAfter = /^([^.]+)\.$/, dotBefore = /^\.([^.]+)$/, isInfinityOrNaN = /^-?(Infinity|NaN)$/, whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
return function(x, str, isNum, b) {
var base, s = isNum ? str : str.replace(whitespaceOrPlus, "");
if (isInfinityOrNaN.test(s)) {
x.s = isNaN(s) ? null : s < 0 ? -1 : 1;
} else {
if (!isNum) {
s = s.replace(basePrefix, function(m, p1, p2) {
base = (p2 = p2.toLowerCase()) == "x" ? 16 : p2 == "b" ? 2 : 8;
return !b || b == base ? p1 : m;
});
if (b) {
base = b;
s = s.replace(dotAfter, "$1").replace(dotBefore, "0.$1");
}
if (str != s) return new BigNumber2(s, base);
}
if (BigNumber2.DEBUG) {
throw Error(bignumberError + "Not a" + (b ? " base " + b : "") + " number: " + str);
}
x.s = null;
}
x.c = x.e = null;
};
}();
function round(x, sd, rm, r) {
var d, i, j, k, n, ni, rd, xc = x.c, pows10 = POWS_TEN;
if (xc) {
out: {
for (d = 1, k = xc[0]; k >= 10; k /= 10, d++) ;
i = sd - d;
if (i < 0) {
i += LOG_BASE;
j = sd;
n = xc[ni = 0];
rd = mathfloor(n / pows10[d - j - 1] % 10);
} else {
ni = mathceil((i + 1) / LOG_BASE);
if (ni >= xc.length) {
if (r) {
for (; xc.length <= ni; xc.push(0)) ;
n = rd = 0;
d = 1;
i %= LOG_BASE;
j = i - LOG_BASE + 1;
} else {
break out;
}
} else {
n = k = xc[ni];
for (d = 1; k >= 10; k /= 10, d++) ;
i %= LOG_BASE;
j = i - LOG_BASE + d;
rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);
}
}
r = r || sd < 0 || // Are there any non-zero digits after the rounding digit?
// The expression n % pows10[d - j - 1] returns all digits of n to the right
// of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.
xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);
r = rm < 4 ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 && // Check whether the digit to the left of the rounding digit is odd.
(i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10 & 1 || rm == (x.s < 0 ? 8 : 7));
if (sd < 1 || !xc[0]) {
xc.length = 0;
if (r) {
sd -= x.e + 1;
xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];
x.e = -sd || 0;
} else {
xc[0] = x.e = 0;
}
return x;
}
if (i == 0) {
xc.length = ni;
k = 1;
ni--;
} else {
xc.length = ni + 1;
k = pows10[LOG_BASE - i];
xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;
}
if (r) {
for (; ; ) {
if (ni == 0) {
for (i = 1, j = xc[0]; j >= 10; j /= 10, i++) ;
j = xc[0] += k;
for (k = 1; j >= 10; j /= 10, k++) ;
if (i != k) {
x.e++;
if (xc[0] == BASE) xc[0] = 1;
}
break;
} else {
xc[ni] += k;
if (xc[ni] != BASE) break;
xc[ni--] = 0;
k = 1;
}
}
}
for (i = xc.length; xc[--i] === 0; xc.pop()) ;
}
if (x.e > MAX_EXP) {
x.c = x.e = null;
} else if (x.e < MIN_EXP) {
x.c = [x.e = 0];
}
}
return x;
}
function valueOf(n) {
var str, e = n.e;
if (e === null) return n.toString();
str = coeffToString(n.c);
str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(str, e) : toFixedPoint(str, e, "0");
return n.s < 0 ? "-" + str : str;
}
P.absoluteValue = P.abs = function() {
var x = new BigNumber2(this);
if (x.s < 0) x.s = 1;
return x;
};
P.comparedTo = function(y, b) {
return compare(this, new BigNumber2(y, b));
};
P.decimalPlaces = P.dp = function(dp, rm) {
var c, n, v, x = this;
if (dp != null) {
intCheck(dp, 0, MAX);
if (rm == null) rm = ROUNDING_MODE;
else intCheck(rm, 0, 8);
return round(new BigNumber2(x), dp + x.e + 1, rm);
}
if (!(c = x.c)) return null;
n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;
if (v = c[v]) for (; v % 10 == 0; v /= 10, n--) ;
if (n < 0) n = 0;
return n;
};
P.dividedBy = P.div = function(y, b) {
return div(this, new BigNumber2(y, b), DECIMAL_PLACES, ROUNDING_MODE);
};
P.dividedToIntegerBy = P.idiv = function(y, b) {
return div(this, new BigNumber2(y, b), 0, 1);
};
P.exponentiatedBy = P.pow = function(n, m) {
var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y, x = this;
n = new BigNumber2(n);
if (n.c && !n.isInteger()) {
throw Error(bignumberError + "Exponent not an integer: " + valueOf(n));
}
if (m != null) m = new BigNumber2(m);
nIsBig = n.e > 14;
if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {
y = new BigNumber2(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));
return m ? y.mod(m) : y;
}
nIsNeg = n.s < 0;
if (m) {
if (m.c ? !m.c[0] : !m.s) return new BigNumber2(NaN);
isModExp = !nIsNeg && x.isInteger() && m.isInteger();
if (isModExp) x = x.mod(m);
} else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0 ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7 : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {
k = x.s < 0 && isOdd(n) ? -0 : 0;
if (x.e > -1) k = 1 / k;
return new BigNumber2(nIsNeg ? 1 / k : k);
} else if (POW_PRECISION) {
k = mathceil(POW_PRECISION / LOG_BASE + 2);
}
if (nIsBig) {
half = new BigNumber2(0.5);
if (nIsNeg) n.s = 1;
nIsOdd = isOdd(n);
} else {
i = Math.abs(+valueOf(n));
nIsOdd = i % 2;
}
y = new BigNumber2(ONE);
for (; ; ) {
if (nIsOdd) {
y = y.times(x);
if (!y.c) break;
if (k) {
if (y.c.length > k) y.c.length = k;
} else if (isModExp) {
y = y.mod(m);
}
}
if (i) {
i = mathfloor(i / 2);
if (i === 0) break;
nIsOdd = i % 2;
} else {
n = n.times(half);
round(n, n.e + 1, 1);
if (n.e > 14) {
nIsOdd = isOdd(n);
} else {
i = +valueOf(n);
if (i === 0) break;
nIsOdd = i % 2;
}
}
x = x.times(x);
if (k) {
if (x.c && x.c.length > k) x.c.length = k;
} else if (isModExp) {
x = x.mod(m);
}
}
if (isModExp) return y;
if (nIsNeg) y = ONE.div(y);
return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;
};
P.integerValue = function(rm) {
var n = new BigNumber2(this);
if (rm == null) rm = ROUNDING_MODE;
else intCheck(rm, 0, 8);
return round(n, n.e + 1, rm);
};
P.isEqualTo = P.eq = function(y, b) {
return compare(this, new BigNumber2(y, b)) === 0;
};
P.isFinite = function() {
return !!this.c;
};
P.isGreaterThan = P.gt = function(y, b) {
return compare(this, new BigNumber2(y, b)) > 0;
};
P.isGreaterThanOrEqualTo = P.gte = function(y, b) {
return (b = compare(this, new BigNumber2(y, b))) === 1 || b === 0;
};
P.isInteger = function() {
return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;
};
P.isLessThan = P.lt = function(y, b) {
return compare(this, new BigNumber2(y, b)) < 0;
};
P.isLessThanOrEqualTo = P.lte = function(y, b) {
return (b = compare(this, new BigNumber2(y, b))) === -1 || b === 0;
};
P.isNaN = function() {
return !this.s;
};
P.isNegative = function() {
return this.s < 0;
};
P.isPositive = function() {
return this.s > 0;
};
P.isZero = function() {
return !!this.c && this.c[0] == 0;
};
P.minus = function(y, b) {
var i, j, t, xLTy, x = this, a = x.s;
y = new BigNumber2(y, b);
b = y.s;
if (!a || !b) return new BigNumber2(NaN);
if (a != b) {
y.s = -b;
return x.plus(y);
}
var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
if (!xe || !ye) {
if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber2(yc ? x : NaN);
if (!xc[0] || !yc[0]) {
return yc[0] ? (y.s = -b, y) : new BigNumber2(xc[0] ? x : (
// IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity
ROUNDING_MODE == 3 ? -0 : 0
));
}
}
xe = bitFloor(xe);
ye = bitFloor(ye);
xc = xc.slice();
if (a = xe - ye) {
if (xLTy = a < 0) {
a = -a;
t = xc;
} else {
ye = xe;
t = yc;
}
t.reverse();
for (b = a; b--; t.push(0)) ;
t.reverse();
} else {
j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;
for (a = b = 0; b < j; b++) {
if (xc[b] != yc[b]) {
xLTy = xc[b] < yc[b];
break;
}
}
}
if (xLTy) {
t = xc;
xc = yc;
yc = t;
y.s = -y.s;
}
b = (j = yc.length) - (i = xc.length);
if (b > 0) for (; b--; xc[i++] = 0) ;
b = BASE - 1;
for (; j > a; ) {
if (xc[--j] < yc[j]) {
for (i = j; i && !xc[--i]; xc[i] = b) ;
--xc[i];
xc[j] += BASE;
}
xc[j] -= yc[j];
}
for (; xc[0] == 0; xc.splice(0, 1), --ye) ;
if (!xc[0]) {
y.s = ROUNDING_MODE == 3 ? -1 : 1;
y.c = [y.e = 0];
return y;
}
return normalise(y, xc, ye);
};
P.modulo = P.mod = function(y, b) {
var q, s, x = this;
y = new BigNumber2(y, b);
if (!x.c || !y.s || y.c && !y.c[0]) {
return new BigNumber2(NaN);
} else if (!y.c || x.c && !x.c[0]) {
return new BigNumber2(x);
}
if (MODULO_MODE == 9) {
s = y.s;
y.s = 1;
q = div(x, y, 0, 3);
y.s = s;
q.s *= s;
} else {
q = div(x, y, 0, MODULO_MODE);
}
y = x.minus(q.times(y));
if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;
return y;
};
P.multipliedBy = P.times = function(y, b) {
var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc, base, sqrtBase, x = this, xc = x.c, yc = (y = new BigNumber2(y, b)).c;
if (!xc || !yc || !xc[0] || !yc[0]) {
if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {
y.c = y.e = y.s = null;
} else {
y.s *= x.s;
if (!xc || !yc) {
y.c = y.e = null;
} else {
y.c = [0];
y.e = 0;
}
}
return y;
}
e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);
y.s *= x.s;
xcL = xc.length;
ycL = yc.length;
if (xcL < ycL) {
zc = xc;
xc = yc;
yc = zc;
i = xcL;
xcL = ycL;
ycL = i;
}
for (i = xcL + ycL, zc = []; i--; zc.push(0)) ;
base = BASE;
sqrtBase = SQRT_BASE;
for (i = ycL; --i >= 0; ) {
c = 0;
ylo = yc[i] % sqrtBase;
yhi = yc[i] / sqrtBase | 0;
for (k = xcL, j = i + k; j > i; ) {
xlo = xc[--k] % sqrtBase;
xhi = xc[k] / sqrtBase | 0;
m = yhi * xlo + xhi * ylo;
xlo = ylo * xlo + m % sqrtBase * sqrtBase + zc[j] + c;
c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;
zc[j--] = xlo % base;
}
zc[j] = c;
}
if (c) {
++e;
} else {
zc.splice(0, 1);
}
return normalise(y, zc, e);
};
P.negated = function() {
var x = new BigNumber2(this);
x.s = -x.s || null;
return x;
};
P.plus = function(y, b) {
var t, x = this, a = x.s;
y = new BigNumber2(y, b);
b = y.s;
if (!a || !b) return new BigNumber2(NaN);
if (a != b) {
y.s = -b;
return x.minus(y);
}
var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
if (!xe || !ye) {
if (!xc || !yc) return new BigNumber2(a / 0);
if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber2(xc[0] ? x : a * 0);
}
xe = bitFloor(xe);
ye = bitFloor(ye);
xc = xc.slice();
if (a = xe - ye) {
if (a > 0) {
ye = xe;
t = yc;
} else {
a = -a;
t = xc;
}
t.reverse();
for (; a--; t.push(0)) ;
t.reverse();
}
a = xc.length;
b = yc.length;
if (a - b < 0) {
t = yc;
yc = xc;
xc = t;
b = a;
}
for (a = 0; b; ) {
a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;
xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;
}
if (a) {
xc = [a].concat(xc);
++ye;
}
return normalise(y, xc, ye);
};
P.precision = P.sd = function(sd, rm) {
var c, n, v, x = this;
if (sd != null && sd !== !!sd) {
intCheck(sd, 1, MAX);
if (rm == null) rm = ROUNDING_MODE;
else intCheck(rm, 0, 8);
return round(new BigNumber2(x), sd, rm);
}
if (!(c = x.c)) return null;
v = c.length - 1;
n = v * LOG_BASE + 1;
if (v = c[v]) {
for (; v % 10 == 0; v /= 10, n--) ;
for (v = c[0]; v >= 10; v /= 10, n++) ;
}
if (sd && x.e + 1 > n) n = x.e + 1;
return n;
};
P.shiftedBy = function(k) {
intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
return this.times("1e" + k);
};
P.squareRoot = P.sqrt = function() {
var m, n, r, rep, t, x = this, c = x.c, s = x.s, e = x.e, dp = DECIMAL_PLACES + 4, half = new BigNumber2("0.5");
if (s !== 1 || !c || !c[0]) {
return new BigNumber2(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);
}
s = Math.sqrt(+valueOf(x));
if (s == 0 || s == 1 / 0) {
n = coeffToString(c);
if ((n.length + e) % 2 == 0) n += "0";
s = Math.sqrt(+n);
e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);
if (s == 1 / 0) {
n = "5e" + e;
} else {
n = s.toExponential();
n = n.slice(0, n.indexOf("e") + 1) + e;
}
r = new BigNumber2(n);
} else {
r = new BigNumber2(s + "");
}
if (r.c[0]) {
e = r.e;
s = e + dp;
if (s < 3) s = 0;
for (; ; ) {
t = r;
r = half.times(t.plus(div(x, t, dp, 1)));
if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {
if (r.e < e) --s;
n = n.slice(s - 3, s + 1);
if (n == "9999" || !rep && n == "4999") {
if (!rep) {
round(t, t.e + DECIMAL_PLACES + 2, 0);
if (t.times(t).eq(x)) {
r = t;
break;
}
}
dp += 4;
s += 4;
rep = 1;
} else {
if (!+n || !+n.slice(1) && n.charAt(0) == "5") {
round(r, r.e + DECIMAL_PLACES + 2, 1);
m = !r.times(r).eq(x);
}
break;
}
}
}
}
return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);
};
P.toExponential = function(dp, rm) {
if (dp != null) {
intCheck(dp, 0, MAX);
dp++;
}
return format2(this, dp, rm, 1);
};
P.toFixed = function(dp, rm) {
if (dp != null) {
intCheck(dp, 0, MAX);
dp = dp + this.e + 1;
}
return format2(this, dp, rm);
};
P.toFormat = function(dp, rm, format3) {
var str, x = this;
if (format3 == null) {
if (dp != null && rm && typeof rm == "object") {
format3 = rm;
rm = null;
} else if (dp && typeof dp == "object") {
format3 = dp;
dp = rm = null;
} else {
format3 = FORMAT;
}
} else if (typeof format3 != "object") {
throw Error(bignumberError + "Argument not an object: " + format3);
}
str = x.toFixed(dp, rm);
if (x.c) {
var i, arr = str.split("."), g1 = +format3.groupSize, g2 = +format3.secondaryGroupSize, groupSeparator = format3.groupSeparator || "", intPart = arr[0], fractionPart = arr[1], isNeg = x.s < 0, intDigits = isNeg ? intPart.slice(1) : intPart, len = intDigits.length;
if (g2) {
i = g1;
g1 = g2;
g2 = i;
len -= i;
}
if (g1 > 0 && len > 0) {
i = len % g1 || g1;
intPart = intDigits.substr(0, i);
for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);
if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);
if (isNeg) intPart = "-" + intPart;
}
str = fractionPart ? intPart + (format3.decimalSeparator || "") + ((g2 = +format3.fractionGroupSize) ? fractionPart.replace(
new RegExp("\\d{" + g2 + "}\\B", "g"),
"$&" + (format3.fractionGroupSeparator || "")
) : fractionPart) : intPart;
}
return (format3.prefix || "") + str + (format3.suffix || "");
};
P.toFraction = function(md) {
var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s, x = this, xc = x.c;
if (md != null) {
n = new BigNumber2(md);
if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {
throw Error(bignumberError + "Argument " + (n.isInteger() ? "out of range: " : "not an integer: ") + valueOf(n));
}
}
if (!xc) return new BigNumber2(x);
d = new BigNumber2(ONE);
n1 = d0 = new BigNumber2(ONE);
d1 = n0 = new BigNumber2(ONE);
s = coeffToString(xc);
e = d.e = s.length - x.e - 1;
d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];
md = !md || n.comparedTo(d) > 0 ? e > 0 ? d : n1 : n;
exp = MAX_EXP;
MAX_EXP = 1 / 0;
n = new BigNumber2(s);
n0.c[0] = 0;
for (; ; ) {
q = div(n, d, 0, 1);
d2 = d0.plus(q.times(d1));
if (d2.comparedTo(md) == 1) break;
d0 = d1;
d1 = d2;
n1 = n0.plus(q.times(d2 = n1));
n0 = d2;
d = n.minus(q.times(d2 = d));
n = d2;
}
d2 = div(md.minus(d0), d1, 0, 1);
n0 = n0.plus(d2.times(n1));
d0 = d0.plus(d2.times(d1));
n0.s = n1.s = x.s;
e = e * 2;
r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(
div(n0, d0, e, ROUNDING_MODE).minus(x).abs()
) < 1 ? [n1, d1] : [n0, d0];
MAX_EXP = exp;
return r;
};
P.toNumber = function() {
return +valueOf(this);
};
P.toPrecision = function(sd, rm) {
if (sd != null) intCheck(sd, 1, MAX);
return format2(this, sd, rm, 2);
};
P.toString = function(b) {
var str, n = this, s = n.s, e = n.e;
if (e === null) {
if (s) {
str = "Infinity";
if (s < 0) str = "-" + str;
} else {
str = "NaN";
}
} else {
if (b == null) {
str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(coeffToString(n.c), e) : toFixedPoint(coeffToString(n.c), e, "0");
} else if (b === 10 && alphabetHasNormalDecimalDigits) {
n = round(new BigNumber2(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);
str = toFixedPoint(coeffToString(n.c), n.e, "0");
} else {
intCheck(b, 2, ALPHABET.length, "Base");
str = convertBase(toFixedPoint(coeffToString(n.c), e, "0"), 10, b, s, true);
}
if (s < 0 && n.c[0]) str = "-" + str;
}
return str;
};
P.valueOf = P.toJSON = function() {
return valueOf(this);
};
P._isBigNumber = true;
if (configObject != null) BigNumber2.set(configObject);
return BigNumber2;
}
function bitFloor(n) {
var i = n | 0;
return n > 0 || n === i ? i : i - 1;
}
function coeffToString(a) {
var s, z, i = 1, j = a.length, r = a[0] + "";
for (; i < j; ) {
s = a[i++] + "";
z = LOG_BASE - s.length;
for (; z--; s = "0" + s) ;
r += s;
}
for (j = r.length; r.charCodeAt(--j) === 48; ) ;
return r.slice(0, j + 1 || 1);
}
function compare(x, y) {
var a, b, xc = x.c, yc = y.c, i = x.s, j = y.s, k = x.e, l = y.e;
if (!i || !j) return null;
a = xc && !xc[0];
b = yc && !yc[0];
if (a || b) return a ? b ? 0 : -j : i;
if (i != j) return i;
a = i < 0;
b = k == l;
if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;
if (!b) return k > l ^ a ? 1 : -1;
j = (k = xc.length) < (l = yc.length) ? k : l;
for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;
return k == l ? 0 : k > l ^ a ? 1 : -1;
}
function intCheck(n, min, max, name) {
if (n < min || n > max || n !== mathfloor(n)) {
throw Error(bignumberError + (name || "Argument") + (typeof n == "number" ? n < min || n > max ? " out of range: " : " not an integer: " : " not a primitive number: ") + String(n));
}
}
function isOdd(n) {
var k = n.c.length - 1;
return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;
}
function toExponential(str, e) {
return (str.length > 1 ? str.charAt(0) + "." + str.slice(1) : str) + (e < 0 ? "e" : "e+") + e;
}
function toFixedPoint(str, e, z) {
var len, zs;
if (e < 0) {
for (zs = z + "."; ++e; zs += z) ;
str = zs + str;
} else {
len = str.length;
if (++e > len) {
for (zs = z, e -= len; --e; zs += z) ;
str += zs;
} else if (e < len) {
str = str.slice(0, e) + "." + str.slice(e);
}
}
return str;
}
BigNumber = clone();
BigNumber["default"] = BigNumber.BigNumber = BigNumber;
if (typeof define == "function" && define.amd) {
define(function() {
return BigNumber;
});
} else if (typeof module != "undefined" && module.exports) {
module.exports = BigNumber;
} else {
if (!globalObject) {
globalObject = typeof self != "undefined" && self ? self : window;
}
globalObject.BigNumber = BigNumber;
}
})(exports);
}
});
// node_modules/json-bigint/lib/stringify.js
var require_stringify = __commonJS({
"node_modules/json-bigint/lib/stringify.js"(exports, module) {
var BigNumber = require_bignumber();
var JSON2 = module.exports;
(function() {
"use strict";
function f(n) {
return n < 10 ? "0" + n : n;
}
var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, gap, indent, meta = {
// table of character substitutions
"\b": "\\b",
" ": "\\t",
"\n": "\\n",
"\f": "\\f",
"\r": "\\r",
'"': '\\"',
"\\": "\\\\"
}, rep;
function quote(string) {
escapable.lastIndex = 0;
return escapable.test(string) ? '"' + string.replace(escapable, function(a) {
var c = meta[a];
return typeof c === "string" ? c : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
}) + '"' : '"' + string + '"';
}
function str(key, holder) {
var i, k, v, length, mind = gap, partial, value = holder[key], isBigNumber = value != null && (value instanceof BigNumber || BigNumber.isBigNumber(value));
if (value && typeof value === "object" && typeof value.toJSON === "function") {
value = value.toJSON(key);
}
if (typeof rep === "function") {
value = rep.call(holder, key, value);
}
switch (typeof value) {
case "string":
if (isBigNumber) {
return value;
} else {
return quote(value);
}
case "number":
return isFinite(value) ? String(value) : "null";
case "boolean":
case "null":
case "bigint":
return String(value);
// If the type is 'object', we might be dealing with an object or an array or
// null.
case "object":
if (!value) {
return "null";
}
gap += indent;
partial = [];
if (Object.prototype.toString.apply(value) === "[object Array]") {
length = value.length;
for (i = 0; i < length; i += 1) {
partial[i] = str(i, value) || "null";
}
v = partial.length === 0 ? "[]" : gap ? "[\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "]" : "[" + partial.join(",") + "]";
gap = mind;
return v;
}
if (rep && typeof rep === "object") {
length = rep.length;
for (i = 0; i < length; i += 1) {
if (typeof rep[i] === "string") {
k = rep[i];
v = str(k, value);
if (v) {
partial.push(quote(k) + (gap ? ": " : ":") + v);
}
}
}
} else {
Object.keys(value).forEach(function(k2) {
var v2 = str(k2, value);
if (v2) {
partial.push(quote(k2) + (gap ? ": " : ":") + v2);
}
});
}
v = partial.length === 0 ? "{}" : gap ? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}" : "{" + partial.join(",") + "}";
gap = mind;
return v;
}
}
if (typeof JSON2.stringify !== "function") {
JSON2.stringify = function(value, replacer, space) {
var i;
gap = "";
indent = "";
if (typeof space === "number") {
for (i = 0; i < space; i += 1) {
indent += " ";
}
} else if (typeof space === "string") {
indent = space;
}
rep = replacer;
if (replacer && typeof replacer !== "function" && (typeof replacer !== "object" || typeof replacer.length !== "number")) {
throw new Error("JSON.stringify");
}
return str("", { "": value });
};
}
})();
}
});
// node_modules/json-bigint/lib/parse.js
var require_parse = __commonJS({
"node_modules/json-bigint/lib/parse.js"(exports, module) {
var BigNumber = null;
var suspectProtoRx = /(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])/;
var suspectConstructorRx = /(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)/;
var json_parse = function(options) {
"use strict";
var _options = {
strict: false,
// not being strict means do not generate syntax errors for "duplicate key"
storeAsString: false,
// toggles whether the values should be stored as BigNumber (default) or a string
alwaysParseAsBig: false,
// toggles whether all numbers should be Big
useNativeBigInt: false,
// toggles whether to use native BigInt instead of bignumber.js
protoAction: "error",
constructorAction: "error"
};
if (options !== void 0 && options !== null) {
if (options.strict === true) {
_options.strict = true;
}
if (options.storeAsString === true) {
_options.storeAsString = true;
}
_options.alwaysParseAsBig = options.alwaysParseAsBig === true ? options.alwaysParseAsBig : false;
_options.useNativeBigInt = options.useNativeBigInt === true ? options.useNativeBigInt : false;
if (typeof options.constructorAction !== "undefined") {
if (options.constructorAction === "error" || options.constructorAction === "ignore" || options.constructorAction === "preserve") {
_options.constructorAction = options.constructorAction;
} else {
throw new Error(
`Incorrect value for constructorAction option, must be "error", "ignore" or undefined but passed ${options.constructorAction}`
);
}
}
if (typeof options.protoAction !== "undefined") {
if (options.protoAction === "error" || options.protoAction === "ignore" || options.protoAction === "preserve") {
_options.protoAction = options.protoAction;
} else {
throw new Error(
`Incorrect value for protoAction option, must be "error", "ignore" or undefined but passed ${options.protoAction}`
);
}
}
}
var at, ch, escapee = {
'"': '"',
"\\": "\\",
"/": "/",
b: "\b",
f: "\f",
n: "\n",
r: "\r",
t: " "
}, text, error = function(m) {
throw {
name: "SyntaxError",
message: m,
at,
text
};
}, next = function(c) {
if (c && c !== ch) {
error("Expected '" + c + "' instead of '" + ch + "'");
}
ch = text.charAt(at);
at += 1;
return ch;
}, number = function() {
var number2, string2 = "";
if (ch === "-") {
string2 = "-";
next("-");
}
while (ch >= "0" && ch <= "9") {
string2 += ch;
next();
}
if (ch === ".") {
string2 += ".";
while (next() && ch >= "0" && ch <= "9") {
string2 += ch;
}
}
if (ch === "e" || ch === "E") {
string2 += ch;
next();
if (ch === "-" || ch === "+") {
string2 += ch;
next();
}
while (ch >= "0" && ch <= "9") {
string2 += ch;
next();
}
}
number2 = +string2;
if (!isFinite(number2)) {
error("Bad number");
} else {
if (BigNumber == null) BigNumber = require_bignumber();
if (string2.length > 15)
return _options.storeAsString ? string2 : _options.useNativeBigInt ? BigInt(string2) : new BigNumber(string2);
else
return !_options.alwaysParseAsBig ? number2 : _options.useNativeBigInt ? BigInt(number2) : new BigNumber(number2);
}
}, string = function() {
var hex, i, string2 = "", uffff;
if (ch === '"') {
var startAt = at;
while (next()) {
if (ch === '"') {
if (at - 1 > startAt) string2 += text.substring(startAt, at - 1);
next();
return string2;
}
if (ch === "\\") {
if (at - 1 > startAt) string2 += text.substring(startAt, at - 1);
next();
if (ch === "u") {
uffff = 0;
for (i = 0; i < 4; i += 1) {
hex = parseInt(next(), 16);
if (!isFinite(hex)) {
break;
}
uffff = uffff * 16 + hex;
}
string2 += String.fromCharCode(uffff);
} else if (typeof escapee[ch] === "string") {
string2 += escapee[ch];
} else {
break;
}
startAt = at;
}
}
}
error("Bad string");
}, white = function() {
while (ch && ch <= " ") {
next();
}
}, word = function() {
switch (ch) {
case "t":
next("t");
next("r");
next("u");
next("e");
return true;
case "f":
next("f");
next("a");
next("l");
next("s");
next("e");
return false;
case "n":
next("n");
next("u");
next("l");
next("l");
return null;
}
error("Unexpected '" + ch + "'");
}, value, array = function() {
var array2 = [];
if (ch === "[") {
next("[");
white();
if (ch === "]") {
next("]");
return array2;
}
while (ch) {
array2.push(value());
white();
if (ch === "]") {
next("]");
return array2;
}
next(",");
white();
}
}
error("Bad array");
}, object = function() {
var key, object2 = /* @__PURE__ */ Object.create(null);
if (ch === "{") {
next("{");
white();
if (ch === "}") {
next("}");
return object2;
}
while (ch) {
key = string();
white();
next(":");
if (_options.strict === true && Object.hasOwnProperty.call(object2, key)) {
error('Duplicate key "' + key + '"');
}
if (suspectProtoRx.test(key) === true) {
if (_options.protoAction === "error") {
error("Object contains forbidden prototype property");
} else if (_options.protoAction === "ignore") {
value();
} else {
object2[key] = value();
}
} else if (suspectConstructorRx.test(key) === true) {
if (_options.constructorAction === "error") {
error("Object contains forbidden constructor property");
} else if (_options.constructorAction === "ignore") {
value();
} else {
object2[key] = value();
}
} else {
object2[key] = value();
}
white();
if (ch === "}") {
next("}");
return object2;
}
next(",");
white();
}
}
error("Bad object");
};
value = function() {
white();
switch (ch) {
case "{":
return object();
case "[":
return array();
case '"':
return string();
case "-":
return number();
default:
return ch >= "0" && ch <= "9" ? number() : word();
}
};
return function(source, reviver) {
var result;
text = source + "";
at = 0;
ch = " ";
result = value();
white();
if (ch) {
error("Syntax error");
}
return typeof reviver === "function" ? function walk(holder, key) {
var k, v, value2 = holder[key];
if (value2 && typeof value2 === "object") {
Object.keys(value2).forEach(function(k2) {
v = walk(value2, k2);
if (v !== void 0) {
value2[k2] = v;
} else {
delete value2[k2];
}
});
}
return reviver.call(holder, key, value2);
}({ "": result }, "") : result;
};
};
module.exports = json_parse;
}
});
// node_modules/json-bigint/index.js
var require_json_bigint = __commonJS({
"node_modules/json-bigint/index.js"(exports, module) {
var json_stringify = require_stringify().stringify;
var json_parse = require_parse();
module.exports = function(options) {
return {
parse: json_parse(options),
stringify: json_stringify
};
};
module.exports.parse = json_parse();
module.exports.stringify = json_stringify;
}
});
// node_modules/@google/genai/node_modules/gcp-metadata/build/src/gcp-residency.js
var require_gcp_residency = __commonJS({
"node_modules/@google/genai/node_modules/gcp-metadata/build/src/gcp-residency.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GCE_LINUX_BIOS_PATHS = void 0;
exports.isGoogleCloudServerless = isGoogleCloudServerless;
exports.isGoogleComputeEngineLinux = isGoogleComputeEngineLinux;
exports.isGoogleComputeEngineMACAddress = isGoogleComputeEngineMACAddress;
exports.isGoogleComputeEngine = isGoogleComputeEngine;
exports.detectGCPResidency = detectGCPResidency;
var fs_1 = __require("fs");
var os_1 = __require("os");
exports.GCE_LINUX_BIOS_PATHS = {
BIOS_DATE: "/sys/class/dmi/id/bios_date",
BIOS_VENDOR: "/sys/class/dmi/id/bios_vendor"
};
var GCE_MAC_ADDRESS_REGEX = /^42:01/;
function isGoogleCloudServerless() {
const isGFEnvironment = process.env.CLOUD_RUN_JOB || process.env.FUNCTION_NAME || process.env.K_SERVICE;
return !!isGFEnvironment;
}
function isGoogleComputeEngineLinux() {
if ((0, os_1.platform)() !== "linux")
return false;
try {
(0, fs_1.statSync)(exports.GCE_LINUX_BIOS_PATHS.BIOS_DATE);
const biosVendor = (0, fs_1.readFileSync)(exports.GCE_LINUX_BIOS_PATHS.BIOS_VENDOR, "utf8");
return /Google/.test(biosVendor);
} catch {
return false;
}
}
function isGoogleComputeEngineMACAddress() {
const interfaces = (0, os_1.networkInterfaces)();
for (const item of Object.values(interfaces)) {
if (!item)
continue;
for (const { mac } of item) {
if (GCE_MAC_ADDRESS_REGEX.test(mac)) {
return true;
}
}
}
return false;
}
function isGoogleComputeEngine() {
return isGoogleComputeEngineLinux() || isGoogleComputeEngineMACAddress();
}
function detectGCPResidency() {
return isGoogleCloudServerless() || isGoogleComputeEngine();
}
}
});
// node_modules/@google/genai/node_modules/google-logging-utils/build/src/colours.js
var require_colours = __commonJS({
"node_modules/@google/genai/node_modules/google-logging-utils/build/src/colours.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Colours = void 0;
var Colours = class _Colours {
/**
* @param stream The stream (e.g. process.stderr)
* @returns true if the stream should have colourization enabled
*/
static isEnabled(stream) {
return stream && // May happen in browsers.
stream.isTTY && (typeof stream.getColorDepth === "function" ? stream.getColorDepth() > 2 : true);
}
static refresh() {
_Colours.enabled = _Colours.isEnabled(process === null || process === void 0 ? void 0 : process.stderr);
if (!this.enabled) {
_Colours.reset = "";
_Colours.bright = "";
_Colours.dim = "";
_Colours.red = "";
_Colours.green = "";
_Colours.yellow = "";
_Colours.blue = "";
_Colours.magenta = "";
_Colours.cyan = "";
_Colours.white = "";
_Colours.grey = "";
} else {
_Colours.reset = "\x1B[0m";
_Colours.bright = "\x1B[1m";
_Colours.dim = "\x1B[2m";
_Colours.red = "\x1B[31m";
_Colours.green = "\x1B[32m";
_Colours.yellow = "\x1B[33m";
_Colours.blue = "\x1B[34m";
_Colours.magenta = "\x1B[35m";
_Colours.cyan = "\x1B[36m";
_Colours.white = "\x1B[37m";
_Colours.grey = "\x1B[90m";
}
}
};
exports.Colours = Colours;
Colours.enabled = false;
Colours.reset = "";
Colours.bright = "";
Colours.dim = "";
Colours.red = "";
Colours.green = "";
Colours.yellow = "";
Colours.blue = "";
Colours.magenta = "";
Colours.cyan = "";
Colours.white = "";
Colours.grey = "";
Colours.refresh();
}
});
// node_modules/@google/genai/node_modules/google-logging-utils/build/src/logging-utils.js
var require_logging_utils = __commonJS({
"node_modules/@google/genai/node_modules/google-logging-utils/build/src/logging-utils.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: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
} : function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
} : function(o, v) {
o["default"] = v;
});
var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function(o2) {
var ar = [];
for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
}
__setModuleDefault(result, mod);
return result;
};
}();
Object.defineProperty(exports, "__esModule", { value: true });
exports.env = exports.DebugLogBackendBase = exports.placeholder = exports.AdhocDebugLogger = exports.LogSeverity = void 0;
exports.getNodeBackend = getNodeBackend;
exports.getDebugBackend = getDebugBackend;
exports.getStructuredBackend = getStructuredBackend;
exports.setBackend = setBackend;
exports.log = log;
var events_1 = __require("events");
var process2 = __importStar(__require("process"));
var util3 = __importStar(__require("util"));
var colours_1 = require_colours();
var LogSeverity;
(function(LogSeverity2) {
LogSeverity2["DEFAULT"] = "DEFAULT";
LogSeverity2["DEBUG"] = "DEBUG";
LogSeverity2["INFO"] = "INFO";
LogSeverity2["WARNING"] = "WARNING";
LogSeverity2["ERROR"] = "ERROR";
})(LogSeverity || (exports.LogSeverity = LogSeverity = {}));
var AdhocDebugLogger = class extends events_1.EventEmitter {
/**
* @param upstream The backend will pass a function that will be
* called whenever our logger function is invoked.
*/
constructor(namespace, upstream) {
super();
this.namespace = namespace;
this.upstream = upstream;
this.func = Object.assign(this.invoke.bind(this), {
// Also add an instance pointer back to us.
instance: this,
// And pull over the EventEmitter functionality.
on: (event, listener) => this.on(event, listener)
});
this.func.debug = (...args) => this.invokeSeverity(LogSeverity.DEBUG, ...args);
this.func.info = (...args) => this.invokeSeverity(LogSeverity.INFO, ...args);
this.func.warn = (...args) => this.invokeSeverity(LogSeverity.WARNING, ...args);
this.func.error = (...args) => this.invokeSeverity(LogSeverity.ERROR, ...args);
this.func.sublog = (namespace2) => log(namespace2, this.func);
}
invoke(fields, ...args) {
if (this.upstream) {
try {
this.upstream(fields, ...args);
} catch (e) {
}
}
try {
this.emit("log", fields, args);
} catch (e) {
}
}
invokeSeverity(severity, ...args) {
this.invoke({ severity }, ...args);
}
};
exports.AdhocDebugLogger = AdhocDebugLogger;
exports.placeholder = new AdhocDebugLogger("", () => {
}).func;
var DebugLogBackendBase = class {
constructor() {
var _a;
this.cached = /* @__PURE__ */ new Map();
this.filters = [];
this.filtersSet = false;
let nodeFlag = (_a = process2.env[exports.env.nodeEnables]) !== null && _a !== void 0 ? _a : "*";
if (nodeFlag === "all") {
nodeFlag = "*";
}
this.filters = nodeFlag.split(",");
}
log(namespace, fields, ...args) {
try {
if (!this.filtersSet) {
this.setFilters();
this.filtersSet = true;
}
let logger4 = this.cached.get(namespace);
if (!logger4) {
logger4 = this.makeLogger(namespace);
this.cached.set(namespace, logger4);
}
logger4(fields, ...args);
} catch (e) {
console.error(e);
}
}
};
exports.DebugLogBackendBase = DebugLogBackendBase;
var NodeBackend = class extends DebugLogBackendBase {
constructor() {
super(...arguments);
this.enabledRegexp = /.*/g;
}
isEnabled(namespace) {
return this.enabledRegexp.test(namespace);
}
makeLogger(namespace) {
if (!this.enabledRegexp.test(namespace)) {
return () => {
};
}
return (fields, ...args) => {
var _a;
const nscolour = `${colours_1.Colours.green}${namespace}${colours_1.Colours.reset}`;
const pid = `${colours_1.Colours.yellow}${process2.pid}${colours_1.Colours.reset}`;
let level;
switch (fields.severity) {
case LogSeverity.ERROR:
level = `${colours_1.Colours.red}${fields.severity}${colours_1.Colours.reset}`;
break;
case LogSeverity.INFO:
level = `${colours_1.Colours.magenta}${fields.severity}${colours_1.Colours.reset}`;
break;
case LogSeverity.WARNING:
level = `${colours_1.Colours.yellow}${fields.severity}${colours_1.Colours.reset}`;
break;
default:
level = (_a = fields.severity) !== null && _a !== void 0 ? _a : LogSeverity.DEFAULT;
break;
}
const msg = util3.formatWithOptions({ colors: colours_1.Colours.enabled }, ...args);
const filteredFields = Object.assign({}, fields);
delete filteredFields.severity;
const fieldsJson = Object.getOwnPropertyNames(filteredFields).length ? JSON.stringify(filteredFields) : "";
const fieldsColour = fieldsJson ? `${colours_1.Colours.grey}${fieldsJson}${colours_1.Colours.reset}` : "";
console.error("%s [%s|%s] %s%s", pid, nscolour, level, msg, fieldsJson ? ` ${fieldsColour}` : "");
};
}
// Regexp patterns below are from here:
// https://github.com/nodejs/node/blob/c0aebed4b3395bd65d54b18d1fd00f071002ac20/lib/internal/util/debuglog.js#L36
setFilters() {
const totalFilters = this.filters.join(",");
const regexp = totalFilters.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^");
this.enabledRegexp = new RegExp(`^${regexp}$`, "i");
}
};
function getNodeBackend() {
return new NodeBackend();
}
var DebugBackend = class extends DebugLogBackendBase {
constructor(pkg) {
super();
this.debugPkg = pkg;
}
makeLogger(namespace) {
const debugLogger2 = this.debugPkg(namespace);
return (fields, ...args) => {
debugLogger2(args[0], ...args.slice(1));
};
}
setFilters() {
var _a;
const existingFilters = (_a = process2.env["NODE_DEBUG"]) !== null && _a !== void 0 ? _a : "";
process2.env["NODE_DEBUG"] = `${existingFilters}${existingFilters ? "," : ""}${this.filters.join(",")}`;
}
};
function getDebugBackend(debugPkg) {
return new DebugBackend(debugPkg);
}
var StructuredBackend = class extends DebugLogBackendBase {
constructor(upstream) {
var _a;
super();
this.upstream = (_a = upstream) !== null && _a !== void 0 ? _a : void 0;
}
makeLogger(namespace) {
var _a;
const debugLogger2 = (_a = this.upstream) === null || _a === void 0 ? void 0 : _a.makeLogger(namespace);
return (fields, ...args) => {
var _a2;
const severity = (_a2 = fields.severity) !== null && _a2 !== void 0 ? _a2 : LogSeverity.INFO;
const json = Object.assign({
severity,
message: util3.format(...args)
}, fields);
const jsonString = JSON.stringify(json);
if (debugLogger2) {
debugLogger2(fields, jsonString);
} else {
console.log("%s", jsonString);
}
};
}
setFilters() {
var _a;
(_a = this.upstream) === null || _a === void 0 ? void 0 : _a.setFilters();
}
};
function getStructuredBackend(upstream) {
return new StructuredBackend(upstream);
}
exports.env = {
/**
* Filter wildcards specific to the Node syntax, and similar to the built-in
* utils.debuglog() environment variable. If missing, disables logging.
*/
nodeEnables: "GOOGLE_SDK_NODE_LOGGING"
};
var loggerCache = /* @__PURE__ */ new Map();
var cachedBackend = void 0;
function setBackend(backend) {
cachedBackend = backend;
loggerCache.clear();
}
function log(namespace, parent) {
if (!cachedBackend) {
const enablesFlag = process2.env[exports.env.nodeEnables];
if (!enablesFlag) {
return exports.placeholder;
}
}
if (!namespace) {
return exports.placeholder;
}
if (parent) {
namespace = `${parent.instance.namespace}:${namespace}`;
}
const existing = loggerCache.get(namespace);
if (existing) {
return existing.func;
}
if (cachedBackend === null) {
return exports.placeholder;
} else if (cachedBackend === void 0) {
cachedBackend = getNodeBackend();
}
const logger4 = (() => {
let previousBackend = void 0;
const newLogger = new AdhocDebugLogger(namespace, (fields, ...args) => {
if (previousBackend !== cachedBackend) {
if (cachedBackend === null) {
return;
} else if (cachedBackend === void 0) {
cachedBackend = getNodeBackend();
}
previousBackend = cachedBackend;
}
cachedBackend === null || cachedBackend === void 0 ? void 0 : cachedBackend.log(namespace, fields, ...args);
});
return newLogger;
})();
loggerCache.set(namespace, logger4);
return logger4.func;
}
}
});
// node_modules/@google/genai/node_modules/google-logging-utils/build/src/index.js
var require_src2 = __commonJS({
"node_modules/@google/genai/node_modules/google-logging-utils/build/src/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: function() {
return m[k];
} };
}
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 });
__exportStar(require_logging_utils(), exports);
}
});
// node_modules/@google/genai/node_modules/gcp-metadata/build/src/index.js
var require_src3 = __commonJS({
"node_modules/@google/genai/node_modules/gcp-metadata/build/src/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: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
} : function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
} : function(o, v) {
o["default"] = v;
});
var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function(o2) {
var ar = [];
for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
}
__setModuleDefault(result, mod);
return result;
};
}();
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.gcpResidencyCache = exports.METADATA_SERVER_DETECTION = exports.HEADERS = exports.HEADER_VALUE = exports.HEADER_NAME = exports.SECONDARY_HOST_ADDRESS = exports.HOST_ADDRESS = exports.BASE_PATH = void 0;
exports.instance = instance;
exports.project = project;
exports.universe = universe;
exports.bulk = bulk;
exports.isAvailable = isAvailable;
exports.resetIsAvailableCache = resetIsAvailableCache;
exports.getGCPResidency = getGCPResidency;
exports.setGCPResidency = setGCPResidency;
exports.requestTimeout = requestTimeout;
var gaxios_1 = require_src();
var jsonBigint = require_json_bigint();
var gcp_residency_1 = require_gcp_residency();
var logger4 = __importStar(require_src2());
exports.BASE_PATH = "/computeMetadata/v1";
exports.HOST_ADDRESS = "http://169.254.169.254";
exports.SECONDARY_HOST_ADDRESS = "http://metadata.google.internal.";
exports.HEADER_NAME = "Metadata-Flavor";
exports.HEADER_VALUE = "Google";
exports.HEADERS = Object.freeze({ [exports.HEADER_NAME]: exports.HEADER_VALUE });
var log = logger4.log("gcp-metadata");
exports.METADATA_SERVER_DETECTION = Object.freeze({
"assume-present": "don't try to ping the metadata server, but assume it's present",
none: "don't try to ping the metadata server, but don't try to use it either",
"bios-only": "treat the result of a BIOS probe as canonical (don't fall back to pinging)",
"ping-only": "skip the BIOS probe, and go straight to pinging"
});
function getBaseUrl2(baseUrl) {
if (!baseUrl) {
baseUrl = process.env.GCE_METADATA_IP || process.env.GCE_METADATA_HOST || exports.HOST_ADDRESS;
}
if (!/^https?:\/\//.test(baseUrl)) {
baseUrl = `http://${baseUrl}`;
}
return new URL(exports.BASE_PATH, baseUrl).href;
}
function validate(options) {
Object.keys(options).forEach((key) => {
switch (key) {
case "params":
case "property":
case "headers":
break;
case "qs":
throw new Error("'qs' is not a valid configuration option. Please use 'params' instead.");
default:
throw new Error(`'${key}' is not a valid configuration option.`);
}
});
}
async function metadataAccessor(type, options = {}, noResponseRetries = 3, fastFail = false) {
const headers = new Headers(exports.HEADERS);
let metadataKey = "";
let params = {};
if (typeof type === "object") {
const metadataAccessor2 = type;
new Headers(metadataAccessor2.headers).forEach((value, key) => headers.set(key, value));
metadataKey = metadataAccessor2.metadataKey;
params = metadataAccessor2.params || params;
noResponseRetries = metadataAccessor2.noResponseRetries || noResponseRetries;
fastFail = metadataAccessor2.fastFail || fastFail;
} else {
metadataKey = type;
}
if (typeof options === "string") {
metadataKey += `/${options}`;
} else {
validate(options);
if (options.property) {
metadataKey += `/${options.property}`;
}
new Headers(options.headers).forEach((value, key) => headers.set(key, value));
params = options.params || params;
}
const requestMethod = fastFail ? fastFailMetadataRequest : gaxios_1.request;
const req = {
url: `${getBaseUrl2()}/${metadataKey}`,
headers,
retryConfig: { noResponseRetries },
params,
responseType: "text",
timeout: requestTimeout()
};
log.info("instance request %j", req);
const res = await requestMethod(req);
log.info("instance metadata is %s", res.data);
const metadataFlavor = res.headers.get(exports.HEADER_NAME);
if (metadataFlavor !== exports.HEADER_VALUE) {
throw new RangeError(`Invalid response from metadata service: incorrect ${exports.HEADER_NAME} header. Expected '${exports.HEADER_VALUE}', got ${metadataFlavor ? `'${metadataFlavor}'` : "no header"}`);
}
if (typeof res.data === "string") {
try {
return jsonBigint.parse(res.data);
} catch {
}
}
return res.data;
}
async function fastFailMetadataRequest(options) {
const secondaryOptions = {
...options,
url: options.url?.toString().replace(getBaseUrl2(), getBaseUrl2(exports.SECONDARY_HOST_ADDRESS))
};
const r1 = (0, gaxios_1.request)(options);
const r2 = (0, gaxios_1.request)(secondaryOptions);
return Promise.any([r1, r2]);
}
function instance(options) {
return metadataAccessor("instance", options);
}
function project(options) {
return metadataAccessor("project", options);
}
function universe(options) {
return metadataAccessor("universe", options);
}
async function bulk(properties) {
const r = {};
await Promise.all(properties.map((item) => {
return (async () => {
const res = await metadataAccessor(item);
const key = item.metadataKey;
r[key] = res;
})();
}));
return r;
}
function detectGCPAvailableRetries() {
return process.env.DETECT_GCP_RETRIES ? Number(process.env.DETECT_GCP_RETRIES) : 0;
}
var cachedIsAvailableResponse;
async function isAvailable() {
if (process.env.METADATA_SERVER_DETECTION) {
const value = process.env.METADATA_SERVER_DETECTION.trim().toLocaleLowerCase();
if (!(value in exports.METADATA_SERVER_DETECTION)) {
throw new RangeError(`Unknown \`METADATA_SERVER_DETECTION\` env variable. Got \`${value}\`, but it should be \`${Object.keys(exports.METADATA_SERVER_DETECTION).join("`, `")}\`, or unset`);
}
switch (value) {
case "assume-present":
return true;
case "none":
return false;
case "bios-only":
return getGCPResidency();
case "ping-only":
}
}
try {
if (cachedIsAvailableResponse === void 0) {
cachedIsAvailableResponse = metadataAccessor(
"instance",
void 0,
detectGCPAvailableRetries(),
// If the default HOST_ADDRESS has been overridden, we should not
// make an effort to try SECONDARY_HOST_ADDRESS (as we are likely in
// a non-GCP environment):
!(process.env.GCE_METADATA_IP || process.env.GCE_METADATA_HOST)
);
}
await cachedIsAvailableResponse;
return true;
} catch (e) {
const err = e;
if (process.env.DEBUG_AUTH) {
console.info(err);
}
if (err.type === "request-timeout") {
return false;
}
if (err.response && err.response.status === 404) {
return false;
} else {
if (!(err.response && err.response.status === 404) && // A warning is emitted if we see an unexpected err.code, or err.code
// is not populated:
(!err.code || ![
"EHOSTDOWN",
"EHOSTUNREACH",
"ENETUNREACH",
"ENOENT",
"ENOTFOUND",
"ECONNREFUSED"
].includes(err.code.toString()))) {
let code = "UNKNOWN";
if (err.code)
code = err.code.toString();
process.emitWarning(`received unexpected error = ${err.message} code = ${code}`, "MetadataLookupWarning");
}
return false;
}
}
}
function resetIsAvailableCache() {
cachedIsAvailableResponse = void 0;
}
exports.gcpResidencyCache = null;
function getGCPResidency() {
if (exports.gcpResidencyCache === null) {
setGCPResidency();
}
return exports.gcpResidencyCache;
}
function setGCPResidency(value = null) {
exports.gcpResidencyCache = value !== null ? value : (0, gcp_residency_1.detectGCPResidency)();
}
function requestTimeout() {
return getGCPResidency() ? 0 : 3e3;
}
__exportStar(require_gcp_residency(), exports);
}
});
// node_modules/base64-js/index.js
var require_base64_js = __commonJS({
"node_modules/base64-js/index.js"(exports) {
"use strict";
exports.byteLength = byteLength;
exports.toByteArray = toByteArray;
exports.fromByteArray = fromByteArray;
var lookup = [];
var revLookup = [];
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
for (i = 0, len = code.length; i < len; ++i) {
lookup[i] = code[i];
revLookup[code.charCodeAt(i)] = i;
}
var i;
var len;
revLookup["-".charCodeAt(0)] = 62;
revLookup["_".charCodeAt(0)] = 63;
function getLens(b64) {
var len2 = b64.length;
if (len2 % 4 > 0) {
throw new Error("Invalid string. Length must be a multiple of 4");
}
var validLen = b64.indexOf("=");
if (validLen === -1) validLen = len2;
var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
return [validLen, placeHoldersLen];
}
function byteLength(b64) {
var lens = getLens(b64);
var validLen = lens[0];
var placeHoldersLen = lens[1];
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
function _byteLength(b64, validLen, placeHoldersLen) {
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
function toByteArray(b64) {
var tmp;
var lens = getLens(b64);
var validLen = lens[0];
var placeHoldersLen = lens[1];
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
var curByte = 0;
var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
var i2;
for (i2 = 0; i2 < len2; i2 += 4) {
tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
arr[curByte++] = tmp >> 16 & 255;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 2) {
tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 1) {
tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
return arr;
}
function tripletToBase64(num) {
return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
}
function encodeChunk(uint8, start, end) {
var tmp;
var output = [];
for (var i2 = start; i2 < end; i2 += 3) {
tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
output.push(tripletToBase64(tmp));
}
return output.join("");
}
function fromByteArray(uint8) {
var tmp;
var len2 = uint8.length;
var extraBytes = len2 % 3;
var parts = [];
var maxChunkLength = 16383;
for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
}
if (extraBytes === 1) {
tmp = uint8[len2 - 1];
parts.push(
lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
);
} else if (extraBytes === 2) {
tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
parts.push(
lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
);
}
return parts.join("");
}
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/crypto/shared.js
var require_shared = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/crypto/shared.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.fromArrayBufferToHex = fromArrayBufferToHex;
function fromArrayBufferToHex(arrayBuffer) {
const byteArray = Array.from(new Uint8Array(arrayBuffer));
return byteArray.map((byte) => {
return byte.toString(16).padStart(2, "0");
}).join("");
}
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/crypto/browser/crypto.js
var require_crypto = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/crypto/browser/crypto.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BrowserCrypto = void 0;
var base64js = require_base64_js();
var shared_1 = require_shared();
var BrowserCrypto = class _BrowserCrypto {
constructor() {
if (typeof window === "undefined" || window.crypto === void 0 || window.crypto.subtle === void 0) {
throw new Error("SubtleCrypto not found. Make sure it's an https:// website.");
}
}
async sha256DigestBase64(str) {
const inputBuffer = new TextEncoder().encode(str);
const outputBuffer = await window.crypto.subtle.digest("SHA-256", inputBuffer);
return base64js.fromByteArray(new Uint8Array(outputBuffer));
}
randomBytesBase64(count) {
const array = new Uint8Array(count);
window.crypto.getRandomValues(array);
return base64js.fromByteArray(array);
}
static padBase64(base64) {
while (base64.length % 4 !== 0) {
base64 += "=";
}
return base64;
}
async verify(pubkey, data, signature) {
const algo = {
name: "RSASSA-PKCS1-v1_5",
hash: { name: "SHA-256" }
};
const dataArray = new TextEncoder().encode(data);
const signatureArray = base64js.toByteArray(_BrowserCrypto.padBase64(signature));
const cryptoKey = await window.crypto.subtle.importKey("jwk", pubkey, algo, true, ["verify"]);
const result = await window.crypto.subtle.verify(algo, cryptoKey, signatureArray, dataArray);
return result;
}
async sign(privateKey, data) {
const algo = {
name: "RSASSA-PKCS1-v1_5",
hash: { name: "SHA-256" }
};
const dataArray = new TextEncoder().encode(data);
const cryptoKey = await window.crypto.subtle.importKey("jwk", privateKey, algo, true, ["sign"]);
const result = await window.crypto.subtle.sign(algo, cryptoKey, dataArray);
return base64js.fromByteArray(new Uint8Array(result));
}
decodeBase64StringUtf8(base64) {
const uint8array = base64js.toByteArray(_BrowserCrypto.padBase64(base64));
const result = new TextDecoder().decode(uint8array);
return result;
}
encodeBase64StringUtf8(text) {
const uint8array = new TextEncoder().encode(text);
const result = base64js.fromByteArray(uint8array);
return result;
}
/**
* Computes the SHA-256 hash of the provided string.
* @param str The plain text string to hash.
* @return A promise that resolves with the SHA-256 hash of the provided
* string in hexadecimal encoding.
*/
async sha256DigestHex(str) {
const inputBuffer = new TextEncoder().encode(str);
const outputBuffer = await window.crypto.subtle.digest("SHA-256", inputBuffer);
return (0, shared_1.fromArrayBufferToHex)(outputBuffer);
}
/**
* Computes the HMAC hash of a message using the provided crypto key and the
* SHA-256 algorithm.
* @param key The secret crypto key in utf-8 or ArrayBuffer format.
* @param msg The plain text message.
* @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
* format.
*/
async signWithHmacSha256(key, msg) {
const rawKey = typeof key === "string" ? key : String.fromCharCode(...new Uint16Array(key));
const enc = new TextEncoder();
const cryptoKey = await window.crypto.subtle.importKey("raw", enc.encode(rawKey), {
name: "HMAC",
hash: {
name: "SHA-256"
}
}, false, ["sign"]);
return window.crypto.subtle.sign("HMAC", cryptoKey, enc.encode(msg));
}
};
exports.BrowserCrypto = BrowserCrypto;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/crypto/node/crypto.js
var require_crypto2 = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/crypto/node/crypto.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.NodeCrypto = void 0;
var crypto4 = __require("crypto");
var NodeCrypto = class {
async sha256DigestBase64(str) {
return crypto4.createHash("sha256").update(str).digest("base64");
}
randomBytesBase64(count) {
return crypto4.randomBytes(count).toString("base64");
}
async verify(pubkey, data, signature) {
const verifier = crypto4.createVerify("RSA-SHA256");
verifier.update(data);
verifier.end();
return verifier.verify(pubkey, signature, "base64");
}
async sign(privateKey, data) {
const signer = crypto4.createSign("RSA-SHA256");
signer.update(data);
signer.end();
return signer.sign(privateKey, "base64");
}
decodeBase64StringUtf8(base64) {
return Buffer.from(base64, "base64").toString("utf-8");
}
encodeBase64StringUtf8(text) {
return Buffer.from(text, "utf-8").toString("base64");
}
/**
* Computes the SHA-256 hash of the provided string.
* @param str The plain text string to hash.
* @return A promise that resolves with the SHA-256 hash of the provided
* string in hexadecimal encoding.
*/
async sha256DigestHex(str) {
return crypto4.createHash("sha256").update(str).digest("hex");
}
/**
* Computes the HMAC hash of a message using the provided crypto key and the
* SHA-256 algorithm.
* @param key The secret crypto key in utf-8 or ArrayBuffer format.
* @param msg The plain text message.
* @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
* format.
*/
async signWithHmacSha256(key, msg) {
const cryptoKey = typeof key === "string" ? key : toBuffer(key);
return toArrayBuffer(crypto4.createHmac("sha256", cryptoKey).update(msg).digest());
}
};
exports.NodeCrypto = NodeCrypto;
function toArrayBuffer(buffer) {
return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
}
function toBuffer(arrayBuffer) {
return Buffer.from(arrayBuffer);
}
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/crypto/crypto.js
var require_crypto3 = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/crypto/crypto.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: function() {
return m[k];
} };
}
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.createCrypto = createCrypto;
exports.hasBrowserCrypto = hasBrowserCrypto;
var crypto_1 = require_crypto();
var crypto_2 = require_crypto2();
__exportStar(require_shared(), exports);
function createCrypto() {
if (hasBrowserCrypto()) {
return new crypto_1.BrowserCrypto();
}
return new crypto_2.NodeCrypto();
}
function hasBrowserCrypto() {
return typeof window !== "undefined" && typeof window.crypto !== "undefined" && typeof window.crypto.subtle !== "undefined";
}
}
});
// node_modules/safe-buffer/index.js
var require_safe_buffer = __commonJS({
"node_modules/safe-buffer/index.js"(exports, module) {
var buffer = __require("buffer");
var Buffer2 = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) {
dst[key] = src[key];
}
}
if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
module.exports = buffer;
} else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer2(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer2.prototype);
copyProps(Buffer2, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") {
throw new TypeError("Argument must not be a number");
}
return Buffer2(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") {
throw new TypeError("Argument must be a number");
}
var buf = Buffer2(size);
if (fill !== void 0) {
if (typeof encoding === "string") {
buf.fill(fill, encoding);
} else {
buf.fill(fill);
}
} else {
buf.fill(0);
}
return buf;
};
SafeBuffer.allocUnsafe = function(size) {
if (typeof size !== "number") {
throw new TypeError("Argument must be a number");
}
return Buffer2(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") {
throw new TypeError("Argument must be a number");
}
return buffer.SlowBuffer(size);
};
}
});
// node_modules/ecdsa-sig-formatter/src/param-bytes-for-alg.js
var require_param_bytes_for_alg = __commonJS({
"node_modules/ecdsa-sig-formatter/src/param-bytes-for-alg.js"(exports, module) {
"use strict";
function getParamSize(keySize) {
var result = (keySize / 8 | 0) + (keySize % 8 === 0 ? 0 : 1);
return result;
}
var paramBytesForAlg = {
ES256: getParamSize(256),
ES384: getParamSize(384),
ES512: getParamSize(521)
};
function getParamBytesForAlg(alg) {
var paramBytes = paramBytesForAlg[alg];
if (paramBytes) {
return paramBytes;
}
throw new Error('Unknown algorithm "' + alg + '"');
}
module.exports = getParamBytesForAlg;
}
});
// node_modules/ecdsa-sig-formatter/src/ecdsa-sig-formatter.js
var require_ecdsa_sig_formatter = __commonJS({
"node_modules/ecdsa-sig-formatter/src/ecdsa-sig-formatter.js"(exports, module) {
"use strict";
var Buffer2 = require_safe_buffer().Buffer;
var getParamBytesForAlg = require_param_bytes_for_alg();
var MAX_OCTET = 128;
var CLASS_UNIVERSAL = 0;
var PRIMITIVE_BIT = 32;
var TAG_SEQ = 16;
var TAG_INT = 2;
var ENCODED_TAG_SEQ = TAG_SEQ | PRIMITIVE_BIT | CLASS_UNIVERSAL << 6;
var ENCODED_TAG_INT = TAG_INT | CLASS_UNIVERSAL << 6;
function base64Url(base64) {
return base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
}
function signatureAsBuffer(signature) {
if (Buffer2.isBuffer(signature)) {
return signature;
} else if ("string" === typeof signature) {
return Buffer2.from(signature, "base64");
}
throw new TypeError("ECDSA signature must be a Base64 string or a Buffer");
}
function derToJose(signature, alg) {
signature = signatureAsBuffer(signature);
var paramBytes = getParamBytesForAlg(alg);
var maxEncodedParamLength = paramBytes + 1;
var inputLength = signature.length;
var offset = 0;
if (signature[offset++] !== ENCODED_TAG_SEQ) {
throw new Error('Could not find expected "seq"');
}
var seqLength = signature[offset++];
if (seqLength === (MAX_OCTET | 1)) {
seqLength = signature[offset++];
}
if (inputLength - offset < seqLength) {
throw new Error('"seq" specified length of "' + seqLength + '", only "' + (inputLength - offset) + '" remaining');
}
if (signature[offset++] !== ENCODED_TAG_INT) {
throw new Error('Could not find expected "int" for "r"');
}
var rLength = signature[offset++];
if (inputLength - offset - 2 < rLength) {
throw new Error('"r" specified length of "' + rLength + '", only "' + (inputLength - offset - 2) + '" available');
}
if (maxEncodedParamLength < rLength) {
throw new Error('"r" specified length of "' + rLength + '", max of "' + maxEncodedParamLength + '" is acceptable');
}
var rOffset = offset;
offset += rLength;
if (signature[offset++] !== ENCODED_TAG_INT) {
throw new Error('Could not find expected "int" for "s"');
}
var sLength = signature[offset++];
if (inputLength - offset !== sLength) {
throw new Error('"s" specified length of "' + sLength + '", expected "' + (inputLength - offset) + '"');
}
if (maxEncodedParamLength < sLength) {
throw new Error('"s" specified length of "' + sLength + '", max of "' + maxEncodedParamLength + '" is acceptable');
}
var sOffset = offset;
offset += sLength;
if (offset !== inputLength) {
throw new Error('Expected to consume entire buffer, but "' + (inputLength - offset) + '" bytes remain');
}
var rPadding = paramBytes - rLength, sPadding = paramBytes - sLength;
var dst = Buffer2.allocUnsafe(rPadding + rLength + sPadding + sLength);
for (offset = 0; offset < rPadding; ++offset) {
dst[offset] = 0;
}
signature.copy(dst, offset, rOffset + Math.max(-rPadding, 0), rOffset + rLength);
offset = paramBytes;
for (var o = offset; offset < o + sPadding; ++offset) {
dst[offset] = 0;
}
signature.copy(dst, offset, sOffset + Math.max(-sPadding, 0), sOffset + sLength);
dst = dst.toString("base64");
dst = base64Url(dst);
return dst;
}
function countPadding(buf, start, stop) {
var padding = 0;
while (start + padding < stop && buf[start + padding] === 0) {
++padding;
}
var needsSign = buf[start + padding] >= MAX_OCTET;
if (needsSign) {
--padding;
}
return padding;
}
function joseToDer(signature, alg) {
signature = signatureAsBuffer(signature);
var paramBytes = getParamBytesForAlg(alg);
var signatureBytes = signature.length;
if (signatureBytes !== paramBytes * 2) {
throw new TypeError('"' + alg + '" signatures must be "' + paramBytes * 2 + '" bytes, saw "' + signatureBytes + '"');
}
var rPadding = countPadding(signature, 0, paramBytes);
var sPadding = countPadding(signature, paramBytes, signature.length);
var rLength = paramBytes - rPadding;
var sLength = paramBytes - sPadding;
var rsBytes = 1 + 1 + rLength + 1 + 1 + sLength;
var shortLength = rsBytes < MAX_OCTET;
var dst = Buffer2.allocUnsafe((shortLength ? 2 : 3) + rsBytes);
var offset = 0;
dst[offset++] = ENCODED_TAG_SEQ;
if (shortLength) {
dst[offset++] = rsBytes;
} else {
dst[offset++] = MAX_OCTET | 1;
dst[offset++] = rsBytes & 255;
}
dst[offset++] = ENCODED_TAG_INT;
dst[offset++] = rLength;
if (rPadding < 0) {
dst[offset++] = 0;
offset += signature.copy(dst, offset, 0, paramBytes);
} else {
offset += signature.copy(dst, offset, rPadding, paramBytes);
}
dst[offset++] = ENCODED_TAG_INT;
dst[offset++] = sLength;
if (sPadding < 0) {
dst[offset++] = 0;
signature.copy(dst, offset, paramBytes);
} else {
signature.copy(dst, offset, paramBytes + sPadding);
}
return dst;
}
module.exports = {
derToJose,
joseToDer
};
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/util.js
var require_util4 = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/util.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.LRUCache = void 0;
exports.snakeToCamel = snakeToCamel;
exports.originalOrCamelOptions = originalOrCamelOptions;
exports.removeUndefinedValuesInObject = removeUndefinedValuesInObject;
exports.isValidFile = isValidFile;
exports.getWellKnownCertificateConfigFileLocation = getWellKnownCertificateConfigFileLocation;
var fs11 = __require("fs");
var os5 = __require("os");
var path10 = __require("path");
var WELL_KNOWN_CERTIFICATE_CONFIG_FILE = "certificate_config.json";
var CLOUDSDK_CONFIG_DIRECTORY = "gcloud";
function snakeToCamel(str) {
return str.replace(/([_][^_])/g, (match) => match.slice(1).toUpperCase());
}
function originalOrCamelOptions(obj) {
function get(key) {
const o = obj || {};
return o[key] ?? o[snakeToCamel(key)];
}
return { get };
}
var LRUCache = class {
capacity;
/**
* Maps are in order. Thus, the older item is the first item.
*
* {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map}
*/
#cache = /* @__PURE__ */ new Map();
maxAge;
constructor(options) {
this.capacity = options.capacity;
this.maxAge = options.maxAge;
}
/**
* Moves the key to the end of the cache.
*
* @param key the key to move
* @param value the value of the key
*/
#moveToEnd(key, value) {
this.#cache.delete(key);
this.#cache.set(key, {
value,
lastAccessed: Date.now()
});
}
/**
* Add an item to the cache.
*
* @param key the key to upsert
* @param value the value of the key
*/
set(key, value) {
this.#moveToEnd(key, value);
this.#evict();
}
/**
* Get an item from the cache.
*
* @param key the key to retrieve
*/
get(key) {
const item = this.#cache.get(key);
if (!item)
return;
this.#moveToEnd(key, item.value);
this.#evict();
return item.value;
}
/**
* Maintain the cache based on capacity and TTL.
*/
#evict() {
const cutoffDate = this.maxAge ? Date.now() - this.maxAge : 0;
let oldestItem = this.#cache.entries().next();
while (!oldestItem.done && (this.#cache.size > this.capacity || // too many
oldestItem.value[1].lastAccessed < cutoffDate)) {
this.#cache.delete(oldestItem.value[0]);
oldestItem = this.#cache.entries().next();
}
}
};
exports.LRUCache = LRUCache;
function removeUndefinedValuesInObject(object) {
Object.entries(object).forEach(([key, value]) => {
if (value === void 0 || value === "undefined") {
delete object[key];
}
});
return object;
}
async function isValidFile(filePath) {
try {
const stats = await fs11.promises.lstat(filePath);
return stats.isFile();
} catch (e) {
return false;
}
}
function getWellKnownCertificateConfigFileLocation() {
const configDir = process.env.CLOUDSDK_CONFIG || (_isWindows() ? path10.join(process.env.APPDATA || "", CLOUDSDK_CONFIG_DIRECTORY) : path10.join(process.env.HOME || "", ".config", CLOUDSDK_CONFIG_DIRECTORY));
return path10.join(configDir, WELL_KNOWN_CERTIFICATE_CONFIG_FILE);
}
function _isWindows() {
return os5.platform().startsWith("win");
}
}
});
// node_modules/@google/genai/node_modules/google-auth-library/package.json
var require_package2 = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/package.json"(exports, module) {
module.exports = {
name: "google-auth-library",
version: "10.5.0",
author: "Google Inc.",
description: "Google APIs Authentication Client Library for Node.js",
engines: {
node: ">=18"
},
main: "./build/src/index.js",
types: "./build/src/index.d.ts",
repository: "googleapis/google-auth-library-nodejs.git",
keywords: [
"google",
"api",
"google apis",
"client",
"client library"
],
dependencies: {
"base64-js": "^1.3.0",
"ecdsa-sig-formatter": "^1.0.11",
gaxios: "^7.0.0",
"gcp-metadata": "^8.0.0",
"google-logging-utils": "^1.0.0",
gtoken: "^8.0.0",
jws: "^4.0.0"
},
devDependencies: {
"@types/base64-js": "^1.2.5",
"@types/jws": "^3.1.0",
"@types/mocha": "^10.0.10",
"@types/mv": "^2.1.0",
"@types/ncp": "^2.0.1",
"@types/node": "^22.0.0",
"@types/sinon": "^17.0.0",
"assert-rejects": "^1.0.0",
c8: "^10.0.0",
codecov: "^3.0.2",
gts: "^6.0.0",
"is-docker": "^3.0.0",
jsdoc: "^4.0.0",
"jsdoc-fresh": "^5.0.0",
"jsdoc-region-tag": "^4.0.0",
karma: "^6.0.0",
"karma-chrome-launcher": "^3.0.0",
"karma-coverage": "^2.0.0",
"karma-firefox-launcher": "^2.0.0",
"karma-mocha": "^2.0.0",
"karma-sourcemap-loader": "^0.4.0",
"karma-webpack": "^5.0.1",
keypair: "^1.0.4",
mocha: "^11.1.0",
mv: "^2.1.1",
ncp: "^2.0.0",
nock: "^14.0.5",
"null-loader": "^4.0.0",
puppeteer: "^24.0.0",
sinon: "^21.0.0",
"ts-loader": "^8.0.0",
typescript: "5.8.2",
webpack: "^5.21.2",
"webpack-cli": "^4.0.0"
},
files: [
"build/src",
"!build/src/**/*.map"
],
scripts: {
test: "c8 mocha build/test",
clean: "gts clean",
prepare: "npm run compile",
lint: "gts check --no-inline-config",
compile: "tsc -p .",
fix: "gts fix",
pretest: "npm run compile -- --sourceMap",
docs: "jsdoc -c .jsdoc.js",
"samples-setup": "cd samples/ && npm link ../ && npm run setup && cd ../",
"samples-test": "cd samples/ && npm link ../ && npm test && cd ../",
"system-test": "mocha build/system-test --timeout 60000",
"presystem-test": "npm run compile -- --sourceMap",
webpack: "webpack",
"browser-test": "karma start",
"docs-test": "echo 'disabled until linkinator is fixed'",
"predocs-test": "npm run docs",
prelint: "cd samples; npm link ../; npm install"
},
license: "Apache-2.0"
};
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/shared.cjs
var require_shared2 = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/shared.cjs"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.USER_AGENT = exports.PRODUCT_NAME = exports.pkg = void 0;
var pkg = require_package2();
exports.pkg = pkg;
var PRODUCT_NAME = "google-api-nodejs-client";
exports.PRODUCT_NAME = PRODUCT_NAME;
var USER_AGENT = `${PRODUCT_NAME}/${pkg.version}`;
exports.USER_AGENT = USER_AGENT;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/authclient.js
var require_authclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/authclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AuthClient = exports.DEFAULT_EAGER_REFRESH_THRESHOLD_MILLIS = exports.DEFAULT_UNIVERSE = void 0;
var events_1 = __require("events");
var gaxios_1 = require_src();
var util_1 = require_util4();
var google_logging_utils_1 = require_src2();
var shared_cjs_1 = require_shared2();
exports.DEFAULT_UNIVERSE = "googleapis.com";
exports.DEFAULT_EAGER_REFRESH_THRESHOLD_MILLIS = 5 * 60 * 1e3;
var AuthClient = class _AuthClient extends events_1.EventEmitter {
apiKey;
projectId;
/**
* The quota project ID. The quota project can be used by client libraries for the billing purpose.
* See {@link https://cloud.google.com/docs/quota Working with quotas}
*/
quotaProjectId;
/**
* The {@link Gaxios `Gaxios`} instance used for making requests.
*/
transporter;
credentials = {};
eagerRefreshThresholdMillis = exports.DEFAULT_EAGER_REFRESH_THRESHOLD_MILLIS;
forceRefreshOnFailure = false;
universeDomain = exports.DEFAULT_UNIVERSE;
/**
* Symbols that can be added to GaxiosOptions to specify the method name that is
* making an RPC call, for logging purposes, as well as a string ID that can be
* used to correlate calls and responses.
*/
static RequestMethodNameSymbol = Symbol("request method name");
static RequestLogIdSymbol = Symbol("request log id");
constructor(opts = {}) {
super();
const options = (0, util_1.originalOrCamelOptions)(opts);
this.apiKey = opts.apiKey;
this.projectId = options.get("project_id") ?? null;
this.quotaProjectId = options.get("quota_project_id");
this.credentials = options.get("credentials") ?? {};
this.universeDomain = options.get("universe_domain") ?? exports.DEFAULT_UNIVERSE;
this.transporter = opts.transporter ?? new gaxios_1.Gaxios(opts.transporterOptions);
if (options.get("useAuthRequestParameters") !== false) {
this.transporter.interceptors.request.add(_AuthClient.DEFAULT_REQUEST_INTERCEPTOR);
this.transporter.interceptors.response.add(_AuthClient.DEFAULT_RESPONSE_INTERCEPTOR);
}
if (opts.eagerRefreshThresholdMillis) {
this.eagerRefreshThresholdMillis = opts.eagerRefreshThresholdMillis;
}
this.forceRefreshOnFailure = opts.forceRefreshOnFailure ?? false;
}
/**
* A {@link fetch `fetch`} compliant API for {@link AuthClient}.
*
* @see {@link AuthClient.request} for the classic method.
*
* @remarks
*
* This is useful as a drop-in replacement for `fetch` API usage.
*
* @example
*
* ```ts
* const authClient = new AuthClient();
* const fetchWithAuthClient: typeof fetch = (...args) => authClient.fetch(...args);
* await fetchWithAuthClient('https://example.com');
* ```
*
* @param args `fetch` API or {@link Gaxios.fetch `Gaxios#fetch`} parameters
* @returns the {@link GaxiosResponse} with Gaxios-added properties
*/
fetch(...args) {
const input = args[0];
const init = args[1];
let url = void 0;
const headers = new Headers();
if (typeof input === "string") {
url = new URL(input);
} else if (input instanceof URL) {
url = input;
} else if (input && input.url) {
url = new URL(input.url);
}
if (input && typeof input === "object" && "headers" in input) {
gaxios_1.Gaxios.mergeHeaders(headers, input.headers);
}
if (init) {
gaxios_1.Gaxios.mergeHeaders(headers, new Headers(init.headers));
}
if (typeof input === "object" && !(input instanceof URL)) {
return this.request({ ...init, ...input, headers, url });
} else {
return this.request({ ...init, headers, url });
}
}
/**
* Sets the auth credentials.
*/
setCredentials(credentials) {
this.credentials = credentials;
}
/**
* Append additional headers, e.g., x-goog-user-project, shared across the
* classes inheriting AuthClient. This method should be used by any method
* that overrides getRequestMetadataAsync(), which is a shared helper for
* setting request information in both gRPC and HTTP API calls.
*
* @param headers object to append additional headers to.
*/
addSharedMetadataHeaders(headers) {
if (!headers.has("x-goog-user-project") && // don't override a value the user sets.
this.quotaProjectId) {
headers.set("x-goog-user-project", this.quotaProjectId);
}
return headers;
}
/**
* Adds the `x-goog-user-project` and `authorization` headers to the target Headers
* object, if they exist on the source.
*
* @param target the headers to target
* @param source the headers to source from
* @returns the target headers
*/
addUserProjectAndAuthHeaders(target, source) {
const xGoogUserProject = source.get("x-goog-user-project");
const authorizationHeader = source.get("authorization");
if (xGoogUserProject) {
target.set("x-goog-user-project", xGoogUserProject);
}
if (authorizationHeader) {
target.set("authorization", authorizationHeader);
}
return target;
}
static log = (0, google_logging_utils_1.log)("auth");
static DEFAULT_REQUEST_INTERCEPTOR = {
resolved: async (config) => {
if (!config.headers.has("x-goog-api-client")) {
const nodeVersion = process.version.replace(/^v/, "");
config.headers.set("x-goog-api-client", `gl-node/${nodeVersion}`);
}
const userAgent = config.headers.get("User-Agent");
if (!userAgent) {
config.headers.set("User-Agent", shared_cjs_1.USER_AGENT);
} else if (!userAgent.includes(`${shared_cjs_1.PRODUCT_NAME}/`)) {
config.headers.set("User-Agent", `${userAgent} ${shared_cjs_1.USER_AGENT}`);
}
try {
const symbols = config;
const methodName = symbols[_AuthClient.RequestMethodNameSymbol];
const logId = `${Math.floor(Math.random() * 1e3)}`;
symbols[_AuthClient.RequestLogIdSymbol] = logId;
const logObject = {
url: config.url,
headers: config.headers
};
if (methodName) {
_AuthClient.log.info("%s [%s] request %j", methodName, logId, logObject);
} else {
_AuthClient.log.info("[%s] request %j", logId, logObject);
}
} catch (e) {
}
return config;
}
};
static DEFAULT_RESPONSE_INTERCEPTOR = {
resolved: async (response) => {
try {
const symbols = response.config;
const methodName = symbols[_AuthClient.RequestMethodNameSymbol];
const logId = symbols[_AuthClient.RequestLogIdSymbol];
if (methodName) {
_AuthClient.log.info("%s [%s] response %j", methodName, logId, response.data);
} else {
_AuthClient.log.info("[%s] response %j", logId, response.data);
}
} catch (e) {
}
return response;
},
rejected: async (error) => {
try {
const symbols = error.config;
const methodName = symbols[_AuthClient.RequestMethodNameSymbol];
const logId = symbols[_AuthClient.RequestLogIdSymbol];
if (methodName) {
_AuthClient.log.info("%s [%s] error %j", methodName, logId, error.response?.data);
} else {
_AuthClient.log.error("[%s] error %j", logId, error.response?.data);
}
} catch (e) {
}
throw error;
}
};
/**
* Sets the method name that is making a Gaxios request, so that logging may tag
* log lines with the operation.
* @param config A Gaxios request config
* @param methodName The method name making the call
*/
static setMethodName(config, methodName) {
try {
const symbols = config;
symbols[_AuthClient.RequestMethodNameSymbol] = methodName;
} catch (e) {
}
}
/**
* Retry config for Auth-related requests.
*
* @remarks
*
* This is not a part of the default {@link AuthClient.transporter transporter/gaxios}
* config as some downstream APIs would prefer if customers explicitly enable retries,
* such as GCS.
*/
static get RETRY_CONFIG() {
return {
retry: true,
retryConfig: {
httpMethodsToRetry: ["GET", "PUT", "POST", "HEAD", "OPTIONS", "DELETE"]
}
};
}
};
exports.AuthClient = AuthClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/loginticket.js
var require_loginticket = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/loginticket.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.LoginTicket = void 0;
var LoginTicket = class {
envelope;
payload;
/**
* Create a simple class to extract user ID from an ID Token
*
* @param {string} env Envelope of the jwt
* @param {TokenPayload} pay Payload of the jwt
* @constructor
*/
constructor(env, pay) {
this.envelope = env;
this.payload = pay;
}
getEnvelope() {
return this.envelope;
}
getPayload() {
return this.payload;
}
/**
* Create a simple class to extract user ID from an ID Token
*
* @return The user ID
*/
getUserId() {
const payload = this.getPayload();
if (payload && payload.sub) {
return payload.sub;
}
return null;
}
/**
* Returns attributes from the login ticket. This can contain
* various information about the user session.
*
* @return The envelope and payload
*/
getAttributes() {
return { envelope: this.getEnvelope(), payload: this.getPayload() };
}
};
exports.LoginTicket = LoginTicket;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/oauth2client.js
var require_oauth2client = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/oauth2client.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.OAuth2Client = exports.ClientAuthentication = exports.CertificateFormat = exports.CodeChallengeMethod = void 0;
var gaxios_1 = require_src();
var querystring = __require("querystring");
var stream = __require("stream");
var formatEcdsa = require_ecdsa_sig_formatter();
var util_1 = require_util4();
var crypto_1 = require_crypto3();
var authclient_1 = require_authclient();
var loginticket_1 = require_loginticket();
var CodeChallengeMethod;
(function(CodeChallengeMethod2) {
CodeChallengeMethod2["Plain"] = "plain";
CodeChallengeMethod2["S256"] = "S256";
})(CodeChallengeMethod || (exports.CodeChallengeMethod = CodeChallengeMethod = {}));
var CertificateFormat;
(function(CertificateFormat2) {
CertificateFormat2["PEM"] = "PEM";
CertificateFormat2["JWK"] = "JWK";
})(CertificateFormat || (exports.CertificateFormat = CertificateFormat = {}));
var ClientAuthentication;
(function(ClientAuthentication2) {
ClientAuthentication2["ClientSecretPost"] = "ClientSecretPost";
ClientAuthentication2["ClientSecretBasic"] = "ClientSecretBasic";
ClientAuthentication2["None"] = "None";
})(ClientAuthentication || (exports.ClientAuthentication = ClientAuthentication = {}));
var OAuth2Client = class _OAuth2Client extends authclient_1.AuthClient {
redirectUri;
certificateCache = {};
certificateExpiry = null;
certificateCacheFormat = CertificateFormat.PEM;
refreshTokenPromises = /* @__PURE__ */ new Map();
endpoints;
issuers;
clientAuthentication;
// TODO: refactor tests to make this private
_clientId;
// TODO: refactor tests to make this private
_clientSecret;
refreshHandler;
/**
* An OAuth2 Client for Google APIs.
*
* @param options The OAuth2 Client Options. Passing an `clientId` directly is **@DEPRECATED**.
* @param clientSecret **@DEPRECATED**. Provide a {@link OAuth2ClientOptions `OAuth2ClientOptions`} object in the first parameter instead.
* @param redirectUri **@DEPRECATED**. Provide a {@link OAuth2ClientOptions `OAuth2ClientOptions`} object in the first parameter instead.
*/
constructor(options = {}, clientSecret, redirectUri) {
super(typeof options === "object" ? options : {});
if (typeof options !== "object") {
options = {
clientId: options,
clientSecret,
redirectUri
};
}
this._clientId = options.clientId || options.client_id;
this._clientSecret = options.clientSecret || options.client_secret;
this.redirectUri = options.redirectUri || options.redirect_uris?.[0];
this.endpoints = {
tokenInfoUrl: "https://oauth2.googleapis.com/tokeninfo",
oauth2AuthBaseUrl: "https://accounts.google.com/o/oauth2/v2/auth",
oauth2TokenUrl: "https://oauth2.googleapis.com/token",
oauth2RevokeUrl: "https://oauth2.googleapis.com/revoke",
oauth2FederatedSignonPemCertsUrl: "https://www.googleapis.com/oauth2/v1/certs",
oauth2FederatedSignonJwkCertsUrl: "https://www.googleapis.com/oauth2/v3/certs",
oauth2IapPublicKeyUrl: "https://www.gstatic.com/iap/verify/public_key",
...options.endpoints
};
this.clientAuthentication = options.clientAuthentication || ClientAuthentication.ClientSecretPost;
this.issuers = options.issuers || [
"accounts.google.com",
"https://accounts.google.com",
this.universeDomain
];
}
/**
* @deprecated use instance's {@link OAuth2Client.endpoints}
*/
static GOOGLE_TOKEN_INFO_URL = "https://oauth2.googleapis.com/tokeninfo";
/**
* Clock skew - five minutes in seconds
*/
static CLOCK_SKEW_SECS_ = 300;
/**
* The default max Token Lifetime is one day in seconds
*/
static DEFAULT_MAX_TOKEN_LIFETIME_SECS_ = 86400;
/**
* Generates URL for consent page landing.
* @param opts Options.
* @return URL to consent page.
*/
generateAuthUrl(opts = {}) {
if (opts.code_challenge_method && !opts.code_challenge) {
throw new Error("If a code_challenge_method is provided, code_challenge must be included.");
}
opts.response_type = opts.response_type || "code";
opts.client_id = opts.client_id || this._clientId;
opts.redirect_uri = opts.redirect_uri || this.redirectUri;
if (Array.isArray(opts.scope)) {
opts.scope = opts.scope.join(" ");
}
const rootUrl = this.endpoints.oauth2AuthBaseUrl.toString();
return rootUrl + "?" + querystring.stringify(opts);
}
generateCodeVerifier() {
throw new Error("generateCodeVerifier is removed, please use generateCodeVerifierAsync instead.");
}
/**
* Convenience method to automatically generate a code_verifier, and its
* resulting SHA256. If used, this must be paired with a S256
* code_challenge_method.
*
* For a full example see:
* https://github.com/googleapis/google-auth-library-nodejs/blob/main/samples/oauth2-codeVerifier.js
*/
async generateCodeVerifierAsync() {
const crypto4 = (0, crypto_1.createCrypto)();
const randomString = crypto4.randomBytesBase64(96);
const codeVerifier = randomString.replace(/\+/g, "~").replace(/=/g, "_").replace(/\//g, "-");
const unencodedCodeChallenge = await crypto4.sha256DigestBase64(codeVerifier);
const codeChallenge = unencodedCodeChallenge.split("=")[0].replace(/\+/g, "-").replace(/\//g, "_");
return { codeVerifier, codeChallenge };
}
getToken(codeOrOptions, callback) {
const options = typeof codeOrOptions === "string" ? { code: codeOrOptions } : codeOrOptions;
if (callback) {
this.getTokenAsync(options).then((r) => callback(null, r.tokens, r.res), (e) => callback(e, null, e.response));
} else {
return this.getTokenAsync(options);
}
}
async getTokenAsync(options) {
const url = this.endpoints.oauth2TokenUrl.toString();
const headers = new Headers();
const values = {
client_id: options.client_id || this._clientId,
code_verifier: options.codeVerifier,
code: options.code,
grant_type: "authorization_code",
redirect_uri: options.redirect_uri || this.redirectUri
};
if (this.clientAuthentication === ClientAuthentication.ClientSecretBasic) {
const basic = Buffer.from(`${this._clientId}:${this._clientSecret}`);
headers.set("authorization", `Basic ${basic.toString("base64")}`);
}
if (this.clientAuthentication === ClientAuthentication.ClientSecretPost) {
values.client_secret = this._clientSecret;
}
const opts = {
..._OAuth2Client.RETRY_CONFIG,
method: "POST",
url,
data: new URLSearchParams((0, util_1.removeUndefinedValuesInObject)(values)),
headers
};
authclient_1.AuthClient.setMethodName(opts, "getTokenAsync");
const res = await this.transporter.request(opts);
const tokens = res.data;
if (res.data && res.data.expires_in) {
tokens.expiry_date = (/* @__PURE__ */ new Date()).getTime() + res.data.expires_in * 1e3;
delete tokens.expires_in;
}
this.emit("tokens", tokens);
return { tokens, res };
}
/**
* Refreshes the access token.
* @param refresh_token Existing refresh token.
* @private
*/
async refreshToken(refreshToken) {
if (!refreshToken) {
return this.refreshTokenNoCache(refreshToken);
}
if (this.refreshTokenPromises.has(refreshToken)) {
return this.refreshTokenPromises.get(refreshToken);
}
const p = this.refreshTokenNoCache(refreshToken).then((r) => {
this.refreshTokenPromises.delete(refreshToken);
return r;
}, (e) => {
this.refreshTokenPromises.delete(refreshToken);
throw e;
});
this.refreshTokenPromises.set(refreshToken, p);
return p;
}
async refreshTokenNoCache(refreshToken) {
if (!refreshToken) {
throw new Error("No refresh token is set.");
}
const url = this.endpoints.oauth2TokenUrl.toString();
const data = {
refresh_token: refreshToken,
client_id: this._clientId,
client_secret: this._clientSecret,
grant_type: "refresh_token"
};
let res;
try {
const opts = {
..._OAuth2Client.RETRY_CONFIG,
method: "POST",
url,
data: new URLSearchParams((0, util_1.removeUndefinedValuesInObject)(data))
};
authclient_1.AuthClient.setMethodName(opts, "refreshTokenNoCache");
res = await this.transporter.request(opts);
} catch (e) {
if (e instanceof gaxios_1.GaxiosError && e.message === "invalid_grant" && e.response?.data && /ReAuth/i.test(e.response.data.error_description)) {
e.message = JSON.stringify(e.response.data);
}
throw e;
}
const tokens = res.data;
if (res.data && res.data.expires_in) {
tokens.expiry_date = (/* @__PURE__ */ new Date()).getTime() + res.data.expires_in * 1e3;
delete tokens.expires_in;
}
this.emit("tokens", tokens);
return { tokens, res };
}
refreshAccessToken(callback) {
if (callback) {
this.refreshAccessTokenAsync().then((r) => callback(null, r.credentials, r.res), callback);
} else {
return this.refreshAccessTokenAsync();
}
}
async refreshAccessTokenAsync() {
const r = await this.refreshToken(this.credentials.refresh_token);
const tokens = r.tokens;
tokens.refresh_token = this.credentials.refresh_token;
this.credentials = tokens;
return { credentials: this.credentials, res: r.res };
}
getAccessToken(callback) {
if (callback) {
this.getAccessTokenAsync().then((r) => callback(null, r.token, r.res), callback);
} else {
return this.getAccessTokenAsync();
}
}
async getAccessTokenAsync() {
const shouldRefresh = !this.credentials.access_token || this.isTokenExpiring();
if (shouldRefresh) {
if (!this.credentials.refresh_token) {
if (this.refreshHandler) {
const refreshedAccessToken = await this.processAndValidateRefreshHandler();
if (refreshedAccessToken?.access_token) {
this.setCredentials(refreshedAccessToken);
return { token: this.credentials.access_token };
}
} else {
throw new Error("No refresh token or refresh handler callback is set.");
}
}
const r = await this.refreshAccessTokenAsync();
if (!r.credentials || r.credentials && !r.credentials.access_token) {
throw new Error("Could not refresh access token.");
}
return { token: r.credentials.access_token, res: r.res };
} else {
return { token: this.credentials.access_token };
}
}
/**
* The main authentication interface. It takes an optional url which when
* present is the endpoint being accessed, and returns a Promise which
* resolves with authorization header fields.
*
* In OAuth2Client, the result has the form:
* { authorization: 'Bearer <access_token_value>' }
*/
async getRequestHeaders(url) {
const headers = (await this.getRequestMetadataAsync(url)).headers;
return headers;
}
async getRequestMetadataAsync(url) {
url;
const thisCreds = this.credentials;
if (!thisCreds.access_token && !thisCreds.refresh_token && !this.apiKey && !this.refreshHandler) {
throw new Error("No access, refresh token, API key or refresh handler callback is set.");
}
if (thisCreds.access_token && !this.isTokenExpiring()) {
thisCreds.token_type = thisCreds.token_type || "Bearer";
const headers2 = new Headers({
authorization: thisCreds.token_type + " " + thisCreds.access_token
});
return { headers: this.addSharedMetadataHeaders(headers2) };
}
if (this.refreshHandler) {
const refreshedAccessToken = await this.processAndValidateRefreshHandler();
if (refreshedAccessToken?.access_token) {
this.setCredentials(refreshedAccessToken);
const headers2 = new Headers({
authorization: "Bearer " + this.credentials.access_token
});
return { headers: this.addSharedMetadataHeaders(headers2) };
}
}
if (this.apiKey) {
return { headers: new Headers({ "X-Goog-Api-Key": this.apiKey }) };
}
let r = null;
let tokens = null;
try {
r = await this.refreshToken(thisCreds.refresh_token);
tokens = r.tokens;
} catch (err) {
const e = err;
if (e.response && (e.response.status === 403 || e.response.status === 404)) {
e.message = `Could not refresh access token: ${e.message}`;
}
throw e;
}
const credentials = this.credentials;
credentials.token_type = credentials.token_type || "Bearer";
tokens.refresh_token = credentials.refresh_token;
this.credentials = tokens;
const headers = new Headers({
authorization: credentials.token_type + " " + tokens.access_token
});
return { headers: this.addSharedMetadataHeaders(headers), res: r.res };
}
/**
* Generates an URL to revoke the given token.
* @param token The existing token to be revoked.
*
* @deprecated use instance method {@link OAuth2Client.getRevokeTokenURL}
*/
static getRevokeTokenUrl(token) {
return new _OAuth2Client().getRevokeTokenURL(token).toString();
}
/**
* Generates a URL to revoke the given token.
*
* @param token The existing token to be revoked.
*/
getRevokeTokenURL(token) {
const url = new URL(this.endpoints.oauth2RevokeUrl);
url.searchParams.append("token", token);
return url;
}
revokeToken(token, callback) {
const opts = {
..._OAuth2Client.RETRY_CONFIG,
url: this.getRevokeTokenURL(token).toString(),
method: "POST"
};
authclient_1.AuthClient.setMethodName(opts, "revokeToken");
if (callback) {
this.transporter.request(opts).then((r) => callback(null, r), callback);
} else {
return this.transporter.request(opts);
}
}
revokeCredentials(callback) {
if (callback) {
this.revokeCredentialsAsync().then((res) => callback(null, res), callback);
} else {
return this.revokeCredentialsAsync();
}
}
async revokeCredentialsAsync() {
const token = this.credentials.access_token;
this.credentials = {};
if (token) {
return this.revokeToken(token);
} else {
throw new Error("No access token to revoke.");
}
}
request(opts, callback) {
if (callback) {
this.requestAsync(opts).then((r) => callback(null, r), (e) => {
return callback(e, e.response);
});
} else {
return this.requestAsync(opts);
}
}
async requestAsync(opts, reAuthRetried = false) {
try {
const r = await this.getRequestMetadataAsync();
opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers);
this.addUserProjectAndAuthHeaders(opts.headers, r.headers);
if (this.apiKey) {
opts.headers.set("X-Goog-Api-Key", this.apiKey);
}
return await this.transporter.request(opts);
} catch (e) {
const res = e.response;
if (res) {
const statusCode = res.status;
const mayRequireRefresh = this.credentials && this.credentials.access_token && this.credentials.refresh_token && (!this.credentials.expiry_date || this.forceRefreshOnFailure);
const mayRequireRefreshWithNoRefreshToken = this.credentials && this.credentials.access_token && !this.credentials.refresh_token && (!this.credentials.expiry_date || this.forceRefreshOnFailure) && this.refreshHandler;
const isReadableStream = res.config.data instanceof stream.Readable;
const isAuthErr = statusCode === 401 || statusCode === 403;
if (!reAuthRetried && isAuthErr && !isReadableStream && mayRequireRefresh) {
await this.refreshAccessTokenAsync();
return this.requestAsync(opts, true);
} else if (!reAuthRetried && isAuthErr && !isReadableStream && mayRequireRefreshWithNoRefreshToken) {
const refreshedAccessToken = await this.processAndValidateRefreshHandler();
if (refreshedAccessToken?.access_token) {
this.setCredentials(refreshedAccessToken);
}
return this.requestAsync(opts, true);
}
}
throw e;
}
}
verifyIdToken(options, callback) {
if (callback && typeof callback !== "function") {
throw new Error("This method accepts an options object as the first parameter, which includes the idToken, audience, and maxExpiry.");
}
if (callback) {
this.verifyIdTokenAsync(options).then((r) => callback(null, r), callback);
} else {
return this.verifyIdTokenAsync(options);
}
}
async verifyIdTokenAsync(options) {
if (!options.idToken) {
throw new Error("The verifyIdToken method requires an ID Token");
}
const response = await this.getFederatedSignonCertsAsync();
const login = await this.verifySignedJwtWithCertsAsync(options.idToken, response.certs, options.audience, this.issuers, options.maxExpiry);
return login;
}
/**
* Obtains information about the provisioned access token. Especially useful
* if you want to check the scopes that were provisioned to a given token.
*
* @param accessToken Required. The Access Token for which you want to get
* user info.
*/
async getTokenInfo(accessToken) {
const { data } = await this.transporter.request({
..._OAuth2Client.RETRY_CONFIG,
method: "POST",
headers: {
"content-type": "application/x-www-form-urlencoded;charset=UTF-8",
authorization: `Bearer ${accessToken}`
},
url: this.endpoints.tokenInfoUrl.toString()
});
const info = Object.assign({
expiry_date: (/* @__PURE__ */ new Date()).getTime() + data.expires_in * 1e3,
scopes: data.scope.split(" ")
}, data);
delete info.expires_in;
delete info.scope;
return info;
}
getFederatedSignonCerts(callback) {
if (callback) {
this.getFederatedSignonCertsAsync().then((r) => callback(null, r.certs, r.res), callback);
} else {
return this.getFederatedSignonCertsAsync();
}
}
async getFederatedSignonCertsAsync() {
const nowTime = (/* @__PURE__ */ new Date()).getTime();
const format2 = (0, crypto_1.hasBrowserCrypto)() ? CertificateFormat.JWK : CertificateFormat.PEM;
if (this.certificateExpiry && nowTime < this.certificateExpiry.getTime() && this.certificateCacheFormat === format2) {
return { certs: this.certificateCache, format: format2 };
}
let res;
let url;
switch (format2) {
case CertificateFormat.PEM:
url = this.endpoints.oauth2FederatedSignonPemCertsUrl.toString();
break;
case CertificateFormat.JWK:
url = this.endpoints.oauth2FederatedSignonJwkCertsUrl.toString();
break;
default:
throw new Error(`Unsupported certificate format ${format2}`);
}
try {
const opts = {
..._OAuth2Client.RETRY_CONFIG,
url
};
authclient_1.AuthClient.setMethodName(opts, "getFederatedSignonCertsAsync");
res = await this.transporter.request(opts);
} catch (e) {
if (e instanceof Error) {
e.message = `Failed to retrieve verification certificates: ${e.message}`;
}
throw e;
}
const cacheControl = res?.headers.get("cache-control");
let cacheAge = -1;
if (cacheControl) {
const maxAge = /max-age=(?<maxAge>[0-9]+)/.exec(cacheControl)?.groups?.maxAge;
if (maxAge) {
cacheAge = Number(maxAge) * 1e3;
}
}
let certificates = {};
switch (format2) {
case CertificateFormat.PEM:
certificates = res.data;
break;
case CertificateFormat.JWK:
for (const key of res.data.keys) {
certificates[key.kid] = key;
}
break;
default:
throw new Error(`Unsupported certificate format ${format2}`);
}
const now = /* @__PURE__ */ new Date();
this.certificateExpiry = cacheAge === -1 ? null : new Date(now.getTime() + cacheAge);
this.certificateCache = certificates;
this.certificateCacheFormat = format2;
return { certs: certificates, format: format2, res };
}
getIapPublicKeys(callback) {
if (callback) {
this.getIapPublicKeysAsync().then((r) => callback(null, r.pubkeys, r.res), callback);
} else {
return this.getIapPublicKeysAsync();
}
}
async getIapPublicKeysAsync() {
let res;
const url = this.endpoints.oauth2IapPublicKeyUrl.toString();
try {
const opts = {
..._OAuth2Client.RETRY_CONFIG,
url
};
authclient_1.AuthClient.setMethodName(opts, "getIapPublicKeysAsync");
res = await this.transporter.request(opts);
} catch (e) {
if (e instanceof Error) {
e.message = `Failed to retrieve verification certificates: ${e.message}`;
}
throw e;
}
return { pubkeys: res.data, res };
}
verifySignedJwtWithCerts() {
throw new Error("verifySignedJwtWithCerts is removed, please use verifySignedJwtWithCertsAsync instead.");
}
/**
* Verify the id token is signed with the correct certificate
* and is from the correct audience.
* @param jwt The jwt to verify (The ID Token in this case).
* @param certs The array of certs to test the jwt against.
* @param requiredAudience The audience to test the jwt against.
* @param issuers The allowed issuers of the jwt (Optional).
* @param maxExpiry The max expiry the certificate can be (Optional).
* @return Returns a promise resolving to LoginTicket on verification.
*/
async verifySignedJwtWithCertsAsync(jwt, certs, requiredAudience, issuers, maxExpiry) {
const crypto4 = (0, crypto_1.createCrypto)();
if (!maxExpiry) {
maxExpiry = _OAuth2Client.DEFAULT_MAX_TOKEN_LIFETIME_SECS_;
}
const segments = jwt.split(".");
if (segments.length !== 3) {
throw new Error("Wrong number of segments in token: " + jwt);
}
const signed = segments[0] + "." + segments[1];
let signature = segments[2];
let envelope;
let payload;
try {
envelope = JSON.parse(crypto4.decodeBase64StringUtf8(segments[0]));
} catch (err) {
if (err instanceof Error) {
err.message = `Can't parse token envelope: ${segments[0]}': ${err.message}`;
}
throw err;
}
if (!envelope) {
throw new Error("Can't parse token envelope: " + segments[0]);
}
try {
payload = JSON.parse(crypto4.decodeBase64StringUtf8(segments[1]));
} catch (err) {
if (err instanceof Error) {
err.message = `Can't parse token payload '${segments[0]}`;
}
throw err;
}
if (!payload) {
throw new Error("Can't parse token payload: " + segments[1]);
}
if (!Object.prototype.hasOwnProperty.call(certs, envelope.kid)) {
throw new Error("No pem found for envelope: " + JSON.stringify(envelope));
}
const cert = certs[envelope.kid];
if (envelope.alg === "ES256") {
signature = formatEcdsa.joseToDer(signature, "ES256").toString("base64");
}
const verified = await crypto4.verify(cert, signed, signature);
if (!verified) {
throw new Error("Invalid token signature: " + jwt);
}
if (!payload.iat) {
throw new Error("No issue time in token: " + JSON.stringify(payload));
}
if (!payload.exp) {
throw new Error("No expiration time in token: " + JSON.stringify(payload));
}
const iat = Number(payload.iat);
if (isNaN(iat))
throw new Error("iat field using invalid format");
const exp = Number(payload.exp);
if (isNaN(exp))
throw new Error("exp field using invalid format");
const now = (/* @__PURE__ */ new Date()).getTime() / 1e3;
if (exp >= now + maxExpiry) {
throw new Error("Expiration time too far in future: " + JSON.stringify(payload));
}
const earliest = iat - _OAuth2Client.CLOCK_SKEW_SECS_;
const latest = exp + _OAuth2Client.CLOCK_SKEW_SECS_;
if (now < earliest) {
throw new Error("Token used too early, " + now + " < " + earliest + ": " + JSON.stringify(payload));
}
if (now > latest) {
throw new Error("Token used too late, " + now + " > " + latest + ": " + JSON.stringify(payload));
}
if (issuers && issuers.indexOf(payload.iss) < 0) {
throw new Error("Invalid issuer, expected one of [" + issuers + "], but got " + payload.iss);
}
if (typeof requiredAudience !== "undefined" && requiredAudience !== null) {
const aud = payload.aud;
let audVerified = false;
if (requiredAudience.constructor === Array) {
audVerified = requiredAudience.indexOf(aud) > -1;
} else {
audVerified = aud === requiredAudience;
}
if (!audVerified) {
throw new Error("Wrong recipient, payload audience != requiredAudience");
}
}
return new loginticket_1.LoginTicket(envelope, payload);
}
/**
* Returns a promise that resolves with AccessTokenResponse type if
* refreshHandler is defined.
* If not, nothing is returned.
*/
async processAndValidateRefreshHandler() {
if (this.refreshHandler) {
const accessTokenResponse = await this.refreshHandler();
if (!accessTokenResponse.access_token) {
throw new Error("No access token is returned by the refreshHandler callback.");
}
return accessTokenResponse;
}
return;
}
/**
* Returns true if a token is expired or will expire within
* eagerRefreshThresholdMillismilliseconds.
* If there is no expiry time, assumes the token is not expired or expiring.
*/
isTokenExpiring() {
const expiryDate = this.credentials.expiry_date;
return expiryDate ? expiryDate <= (/* @__PURE__ */ new Date()).getTime() + this.eagerRefreshThresholdMillis : false;
}
};
exports.OAuth2Client = OAuth2Client;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/computeclient.js
var require_computeclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/computeclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Compute = void 0;
var gaxios_1 = require_src();
var gcpMetadata = require_src3();
var oauth2client_1 = require_oauth2client();
var Compute = class extends oauth2client_1.OAuth2Client {
serviceAccountEmail;
scopes;
/**
* Google Compute Engine service account credentials.
*
* Retrieve access token from the metadata server.
* See: https://cloud.google.com/compute/docs/access/authenticate-workloads#applications
*/
constructor(options = {}) {
super(options);
this.credentials = { expiry_date: 1, refresh_token: "compute-placeholder" };
this.serviceAccountEmail = options.serviceAccountEmail || "default";
this.scopes = Array.isArray(options.scopes) ? options.scopes : options.scopes ? [options.scopes] : [];
}
/**
* Refreshes the access token.
* @param refreshToken Unused parameter
*/
async refreshTokenNoCache() {
const tokenPath = `service-accounts/${this.serviceAccountEmail}/token`;
let data;
try {
const instanceOptions = {
property: tokenPath
};
if (this.scopes.length > 0) {
instanceOptions.params = {
scopes: this.scopes.join(",")
};
}
data = await gcpMetadata.instance(instanceOptions);
} catch (e) {
if (e instanceof gaxios_1.GaxiosError) {
e.message = `Could not refresh access token: ${e.message}`;
this.wrapError(e);
}
throw e;
}
const tokens = data;
if (data && data.expires_in) {
tokens.expiry_date = (/* @__PURE__ */ new Date()).getTime() + data.expires_in * 1e3;
delete tokens.expires_in;
}
this.emit("tokens", tokens);
return { tokens, res: null };
}
/**
* Fetches an ID token.
* @param targetAudience the audience for the fetched ID token.
*/
async fetchIdToken(targetAudience) {
const idTokenPath = `service-accounts/${this.serviceAccountEmail}/identity?format=full&audience=${targetAudience}`;
let idToken;
try {
const instanceOptions = {
property: idTokenPath
};
idToken = await gcpMetadata.instance(instanceOptions);
} catch (e) {
if (e instanceof Error) {
e.message = `Could not fetch ID token: ${e.message}`;
}
throw e;
}
return idToken;
}
wrapError(e) {
const res = e.response;
if (res && res.status) {
e.status = res.status;
if (res.status === 403) {
e.message = "A Forbidden error was returned while attempting to retrieve an access token for the Compute Engine built-in service account. This may be because the Compute Engine instance does not have the correct permission scopes specified: " + e.message;
} else if (res.status === 404) {
e.message = "A Not Found error was returned while attempting to retrieve an accesstoken for the Compute Engine built-in service account. This may be because the Compute Engine instance does not have any permission scopes specified: " + e.message;
}
}
}
};
exports.Compute = Compute;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/idtokenclient.js
var require_idtokenclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/idtokenclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.IdTokenClient = void 0;
var oauth2client_1 = require_oauth2client();
var IdTokenClient = class extends oauth2client_1.OAuth2Client {
targetAudience;
idTokenProvider;
/**
* Google ID Token client
*
* Retrieve ID token from the metadata server.
* See: https://cloud.google.com/docs/authentication/get-id-token#metadata-server
*/
constructor(options) {
super(options);
this.targetAudience = options.targetAudience;
this.idTokenProvider = options.idTokenProvider;
}
async getRequestMetadataAsync() {
if (!this.credentials.id_token || !this.credentials.expiry_date || this.isTokenExpiring()) {
const idToken = await this.idTokenProvider.fetchIdToken(this.targetAudience);
this.credentials = {
id_token: idToken,
expiry_date: this.getIdTokenExpiryDate(idToken)
};
}
const headers = new Headers({
authorization: "Bearer " + this.credentials.id_token
});
return { headers };
}
getIdTokenExpiryDate(idToken) {
const payloadB64 = idToken.split(".")[1];
if (payloadB64) {
const payload = JSON.parse(Buffer.from(payloadB64, "base64").toString("ascii"));
return payload.exp * 1e3;
}
}
};
exports.IdTokenClient = IdTokenClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/envDetect.js
var require_envDetect = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/envDetect.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GCPEnv = void 0;
exports.clear = clear;
exports.getEnv = getEnv2;
var gcpMetadata = require_src3();
var GCPEnv;
(function(GCPEnv2) {
GCPEnv2["APP_ENGINE"] = "APP_ENGINE";
GCPEnv2["KUBERNETES_ENGINE"] = "KUBERNETES_ENGINE";
GCPEnv2["CLOUD_FUNCTIONS"] = "CLOUD_FUNCTIONS";
GCPEnv2["COMPUTE_ENGINE"] = "COMPUTE_ENGINE";
GCPEnv2["CLOUD_RUN"] = "CLOUD_RUN";
GCPEnv2["CLOUD_RUN_JOBS"] = "CLOUD_RUN_JOBS";
GCPEnv2["NONE"] = "NONE";
})(GCPEnv || (exports.GCPEnv = GCPEnv = {}));
var envPromise;
function clear() {
envPromise = void 0;
}
async function getEnv2() {
if (envPromise) {
return envPromise;
}
envPromise = getEnvMemoized();
return envPromise;
}
async function getEnvMemoized() {
let env = GCPEnv.NONE;
if (isAppEngine()) {
env = GCPEnv.APP_ENGINE;
} else if (isCloudFunction()) {
env = GCPEnv.CLOUD_FUNCTIONS;
} else if (await isComputeEngine()) {
if (await isKubernetesEngine()) {
env = GCPEnv.KUBERNETES_ENGINE;
} else if (isCloudRun()) {
env = GCPEnv.CLOUD_RUN;
} else if (isCloudRunJob()) {
env = GCPEnv.CLOUD_RUN_JOBS;
} else {
env = GCPEnv.COMPUTE_ENGINE;
}
} else {
env = GCPEnv.NONE;
}
return env;
}
function isAppEngine() {
return !!(process.env.GAE_SERVICE || process.env.GAE_MODULE_NAME);
}
function isCloudFunction() {
return !!(process.env.FUNCTION_NAME || process.env.FUNCTION_TARGET);
}
function isCloudRun() {
return !!process.env.K_CONFIGURATION;
}
function isCloudRunJob() {
return !!process.env.CLOUD_RUN_JOB;
}
async function isKubernetesEngine() {
try {
await gcpMetadata.instance("attributes/cluster-name");
return true;
} catch (e) {
return false;
}
}
async function isComputeEngine() {
return gcpMetadata.isAvailable();
}
}
});
// node_modules/jws/lib/data-stream.js
var require_data_stream = __commonJS({
"node_modules/jws/lib/data-stream.js"(exports, module) {
var Buffer2 = require_safe_buffer().Buffer;
var Stream = __require("stream");
var util3 = __require("util");
function DataStream(data) {
this.buffer = null;
this.writable = true;
this.readable = true;
if (!data) {
this.buffer = Buffer2.alloc(0);
return this;
}
if (typeof data.pipe === "function") {
this.buffer = Buffer2.alloc(0);
data.pipe(this);
return this;
}
if (data.length || typeof data === "object") {
this.buffer = data;
this.writable = false;
process.nextTick(function() {
this.emit("end", data);
this.readable = false;
this.emit("close");
}.bind(this));
return this;
}
throw new TypeError("Unexpected data type (" + typeof data + ")");
}
util3.inherits(DataStream, Stream);
DataStream.prototype.write = function write(data) {
this.buffer = Buffer2.concat([this.buffer, Buffer2.from(data)]);
this.emit("data", data);
};
DataStream.prototype.end = function end(data) {
if (data)
this.write(data);
this.emit("end", data);
this.emit("close");
this.writable = false;
this.readable = false;
};
module.exports = DataStream;
}
});
// node_modules/buffer-equal-constant-time/index.js
var require_buffer_equal_constant_time = __commonJS({
"node_modules/buffer-equal-constant-time/index.js"(exports, module) {
"use strict";
var Buffer2 = __require("buffer").Buffer;
var SlowBuffer = __require("buffer").SlowBuffer;
module.exports = bufferEq;
function bufferEq(a, b) {
if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
return false;
}
if (a.length !== b.length) {
return false;
}
var c = 0;
for (var i = 0; i < a.length; i++) {
c |= a[i] ^ b[i];
}
return c === 0;
}
bufferEq.install = function() {
Buffer2.prototype.equal = SlowBuffer.prototype.equal = function equal(that) {
return bufferEq(this, that);
};
};
var origBufEqual = Buffer2.prototype.equal;
var origSlowBufEqual = SlowBuffer.prototype.equal;
bufferEq.restore = function() {
Buffer2.prototype.equal = origBufEqual;
SlowBuffer.prototype.equal = origSlowBufEqual;
};
}
});
// node_modules/jwa/index.js
var require_jwa = __commonJS({
"node_modules/jwa/index.js"(exports, module) {
var Buffer2 = require_safe_buffer().Buffer;
var crypto4 = __require("crypto");
var formatEcdsa = require_ecdsa_sig_formatter();
var util3 = __require("util");
var MSG_INVALID_ALGORITHM = '"%s" is not a valid algorithm.\n Supported algorithms are:\n "HS256", "HS384", "HS512", "RS256", "RS384", "RS512", "PS256", "PS384", "PS512", "ES256", "ES384", "ES512" and "none".';
var MSG_INVALID_SECRET = "secret must be a string or buffer";
var MSG_INVALID_VERIFIER_KEY = "key must be a string or a buffer";
var MSG_INVALID_SIGNER_KEY = "key must be a string, a buffer or an object";
var supportsKeyObjects = typeof crypto4.createPublicKey === "function";
if (supportsKeyObjects) {
MSG_INVALID_VERIFIER_KEY += " or a KeyObject";
MSG_INVALID_SECRET += "or a KeyObject";
}
function checkIsPublicKey(key) {
if (Buffer2.isBuffer(key)) {
return;
}
if (typeof key === "string") {
return;
}
if (!supportsKeyObjects) {
throw typeError(MSG_INVALID_VERIFIER_KEY);
}
if (typeof key !== "object") {
throw typeError(MSG_INVALID_VERIFIER_KEY);
}
if (typeof key.type !== "string") {
throw typeError(MSG_INVALID_VERIFIER_KEY);
}
if (typeof key.asymmetricKeyType !== "string") {
throw typeError(MSG_INVALID_VERIFIER_KEY);
}
if (typeof key.export !== "function") {
throw typeError(MSG_INVALID_VERIFIER_KEY);
}
}
function checkIsPrivateKey(key) {
if (Buffer2.isBuffer(key)) {
return;
}
if (typeof key === "string") {
return;
}
if (typeof key === "object") {
return;
}
throw typeError(MSG_INVALID_SIGNER_KEY);
}
function checkIsSecretKey(key) {
if (Buffer2.isBuffer(key)) {
return;
}
if (typeof key === "string") {
return key;
}
if (!supportsKeyObjects) {
throw typeError(MSG_INVALID_SECRET);
}
if (typeof key !== "object") {
throw typeError(MSG_INVALID_SECRET);
}
if (key.type !== "secret") {
throw typeError(MSG_INVALID_SECRET);
}
if (typeof key.export !== "function") {
throw typeError(MSG_INVALID_SECRET);
}
}
function fromBase64(base64) {
return base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
}
function toBase64(base64url) {
base64url = base64url.toString();
var padding = 4 - base64url.length % 4;
if (padding !== 4) {
for (var i = 0; i < padding; ++i) {
base64url += "=";
}
}
return base64url.replace(/\-/g, "+").replace(/_/g, "/");
}
function typeError(template) {
var args = [].slice.call(arguments, 1);
var errMsg = util3.format.bind(util3, template).apply(null, args);
return new TypeError(errMsg);
}
function bufferOrString(obj) {
return Buffer2.isBuffer(obj) || typeof obj === "string";
}
function normalizeInput(thing) {
if (!bufferOrString(thing))
thing = JSON.stringify(thing);
return thing;
}
function createHmacSigner(bits) {
return function sign(thing, secret) {
checkIsSecretKey(secret);
thing = normalizeInput(thing);
var hmac = crypto4.createHmac("sha" + bits, secret);
var sig = (hmac.update(thing), hmac.digest("base64"));
return fromBase64(sig);
};
}
var bufferEqual;
var timingSafeEqual = "timingSafeEqual" in crypto4 ? function timingSafeEqual2(a, b) {
if (a.byteLength !== b.byteLength) {
return false;
}
return crypto4.timingSafeEqual(a, b);
} : function timingSafeEqual2(a, b) {
if (!bufferEqual) {
bufferEqual = require_buffer_equal_constant_time();
}
return bufferEqual(a, b);
};
function createHmacVerifier(bits) {
return function verify(thing, signature, secret) {
var computedSig = createHmacSigner(bits)(thing, secret);
return timingSafeEqual(Buffer2.from(signature), Buffer2.from(computedSig));
};
}
function createKeySigner(bits) {
return function sign(thing, privateKey) {
checkIsPrivateKey(privateKey);
thing = normalizeInput(thing);
var signer = crypto4.createSign("RSA-SHA" + bits);
var sig = (signer.update(thing), signer.sign(privateKey, "base64"));
return fromBase64(sig);
};
}
function createKeyVerifier(bits) {
return function verify(thing, signature, publicKey) {
checkIsPublicKey(publicKey);
thing = normalizeInput(thing);
signature = toBase64(signature);
var verifier = crypto4.createVerify("RSA-SHA" + bits);
verifier.update(thing);
return verifier.verify(publicKey, signature, "base64");
};
}
function createPSSKeySigner(bits) {
return function sign(thing, privateKey) {
checkIsPrivateKey(privateKey);
thing = normalizeInput(thing);
var signer = crypto4.createSign("RSA-SHA" + bits);
var sig = (signer.update(thing), signer.sign({
key: privateKey,
padding: crypto4.constants.RSA_PKCS1_PSS_PADDING,
saltLength: crypto4.constants.RSA_PSS_SALTLEN_DIGEST
}, "base64"));
return fromBase64(sig);
};
}
function createPSSKeyVerifier(bits) {
return function verify(thing, signature, publicKey) {
checkIsPublicKey(publicKey);
thing = normalizeInput(thing);
signature = toBase64(signature);
var verifier = crypto4.createVerify("RSA-SHA" + bits);
verifier.update(thing);
return verifier.verify({
key: publicKey,
padding: crypto4.constants.RSA_PKCS1_PSS_PADDING,
saltLength: crypto4.constants.RSA_PSS_SALTLEN_DIGEST
}, signature, "base64");
};
}
function createECDSASigner(bits) {
var inner = createKeySigner(bits);
return function sign() {
var signature = inner.apply(null, arguments);
signature = formatEcdsa.derToJose(signature, "ES" + bits);
return signature;
};
}
function createECDSAVerifer(bits) {
var inner = createKeyVerifier(bits);
return function verify(thing, signature, publicKey) {
signature = formatEcdsa.joseToDer(signature, "ES" + bits).toString("base64");
var result = inner(thing, signature, publicKey);
return result;
};
}
function createNoneSigner() {
return function sign() {
return "";
};
}
function createNoneVerifier() {
return function verify(thing, signature) {
return signature === "";
};
}
module.exports = function jwa(algorithm) {
var signerFactories = {
hs: createHmacSigner,
rs: createKeySigner,
ps: createPSSKeySigner,
es: createECDSASigner,
none: createNoneSigner
};
var verifierFactories = {
hs: createHmacVerifier,
rs: createKeyVerifier,
ps: createPSSKeyVerifier,
es: createECDSAVerifer,
none: createNoneVerifier
};
var match = algorithm.match(/^(RS|PS|ES|HS)(256|384|512)$|^(none)$/);
if (!match)
throw typeError(MSG_INVALID_ALGORITHM, algorithm);
var algo = (match[1] || match[3]).toLowerCase();
var bits = match[2];
return {
sign: signerFactories[algo](bits),
verify: verifierFactories[algo](bits)
};
};
}
});
// node_modules/jws/lib/tostring.js
var require_tostring = __commonJS({
"node_modules/jws/lib/tostring.js"(exports, module) {
var Buffer2 = __require("buffer").Buffer;
module.exports = function toString(obj) {
if (typeof obj === "string")
return obj;
if (typeof obj === "number" || Buffer2.isBuffer(obj))
return obj.toString();
return JSON.stringify(obj);
};
}
});
// node_modules/jws/lib/sign-stream.js
var require_sign_stream = __commonJS({
"node_modules/jws/lib/sign-stream.js"(exports, module) {
var Buffer2 = require_safe_buffer().Buffer;
var DataStream = require_data_stream();
var jwa = require_jwa();
var Stream = __require("stream");
var toString = require_tostring();
var util3 = __require("util");
function base64url(string, encoding) {
return Buffer2.from(string, encoding).toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
}
function jwsSecuredInput(header, payload, encoding) {
encoding = encoding || "utf8";
var encodedHeader = base64url(toString(header), "binary");
var encodedPayload = base64url(toString(payload), encoding);
return util3.format("%s.%s", encodedHeader, encodedPayload);
}
function jwsSign(opts) {
var header = opts.header;
var payload = opts.payload;
var secretOrKey = opts.secret || opts.privateKey;
var encoding = opts.encoding;
var algo = jwa(header.alg);
var securedInput = jwsSecuredInput(header, payload, encoding);
var signature = algo.sign(securedInput, secretOrKey);
return util3.format("%s.%s", securedInput, signature);
}
function SignStream(opts) {
var secret = opts.secret;
secret = secret == null ? opts.privateKey : secret;
secret = secret == null ? opts.key : secret;
if (/^hs/i.test(opts.header.alg) === true && secret == null) {
throw new TypeError("secret must be a string or buffer or a KeyObject");
}
var secretStream = new DataStream(secret);
this.readable = true;
this.header = opts.header;
this.encoding = opts.encoding;
this.secret = this.privateKey = this.key = secretStream;
this.payload = new DataStream(opts.payload);
this.secret.once("close", function() {
if (!this.payload.writable && this.readable)
this.sign();
}.bind(this));
this.payload.once("close", function() {
if (!this.secret.writable && this.readable)
this.sign();
}.bind(this));
}
util3.inherits(SignStream, Stream);
SignStream.prototype.sign = function sign() {
try {
var signature = jwsSign({
header: this.header,
payload: this.payload.buffer,
secret: this.secret.buffer,
encoding: this.encoding
});
this.emit("done", signature);
this.emit("data", signature);
this.emit("end");
this.readable = false;
return signature;
} catch (e) {
this.readable = false;
this.emit("error", e);
this.emit("close");
}
};
SignStream.sign = jwsSign;
module.exports = SignStream;
}
});
// node_modules/jws/lib/verify-stream.js
var require_verify_stream = __commonJS({
"node_modules/jws/lib/verify-stream.js"(exports, module) {
var Buffer2 = require_safe_buffer().Buffer;
var DataStream = require_data_stream();
var jwa = require_jwa();
var Stream = __require("stream");
var toString = require_tostring();
var util3 = __require("util");
var JWS_REGEX = /^[a-zA-Z0-9\-_]+?\.[a-zA-Z0-9\-_]+?\.([a-zA-Z0-9\-_]+)?$/;
function isObject(thing) {
return Object.prototype.toString.call(thing) === "[object Object]";
}
function safeJsonParse(thing) {
if (isObject(thing))
return thing;
try {
return JSON.parse(thing);
} catch (e) {
return void 0;
}
}
function headerFromJWS(jwsSig) {
var encodedHeader = jwsSig.split(".", 1)[0];
return safeJsonParse(Buffer2.from(encodedHeader, "base64").toString("binary"));
}
function securedInputFromJWS(jwsSig) {
return jwsSig.split(".", 2).join(".");
}
function signatureFromJWS(jwsSig) {
return jwsSig.split(".")[2];
}
function payloadFromJWS(jwsSig, encoding) {
encoding = encoding || "utf8";
var payload = jwsSig.split(".")[1];
return Buffer2.from(payload, "base64").toString(encoding);
}
function isValidJws(string) {
return JWS_REGEX.test(string) && !!headerFromJWS(string);
}
function jwsVerify(jwsSig, algorithm, secretOrKey) {
if (!algorithm) {
var err = new Error("Missing algorithm parameter for jws.verify");
err.code = "MISSING_ALGORITHM";
throw err;
}
jwsSig = toString(jwsSig);
var signature = signatureFromJWS(jwsSig);
var securedInput = securedInputFromJWS(jwsSig);
var algo = jwa(algorithm);
return algo.verify(securedInput, signature, secretOrKey);
}
function jwsDecode(jwsSig, opts) {
opts = opts || {};
jwsSig = toString(jwsSig);
if (!isValidJws(jwsSig))
return null;
var header = headerFromJWS(jwsSig);
if (!header)
return null;
var payload = payloadFromJWS(jwsSig);
if (header.typ === "JWT" || opts.json)
payload = JSON.parse(payload, opts.encoding);
return {
header,
payload,
signature: signatureFromJWS(jwsSig)
};
}
function VerifyStream(opts) {
opts = opts || {};
var secretOrKey = opts.secret;
secretOrKey = secretOrKey == null ? opts.publicKey : secretOrKey;
secretOrKey = secretOrKey == null ? opts.key : secretOrKey;
if (/^hs/i.test(opts.algorithm) === true && secretOrKey == null) {
throw new TypeError("secret must be a string or buffer or a KeyObject");
}
var secretStream = new DataStream(secretOrKey);
this.readable = true;
this.algorithm = opts.algorithm;
this.encoding = opts.encoding;
this.secret = this.publicKey = this.key = secretStream;
this.signature = new DataStream(opts.signature);
this.secret.once("close", function() {
if (!this.signature.writable && this.readable)
this.verify();
}.bind(this));
this.signature.once("close", function() {
if (!this.secret.writable && this.readable)
this.verify();
}.bind(this));
}
util3.inherits(VerifyStream, Stream);
VerifyStream.prototype.verify = function verify() {
try {
var valid = jwsVerify(this.signature.buffer, this.algorithm, this.key.buffer);
var obj = jwsDecode(this.signature.buffer, this.encoding);
this.emit("done", valid, obj);
this.emit("data", valid);
this.emit("end");
this.readable = false;
return valid;
} catch (e) {
this.readable = false;
this.emit("error", e);
this.emit("close");
}
};
VerifyStream.decode = jwsDecode;
VerifyStream.isValid = isValidJws;
VerifyStream.verify = jwsVerify;
module.exports = VerifyStream;
}
});
// node_modules/jws/index.js
var require_jws = __commonJS({
"node_modules/jws/index.js"(exports) {
var SignStream = require_sign_stream();
var VerifyStream = require_verify_stream();
var ALGORITHMS = [
"HS256",
"HS384",
"HS512",
"RS256",
"RS384",
"RS512",
"PS256",
"PS384",
"PS512",
"ES256",
"ES384",
"ES512"
];
exports.ALGORITHMS = ALGORITHMS;
exports.sign = SignStream.sign;
exports.verify = VerifyStream.verify;
exports.decode = VerifyStream.decode;
exports.isValid = VerifyStream.isValid;
exports.createSign = function createSign(opts) {
return new SignStream(opts);
};
exports.createVerify = function createVerify(opts) {
return new VerifyStream(opts);
};
}
});
// node_modules/@google/genai/node_modules/gtoken/build/cjs/src/index.cjs
var require_src4 = __commonJS({
"node_modules/@google/genai/node_modules/gtoken/build/cjs/src/index.cjs"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.GoogleToken = void 0;
var fs11 = _interopRequireWildcard(__require("fs"));
var _gaxios = require_src();
var jws = _interopRequireWildcard(require_jws());
var path10 = _interopRequireWildcard(__require("path"));
var _util = __require("util");
function _interopRequireWildcard(e, t) {
if ("function" == typeof WeakMap) var r = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
return (_interopRequireWildcard = function _interopRequireWildcard2(e2, t2) {
if (!t2 && e2 && e2.__esModule) return e2;
var o, i, f = { __proto__: null, "default": e2 };
if (null === e2 || "object" != _typeof(e2) && "function" != typeof e2) return f;
if (o = t2 ? n : r) {
if (o.has(e2)) return o.get(e2);
o.set(e2, f);
}
for (var _t3 in e2) "default" !== _t3 && {}.hasOwnProperty.call(e2, _t3) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e2, _t3)) && (i.get || i.set) ? o(f, _t3, i) : f[_t3] = e2[_t3]);
return f;
})(e, t);
}
function _typeof(o) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof(o);
}
function _classPrivateMethodInitSpec(e, a) {
_checkPrivateRedeclaration(e, a), a.add(e);
}
function _classPrivateFieldInitSpec(e, t, a) {
_checkPrivateRedeclaration(e, t), t.set(e, a);
}
function _checkPrivateRedeclaration(e, t) {
if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
}
function _classPrivateFieldSet(s, a, r) {
return s.set(_assertClassBrand(s, a), r), r;
}
function _classPrivateFieldGet(s, a) {
return s.get(_assertClassBrand(s, a));
}
function _assertClassBrand(e, t, n) {
if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
throw new TypeError("Private element is not present on this object");
}
function _defineProperties(e, r) {
for (var t = 0; t < r.length; t++) {
var o = r[t];
o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
}
}
function _createClass(e, r, t) {
return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: false }), e;
}
function _classCallCheck(a, n) {
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _callSuper(t, o, e) {
return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
}
function _possibleConstructorReturn(t, e) {
if (e && ("object" == _typeof(e) || "function" == typeof e)) return e;
if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
return _assertThisInitialized(t);
}
function _assertThisInitialized(e) {
if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
return e;
}
function _inherits(t, e) {
if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: true, configurable: true } }), Object.defineProperty(t, "prototype", { writable: false }), e && _setPrototypeOf(t, e);
}
function _wrapNativeSuper(t) {
var r = "function" == typeof Map ? /* @__PURE__ */ new Map() : void 0;
return _wrapNativeSuper = function _wrapNativeSuper2(t2) {
if (null === t2 || !_isNativeFunction(t2)) return t2;
if ("function" != typeof t2) throw new TypeError("Super expression must either be null or a function");
if (void 0 !== r) {
if (r.has(t2)) return r.get(t2);
r.set(t2, Wrapper);
}
function Wrapper() {
return _construct(t2, arguments, _getPrototypeOf(this).constructor);
}
return Wrapper.prototype = Object.create(t2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }), _setPrototypeOf(Wrapper, t2);
}, _wrapNativeSuper(t);
}
function _construct(t, e, r) {
if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
var o = [null];
o.push.apply(o, e);
var p = new (t.bind.apply(t, o))();
return r && _setPrototypeOf(p, r.prototype), p;
}
function _isNativeReflectConstruct() {
try {
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
}));
} catch (t2) {
}
return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
return !!t;
})();
}
function _isNativeFunction(t) {
try {
return -1 !== Function.toString.call(t).indexOf("[native code]");
} catch (n) {
return "function" == typeof t;
}
}
function _setPrototypeOf(t, e) {
return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
return t2.__proto__ = e2, t2;
}, _setPrototypeOf(t, e);
}
function _getPrototypeOf(t) {
return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
return t2.__proto__ || Object.getPrototypeOf(t2);
}, _getPrototypeOf(t);
}
function _defineProperty(e, r, t) {
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == _typeof(i) ? i : i + "";
}
function _toPrimitive(t, r) {
if ("object" != _typeof(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
function _regenerator() {
var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag";
function i(r2, n2, o2, i2) {
var c2 = n2 && n2.prototype instanceof Generator ? n2 : Generator, u2 = Object.create(c2.prototype);
return _regeneratorDefine2(u2, "_invoke", function(r3, n3, o3) {
var i3, c3, u3, f2 = 0, p = o3 || [], y = false, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d2(t2, r4) {
return i3 = t2, c3 = 0, u3 = e, G.n = r4, a;
} };
function d(r4, n4) {
for (c3 = r4, u3 = n4, t = 0; !y && f2 && !o4 && t < p.length; t++) {
var o4, i4 = p[t], d2 = G.p, l = i4[2];
r4 > 3 ? (o4 = l === n4) && (u3 = i4[(c3 = i4[4]) ? 5 : (c3 = 3, 3)], i4[4] = i4[5] = e) : i4[0] <= d2 && ((o4 = r4 < 2 && d2 < i4[1]) ? (c3 = 0, G.v = n4, G.n = i4[1]) : d2 < l && (o4 = r4 < 3 || i4[0] > n4 || n4 > l) && (i4[4] = r4, i4[5] = n4, G.n = l, c3 = 0));
}
if (o4 || r4 > 1) return a;
throw y = true, n4;
}
return function(o4, p2, l) {
if (f2 > 1) throw TypeError("Generator is already running");
for (y && 1 === p2 && d(p2, l), c3 = p2, u3 = l; (t = c3 < 2 ? e : u3) || !y; ) {
i3 || (c3 ? c3 < 3 ? (c3 > 1 && (G.n = -1), d(c3, u3)) : G.n = u3 : G.v = u3);
try {
if (f2 = 2, i3) {
if (c3 || (o4 = "next"), t = i3[o4]) {
if (!(t = t.call(i3, u3))) throw TypeError("iterator result is not an object");
if (!t.done) return t;
u3 = t.value, c3 < 2 && (c3 = 0);
} else 1 === c3 && (t = i3["return"]) && t.call(i3), c3 < 2 && (u3 = TypeError("The iterator does not provide a '" + o4 + "' method"), c3 = 1);
i3 = e;
} else if ((t = (y = G.n < 0) ? u3 : r3.call(n3, G)) !== a) break;
} catch (t2) {
i3 = e, c3 = 1, u3 = t2;
} finally {
f2 = 1;
}
}
return { value: t, done: y };
};
}(r2, o2, i2), true), u2;
}
var a = {};
function Generator() {
}
function GeneratorFunction() {
}
function GeneratorFunctionPrototype() {
}
t = Object.getPrototypeOf;
var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function() {
return this;
}), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
function f(e2) {
return Object.setPrototypeOf ? Object.setPrototypeOf(e2, GeneratorFunctionPrototype) : (e2.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e2, o, "GeneratorFunction")), e2.prototype = Object.create(u), e2;
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function() {
return this;
}), _regeneratorDefine2(u, "toString", function() {
return "[object Generator]";
}), (_regenerator = function _regenerator2() {
return { w: i, m: f };
})();
}
function _regeneratorDefine2(e, r, n, t) {
var i = Object.defineProperty;
try {
i({}, "", {});
} catch (e2) {
i = 0;
}
_regeneratorDefine2 = function _regeneratorDefine(e2, r2, n2, t2) {
if (r2) i ? i(e2, r2, { value: n2, enumerable: !t2, configurable: !t2, writable: !t2 }) : e2[r2] = n2;
else {
var o = function o2(r3, n3) {
_regeneratorDefine2(e2, r3, function(e3) {
return this._invoke(r3, n3, e3);
});
};
o("next", 0), o("throw", 1), o("return", 2);
}
}, _regeneratorDefine2(e, r, n, t);
}
function asyncGeneratorStep(n, t, e, r, o, a, c) {
try {
var i = n[a](c), u = i.value;
} catch (n2) {
return void e(n2);
}
i.done ? t(u) : Promise.resolve(u).then(r, o);
}
function _asyncToGenerator(n) {
return function() {
var t = this, e = arguments;
return new Promise(function(r, o) {
var a = n.apply(t, e);
function _next(n2) {
asyncGeneratorStep(a, r, o, _next, _throw, "next", n2);
}
function _throw(n2) {
asyncGeneratorStep(a, r, o, _next, _throw, "throw", n2);
}
_next(void 0);
});
};
}
var readFile4 = fs11.readFile ? (0, _util.promisify)(fs11.readFile) : /* @__PURE__ */ _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee() {
return _regenerator().w(function(_context) {
while (1) switch (_context.n) {
case 0:
throw new ErrorWithCode("use key rather than keyFile.", "MISSING_CREDENTIALS");
case 1:
return _context.a(2);
}
}, _callee);
}));
var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
var GOOGLE_REVOKE_TOKEN_URL = "https://oauth2.googleapis.com/revoke?token=";
var ErrorWithCode = /* @__PURE__ */ function(_Error) {
function ErrorWithCode2(message, code) {
var _this;
_classCallCheck(this, ErrorWithCode2);
_this = _callSuper(this, ErrorWithCode2, [message]);
_defineProperty(_this, "code", void 0);
_this.code = code;
return _this;
}
_inherits(ErrorWithCode2, _Error);
return _createClass(ErrorWithCode2);
}(/* @__PURE__ */ _wrapNativeSuper(Error));
var _inFlightRequest = /* @__PURE__ */ new WeakMap();
var _GoogleToken_brand = /* @__PURE__ */ new WeakSet();
var GoogleToken = exports.GoogleToken = /* @__PURE__ */ function() {
function GoogleToken2(_options) {
_classCallCheck(this, GoogleToken2);
_classPrivateMethodInitSpec(this, _GoogleToken_brand);
_defineProperty(this, "expiresAt", void 0);
_defineProperty(this, "key", void 0);
_defineProperty(this, "keyFile", void 0);
_defineProperty(this, "iss", void 0);
_defineProperty(this, "sub", void 0);
_defineProperty(this, "scope", void 0);
_defineProperty(this, "rawToken", void 0);
_defineProperty(this, "tokenExpires", void 0);
_defineProperty(this, "email", void 0);
_defineProperty(this, "additionalClaims", void 0);
_defineProperty(this, "eagerRefreshThresholdMillis", void 0);
_defineProperty(this, "transporter", {
request: function request(opts) {
return (0, _gaxios.request)(opts);
}
});
_classPrivateFieldInitSpec(this, _inFlightRequest, void 0);
_assertClassBrand(_GoogleToken_brand, this, _configure).call(this, _options);
}
return _createClass(GoogleToken2, [{
key: "accessToken",
get: function get() {
return this.rawToken ? this.rawToken.access_token : void 0;
}
}, {
key: "idToken",
get: function get() {
return this.rawToken ? this.rawToken.id_token : void 0;
}
}, {
key: "tokenType",
get: function get() {
return this.rawToken ? this.rawToken.token_type : void 0;
}
}, {
key: "refreshToken",
get: function get() {
return this.rawToken ? this.rawToken.refresh_token : void 0;
}
}, {
key: "hasExpired",
value: function hasExpired() {
var now = (/* @__PURE__ */ new Date()).getTime();
if (this.rawToken && this.expiresAt) {
return now >= this.expiresAt;
} else {
return true;
}
}
/**
* Returns whether the token will expire within eagerRefreshThresholdMillis
*
* @return true if the token will be expired within eagerRefreshThresholdMillis, false otherwise.
*/
}, {
key: "isTokenExpiring",
value: function isTokenExpiring() {
var _this$eagerRefreshThr;
var now = (/* @__PURE__ */ new Date()).getTime();
var eagerRefreshThresholdMillis = (_this$eagerRefreshThr = this.eagerRefreshThresholdMillis) !== null && _this$eagerRefreshThr !== void 0 ? _this$eagerRefreshThr : 0;
if (this.rawToken && this.expiresAt) {
return this.expiresAt <= now + eagerRefreshThresholdMillis;
} else {
return true;
}
}
/**
* Returns a cached token or retrieves a new one from Google.
*
* @param callback The callback function.
*/
}, {
key: "getToken",
value: function getToken(callback) {
var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
if (_typeof(callback) === "object") {
opts = callback;
callback = void 0;
}
opts = Object.assign({
forceRefresh: false
}, opts);
if (callback) {
var cb = callback;
_assertClassBrand(_GoogleToken_brand, this, _getTokenAsync).call(this, opts).then(function(t) {
return cb(null, t);
}, callback);
return;
}
return _assertClassBrand(_GoogleToken_brand, this, _getTokenAsync).call(this, opts);
}
/**
* Given a keyFile, extract the key and client email if available
* @param keyFile Path to a json, pem, or p12 file that contains the key.
* @returns an object with privateKey and clientEmail properties
*/
}, {
key: "getCredentials",
value: function() {
var _getCredentials = _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee2(keyFile) {
var ext, key, body, privateKey, clientEmail, _privateKey, _t;
return _regenerator().w(function(_context2) {
while (1) switch (_context2.n) {
case 0:
ext = path10.extname(keyFile);
_t = ext;
_context2.n = _t === ".json" ? 1 : _t === ".der" ? 4 : _t === ".crt" ? 4 : _t === ".pem" ? 4 : _t === ".p12" ? 6 : _t === ".pfx" ? 6 : 7;
break;
case 1:
_context2.n = 2;
return readFile4(keyFile, "utf8");
case 2:
key = _context2.v;
body = JSON.parse(key);
privateKey = body.private_key;
clientEmail = body.client_email;
if (!(!privateKey || !clientEmail)) {
_context2.n = 3;
break;
}
throw new ErrorWithCode("private_key and client_email are required.", "MISSING_CREDENTIALS");
case 3:
return _context2.a(2, {
privateKey,
clientEmail
});
case 4:
_context2.n = 5;
return readFile4(keyFile, "utf8");
case 5:
_privateKey = _context2.v;
return _context2.a(2, {
privateKey: _privateKey
});
case 6:
throw new ErrorWithCode("*.p12 certificates are not supported after v6.1.2. Consider utilizing *.json format or converting *.p12 to *.pem using the OpenSSL CLI.", "UNKNOWN_CERTIFICATE_TYPE");
case 7:
throw new ErrorWithCode("Unknown certificate type. Type is determined based on file extension. Current supported extensions are *.json, and *.pem.", "UNKNOWN_CERTIFICATE_TYPE");
case 8:
return _context2.a(2);
}
}, _callee2);
}));
function getCredentials(_x) {
return _getCredentials.apply(this, arguments);
}
return getCredentials;
}()
}, {
key: "revokeToken",
value: function revokeToken(callback) {
if (callback) {
_assertClassBrand(_GoogleToken_brand, this, _revokeTokenAsync).call(this).then(function() {
return callback();
}, callback);
return;
}
return _assertClassBrand(_GoogleToken_brand, this, _revokeTokenAsync).call(this);
}
}]);
}();
function _getTokenAsync(_x2) {
return _getTokenAsync2.apply(this, arguments);
}
function _getTokenAsync2() {
_getTokenAsync2 = _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee3(opts) {
return _regenerator().w(function(_context3) {
while (1) switch (_context3.n) {
case 0:
if (!(_classPrivateFieldGet(_inFlightRequest, this) && !opts.forceRefresh)) {
_context3.n = 1;
break;
}
return _context3.a(2, _classPrivateFieldGet(_inFlightRequest, this));
case 1:
_context3.p = 1;
_context3.n = 2;
return _classPrivateFieldSet(_inFlightRequest, this, _assertClassBrand(_GoogleToken_brand, this, _getTokenAsyncInner).call(this, opts));
case 2:
return _context3.a(2, _context3.v);
case 3:
_context3.p = 3;
_classPrivateFieldSet(_inFlightRequest, this, void 0);
return _context3.f(3);
case 4:
return _context3.a(2);
}
}, _callee3, this, [[1, , 3, 4]]);
}));
return _getTokenAsync2.apply(this, arguments);
}
function _getTokenAsyncInner(_x3) {
return _getTokenAsyncInner2.apply(this, arguments);
}
function _getTokenAsyncInner2() {
_getTokenAsyncInner2 = _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee4(opts) {
var creds;
return _regenerator().w(function(_context4) {
while (1) switch (_context4.n) {
case 0:
if (!(this.isTokenExpiring() === false && opts.forceRefresh === false)) {
_context4.n = 1;
break;
}
return _context4.a(2, Promise.resolve(this.rawToken));
case 1:
if (!(!this.key && !this.keyFile)) {
_context4.n = 2;
break;
}
throw new Error("No key or keyFile set.");
case 2:
if (!(!this.key && this.keyFile)) {
_context4.n = 4;
break;
}
_context4.n = 3;
return this.getCredentials(this.keyFile);
case 3:
creds = _context4.v;
this.key = creds.privateKey;
this.iss = creds.clientEmail || this.iss;
if (!creds.clientEmail) {
_assertClassBrand(_GoogleToken_brand, this, _ensureEmail).call(this);
}
case 4:
return _context4.a(2, _assertClassBrand(_GoogleToken_brand, this, _requestToken).call(this));
}
}, _callee4, this);
}));
return _getTokenAsyncInner2.apply(this, arguments);
}
function _ensureEmail() {
if (!this.iss) {
throw new ErrorWithCode("email is required.", "MISSING_CREDENTIALS");
}
}
function _revokeTokenAsync() {
return _revokeTokenAsync2.apply(this, arguments);
}
function _revokeTokenAsync2() {
_revokeTokenAsync2 = _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee5() {
var url;
return _regenerator().w(function(_context5) {
while (1) switch (_context5.n) {
case 0:
if (this.accessToken) {
_context5.n = 1;
break;
}
throw new Error("No token to revoke.");
case 1:
url = GOOGLE_REVOKE_TOKEN_URL + this.accessToken;
_context5.n = 2;
return this.transporter.request({
url,
retry: true
});
case 2:
_assertClassBrand(_GoogleToken_brand, this, _configure).call(this, {
email: this.iss,
sub: this.sub,
key: this.key,
keyFile: this.keyFile,
scope: this.scope,
additionalClaims: this.additionalClaims
});
case 3:
return _context5.a(2);
}
}, _callee5, this);
}));
return _revokeTokenAsync2.apply(this, arguments);
}
function _configure() {
var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
this.keyFile = options.keyFile;
this.key = options.key;
this.rawToken = void 0;
this.iss = options.email || options.iss;
this.sub = options.sub;
this.additionalClaims = options.additionalClaims;
if (_typeof(options.scope) === "object") {
this.scope = options.scope.join(" ");
} else {
this.scope = options.scope;
}
this.eagerRefreshThresholdMillis = options.eagerRefreshThresholdMillis;
if (options.transporter) {
this.transporter = options.transporter;
}
}
function _requestToken() {
return _requestToken2.apply(this, arguments);
}
function _requestToken2() {
_requestToken2 = _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee6() {
var iat, additionalClaims, payload, signedJWT, r, _response, _response2, body, desc, _t2;
return _regenerator().w(function(_context6) {
while (1) switch (_context6.n) {
case 0:
iat = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
additionalClaims = this.additionalClaims || {};
payload = Object.assign({
iss: this.iss,
scope: this.scope,
aud: GOOGLE_TOKEN_URL,
exp: iat + 3600,
iat,
sub: this.sub
}, additionalClaims);
signedJWT = jws.sign({
header: {
alg: "RS256"
},
payload,
secret: this.key
});
_context6.p = 1;
_context6.n = 2;
return this.transporter.request({
method: "POST",
url: GOOGLE_TOKEN_URL,
data: new URLSearchParams({
grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
assertion: signedJWT
}),
responseType: "json",
retryConfig: {
httpMethodsToRetry: ["POST"]
}
});
case 2:
r = _context6.v;
this.rawToken = r.data;
this.expiresAt = r.data.expires_in === null || r.data.expires_in === void 0 ? void 0 : (iat + r.data.expires_in) * 1e3;
return _context6.a(2, this.rawToken);
case 3:
_context6.p = 3;
_t2 = _context6.v;
this.rawToken = void 0;
this.tokenExpires = void 0;
body = _t2.response && (_response = _t2.response) !== null && _response !== void 0 && _response.data ? (_response2 = _t2.response) === null || _response2 === void 0 ? void 0 : _response2.data : {};
if (body.error) {
desc = body.error_description ? ": ".concat(body.error_description) : "";
_t2.message = "".concat(body.error).concat(desc);
}
throw _t2;
case 4:
return _context6.a(2);
}
}, _callee6, this, [[1, 3]]);
}));
return _requestToken2.apply(this, arguments);
}
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/jwtaccess.js
var require_jwtaccess = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/jwtaccess.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.JWTAccess = void 0;
var jws = require_jws();
var util_1 = require_util4();
var DEFAULT_HEADER = {
alg: "RS256",
typ: "JWT"
};
var JWTAccess = class _JWTAccess {
email;
key;
keyId;
projectId;
eagerRefreshThresholdMillis;
cache = new util_1.LRUCache({
capacity: 500,
maxAge: 60 * 60 * 1e3
});
/**
* JWTAccess service account credentials.
*
* Create a new access token by using the credential to create a new JWT token
* that's recognized as the access token.
*
* @param email the service account email address.
* @param key the private key that will be used to sign the token.
* @param keyId the ID of the private key used to sign the token.
*/
constructor(email, key, keyId, eagerRefreshThresholdMillis) {
this.email = email;
this.key = key;
this.keyId = keyId;
this.eagerRefreshThresholdMillis = eagerRefreshThresholdMillis ?? 5 * 60 * 1e3;
}
/**
* Ensures that we're caching a key appropriately, giving precedence to scopes vs. url
*
* @param url The URI being authorized.
* @param scopes The scope or scopes being authorized
* @returns A string that returns the cached key.
*/
getCachedKey(url, scopes) {
let cacheKey = url;
if (scopes && Array.isArray(scopes) && scopes.length) {
cacheKey = url ? `${url}_${scopes.join("_")}` : `${scopes.join("_")}`;
} else if (typeof scopes === "string") {
cacheKey = url ? `${url}_${scopes}` : scopes;
}
if (!cacheKey) {
throw Error("Scopes or url must be provided");
}
return cacheKey;
}
/**
* Get a non-expired access token, after refreshing if necessary.
*
* @param url The URI being authorized.
* @param additionalClaims An object with a set of additional claims to
* include in the payload.
* @returns An object that includes the authorization header.
*/
getRequestHeaders(url, additionalClaims, scopes) {
const key = this.getCachedKey(url, scopes);
const cachedToken = this.cache.get(key);
const now = Date.now();
if (cachedToken && cachedToken.expiration - now > this.eagerRefreshThresholdMillis) {
return new Headers(cachedToken.headers);
}
const iat = Math.floor(Date.now() / 1e3);
const exp = _JWTAccess.getExpirationTime(iat);
let defaultClaims;
if (Array.isArray(scopes)) {
scopes = scopes.join(" ");
}
if (scopes) {
defaultClaims = {
iss: this.email,
sub: this.email,
scope: scopes,
exp,
iat
};
} else {
defaultClaims = {
iss: this.email,
sub: this.email,
aud: url,
exp,
iat
};
}
if (additionalClaims) {
for (const claim in defaultClaims) {
if (additionalClaims[claim]) {
throw new Error(`The '${claim}' property is not allowed when passing additionalClaims. This claim is included in the JWT by default.`);
}
}
}
const header = this.keyId ? { ...DEFAULT_HEADER, kid: this.keyId } : DEFAULT_HEADER;
const payload = Object.assign(defaultClaims, additionalClaims);
const signedJWT = jws.sign({ header, payload, secret: this.key });
const headers = new Headers({ authorization: `Bearer ${signedJWT}` });
this.cache.set(key, {
expiration: exp * 1e3,
headers
});
return headers;
}
/**
* Returns an expiration time for the JWT token.
*
* @param iat The issued at time for the JWT.
* @returns An expiration time for the JWT.
*/
static getExpirationTime(iat) {
const exp = iat + 3600;
return exp;
}
/**
* Create a JWTAccess credentials instance using the given input options.
* @param json The input object.
*/
fromJSON(json) {
if (!json) {
throw new Error("Must pass in a JSON object containing the service account auth settings.");
}
if (!json.client_email) {
throw new Error("The incoming JSON object does not contain a client_email field");
}
if (!json.private_key) {
throw new Error("The incoming JSON object does not contain a private_key field");
}
this.email = json.client_email;
this.key = json.private_key;
this.keyId = json.private_key_id;
this.projectId = json.project_id;
}
fromStream(inputStream, callback) {
if (callback) {
this.fromStreamAsync(inputStream).then(() => callback(), callback);
} else {
return this.fromStreamAsync(inputStream);
}
}
fromStreamAsync(inputStream) {
return new Promise((resolve5, reject) => {
if (!inputStream) {
reject(new Error("Must pass in a stream containing the service account auth settings."));
}
let s = "";
inputStream.setEncoding("utf8").on("data", (chunk) => s += chunk).on("error", reject).on("end", () => {
try {
const data = JSON.parse(s);
this.fromJSON(data);
resolve5();
} catch (err) {
reject(err);
}
});
});
}
};
exports.JWTAccess = JWTAccess;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/jwtclient.js
var require_jwtclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/jwtclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.JWT = void 0;
var gtoken_1 = require_src4();
var jwtaccess_1 = require_jwtaccess();
var oauth2client_1 = require_oauth2client();
var authclient_1 = require_authclient();
var JWT = class _JWT extends oauth2client_1.OAuth2Client {
email;
keyFile;
key;
keyId;
defaultScopes;
scopes;
scope;
subject;
gtoken;
additionalClaims;
useJWTAccessWithScope;
defaultServicePath;
access;
/**
* JWT service account credentials.
*
* Retrieve access token using gtoken.
*
* @param options the
*/
constructor(options = {}) {
super(options);
this.email = options.email;
this.keyFile = options.keyFile;
this.key = options.key;
this.keyId = options.keyId;
this.scopes = options.scopes;
this.subject = options.subject;
this.additionalClaims = options.additionalClaims;
this.credentials = { refresh_token: "jwt-placeholder", expiry_date: 1 };
}
/**
* Creates a copy of the credential with the specified scopes.
* @param scopes List of requested scopes or a single scope.
* @return The cloned instance.
*/
createScoped(scopes) {
const jwt = new _JWT(this);
jwt.scopes = scopes;
return jwt;
}
/**
* Obtains the metadata to be sent with the request.
*
* @param url the URI being authorized.
*/
async getRequestMetadataAsync(url) {
url = this.defaultServicePath ? `https://${this.defaultServicePath}/` : url;
const useSelfSignedJWT = !this.hasUserScopes() && url || this.useJWTAccessWithScope && this.hasAnyScopes() || this.universeDomain !== authclient_1.DEFAULT_UNIVERSE;
if (this.subject && this.universeDomain !== authclient_1.DEFAULT_UNIVERSE) {
throw new RangeError(`Service Account user is configured for the credential. Domain-wide delegation is not supported in universes other than ${authclient_1.DEFAULT_UNIVERSE}`);
}
if (!this.apiKey && useSelfSignedJWT) {
if (this.additionalClaims && this.additionalClaims.target_audience) {
const { tokens } = await this.refreshToken();
return {
headers: this.addSharedMetadataHeaders(new Headers({
authorization: `Bearer ${tokens.id_token}`
}))
};
} else {
if (!this.access) {
this.access = new jwtaccess_1.JWTAccess(this.email, this.key, this.keyId, this.eagerRefreshThresholdMillis);
}
let scopes;
if (this.hasUserScopes()) {
scopes = this.scopes;
} else if (!url) {
scopes = this.defaultScopes;
}
const useScopes = this.useJWTAccessWithScope || this.universeDomain !== authclient_1.DEFAULT_UNIVERSE;
const headers = await this.access.getRequestHeaders(
url ?? void 0,
this.additionalClaims,
// Scopes take precedent over audience for signing,
// so we only provide them if `useJWTAccessWithScope` is on or
// if we are in a non-default universe
useScopes ? scopes : void 0
);
return { headers: this.addSharedMetadataHeaders(headers) };
}
} else if (this.hasAnyScopes() || this.apiKey) {
return super.getRequestMetadataAsync(url);
} else {
return { headers: new Headers() };
}
}
/**
* Fetches an ID token.
* @param targetAudience the audience for the fetched ID token.
*/
async fetchIdToken(targetAudience) {
const gtoken = new gtoken_1.GoogleToken({
iss: this.email,
sub: this.subject,
scope: this.scopes || this.defaultScopes,
keyFile: this.keyFile,
key: this.key,
additionalClaims: { target_audience: targetAudience },
transporter: this.transporter
});
await gtoken.getToken({
forceRefresh: true
});
if (!gtoken.idToken) {
throw new Error("Unknown error: Failed to fetch ID token");
}
return gtoken.idToken;
}
/**
* Determine if there are currently scopes available.
*/
hasUserScopes() {
if (!this.scopes) {
return false;
}
return this.scopes.length > 0;
}
/**
* Are there any default or user scopes defined.
*/
hasAnyScopes() {
if (this.scopes && this.scopes.length > 0)
return true;
if (this.defaultScopes && this.defaultScopes.length > 0)
return true;
return false;
}
authorize(callback) {
if (callback) {
this.authorizeAsync().then((r) => callback(null, r), callback);
} else {
return this.authorizeAsync();
}
}
async authorizeAsync() {
const result = await this.refreshToken();
if (!result) {
throw new Error("No result returned");
}
this.credentials = result.tokens;
this.credentials.refresh_token = "jwt-placeholder";
this.key = this.gtoken.key;
this.email = this.gtoken.iss;
return result.tokens;
}
/**
* Refreshes the access token.
* @param refreshToken ignored
* @private
*/
async refreshTokenNoCache() {
const gtoken = this.createGToken();
const token = await gtoken.getToken({
forceRefresh: this.isTokenExpiring()
});
const tokens = {
access_token: token.access_token,
token_type: "Bearer",
expiry_date: gtoken.expiresAt,
id_token: gtoken.idToken
};
this.emit("tokens", tokens);
return { res: null, tokens };
}
/**
* Create a gToken if it doesn't already exist.
*/
createGToken() {
if (!this.gtoken) {
this.gtoken = new gtoken_1.GoogleToken({
iss: this.email,
sub: this.subject,
scope: this.scopes || this.defaultScopes,
keyFile: this.keyFile,
key: this.key,
additionalClaims: this.additionalClaims,
transporter: this.transporter
});
}
return this.gtoken;
}
/**
* Create a JWT credentials instance using the given input options.
* @param json The input object.
*
* @remarks
*
* **Important**: If you accept a credential configuration (credential JSON/File/Stream) from an external source for authentication to Google Cloud, you must validate it before providing it to any Google API or library. Providing an unvalidated credential configuration to Google APIs can compromise the security of your systems and data. For more information, refer to {@link https://cloud.google.com/docs/authentication/external/externally-sourced-credentials Validate credential configurations from external sources}.
*/
fromJSON(json) {
if (!json) {
throw new Error("Must pass in a JSON object containing the service account auth settings.");
}
if (!json.client_email) {
throw new Error("The incoming JSON object does not contain a client_email field");
}
if (!json.private_key) {
throw new Error("The incoming JSON object does not contain a private_key field");
}
this.email = json.client_email;
this.key = json.private_key;
this.keyId = json.private_key_id;
this.projectId = json.project_id;
this.quotaProjectId = json.quota_project_id;
this.universeDomain = json.universe_domain || this.universeDomain;
}
fromStream(inputStream, callback) {
if (callback) {
this.fromStreamAsync(inputStream).then(() => callback(), callback);
} else {
return this.fromStreamAsync(inputStream);
}
}
fromStreamAsync(inputStream) {
return new Promise((resolve5, reject) => {
if (!inputStream) {
throw new Error("Must pass in a stream containing the service account auth settings.");
}
let s = "";
inputStream.setEncoding("utf8").on("error", reject).on("data", (chunk) => s += chunk).on("end", () => {
try {
const data = JSON.parse(s);
this.fromJSON(data);
resolve5();
} catch (e) {
reject(e);
}
});
});
}
/**
* Creates a JWT credentials instance using an API Key for authentication.
* @param apiKey The API Key in string form.
*/
fromAPIKey(apiKey) {
if (typeof apiKey !== "string") {
throw new Error("Must provide an API Key string.");
}
this.apiKey = apiKey;
}
/**
* Using the key or keyFile on the JWT client, obtain an object that contains
* the key and the client email.
*/
async getCredentials() {
if (this.key) {
return { private_key: this.key, client_email: this.email };
} else if (this.keyFile) {
const gtoken = this.createGToken();
const creds = await gtoken.getCredentials(this.keyFile);
return { private_key: creds.privateKey, client_email: creds.clientEmail };
}
throw new Error("A key or a keyFile must be provided to getCredentials.");
}
};
exports.JWT = JWT;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/refreshclient.js
var require_refreshclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/refreshclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.UserRefreshClient = exports.USER_REFRESH_ACCOUNT_TYPE = void 0;
var oauth2client_1 = require_oauth2client();
var authclient_1 = require_authclient();
exports.USER_REFRESH_ACCOUNT_TYPE = "authorized_user";
var UserRefreshClient = class _UserRefreshClient extends oauth2client_1.OAuth2Client {
// TODO: refactor tests to make this private
// In a future gts release, the _propertyName rule will be lifted.
// This is also a hard one because `this.refreshToken` is a function.
_refreshToken;
/**
* The User Refresh Token client.
*
* @param optionsOrClientId The User Refresh Token client options. Passing an `clientId` directly is **@DEPRECATED**.
* @param clientSecret **@DEPRECATED**. Provide a {@link UserRefreshClientOptions `UserRefreshClientOptions`} object in the first parameter instead.
* @param refreshToken **@DEPRECATED**. Provide a {@link UserRefreshClientOptions `UserRefreshClientOptions`} object in the first parameter instead.
* @param eagerRefreshThresholdMillis **@DEPRECATED**. Provide a {@link UserRefreshClientOptions `UserRefreshClientOptions`} object in the first parameter instead.
* @param forceRefreshOnFailure **@DEPRECATED**. Provide a {@link UserRefreshClientOptions `UserRefreshClientOptions`} object in the first parameter instead.
*/
constructor(optionsOrClientId, clientSecret, refreshToken, eagerRefreshThresholdMillis, forceRefreshOnFailure) {
const opts = optionsOrClientId && typeof optionsOrClientId === "object" ? optionsOrClientId : {
clientId: optionsOrClientId,
clientSecret,
refreshToken,
eagerRefreshThresholdMillis,
forceRefreshOnFailure
};
super(opts);
this._refreshToken = opts.refreshToken;
this.credentials.refresh_token = opts.refreshToken;
}
/**
* Refreshes the access token.
* @param refreshToken An ignored refreshToken..
* @param callback Optional callback.
*/
async refreshTokenNoCache() {
return super.refreshTokenNoCache(this._refreshToken);
}
async fetchIdToken(targetAudience) {
const opts = {
..._UserRefreshClient.RETRY_CONFIG,
url: this.endpoints.oauth2TokenUrl,
method: "POST",
data: new URLSearchParams({
client_id: this._clientId,
client_secret: this._clientSecret,
grant_type: "refresh_token",
refresh_token: this._refreshToken,
target_audience: targetAudience
})
};
authclient_1.AuthClient.setMethodName(opts, "fetchIdToken");
const res = await this.transporter.request(opts);
return res.data.id_token;
}
/**
* Create a UserRefreshClient credentials instance using the given input
* options.
* @param json The input object.
*/
fromJSON(json) {
if (!json) {
throw new Error("Must pass in a JSON object containing the user refresh token");
}
if (json.type !== "authorized_user") {
throw new Error('The incoming JSON object does not have the "authorized_user" type');
}
if (!json.client_id) {
throw new Error("The incoming JSON object does not contain a client_id field");
}
if (!json.client_secret) {
throw new Error("The incoming JSON object does not contain a client_secret field");
}
if (!json.refresh_token) {
throw new Error("The incoming JSON object does not contain a refresh_token field");
}
this._clientId = json.client_id;
this._clientSecret = json.client_secret;
this._refreshToken = json.refresh_token;
this.credentials.refresh_token = json.refresh_token;
this.quotaProjectId = json.quota_project_id;
this.universeDomain = json.universe_domain || this.universeDomain;
}
fromStream(inputStream, callback) {
if (callback) {
this.fromStreamAsync(inputStream).then(() => callback(), callback);
} else {
return this.fromStreamAsync(inputStream);
}
}
async fromStreamAsync(inputStream) {
return new Promise((resolve5, reject) => {
if (!inputStream) {
return reject(new Error("Must pass in a stream containing the user refresh token."));
}
let s = "";
inputStream.setEncoding("utf8").on("error", reject).on("data", (chunk) => s += chunk).on("end", () => {
try {
const data = JSON.parse(s);
this.fromJSON(data);
return resolve5();
} catch (err) {
return reject(err);
}
});
});
}
/**
* Create a UserRefreshClient credentials instance using the given input
* options.
* @param json The input object.
*/
static fromJSON(json) {
const client = new _UserRefreshClient();
client.fromJSON(json);
return client;
}
};
exports.UserRefreshClient = UserRefreshClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/impersonated.js
var require_impersonated = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/impersonated.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Impersonated = exports.IMPERSONATED_ACCOUNT_TYPE = void 0;
var oauth2client_1 = require_oauth2client();
var gaxios_1 = require_src();
var util_1 = require_util4();
exports.IMPERSONATED_ACCOUNT_TYPE = "impersonated_service_account";
var Impersonated = class _Impersonated extends oauth2client_1.OAuth2Client {
sourceClient;
targetPrincipal;
targetScopes;
delegates;
lifetime;
endpoint;
/**
* Impersonated service account credentials.
*
* Create a new access token by impersonating another service account.
*
* Impersonated Credentials allowing credentials issued to a user or
* service account to impersonate another. The source project using
* Impersonated Credentials must enable the "IAMCredentials" API.
* Also, the target service account must grant the orginating principal
* the "Service Account Token Creator" IAM role.
*
* **IMPORTANT**: This method does not validate the credential configuration.
* A security risk occurs when a credential configuration configured with
* malicious URLs is used. When the credential configuration is accepted from
* an untrusted source, you should validate it before using it with this
* method. For more details, see
* https://cloud.google.com/docs/authentication/external/externally-sourced-credentials.
*
* @param {object} options - The configuration object.
* @param {object} [options.sourceClient] the source credential used as to
* acquire the impersonated credentials.
* @param {string} [options.targetPrincipal] the service account to
* impersonate.
* @param {string[]} [options.delegates] the chained list of delegates
* required to grant the final access_token. If set, the sequence of
* identities must have "Service Account Token Creator" capability granted to
* the preceding identity. For example, if set to [serviceAccountB,
* serviceAccountC], the sourceCredential must have the Token Creator role on
* serviceAccountB. serviceAccountB must have the Token Creator on
* serviceAccountC. Finally, C must have Token Creator on target_principal.
* If left unset, sourceCredential must have that role on targetPrincipal.
* @param {string[]} [options.targetScopes] scopes to request during the
* authorization grant.
* @param {number} [options.lifetime] number of seconds the delegated
* credential should be valid for up to 3600 seconds by default, or 43,200
* seconds by extending the token's lifetime, see:
* https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials#sa-credentials-oauth
* @param {string} [options.endpoint] api endpoint override.
*/
constructor(options = {}) {
super(options);
this.credentials = {
expiry_date: 1,
refresh_token: "impersonated-placeholder"
};
this.sourceClient = options.sourceClient ?? new oauth2client_1.OAuth2Client();
this.targetPrincipal = options.targetPrincipal ?? "";
this.delegates = options.delegates ?? [];
this.targetScopes = options.targetScopes ?? [];
this.lifetime = options.lifetime ?? 3600;
const usingExplicitUniverseDomain = !!(0, util_1.originalOrCamelOptions)(options).get("universe_domain");
if (!usingExplicitUniverseDomain) {
this.universeDomain = this.sourceClient.universeDomain;
} else if (this.sourceClient.universeDomain !== this.universeDomain) {
throw new RangeError(`Universe domain ${this.sourceClient.universeDomain} in source credentials does not match ${this.universeDomain} universe domain set for impersonated credentials.`);
}
this.endpoint = options.endpoint ?? `https://iamcredentials.${this.universeDomain}`;
}
/**
* Signs some bytes.
*
* {@link https://cloud.google.com/iam/docs/reference/credentials/rest/v1/projects.serviceAccounts/signBlob Reference Documentation}
* @param blobToSign String to sign.
*
* @returns A {@link SignBlobResponse} denoting the keyID and signedBlob in base64 string
*/
async sign(blobToSign) {
await this.sourceClient.getAccessToken();
const name = `projects/-/serviceAccounts/${this.targetPrincipal}`;
const u = `${this.endpoint}/v1/${name}:signBlob`;
const body = {
delegates: this.delegates,
payload: Buffer.from(blobToSign).toString("base64")
};
const res = await this.sourceClient.request({
..._Impersonated.RETRY_CONFIG,
url: u,
data: body,
method: "POST"
});
return res.data;
}
/** The service account email to be impersonated. */
getTargetPrincipal() {
return this.targetPrincipal;
}
/**
* Refreshes the access token.
*/
async refreshToken() {
try {
await this.sourceClient.getAccessToken();
const name = "projects/-/serviceAccounts/" + this.targetPrincipal;
const u = `${this.endpoint}/v1/${name}:generateAccessToken`;
const body = {
delegates: this.delegates,
scope: this.targetScopes,
lifetime: this.lifetime + "s"
};
const res = await this.sourceClient.request({
..._Impersonated.RETRY_CONFIG,
url: u,
data: body,
method: "POST"
});
const tokenResponse = res.data;
this.credentials.access_token = tokenResponse.accessToken;
this.credentials.expiry_date = Date.parse(tokenResponse.expireTime);
return {
tokens: this.credentials,
res
};
} catch (error) {
if (!(error instanceof Error))
throw error;
let status = 0;
let message = "";
if (error instanceof gaxios_1.GaxiosError) {
status = error?.response?.data?.error?.status;
message = error?.response?.data?.error?.message;
}
if (status && message) {
error.message = `${status}: unable to impersonate: ${message}`;
throw error;
} else {
error.message = `unable to impersonate: ${error}`;
throw error;
}
}
}
/**
* Generates an OpenID Connect ID token for a service account.
*
* {@link https://cloud.google.com/iam/docs/reference/credentials/rest/v1/projects.serviceAccounts/generateIdToken Reference Documentation}
*
* @param targetAudience the audience for the fetched ID token.
* @param options the for the request
* @return an OpenID Connect ID token
*/
async fetchIdToken(targetAudience, options) {
await this.sourceClient.getAccessToken();
const name = `projects/-/serviceAccounts/${this.targetPrincipal}`;
const u = `${this.endpoint}/v1/${name}:generateIdToken`;
const body = {
delegates: this.delegates,
audience: targetAudience,
includeEmail: options?.includeEmail ?? true,
useEmailAzp: options?.includeEmail ?? true
};
const res = await this.sourceClient.request({
..._Impersonated.RETRY_CONFIG,
url: u,
data: body,
method: "POST"
});
return res.data.token;
}
};
exports.Impersonated = Impersonated;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/oauth2common.js
var require_oauth2common = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/oauth2common.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.OAuthClientAuthHandler = void 0;
exports.getErrorFromOAuthErrorResponse = getErrorFromOAuthErrorResponse;
var gaxios_1 = require_src();
var crypto_1 = require_crypto3();
var METHODS_SUPPORTING_REQUEST_BODY = ["PUT", "POST", "PATCH"];
var OAuthClientAuthHandler = class {
#crypto = (0, crypto_1.createCrypto)();
#clientAuthentication;
transporter;
/**
* Instantiates an OAuth client authentication handler.
* @param options The OAuth Client Auth Handler instance options. Passing an `ClientAuthentication` directly is **@DEPRECATED**.
*/
constructor(options) {
if (options && "clientId" in options) {
this.#clientAuthentication = options;
this.transporter = new gaxios_1.Gaxios();
} else {
this.#clientAuthentication = options?.clientAuthentication;
this.transporter = options?.transporter || new gaxios_1.Gaxios();
}
}
/**
* Applies client authentication on the OAuth request's headers or POST
* body but does not process the request.
* @param opts The GaxiosOptions whose headers or data are to be modified
* depending on the client authentication mechanism to be used.
* @param bearerToken The optional bearer token to use for authentication.
* When this is used, no client authentication credentials are needed.
*/
applyClientAuthenticationOptions(opts, bearerToken) {
opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers);
this.injectAuthenticatedHeaders(opts, bearerToken);
if (!bearerToken) {
this.injectAuthenticatedRequestBody(opts);
}
}
/**
* Applies client authentication on the request's header if either
* basic authentication or bearer token authentication is selected.
*
* @param opts The GaxiosOptions whose headers or data are to be modified
* depending on the client authentication mechanism to be used.
* @param bearerToken The optional bearer token to use for authentication.
* When this is used, no client authentication credentials are needed.
*/
injectAuthenticatedHeaders(opts, bearerToken) {
if (bearerToken) {
opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers, {
authorization: `Bearer ${bearerToken}`
});
} else if (this.#clientAuthentication?.confidentialClientType === "basic") {
opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers);
const clientId = this.#clientAuthentication.clientId;
const clientSecret = this.#clientAuthentication.clientSecret || "";
const base64EncodedCreds = this.#crypto.encodeBase64StringUtf8(`${clientId}:${clientSecret}`);
gaxios_1.Gaxios.mergeHeaders(opts.headers, {
authorization: `Basic ${base64EncodedCreds}`
});
}
}
/**
* Applies client authentication on the request's body if request-body
* client authentication is selected.
*
* @param opts The GaxiosOptions whose headers or data are to be modified
* depending on the client authentication mechanism to be used.
*/
injectAuthenticatedRequestBody(opts) {
if (this.#clientAuthentication?.confidentialClientType === "request-body") {
const method = (opts.method || "GET").toUpperCase();
if (!METHODS_SUPPORTING_REQUEST_BODY.includes(method)) {
throw new Error(`${method} HTTP method does not support ${this.#clientAuthentication.confidentialClientType} client authentication`);
}
const headers = new Headers(opts.headers);
const contentType = headers.get("content-type");
if (contentType?.startsWith("application/x-www-form-urlencoded") || opts.data instanceof URLSearchParams) {
const data = new URLSearchParams(opts.data ?? "");
data.append("client_id", this.#clientAuthentication.clientId);
data.append("client_secret", this.#clientAuthentication.clientSecret || "");
opts.data = data;
} else if (contentType?.startsWith("application/json")) {
opts.data = opts.data || {};
Object.assign(opts.data, {
client_id: this.#clientAuthentication.clientId,
client_secret: this.#clientAuthentication.clientSecret || ""
});
} else {
throw new Error(`${contentType} content-types are not supported with ${this.#clientAuthentication.confidentialClientType} client authentication`);
}
}
}
/**
* Retry config for Auth-related requests.
*
* @remarks
*
* This is not a part of the default {@link AuthClient.transporter transporter/gaxios}
* config as some downstream APIs would prefer if customers explicitly enable retries,
* such as GCS.
*/
static get RETRY_CONFIG() {
return {
retry: true,
retryConfig: {
httpMethodsToRetry: ["GET", "PUT", "POST", "HEAD", "OPTIONS", "DELETE"]
}
};
}
};
exports.OAuthClientAuthHandler = OAuthClientAuthHandler;
function getErrorFromOAuthErrorResponse(resp, err) {
const errorCode = resp.error;
const errorDescription = resp.error_description;
const errorUri = resp.error_uri;
let message = `Error code ${errorCode}`;
if (typeof errorDescription !== "undefined") {
message += `: ${errorDescription}`;
}
if (typeof errorUri !== "undefined") {
message += ` - ${errorUri}`;
}
const newError = new Error(message);
if (err) {
const keys = Object.keys(err);
if (err.stack) {
keys.push("stack");
}
keys.forEach((key) => {
if (key !== "message") {
Object.defineProperty(newError, key, {
value: err[key],
writable: false,
enumerable: true
});
}
});
}
return newError;
}
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/stscredentials.js
var require_stscredentials = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/stscredentials.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.StsCredentials = void 0;
var gaxios_1 = require_src();
var authclient_1 = require_authclient();
var oauth2common_1 = require_oauth2common();
var util_1 = require_util4();
var StsCredentials = class _StsCredentials extends oauth2common_1.OAuthClientAuthHandler {
#tokenExchangeEndpoint;
/**
* Initializes an STS credentials instance.
*
* @param options The STS credentials instance options. Passing an `tokenExchangeEndpoint` directly is **@DEPRECATED**.
* @param clientAuthentication **@DEPRECATED**. Provide a {@link StsCredentialsConstructionOptions `StsCredentialsConstructionOptions`} object in the first parameter instead.
*/
constructor(options = {
tokenExchangeEndpoint: ""
}, clientAuthentication) {
if (typeof options !== "object" || options instanceof URL) {
options = {
tokenExchangeEndpoint: options,
clientAuthentication
};
}
super(options);
this.#tokenExchangeEndpoint = options.tokenExchangeEndpoint;
}
/**
* Exchanges the provided token for another type of token based on the
* rfc8693 spec.
* @param stsCredentialsOptions The token exchange options used to populate
* the token exchange request.
* @param additionalHeaders Optional additional headers to pass along the
* request.
* @param options Optional additional GCP-specific non-spec defined options
* to send with the request.
* Example: `&options=${encodeUriComponent(JSON.stringified(options))}`
* @return A promise that resolves with the token exchange response containing
* the requested token and its expiration time.
*/
async exchangeToken(stsCredentialsOptions, headers, options) {
const values = {
grant_type: stsCredentialsOptions.grantType,
resource: stsCredentialsOptions.resource,
audience: stsCredentialsOptions.audience,
scope: stsCredentialsOptions.scope?.join(" "),
requested_token_type: stsCredentialsOptions.requestedTokenType,
subject_token: stsCredentialsOptions.subjectToken,
subject_token_type: stsCredentialsOptions.subjectTokenType,
actor_token: stsCredentialsOptions.actingParty?.actorToken,
actor_token_type: stsCredentialsOptions.actingParty?.actorTokenType,
// Non-standard GCP-specific options.
options: options && JSON.stringify(options)
};
const opts = {
..._StsCredentials.RETRY_CONFIG,
url: this.#tokenExchangeEndpoint.toString(),
method: "POST",
headers,
data: new URLSearchParams((0, util_1.removeUndefinedValuesInObject)(values))
};
authclient_1.AuthClient.setMethodName(opts, "exchangeToken");
this.applyClientAuthenticationOptions(opts);
try {
const response = await this.transporter.request(opts);
const stsSuccessfulResponse = response.data;
stsSuccessfulResponse.res = response;
return stsSuccessfulResponse;
} catch (error) {
if (error instanceof gaxios_1.GaxiosError && error.response) {
throw (0, oauth2common_1.getErrorFromOAuthErrorResponse)(
error.response.data,
// Preserve other fields from the original error.
error
);
}
throw error;
}
}
};
exports.StsCredentials = StsCredentials;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/baseexternalclient.js
var require_baseexternalclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/baseexternalclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaseExternalAccountClient = exports.CLOUD_RESOURCE_MANAGER = exports.EXTERNAL_ACCOUNT_TYPE = exports.EXPIRATION_TIME_OFFSET = void 0;
var gaxios_1 = require_src();
var stream = __require("stream");
var authclient_1 = require_authclient();
var sts = require_stscredentials();
var util_1 = require_util4();
var shared_cjs_1 = require_shared2();
var STS_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:token-exchange";
var STS_REQUEST_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:access_token";
var DEFAULT_OAUTH_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
var DEFAULT_TOKEN_LIFESPAN = 3600;
exports.EXPIRATION_TIME_OFFSET = 5 * 60 * 1e3;
exports.EXTERNAL_ACCOUNT_TYPE = "external_account";
exports.CLOUD_RESOURCE_MANAGER = "https://cloudresourcemanager.googleapis.com/v1/projects/";
var WORKFORCE_AUDIENCE_PATTERN = "//iam\\.googleapis\\.com/locations/[^/]+/workforcePools/[^/]+/providers/.+";
var DEFAULT_TOKEN_URL = "https://sts.{universeDomain}/v1/token";
var BaseExternalAccountClient = class _BaseExternalAccountClient extends authclient_1.AuthClient {
/**
* OAuth scopes for the GCP access token to use. When not provided,
* the default https://www.googleapis.com/auth/cloud-platform is
* used.
*/
scopes;
projectNumber;
audience;
subjectTokenType;
stsCredential;
clientAuth;
credentialSourceType;
cachedAccessToken;
serviceAccountImpersonationUrl;
serviceAccountImpersonationLifetime;
workforcePoolUserProject;
configLifetimeRequested;
tokenUrl;
/**
* @example
* ```ts
* new URL('https://cloudresourcemanager.googleapis.com/v1/projects/');
* ```
*/
cloudResourceManagerURL;
supplierContext;
/**
* A pending access token request. Used for concurrent calls.
*/
#pendingAccessToken = null;
/**
* Instantiate a BaseExternalAccountClient instance using the provided JSON
* object loaded from an external account credentials file.
* @param options The external account options object typically loaded
* from the external account JSON credential file. The camelCased options
* are aliases for the snake_cased options.
*/
constructor(options) {
super(options);
const opts = (0, util_1.originalOrCamelOptions)(options);
const type = opts.get("type");
if (type && type !== exports.EXTERNAL_ACCOUNT_TYPE) {
throw new Error(`Expected "${exports.EXTERNAL_ACCOUNT_TYPE}" type but received "${options.type}"`);
}
const clientId = opts.get("client_id");
const clientSecret = opts.get("client_secret");
this.tokenUrl = opts.get("token_url") ?? DEFAULT_TOKEN_URL.replace("{universeDomain}", this.universeDomain);
const subjectTokenType = opts.get("subject_token_type");
const workforcePoolUserProject = opts.get("workforce_pool_user_project");
const serviceAccountImpersonationUrl = opts.get("service_account_impersonation_url");
const serviceAccountImpersonation = opts.get("service_account_impersonation");
const serviceAccountImpersonationLifetime = (0, util_1.originalOrCamelOptions)(serviceAccountImpersonation).get("token_lifetime_seconds");
this.cloudResourceManagerURL = new URL(opts.get("cloud_resource_manager_url") || `https://cloudresourcemanager.${this.universeDomain}/v1/projects/`);
if (clientId) {
this.clientAuth = {
confidentialClientType: "basic",
clientId,
clientSecret
};
}
this.stsCredential = new sts.StsCredentials({
tokenExchangeEndpoint: this.tokenUrl,
clientAuthentication: this.clientAuth
});
this.scopes = opts.get("scopes") || [DEFAULT_OAUTH_SCOPE];
this.cachedAccessToken = null;
this.audience = opts.get("audience");
this.subjectTokenType = subjectTokenType;
this.workforcePoolUserProject = workforcePoolUserProject;
const workforceAudiencePattern = new RegExp(WORKFORCE_AUDIENCE_PATTERN);
if (this.workforcePoolUserProject && !this.audience.match(workforceAudiencePattern)) {
throw new Error("workforcePoolUserProject should not be set for non-workforce pool credentials.");
}
this.serviceAccountImpersonationUrl = serviceAccountImpersonationUrl;
this.serviceAccountImpersonationLifetime = serviceAccountImpersonationLifetime;
if (this.serviceAccountImpersonationLifetime) {
this.configLifetimeRequested = true;
} else {
this.configLifetimeRequested = false;
this.serviceAccountImpersonationLifetime = DEFAULT_TOKEN_LIFESPAN;
}
this.projectNumber = this.getProjectNumber(this.audience);
this.supplierContext = {
audience: this.audience,
subjectTokenType: this.subjectTokenType,
transporter: this.transporter
};
}
/** The service account email to be impersonated, if available. */
getServiceAccountEmail() {
if (this.serviceAccountImpersonationUrl) {
if (this.serviceAccountImpersonationUrl.length > 256) {
throw new RangeError(`URL is too long: ${this.serviceAccountImpersonationUrl}`);
}
const re = /serviceAccounts\/(?<email>[^:]+):generateAccessToken$/;
const result = re.exec(this.serviceAccountImpersonationUrl);
return result?.groups?.email || null;
}
return null;
}
/**
* Provides a mechanism to inject GCP access tokens directly.
* When the provided credential expires, a new credential, using the
* external account options, is retrieved.
* @param credentials The Credentials object to set on the current client.
*/
setCredentials(credentials) {
super.setCredentials(credentials);
this.cachedAccessToken = credentials;
}
/**
* @return A promise that resolves with the current GCP access token
* response. If the current credential is expired, a new one is retrieved.
*/
async getAccessToken() {
if (!this.cachedAccessToken || this.isExpired(this.cachedAccessToken)) {
await this.refreshAccessTokenAsync();
}
return {
token: this.cachedAccessToken.access_token,
res: this.cachedAccessToken.res
};
}
/**
* The main authentication interface. It takes an optional url which when
* present is the endpoint being accessed, and returns a Promise which
* resolves with authorization header fields.
*
* The result has the form:
* { authorization: 'Bearer <access_token_value>' }
*/
async getRequestHeaders() {
const accessTokenResponse = await this.getAccessToken();
const headers = new Headers({
authorization: `Bearer ${accessTokenResponse.token}`
});
return this.addSharedMetadataHeaders(headers);
}
request(opts, callback) {
if (callback) {
this.requestAsync(opts).then((r) => callback(null, r), (e) => {
return callback(e, e.response);
});
} else {
return this.requestAsync(opts);
}
}
/**
* @return A promise that resolves with the project ID corresponding to the
* current workload identity pool or current workforce pool if
* determinable. For workforce pool credential, it returns the project ID
* corresponding to the workforcePoolUserProject.
* This is introduced to match the current pattern of using the Auth
* library:
* const projectId = await auth.getProjectId();
* const url = `https://dns.googleapis.com/dns/v1/projects/${projectId}`;
* const res = await client.request({ url });
* The resource may not have permission
* (resourcemanager.projects.get) to call this API or the required
* scopes may not be selected:
* https://cloud.google.com/resource-manager/reference/rest/v1/projects/get#authorization-scopes
*/
async getProjectId() {
const projectNumber = this.projectNumber || this.workforcePoolUserProject;
if (this.projectId) {
return this.projectId;
} else if (projectNumber) {
const headers = await this.getRequestHeaders();
const opts = {
..._BaseExternalAccountClient.RETRY_CONFIG,
headers,
url: `${this.cloudResourceManagerURL.toString()}${projectNumber}`
};
authclient_1.AuthClient.setMethodName(opts, "getProjectId");
const response = await this.transporter.request(opts);
this.projectId = response.data.projectId;
return this.projectId;
}
return null;
}
/**
* Authenticates the provided HTTP request, processes it and resolves with the
* returned response.
* @param opts The HTTP request options.
* @param reAuthRetried Whether the current attempt is a retry after a failed attempt due to an auth failure.
* @return A promise that resolves with the successful response.
*/
async requestAsync(opts, reAuthRetried = false) {
let response;
try {
const requestHeaders = await this.getRequestHeaders();
opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers);
this.addUserProjectAndAuthHeaders(opts.headers, requestHeaders);
response = await this.transporter.request(opts);
} catch (e) {
const res = e.response;
if (res) {
const statusCode = res.status;
const isReadableStream = res.config.data instanceof stream.Readable;
const isAuthErr = statusCode === 401 || statusCode === 403;
if (!reAuthRetried && isAuthErr && !isReadableStream && this.forceRefreshOnFailure) {
await this.refreshAccessTokenAsync();
return await this.requestAsync(opts, true);
}
}
throw e;
}
return response;
}
/**
* Forces token refresh, even if unexpired tokens are currently cached.
* External credentials are exchanged for GCP access tokens via the token
* exchange endpoint and other settings provided in the client options
* object.
* If the service_account_impersonation_url is provided, an additional
* step to exchange the external account GCP access token for a service
* account impersonated token is performed.
* @return A promise that resolves with the fresh GCP access tokens.
*/
async refreshAccessTokenAsync() {
this.#pendingAccessToken = this.#pendingAccessToken || this.#internalRefreshAccessTokenAsync();
try {
return await this.#pendingAccessToken;
} finally {
this.#pendingAccessToken = null;
}
}
async #internalRefreshAccessTokenAsync() {
const subjectToken = await this.retrieveSubjectToken();
const stsCredentialsOptions = {
grantType: STS_GRANT_TYPE,
audience: this.audience,
requestedTokenType: STS_REQUEST_TOKEN_TYPE,
subjectToken,
subjectTokenType: this.subjectTokenType,
// generateAccessToken requires the provided access token to have
// scopes:
// https://www.googleapis.com/auth/iam or
// https://www.googleapis.com/auth/cloud-platform
// The new service account access token scopes will match the user
// provided ones.
scope: this.serviceAccountImpersonationUrl ? [DEFAULT_OAUTH_SCOPE] : this.getScopesArray()
};
const additionalOptions = !this.clientAuth && this.workforcePoolUserProject ? { userProject: this.workforcePoolUserProject } : void 0;
const additionalHeaders = new Headers({
"x-goog-api-client": this.getMetricsHeaderValue()
});
const stsResponse = await this.stsCredential.exchangeToken(stsCredentialsOptions, additionalHeaders, additionalOptions);
if (this.serviceAccountImpersonationUrl) {
this.cachedAccessToken = await this.getImpersonatedAccessToken(stsResponse.access_token);
} else if (stsResponse.expires_in) {
this.cachedAccessToken = {
access_token: stsResponse.access_token,
expiry_date: (/* @__PURE__ */ new Date()).getTime() + stsResponse.expires_in * 1e3,
res: stsResponse.res
};
} else {
this.cachedAccessToken = {
access_token: stsResponse.access_token,
res: stsResponse.res
};
}
this.credentials = {};
Object.assign(this.credentials, this.cachedAccessToken);
delete this.credentials.res;
this.emit("tokens", {
refresh_token: null,
expiry_date: this.cachedAccessToken.expiry_date,
access_token: this.cachedAccessToken.access_token,
token_type: "Bearer",
id_token: null
});
return this.cachedAccessToken;
}
/**
* Returns the workload identity pool project number if it is determinable
* from the audience resource name.
* @param audience The STS audience used to determine the project number.
* @return The project number associated with the workload identity pool, if
* this can be determined from the STS audience field. Otherwise, null is
* returned.
*/
getProjectNumber(audience) {
const match = audience.match(/\/projects\/([^/]+)/);
if (!match) {
return null;
}
return match[1];
}
/**
* Exchanges an external account GCP access token for a service
* account impersonated access token using iamcredentials
* GenerateAccessToken API.
* @param token The access token to exchange for a service account access
* token.
* @return A promise that resolves with the service account impersonated
* credentials response.
*/
async getImpersonatedAccessToken(token) {
const opts = {
..._BaseExternalAccountClient.RETRY_CONFIG,
url: this.serviceAccountImpersonationUrl,
method: "POST",
headers: {
"content-type": "application/json",
authorization: `Bearer ${token}`
},
data: {
scope: this.getScopesArray(),
lifetime: this.serviceAccountImpersonationLifetime + "s"
}
};
authclient_1.AuthClient.setMethodName(opts, "getImpersonatedAccessToken");
const response = await this.transporter.request(opts);
const successResponse = response.data;
return {
access_token: successResponse.accessToken,
// Convert from ISO format to timestamp.
expiry_date: new Date(successResponse.expireTime).getTime(),
res: response
};
}
/**
* Returns whether the provided credentials are expired or not.
* If there is no expiry time, assumes the token is not expired or expiring.
* @param accessToken The credentials to check for expiration.
* @return Whether the credentials are expired or not.
*/
isExpired(accessToken) {
const now = (/* @__PURE__ */ new Date()).getTime();
return accessToken.expiry_date ? now >= accessToken.expiry_date - this.eagerRefreshThresholdMillis : false;
}
/**
* @return The list of scopes for the requested GCP access token.
*/
getScopesArray() {
if (typeof this.scopes === "string") {
return [this.scopes];
}
return this.scopes || [DEFAULT_OAUTH_SCOPE];
}
getMetricsHeaderValue() {
const nodeVersion = process.version.replace(/^v/, "");
const saImpersonation = this.serviceAccountImpersonationUrl !== void 0;
const credentialSourceType = this.credentialSourceType ? this.credentialSourceType : "unknown";
return `gl-node/${nodeVersion} auth/${shared_cjs_1.pkg.version} google-byoid-sdk source/${credentialSourceType} sa-impersonation/${saImpersonation} config-lifetime/${this.configLifetimeRequested}`;
}
getTokenUrl() {
return this.tokenUrl;
}
};
exports.BaseExternalAccountClient = BaseExternalAccountClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/filesubjecttokensupplier.js
var require_filesubjecttokensupplier = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/filesubjecttokensupplier.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.FileSubjectTokenSupplier = void 0;
var util_1 = __require("util");
var fs11 = __require("fs");
var readFile4 = (0, util_1.promisify)(fs11.readFile ?? (() => {
}));
var realpath2 = (0, util_1.promisify)(fs11.realpath ?? (() => {
}));
var lstat = (0, util_1.promisify)(fs11.lstat ?? (() => {
}));
var FileSubjectTokenSupplier = class {
filePath;
formatType;
subjectTokenFieldName;
/**
* Instantiates a new file based subject token supplier.
* @param opts The file subject token supplier options to build the supplier
* with.
*/
constructor(opts) {
this.filePath = opts.filePath;
this.formatType = opts.formatType;
this.subjectTokenFieldName = opts.subjectTokenFieldName;
}
/**
* Returns the subject token stored at the file specified in the constructor.
* @param context {@link ExternalAccountSupplierContext} from the calling
* {@link IdentityPoolClient}, contains the requested audience and subject
* token type for the external account identity. Not used.
*/
async getSubjectToken() {
let parsedFilePath = this.filePath;
try {
parsedFilePath = await realpath2(parsedFilePath);
if (!(await lstat(parsedFilePath)).isFile()) {
throw new Error();
}
} catch (err) {
if (err instanceof Error) {
err.message = `The file at ${parsedFilePath} does not exist, or it is not a file. ${err.message}`;
}
throw err;
}
let subjectToken;
const rawText = await readFile4(parsedFilePath, { encoding: "utf8" });
if (this.formatType === "text") {
subjectToken = rawText;
} else if (this.formatType === "json" && this.subjectTokenFieldName) {
const json = JSON.parse(rawText);
subjectToken = json[this.subjectTokenFieldName];
}
if (!subjectToken) {
throw new Error("Unable to parse the subject_token from the credential_source file");
}
return subjectToken;
}
};
exports.FileSubjectTokenSupplier = FileSubjectTokenSupplier;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/urlsubjecttokensupplier.js
var require_urlsubjecttokensupplier = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/urlsubjecttokensupplier.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.UrlSubjectTokenSupplier = void 0;
var authclient_1 = require_authclient();
var UrlSubjectTokenSupplier = class {
url;
headers;
formatType;
subjectTokenFieldName;
additionalGaxiosOptions;
/**
* Instantiates a URL subject token supplier.
* @param opts The URL subject token supplier options to build the supplier with.
*/
constructor(opts) {
this.url = opts.url;
this.formatType = opts.formatType;
this.subjectTokenFieldName = opts.subjectTokenFieldName;
this.headers = opts.headers;
this.additionalGaxiosOptions = opts.additionalGaxiosOptions;
}
/**
* Sends a GET request to the URL provided in the constructor and resolves
* with the returned external subject token.
* @param context {@link ExternalAccountSupplierContext} from the calling
* {@link IdentityPoolClient}, contains the requested audience and subject
* token type for the external account identity. Not used.
*/
async getSubjectToken(context) {
const opts = {
...this.additionalGaxiosOptions,
url: this.url,
method: "GET",
headers: this.headers
};
authclient_1.AuthClient.setMethodName(opts, "getSubjectToken");
let subjectToken;
if (this.formatType === "text") {
const response = await context.transporter.request(opts);
subjectToken = response.data;
} else if (this.formatType === "json" && this.subjectTokenFieldName) {
const response = await context.transporter.request(opts);
subjectToken = response.data[this.subjectTokenFieldName];
}
if (!subjectToken) {
throw new Error("Unable to parse the subject_token from the credential_source URL");
}
return subjectToken;
}
};
exports.UrlSubjectTokenSupplier = UrlSubjectTokenSupplier;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/certificatesubjecttokensupplier.js
var require_certificatesubjecttokensupplier = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/certificatesubjecttokensupplier.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CertificateSubjectTokenSupplier = exports.InvalidConfigurationError = exports.CertificateSourceUnavailableError = exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE = void 0;
var util_1 = require_util4();
var fs11 = __require("fs");
var crypto_1 = __require("crypto");
var https = __require("https");
exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE = "GOOGLE_API_CERTIFICATE_CONFIG";
var CertificateSourceUnavailableError = class extends Error {
constructor(message) {
super(message);
this.name = "CertificateSourceUnavailableError";
}
};
exports.CertificateSourceUnavailableError = CertificateSourceUnavailableError;
var InvalidConfigurationError = class extends Error {
constructor(message) {
super(message);
this.name = "InvalidConfigurationError";
}
};
exports.InvalidConfigurationError = InvalidConfigurationError;
var CertificateSubjectTokenSupplier = class {
certificateConfigPath;
trustChainPath;
cert;
key;
/**
* Initializes a new instance of the CertificateSubjectTokenSupplier.
* @param opts The configuration options for the supplier.
*/
constructor(opts) {
if (!opts.useDefaultCertificateConfig && !opts.certificateConfigLocation) {
throw new InvalidConfigurationError("Either `useDefaultCertificateConfig` must be true or a `certificateConfigLocation` must be provided.");
}
if (opts.useDefaultCertificateConfig && opts.certificateConfigLocation) {
throw new InvalidConfigurationError("Both `useDefaultCertificateConfig` and `certificateConfigLocation` cannot be provided.");
}
this.trustChainPath = opts.trustChainPath;
this.certificateConfigPath = opts.certificateConfigLocation ?? "";
}
/**
* Creates an HTTPS agent configured with the client certificate and private key for mTLS.
* @returns An mTLS-configured https.Agent.
*/
async createMtlsHttpsAgent() {
if (!this.key || !this.cert) {
throw new InvalidConfigurationError("Cannot create mTLS Agent with missing certificate or key");
}
return new https.Agent({ key: this.key, cert: this.cert });
}
/**
* Constructs the subject token, which is the base64-encoded certificate chain.
* @returns A promise that resolves with the subject token.
*/
async getSubjectToken() {
this.certificateConfigPath = await this.#resolveCertificateConfigFilePath();
const { certPath, keyPath } = await this.#getCertAndKeyPaths();
({ cert: this.cert, key: this.key } = await this.#getKeyAndCert(certPath, keyPath));
return await this.#processChainFromPaths(this.cert);
}
/**
* Resolves the absolute path to the certificate configuration file
* by checking the "certificate_config_location" provided in the ADC file,
* or the "GOOGLE_API_CERTIFICATE_CONFIG" environment variable
* or in the default gcloud path.
* @param overridePath An optional path to check first.
* @returns The resolved file path.
*/
async #resolveCertificateConfigFilePath() {
const overridePath = this.certificateConfigPath;
if (overridePath) {
if (await (0, util_1.isValidFile)(overridePath)) {
return overridePath;
}
throw new CertificateSourceUnavailableError(`Provided certificate config path is invalid: ${overridePath}`);
}
const envPath = process.env[exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE];
if (envPath) {
if (await (0, util_1.isValidFile)(envPath)) {
return envPath;
}
throw new CertificateSourceUnavailableError(`Path from environment variable "${exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE}" is invalid: ${envPath}`);
}
const wellKnownPath = (0, util_1.getWellKnownCertificateConfigFileLocation)();
if (await (0, util_1.isValidFile)(wellKnownPath)) {
return wellKnownPath;
}
throw new CertificateSourceUnavailableError(`Could not find certificate configuration file. Searched override path, the "${exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE}" env var, and the gcloud path (${wellKnownPath}).`);
}
/**
* Reads and parses the certificate config JSON file to extract the certificate and key paths.
* @returns An object containing the certificate and key paths.
*/
async #getCertAndKeyPaths() {
const configPath = this.certificateConfigPath;
let fileContents;
try {
fileContents = await fs11.promises.readFile(configPath, "utf8");
} catch (err) {
throw new CertificateSourceUnavailableError(`Failed to read certificate config file at: ${configPath}`);
}
try {
const config = JSON.parse(fileContents);
const certPath = config?.cert_configs?.workload?.cert_path;
const keyPath = config?.cert_configs?.workload?.key_path;
if (!certPath || !keyPath) {
throw new InvalidConfigurationError(`Certificate config file (${configPath}) is missing required "cert_path" or "key_path" in the workload config.`);
}
return { certPath, keyPath };
} catch (e) {
if (e instanceof InvalidConfigurationError)
throw e;
throw new InvalidConfigurationError(`Failed to parse certificate config from ${configPath}: ${e.message}`);
}
}
/**
* Reads and parses the cert and key files get their content and check valid format.
* @returns An object containing the cert content and key content in buffer format.
*/
async #getKeyAndCert(certPath, keyPath) {
let cert, key;
try {
cert = await fs11.promises.readFile(certPath);
new crypto_1.X509Certificate(cert);
} catch (err) {
const message = err instanceof Error ? err.message : String(err);
throw new CertificateSourceUnavailableError(`Failed to read certificate file at ${certPath}: ${message}`);
}
try {
key = await fs11.promises.readFile(keyPath);
(0, crypto_1.createPrivateKey)(key);
} catch (err) {
const message = err instanceof Error ? err.message : String(err);
throw new CertificateSourceUnavailableError(`Failed to read private key file at ${keyPath}: ${message}`);
}
return { cert, key };
}
/**
* Reads the leaf certificate and trust chain, combines them,
* and returns a JSON array of base64-encoded certificates.
* @returns A stringified JSON array of the certificate chain.
*/
async #processChainFromPaths(leafCertBuffer) {
const leafCert = new crypto_1.X509Certificate(leafCertBuffer);
if (!this.trustChainPath) {
return JSON.stringify([leafCert.raw.toString("base64")]);
}
try {
const chainPems = await fs11.promises.readFile(this.trustChainPath, "utf8");
const pemBlocks = chainPems.match(/-----BEGIN CERTIFICATE-----[^-]+-----END CERTIFICATE-----/g) ?? [];
const chainCerts = pemBlocks.map((pem, index) => {
try {
return new crypto_1.X509Certificate(pem);
} catch (err) {
const message = err instanceof Error ? err.message : String(err);
throw new InvalidConfigurationError(`Failed to parse certificate at index ${index} in trust chain file ${this.trustChainPath}: ${message}`);
}
});
const leafIndex = chainCerts.findIndex((chainCert) => leafCert.raw.equals(chainCert.raw));
let finalChain;
if (leafIndex === -1) {
finalChain = [leafCert, ...chainCerts];
} else if (leafIndex === 0) {
finalChain = chainCerts;
} else {
throw new InvalidConfigurationError(`Leaf certificate exists in the trust chain but is not the first entry (found at index ${leafIndex}).`);
}
return JSON.stringify(finalChain.map((cert) => cert.raw.toString("base64")));
} catch (err) {
if (err instanceof InvalidConfigurationError)
throw err;
const message = err instanceof Error ? err.message : String(err);
throw new CertificateSourceUnavailableError(`Failed to process certificate chain from ${this.trustChainPath}: ${message}`);
}
}
};
exports.CertificateSubjectTokenSupplier = CertificateSubjectTokenSupplier;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/identitypoolclient.js
var require_identitypoolclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/identitypoolclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.IdentityPoolClient = void 0;
var baseexternalclient_1 = require_baseexternalclient();
var util_1 = require_util4();
var filesubjecttokensupplier_1 = require_filesubjecttokensupplier();
var urlsubjecttokensupplier_1 = require_urlsubjecttokensupplier();
var certificatesubjecttokensupplier_1 = require_certificatesubjecttokensupplier();
var stscredentials_1 = require_stscredentials();
var gaxios_1 = require_src();
var IdentityPoolClient = class _IdentityPoolClient extends baseexternalclient_1.BaseExternalAccountClient {
subjectTokenSupplier;
/**
* Instantiate an IdentityPoolClient instance using the provided JSON
* object loaded from an external account credentials file.
* An error is thrown if the credential is not a valid file-sourced or
* url-sourced credential or a workforce pool user project is provided
* with a non workforce audience.
* @param options The external account options object typically loaded
* from the external account JSON credential file. The camelCased options
* are aliases for the snake_cased options.
*/
constructor(options) {
super(options);
const opts = (0, util_1.originalOrCamelOptions)(options);
const credentialSource = opts.get("credential_source");
const subjectTokenSupplier = opts.get("subject_token_supplier");
if (!credentialSource && !subjectTokenSupplier) {
throw new Error("A credential source or subject token supplier must be specified.");
}
if (credentialSource && subjectTokenSupplier) {
throw new Error("Only one of credential source or subject token supplier can be specified.");
}
if (subjectTokenSupplier) {
this.subjectTokenSupplier = subjectTokenSupplier;
this.credentialSourceType = "programmatic";
} else {
const credentialSourceOpts = (0, util_1.originalOrCamelOptions)(credentialSource);
const formatOpts = (0, util_1.originalOrCamelOptions)(credentialSourceOpts.get("format"));
const formatType = formatOpts.get("type") || "text";
const formatSubjectTokenFieldName = formatOpts.get("subject_token_field_name");
if (formatType !== "json" && formatType !== "text") {
throw new Error(`Invalid credential_source format "${formatType}"`);
}
if (formatType === "json" && !formatSubjectTokenFieldName) {
throw new Error("Missing subject_token_field_name for JSON credential_source format");
}
const file = credentialSourceOpts.get("file");
const url = credentialSourceOpts.get("url");
const certificate = credentialSourceOpts.get("certificate");
const headers = credentialSourceOpts.get("headers");
if (file && url || url && certificate || file && certificate) {
throw new Error('No valid Identity Pool "credential_source" provided, must be either file, url, or certificate.');
} else if (file) {
this.credentialSourceType = "file";
this.subjectTokenSupplier = new filesubjecttokensupplier_1.FileSubjectTokenSupplier({
filePath: file,
formatType,
subjectTokenFieldName: formatSubjectTokenFieldName
});
} else if (url) {
this.credentialSourceType = "url";
this.subjectTokenSupplier = new urlsubjecttokensupplier_1.UrlSubjectTokenSupplier({
url,
formatType,
subjectTokenFieldName: formatSubjectTokenFieldName,
headers,
additionalGaxiosOptions: _IdentityPoolClient.RETRY_CONFIG
});
} else if (certificate) {
this.credentialSourceType = "certificate";
const certificateSubjecttokensupplier = new certificatesubjecttokensupplier_1.CertificateSubjectTokenSupplier({
useDefaultCertificateConfig: certificate.use_default_certificate_config,
certificateConfigLocation: certificate.certificate_config_location,
trustChainPath: certificate.trust_chain_path
});
this.subjectTokenSupplier = certificateSubjecttokensupplier;
} else {
throw new Error('No valid Identity Pool "credential_source" provided, must be either file, url, or certificate.');
}
}
}
/**
* Triggered when a external subject token is needed to be exchanged for a GCP
* access token via GCP STS endpoint. Gets a subject token by calling
* the configured {@link SubjectTokenSupplier}
* @return A promise that resolves with the external subject token.
*/
async retrieveSubjectToken() {
const subjectToken = await this.subjectTokenSupplier.getSubjectToken(this.supplierContext);
if (this.subjectTokenSupplier instanceof certificatesubjecttokensupplier_1.CertificateSubjectTokenSupplier) {
const mtlsAgent = await this.subjectTokenSupplier.createMtlsHttpsAgent();
this.stsCredential = new stscredentials_1.StsCredentials({
tokenExchangeEndpoint: this.getTokenUrl(),
clientAuthentication: this.clientAuth,
transporter: new gaxios_1.Gaxios({ agent: mtlsAgent })
});
this.transporter = new gaxios_1.Gaxios({
...this.transporter.defaults || {},
agent: mtlsAgent
});
}
return subjectToken;
}
};
exports.IdentityPoolClient = IdentityPoolClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/awsrequestsigner.js
var require_awsrequestsigner = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/awsrequestsigner.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AwsRequestSigner = void 0;
var gaxios_1 = require_src();
var crypto_1 = require_crypto3();
var AWS_ALGORITHM = "AWS4-HMAC-SHA256";
var AWS_REQUEST_TYPE = "aws4_request";
var AwsRequestSigner = class {
getCredentials;
region;
crypto;
/**
* Instantiates an AWS API request signer used to send authenticated signed
* requests to AWS APIs based on the AWS Signature Version 4 signing process.
* This also provides a mechanism to generate the signed request without
* sending it.
* @param getCredentials A mechanism to retrieve AWS security credentials
* when needed.
* @param region The AWS region to use.
*/
constructor(getCredentials, region) {
this.getCredentials = getCredentials;
this.region = region;
this.crypto = (0, crypto_1.createCrypto)();
}
/**
* Generates the signed request for the provided HTTP request for calling
* an AWS API. This follows the steps described at:
* https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html
* @param amzOptions The AWS request options that need to be signed.
* @return A promise that resolves with the GaxiosOptions containing the
* signed HTTP request parameters.
*/
async getRequestOptions(amzOptions) {
if (!amzOptions.url) {
throw new RangeError('"url" is required in "amzOptions"');
}
const requestPayloadData = typeof amzOptions.data === "object" ? JSON.stringify(amzOptions.data) : amzOptions.data;
const url = amzOptions.url;
const method = amzOptions.method || "GET";
const requestPayload = amzOptions.body || requestPayloadData;
const additionalAmzHeaders = amzOptions.headers;
const awsSecurityCredentials = await this.getCredentials();
const uri = new URL(url);
if (typeof requestPayload !== "string" && requestPayload !== void 0) {
throw new TypeError(`'requestPayload' is expected to be a string if provided. Got: ${requestPayload}`);
}
const headerMap = await generateAuthenticationHeaderMap({
crypto: this.crypto,
host: uri.host,
canonicalUri: uri.pathname,
canonicalQuerystring: uri.search.slice(1),
method,
region: this.region,
securityCredentials: awsSecurityCredentials,
requestPayload,
additionalAmzHeaders
});
const headers = gaxios_1.Gaxios.mergeHeaders(
// Add x-amz-date if available.
headerMap.amzDate ? { "x-amz-date": headerMap.amzDate } : {},
{
authorization: headerMap.authorizationHeader,
host: uri.host
},
additionalAmzHeaders || {}
);
if (awsSecurityCredentials.token) {
gaxios_1.Gaxios.mergeHeaders(headers, {
"x-amz-security-token": awsSecurityCredentials.token
});
}
const awsSignedReq = {
url,
method,
headers
};
if (requestPayload !== void 0) {
awsSignedReq.body = requestPayload;
}
return awsSignedReq;
}
};
exports.AwsRequestSigner = AwsRequestSigner;
async function sign(crypto4, key, msg) {
return await crypto4.signWithHmacSha256(key, msg);
}
async function getSigningKey(crypto4, key, dateStamp, region, serviceName) {
const kDate = await sign(crypto4, `AWS4${key}`, dateStamp);
const kRegion = await sign(crypto4, kDate, region);
const kService = await sign(crypto4, kRegion, serviceName);
const kSigning = await sign(crypto4, kService, "aws4_request");
return kSigning;
}
async function generateAuthenticationHeaderMap(options) {
const additionalAmzHeaders = gaxios_1.Gaxios.mergeHeaders(options.additionalAmzHeaders);
const requestPayload = options.requestPayload || "";
const serviceName = options.host.split(".")[0];
const now = /* @__PURE__ */ new Date();
const amzDate = now.toISOString().replace(/[-:]/g, "").replace(/\.[0-9]+/, "");
const dateStamp = now.toISOString().replace(/[-]/g, "").replace(/T.*/, "");
if (options.securityCredentials.token) {
additionalAmzHeaders.set("x-amz-security-token", options.securityCredentials.token);
}
const amzHeaders = gaxios_1.Gaxios.mergeHeaders(
{
host: options.host
},
// Previously the date was not fixed with x-amz- and could be provided manually.
// https://github.com/boto/botocore/blob/879f8440a4e9ace5d3cf145ce8b3d5e5ffb892ef/tests/unit/auth/aws4_testsuite/get-header-value-trim.req
additionalAmzHeaders.has("date") ? {} : { "x-amz-date": amzDate },
additionalAmzHeaders
);
let canonicalHeaders = "";
const signedHeadersList = [
...amzHeaders.keys()
].sort();
signedHeadersList.forEach((key) => {
canonicalHeaders += `${key}:${amzHeaders.get(key)}
`;
});
const signedHeaders = signedHeadersList.join(";");
const payloadHash = await options.crypto.sha256DigestHex(requestPayload);
const canonicalRequest = `${options.method.toUpperCase()}
${options.canonicalUri}
${options.canonicalQuerystring}
${canonicalHeaders}
${signedHeaders}
${payloadHash}`;
const credentialScope = `${dateStamp}/${options.region}/${serviceName}/${AWS_REQUEST_TYPE}`;
const stringToSign = `${AWS_ALGORITHM}
${amzDate}
${credentialScope}
` + await options.crypto.sha256DigestHex(canonicalRequest);
const signingKey = await getSigningKey(options.crypto, options.securityCredentials.secretAccessKey, dateStamp, options.region, serviceName);
const signature = await sign(options.crypto, signingKey, stringToSign);
const authorizationHeader = `${AWS_ALGORITHM} Credential=${options.securityCredentials.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${(0, crypto_1.fromArrayBufferToHex)(signature)}`;
return {
// Do not return x-amz-date if date is available.
amzDate: additionalAmzHeaders.has("date") ? void 0 : amzDate,
authorizationHeader,
canonicalQuerystring: options.canonicalQuerystring
};
}
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/defaultawssecuritycredentialssupplier.js
var require_defaultawssecuritycredentialssupplier = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/defaultawssecuritycredentialssupplier.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DefaultAwsSecurityCredentialsSupplier = void 0;
var authclient_1 = require_authclient();
var DefaultAwsSecurityCredentialsSupplier = class {
regionUrl;
securityCredentialsUrl;
imdsV2SessionTokenUrl;
additionalGaxiosOptions;
/**
* Instantiates a new DefaultAwsSecurityCredentialsSupplier using information
* from the credential_source stored in the ADC file.
* @param opts The default aws security credentials supplier options object to
* build the supplier with.
*/
constructor(opts) {
this.regionUrl = opts.regionUrl;
this.securityCredentialsUrl = opts.securityCredentialsUrl;
this.imdsV2SessionTokenUrl = opts.imdsV2SessionTokenUrl;
this.additionalGaxiosOptions = opts.additionalGaxiosOptions;
}
/**
* Returns the active AWS region. This first checks to see if the region
* is available as an environment variable. If it is not, then the supplier
* will call the region URL.
* @param context {@link ExternalAccountSupplierContext} from the calling
* {@link AwsClient}, contains the requested audience and subject token type
* for the external account identity.
* @return A promise that resolves with the AWS region string.
*/
async getAwsRegion(context) {
if (this.#regionFromEnv) {
return this.#regionFromEnv;
}
const metadataHeaders = new Headers();
if (!this.#regionFromEnv && this.imdsV2SessionTokenUrl) {
metadataHeaders.set("x-aws-ec2-metadata-token", await this.#getImdsV2SessionToken(context.transporter));
}
if (!this.regionUrl) {
throw new RangeError('Unable to determine AWS region due to missing "options.credential_source.region_url"');
}
const opts = {
...this.additionalGaxiosOptions,
url: this.regionUrl,
method: "GET",
headers: metadataHeaders
};
authclient_1.AuthClient.setMethodName(opts, "getAwsRegion");
const response = await context.transporter.request(opts);
return response.data.substr(0, response.data.length - 1);
}
/**
* Returns AWS security credentials. This first checks to see if the credentials
* is available as environment variables. If it is not, then the supplier
* will call the security credentials URL.
* @param context {@link ExternalAccountSupplierContext} from the calling
* {@link AwsClient}, contains the requested audience and subject token type
* for the external account identity.
* @return A promise that resolves with the AWS security credentials.
*/
async getAwsSecurityCredentials(context) {
if (this.#securityCredentialsFromEnv) {
return this.#securityCredentialsFromEnv;
}
const metadataHeaders = new Headers();
if (this.imdsV2SessionTokenUrl) {
metadataHeaders.set("x-aws-ec2-metadata-token", await this.#getImdsV2SessionToken(context.transporter));
}
const roleName = await this.#getAwsRoleName(metadataHeaders, context.transporter);
const awsCreds = await this.#retrieveAwsSecurityCredentials(roleName, metadataHeaders, context.transporter);
return {
accessKeyId: awsCreds.AccessKeyId,
secretAccessKey: awsCreds.SecretAccessKey,
token: awsCreds.Token
};
}
/**
* @param transporter The transporter to use for requests.
* @return A promise that resolves with the IMDSv2 Session Token.
*/
async #getImdsV2SessionToken(transporter) {
const opts = {
...this.additionalGaxiosOptions,
url: this.imdsV2SessionTokenUrl,
method: "PUT",
headers: { "x-aws-ec2-metadata-token-ttl-seconds": "300" }
};
authclient_1.AuthClient.setMethodName(opts, "#getImdsV2SessionToken");
const response = await transporter.request(opts);
return response.data;
}
/**
* @param headers The headers to be used in the metadata request.
* @param transporter The transporter to use for requests.
* @return A promise that resolves with the assigned role to the current
* AWS VM. This is needed for calling the security-credentials endpoint.
*/
async #getAwsRoleName(headers, transporter) {
if (!this.securityCredentialsUrl) {
throw new Error('Unable to determine AWS role name due to missing "options.credential_source.url"');
}
const opts = {
...this.additionalGaxiosOptions,
url: this.securityCredentialsUrl,
method: "GET",
headers
};
authclient_1.AuthClient.setMethodName(opts, "#getAwsRoleName");
const response = await transporter.request(opts);
return response.data;
}
/**
* Retrieves the temporary AWS credentials by calling the security-credentials
* endpoint as specified in the `credential_source` object.
* @param roleName The role attached to the current VM.
* @param headers The headers to be used in the metadata request.
* @param transporter The transporter to use for requests.
* @return A promise that resolves with the temporary AWS credentials
* needed for creating the GetCallerIdentity signed request.
*/
async #retrieveAwsSecurityCredentials(roleName, headers, transporter) {
const opts = {
...this.additionalGaxiosOptions,
url: `${this.securityCredentialsUrl}/${roleName}`,
headers
};
authclient_1.AuthClient.setMethodName(opts, "#retrieveAwsSecurityCredentials");
const response = await transporter.request(opts);
return response.data;
}
get #regionFromEnv() {
return process.env["AWS_REGION"] || process.env["AWS_DEFAULT_REGION"] || null;
}
get #securityCredentialsFromEnv() {
if (process.env["AWS_ACCESS_KEY_ID"] && process.env["AWS_SECRET_ACCESS_KEY"]) {
return {
accessKeyId: process.env["AWS_ACCESS_KEY_ID"],
secretAccessKey: process.env["AWS_SECRET_ACCESS_KEY"],
token: process.env["AWS_SESSION_TOKEN"]
};
}
return null;
}
};
exports.DefaultAwsSecurityCredentialsSupplier = DefaultAwsSecurityCredentialsSupplier;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/awsclient.js
var require_awsclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/awsclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AwsClient = void 0;
var awsrequestsigner_1 = require_awsrequestsigner();
var baseexternalclient_1 = require_baseexternalclient();
var defaultawssecuritycredentialssupplier_1 = require_defaultawssecuritycredentialssupplier();
var util_1 = require_util4();
var gaxios_1 = require_src();
var AwsClient = class _AwsClient extends baseexternalclient_1.BaseExternalAccountClient {
environmentId;
awsSecurityCredentialsSupplier;
regionalCredVerificationUrl;
awsRequestSigner;
region;
static #DEFAULT_AWS_REGIONAL_CREDENTIAL_VERIFICATION_URL = "https://sts.{region}.amazonaws.com?Action=GetCallerIdentity&Version=2011-06-15";
/**
* @deprecated AWS client no validates the EC2 metadata address.
**/
static AWS_EC2_METADATA_IPV4_ADDRESS = "169.254.169.254";
/**
* @deprecated AWS client no validates the EC2 metadata address.
**/
static AWS_EC2_METADATA_IPV6_ADDRESS = "fd00:ec2::254";
/**
* Instantiates an AwsClient instance using the provided JSON
* object loaded from an external account credentials file.
* An error is thrown if the credential is not a valid AWS credential.
* @param options The external account options object typically loaded
* from the external account JSON credential file.
*/
constructor(options) {
super(options);
const opts = (0, util_1.originalOrCamelOptions)(options);
const credentialSource = opts.get("credential_source");
const awsSecurityCredentialsSupplier = opts.get("aws_security_credentials_supplier");
if (!credentialSource && !awsSecurityCredentialsSupplier) {
throw new Error("A credential source or AWS security credentials supplier must be specified.");
}
if (credentialSource && awsSecurityCredentialsSupplier) {
throw new Error("Only one of credential source or AWS security credentials supplier can be specified.");
}
if (awsSecurityCredentialsSupplier) {
this.awsSecurityCredentialsSupplier = awsSecurityCredentialsSupplier;
this.regionalCredVerificationUrl = _AwsClient.#DEFAULT_AWS_REGIONAL_CREDENTIAL_VERIFICATION_URL;
this.credentialSourceType = "programmatic";
} else {
const credentialSourceOpts = (0, util_1.originalOrCamelOptions)(credentialSource);
this.environmentId = credentialSourceOpts.get("environment_id");
const regionUrl = credentialSourceOpts.get("region_url");
const securityCredentialsUrl = credentialSourceOpts.get("url");
const imdsV2SessionTokenUrl = credentialSourceOpts.get("imdsv2_session_token_url");
this.awsSecurityCredentialsSupplier = new defaultawssecuritycredentialssupplier_1.DefaultAwsSecurityCredentialsSupplier({
regionUrl,
securityCredentialsUrl,
imdsV2SessionTokenUrl
});
this.regionalCredVerificationUrl = credentialSourceOpts.get("regional_cred_verification_url");
this.credentialSourceType = "aws";
this.validateEnvironmentId();
}
this.awsRequestSigner = null;
this.region = "";
}
validateEnvironmentId() {
const match = this.environmentId?.match(/^(aws)(\d+)$/);
if (!match || !this.regionalCredVerificationUrl) {
throw new Error('No valid AWS "credential_source" provided');
} else if (parseInt(match[2], 10) !== 1) {
throw new Error(`aws version "${match[2]}" is not supported in the current build.`);
}
}
/**
* Triggered when an external subject token is needed to be exchanged for a
* GCP access token via GCP STS endpoint. This will call the
* {@link AwsSecurityCredentialsSupplier} to retrieve an AWS region and AWS
* Security Credentials, then use them to create a signed AWS STS request that
* can be exchanged for a GCP access token.
* @return A promise that resolves with the external subject token.
*/
async retrieveSubjectToken() {
if (!this.awsRequestSigner) {
this.region = await this.awsSecurityCredentialsSupplier.getAwsRegion(this.supplierContext);
this.awsRequestSigner = new awsrequestsigner_1.AwsRequestSigner(async () => {
return this.awsSecurityCredentialsSupplier.getAwsSecurityCredentials(this.supplierContext);
}, this.region);
}
const options = await this.awsRequestSigner.getRequestOptions({
..._AwsClient.RETRY_CONFIG,
url: this.regionalCredVerificationUrl.replace("{region}", this.region),
method: "POST"
});
const reformattedHeader = [];
const extendedHeaders = gaxios_1.Gaxios.mergeHeaders({
// The full, canonical resource name of the workload identity pool
// provider, with or without the HTTPS prefix.
// Including this header as part of the signature is recommended to
// ensure data integrity.
"x-goog-cloud-target-resource": this.audience
}, options.headers);
extendedHeaders.forEach((value, key) => reformattedHeader.push({ key, value }));
return encodeURIComponent(JSON.stringify({
url: options.url,
method: options.method,
headers: reformattedHeader
}));
}
};
exports.AwsClient = AwsClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/executable-response.js
var require_executable_response = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/executable-response.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.InvalidSubjectTokenError = exports.InvalidMessageFieldError = exports.InvalidCodeFieldError = exports.InvalidTokenTypeFieldError = exports.InvalidExpirationTimeFieldError = exports.InvalidSuccessFieldError = exports.InvalidVersionFieldError = exports.ExecutableResponseError = exports.ExecutableResponse = void 0;
var SAML_SUBJECT_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:saml2";
var OIDC_SUBJECT_TOKEN_TYPE1 = "urn:ietf:params:oauth:token-type:id_token";
var OIDC_SUBJECT_TOKEN_TYPE2 = "urn:ietf:params:oauth:token-type:jwt";
var ExecutableResponse = class {
/**
* The version of the Executable response. Only version 1 is currently supported.
*/
version;
/**
* Whether the executable ran successfully.
*/
success;
/**
* The epoch time for expiration of the token in seconds.
*/
expirationTime;
/**
* The type of subject token in the response, currently supported values are:
* urn:ietf:params:oauth:token-type:saml2
* urn:ietf:params:oauth:token-type:id_token
* urn:ietf:params:oauth:token-type:jwt
*/
tokenType;
/**
* The error code from the executable.
*/
errorCode;
/**
* The error message from the executable.
*/
errorMessage;
/**
* The subject token from the executable, format depends on tokenType.
*/
subjectToken;
/**
* Instantiates an ExecutableResponse instance using the provided JSON object
* from the output of the executable.
* @param responseJson Response from a 3rd party executable, loaded from a
* run of the executable or a cached output file.
*/
constructor(responseJson) {
if (!responseJson.version) {
throw new InvalidVersionFieldError("Executable response must contain a 'version' field.");
}
if (responseJson.success === void 0) {
throw new InvalidSuccessFieldError("Executable response must contain a 'success' field.");
}
this.version = responseJson.version;
this.success = responseJson.success;
if (this.success) {
this.expirationTime = responseJson.expiration_time;
this.tokenType = responseJson.token_type;
if (this.tokenType !== SAML_SUBJECT_TOKEN_TYPE && this.tokenType !== OIDC_SUBJECT_TOKEN_TYPE1 && this.tokenType !== OIDC_SUBJECT_TOKEN_TYPE2) {
throw new InvalidTokenTypeFieldError(`Executable response must contain a 'token_type' field when successful and it must be one of ${OIDC_SUBJECT_TOKEN_TYPE1}, ${OIDC_SUBJECT_TOKEN_TYPE2}, or ${SAML_SUBJECT_TOKEN_TYPE}.`);
}
if (this.tokenType === SAML_SUBJECT_TOKEN_TYPE) {
if (!responseJson.saml_response) {
throw new InvalidSubjectTokenError(`Executable response must contain a 'saml_response' field when token_type=${SAML_SUBJECT_TOKEN_TYPE}.`);
}
this.subjectToken = responseJson.saml_response;
} else {
if (!responseJson.id_token) {
throw new InvalidSubjectTokenError(`Executable response must contain a 'id_token' field when token_type=${OIDC_SUBJECT_TOKEN_TYPE1} or ${OIDC_SUBJECT_TOKEN_TYPE2}.`);
}
this.subjectToken = responseJson.id_token;
}
} else {
if (!responseJson.code) {
throw new InvalidCodeFieldError("Executable response must contain a 'code' field when unsuccessful.");
}
if (!responseJson.message) {
throw new InvalidMessageFieldError("Executable response must contain a 'message' field when unsuccessful.");
}
this.errorCode = responseJson.code;
this.errorMessage = responseJson.message;
}
}
/**
* @return A boolean representing if the response has a valid token. Returns
* true when the response was successful and the token is not expired.
*/
isValid() {
return !this.isExpired() && this.success;
}
/**
* @return A boolean representing if the response is expired. Returns true if the
* provided timeout has passed.
*/
isExpired() {
return this.expirationTime !== void 0 && this.expirationTime < Math.round(Date.now() / 1e3);
}
};
exports.ExecutableResponse = ExecutableResponse;
var ExecutableResponseError = class extends Error {
constructor(message) {
super(message);
Object.setPrototypeOf(this, new.target.prototype);
}
};
exports.ExecutableResponseError = ExecutableResponseError;
var InvalidVersionFieldError = class extends ExecutableResponseError {
};
exports.InvalidVersionFieldError = InvalidVersionFieldError;
var InvalidSuccessFieldError = class extends ExecutableResponseError {
};
exports.InvalidSuccessFieldError = InvalidSuccessFieldError;
var InvalidExpirationTimeFieldError = class extends ExecutableResponseError {
};
exports.InvalidExpirationTimeFieldError = InvalidExpirationTimeFieldError;
var InvalidTokenTypeFieldError = class extends ExecutableResponseError {
};
exports.InvalidTokenTypeFieldError = InvalidTokenTypeFieldError;
var InvalidCodeFieldError = class extends ExecutableResponseError {
};
exports.InvalidCodeFieldError = InvalidCodeFieldError;
var InvalidMessageFieldError = class extends ExecutableResponseError {
};
exports.InvalidMessageFieldError = InvalidMessageFieldError;
var InvalidSubjectTokenError = class extends ExecutableResponseError {
};
exports.InvalidSubjectTokenError = InvalidSubjectTokenError;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/pluggable-auth-handler.js
var require_pluggable_auth_handler = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/pluggable-auth-handler.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PluggableAuthHandler = exports.ExecutableError = void 0;
var executable_response_1 = require_executable_response();
var childProcess = __require("child_process");
var fs11 = __require("fs");
var ExecutableError = class extends Error {
/**
* The exit code returned by the executable.
*/
code;
constructor(message, code) {
super(`The executable failed with exit code: ${code} and error message: ${message}.`);
this.code = code;
Object.setPrototypeOf(this, new.target.prototype);
}
};
exports.ExecutableError = ExecutableError;
var PluggableAuthHandler = class _PluggableAuthHandler {
commandComponents;
timeoutMillis;
outputFile;
/**
* Instantiates a PluggableAuthHandler instance using the provided
* PluggableAuthHandlerOptions object.
*/
constructor(options) {
if (!options.command) {
throw new Error("No command provided.");
}
this.commandComponents = _PluggableAuthHandler.parseCommand(options.command);
this.timeoutMillis = options.timeoutMillis;
if (!this.timeoutMillis) {
throw new Error("No timeoutMillis provided.");
}
this.outputFile = options.outputFile;
}
/**
* Calls user provided executable to get a 3rd party subject token and
* returns the response.
* @param envMap a Map of additional Environment Variables required for
* the executable.
* @return A promise that resolves with the executable response.
*/
retrieveResponseFromExecutable(envMap) {
return new Promise((resolve5, reject) => {
const child = childProcess.spawn(this.commandComponents[0], this.commandComponents.slice(1), {
env: { ...process.env, ...Object.fromEntries(envMap) }
});
let output = "";
child.stdout.on("data", (data) => {
output += data;
});
child.stderr.on("data", (err) => {
output += err;
});
const timeout = setTimeout(() => {
child.removeAllListeners();
child.kill();
return reject(new Error("The executable failed to finish within the timeout specified."));
}, this.timeoutMillis);
child.on("close", (code) => {
clearTimeout(timeout);
if (code === 0) {
try {
const responseJson = JSON.parse(output);
const response = new executable_response_1.ExecutableResponse(responseJson);
return resolve5(response);
} catch (error) {
if (error instanceof executable_response_1.ExecutableResponseError) {
return reject(error);
}
return reject(new executable_response_1.ExecutableResponseError(`The executable returned an invalid response: ${output}`));
}
} else {
return reject(new ExecutableError(output, code.toString()));
}
});
});
}
/**
* Checks user provided output file for response from previous run of
* executable and return the response if it exists, is formatted correctly, and is not expired.
*/
async retrieveCachedResponse() {
if (!this.outputFile || this.outputFile.length === 0) {
return void 0;
}
let filePath;
try {
filePath = await fs11.promises.realpath(this.outputFile);
} catch {
return void 0;
}
if (!(await fs11.promises.lstat(filePath)).isFile()) {
return void 0;
}
const responseString = await fs11.promises.readFile(filePath, {
encoding: "utf8"
});
if (responseString === "") {
return void 0;
}
try {
const responseJson = JSON.parse(responseString);
const response = new executable_response_1.ExecutableResponse(responseJson);
if (response.isValid()) {
return new executable_response_1.ExecutableResponse(responseJson);
}
return void 0;
} catch (error) {
if (error instanceof executable_response_1.ExecutableResponseError) {
throw error;
}
throw new executable_response_1.ExecutableResponseError(`The output file contained an invalid response: ${responseString}`);
}
}
/**
* Parses given command string into component array, splitting on spaces unless
* spaces are between quotation marks.
*/
static parseCommand(command) {
const components = command.match(/(?:[^\s"]+|"[^"]*")+/g);
if (!components) {
throw new Error(`Provided command: "${command}" could not be parsed.`);
}
for (let i = 0; i < components.length; i++) {
if (components[i][0] === '"' && components[i].slice(-1) === '"') {
components[i] = components[i].slice(1, -1);
}
}
return components;
}
};
exports.PluggableAuthHandler = PluggableAuthHandler;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/pluggable-auth-client.js
var require_pluggable_auth_client = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/pluggable-auth-client.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PluggableAuthClient = exports.ExecutableError = void 0;
var baseexternalclient_1 = require_baseexternalclient();
var executable_response_1 = require_executable_response();
var pluggable_auth_handler_1 = require_pluggable_auth_handler();
var pluggable_auth_handler_2 = require_pluggable_auth_handler();
Object.defineProperty(exports, "ExecutableError", { enumerable: true, get: function() {
return pluggable_auth_handler_2.ExecutableError;
} });
var DEFAULT_EXECUTABLE_TIMEOUT_MILLIS = 30 * 1e3;
var MINIMUM_EXECUTABLE_TIMEOUT_MILLIS = 5 * 1e3;
var MAXIMUM_EXECUTABLE_TIMEOUT_MILLIS = 120 * 1e3;
var GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES = "GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES";
var MAXIMUM_EXECUTABLE_VERSION = 1;
var PluggableAuthClient = class extends baseexternalclient_1.BaseExternalAccountClient {
/**
* The command used to retrieve the third party token.
*/
command;
/**
* The timeout in milliseconds for running executable,
* set to default if none provided.
*/
timeoutMillis;
/**
* The path to file to check for cached executable response.
*/
outputFile;
/**
* Executable and output file handler.
*/
handler;
/**
* Instantiates a PluggableAuthClient instance using the provided JSON
* object loaded from an external account credentials file.
* An error is thrown if the credential is not a valid pluggable auth credential.
* @param options The external account options object typically loaded from
* the external account JSON credential file.
*/
constructor(options) {
super(options);
if (!options.credential_source.executable) {
throw new Error('No valid Pluggable Auth "credential_source" provided.');
}
this.command = options.credential_source.executable.command;
if (!this.command) {
throw new Error('No valid Pluggable Auth "credential_source" provided.');
}
if (options.credential_source.executable.timeout_millis === void 0) {
this.timeoutMillis = DEFAULT_EXECUTABLE_TIMEOUT_MILLIS;
} else {
this.timeoutMillis = options.credential_source.executable.timeout_millis;
if (this.timeoutMillis < MINIMUM_EXECUTABLE_TIMEOUT_MILLIS || this.timeoutMillis > MAXIMUM_EXECUTABLE_TIMEOUT_MILLIS) {
throw new Error(`Timeout must be between ${MINIMUM_EXECUTABLE_TIMEOUT_MILLIS} and ${MAXIMUM_EXECUTABLE_TIMEOUT_MILLIS} milliseconds.`);
}
}
this.outputFile = options.credential_source.executable.output_file;
this.handler = new pluggable_auth_handler_1.PluggableAuthHandler({
command: this.command,
timeoutMillis: this.timeoutMillis,
outputFile: this.outputFile
});
this.credentialSourceType = "executable";
}
/**
* Triggered when an external subject token is needed to be exchanged for a
* GCP access token via GCP STS endpoint.
* This uses the `options.credential_source` object to figure out how
* to retrieve the token using the current environment. In this case,
* this calls a user provided executable which returns the subject token.
* The logic is summarized as:
* 1. Validated that the executable is allowed to run. The
* GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES environment must be set to
* 1 for security reasons.
* 2. If an output file is specified by the user, check the file location
* for a response. If the file exists and contains a valid response,
* return the subject token from the file.
* 3. Call the provided executable and return response.
* @return A promise that resolves with the external subject token.
*/
async retrieveSubjectToken() {
if (process.env[GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES] !== "1") {
throw new Error("Pluggable Auth executables need to be explicitly allowed to run by setting the GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES environment Variable to 1.");
}
let executableResponse = void 0;
if (this.outputFile) {
executableResponse = await this.handler.retrieveCachedResponse();
}
if (!executableResponse) {
const envMap = /* @__PURE__ */ new Map();
envMap.set("GOOGLE_EXTERNAL_ACCOUNT_AUDIENCE", this.audience);
envMap.set("GOOGLE_EXTERNAL_ACCOUNT_TOKEN_TYPE", this.subjectTokenType);
envMap.set("GOOGLE_EXTERNAL_ACCOUNT_INTERACTIVE", "0");
if (this.outputFile) {
envMap.set("GOOGLE_EXTERNAL_ACCOUNT_OUTPUT_FILE", this.outputFile);
}
const serviceAccountEmail = this.getServiceAccountEmail();
if (serviceAccountEmail) {
envMap.set("GOOGLE_EXTERNAL_ACCOUNT_IMPERSONATED_EMAIL", serviceAccountEmail);
}
executableResponse = await this.handler.retrieveResponseFromExecutable(envMap);
}
if (executableResponse.version > MAXIMUM_EXECUTABLE_VERSION) {
throw new Error(`Version of executable is not currently supported, maximum supported version is ${MAXIMUM_EXECUTABLE_VERSION}.`);
}
if (!executableResponse.success) {
throw new pluggable_auth_handler_1.ExecutableError(executableResponse.errorMessage, executableResponse.errorCode);
}
if (this.outputFile) {
if (!executableResponse.expirationTime) {
throw new executable_response_1.InvalidExpirationTimeFieldError("The executable response must contain the `expiration_time` field for successful responses when an output_file has been specified in the configuration.");
}
}
if (executableResponse.isExpired()) {
throw new Error("Executable response is expired.");
}
return executableResponse.subjectToken;
}
};
exports.PluggableAuthClient = PluggableAuthClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/externalclient.js
var require_externalclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/externalclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ExternalAccountClient = void 0;
var baseexternalclient_1 = require_baseexternalclient();
var identitypoolclient_1 = require_identitypoolclient();
var awsclient_1 = require_awsclient();
var pluggable_auth_client_1 = require_pluggable_auth_client();
var ExternalAccountClient = class {
constructor() {
throw new Error("ExternalAccountClients should be initialized via: ExternalAccountClient.fromJSON(), directly via explicit constructors, eg. new AwsClient(options), new IdentityPoolClient(options), newPluggableAuthClientOptions, or via new GoogleAuth(options).getClient()");
}
/**
* This static method will instantiate the
* corresponding type of external account credential depending on the
* underlying credential source.
*
* **IMPORTANT**: This method does not validate the credential configuration.
* A security risk occurs when a credential configuration configured with
* malicious URLs is used. When the credential configuration is accepted from
* an untrusted source, you should validate it before using it with this
* method. For more details, see
* https://cloud.google.com/docs/authentication/external/externally-sourced-credentials.
*
* @param options The external account options object typically loaded
* from the external account JSON credential file.
* @return A BaseExternalAccountClient instance or null if the options
* provided do not correspond to an external account credential.
*/
static fromJSON(options) {
if (options && options.type === baseexternalclient_1.EXTERNAL_ACCOUNT_TYPE) {
if (options.credential_source?.environment_id) {
return new awsclient_1.AwsClient(options);
} else if (options.credential_source?.executable) {
return new pluggable_auth_client_1.PluggableAuthClient(options);
} else {
return new identitypoolclient_1.IdentityPoolClient(options);
}
} else {
return null;
}
}
};
exports.ExternalAccountClient = ExternalAccountClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/externalAccountAuthorizedUserClient.js
var require_externalAccountAuthorizedUserClient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/externalAccountAuthorizedUserClient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ExternalAccountAuthorizedUserClient = exports.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE = void 0;
var authclient_1 = require_authclient();
var oauth2common_1 = require_oauth2common();
var gaxios_1 = require_src();
var stream = __require("stream");
var baseexternalclient_1 = require_baseexternalclient();
exports.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE = "external_account_authorized_user";
var DEFAULT_TOKEN_URL = "https://sts.{universeDomain}/v1/oauthtoken";
var ExternalAccountAuthorizedUserHandler = class _ExternalAccountAuthorizedUserHandler extends oauth2common_1.OAuthClientAuthHandler {
#tokenRefreshEndpoint;
/**
* Initializes an ExternalAccountAuthorizedUserHandler instance.
* @param url The URL of the token refresh endpoint.
* @param transporter The transporter to use for the refresh request.
* @param clientAuthentication The client authentication credentials to use
* for the refresh request.
*/
constructor(options) {
super(options);
this.#tokenRefreshEndpoint = options.tokenRefreshEndpoint;
}
/**
* Requests a new access token from the token_url endpoint using the provided
* refresh token.
* @param refreshToken The refresh token to use to generate a new access token.
* @param additionalHeaders Optional additional headers to pass along the
* request.
* @return A promise that resolves with the token refresh response containing
* the requested access token and its expiration time.
*/
async refreshToken(refreshToken, headers) {
const opts = {
..._ExternalAccountAuthorizedUserHandler.RETRY_CONFIG,
url: this.#tokenRefreshEndpoint,
method: "POST",
headers,
data: new URLSearchParams({
grant_type: "refresh_token",
refresh_token: refreshToken
})
};
authclient_1.AuthClient.setMethodName(opts, "refreshToken");
this.applyClientAuthenticationOptions(opts);
try {
const response = await this.transporter.request(opts);
const tokenRefreshResponse = response.data;
tokenRefreshResponse.res = response;
return tokenRefreshResponse;
} catch (error) {
if (error instanceof gaxios_1.GaxiosError && error.response) {
throw (0, oauth2common_1.getErrorFromOAuthErrorResponse)(
error.response.data,
// Preserve other fields from the original error.
error
);
}
throw error;
}
}
};
var ExternalAccountAuthorizedUserClient = class extends authclient_1.AuthClient {
cachedAccessToken;
externalAccountAuthorizedUserHandler;
refreshToken;
/**
* Instantiates an ExternalAccountAuthorizedUserClient instances using the
* provided JSON object loaded from a credentials files.
* An error is throws if the credential is not valid.
* @param options The external account authorized user option object typically
* from the external accoutn authorized user JSON credential file.
*/
constructor(options) {
super(options);
if (options.universe_domain) {
this.universeDomain = options.universe_domain;
}
this.refreshToken = options.refresh_token;
const clientAuthentication = {
confidentialClientType: "basic",
clientId: options.client_id,
clientSecret: options.client_secret
};
this.externalAccountAuthorizedUserHandler = new ExternalAccountAuthorizedUserHandler({
tokenRefreshEndpoint: options.token_url ?? DEFAULT_TOKEN_URL.replace("{universeDomain}", this.universeDomain),
transporter: this.transporter,
clientAuthentication
});
this.cachedAccessToken = null;
this.quotaProjectId = options.quota_project_id;
if (typeof options?.eagerRefreshThresholdMillis !== "number") {
this.eagerRefreshThresholdMillis = baseexternalclient_1.EXPIRATION_TIME_OFFSET;
} else {
this.eagerRefreshThresholdMillis = options.eagerRefreshThresholdMillis;
}
this.forceRefreshOnFailure = !!options?.forceRefreshOnFailure;
}
async getAccessToken() {
if (!this.cachedAccessToken || this.isExpired(this.cachedAccessToken)) {
await this.refreshAccessTokenAsync();
}
return {
token: this.cachedAccessToken.access_token,
res: this.cachedAccessToken.res
};
}
async getRequestHeaders() {
const accessTokenResponse = await this.getAccessToken();
const headers = new Headers({
authorization: `Bearer ${accessTokenResponse.token}`
});
return this.addSharedMetadataHeaders(headers);
}
request(opts, callback) {
if (callback) {
this.requestAsync(opts).then((r) => callback(null, r), (e) => {
return callback(e, e.response);
});
} else {
return this.requestAsync(opts);
}
}
/**
* Authenticates the provided HTTP request, processes it and resolves with the
* returned response.
* @param opts The HTTP request options.
* @param reAuthRetried Whether the current attempt is a retry after a failed attempt due to an auth failure.
* @return A promise that resolves with the successful response.
*/
async requestAsync(opts, reAuthRetried = false) {
let response;
try {
const requestHeaders = await this.getRequestHeaders();
opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers);
this.addUserProjectAndAuthHeaders(opts.headers, requestHeaders);
response = await this.transporter.request(opts);
} catch (e) {
const res = e.response;
if (res) {
const statusCode = res.status;
const isReadableStream = res.config.data instanceof stream.Readable;
const isAuthErr = statusCode === 401 || statusCode === 403;
if (!reAuthRetried && isAuthErr && !isReadableStream && this.forceRefreshOnFailure) {
await this.refreshAccessTokenAsync();
return await this.requestAsync(opts, true);
}
}
throw e;
}
return response;
}
/**
* Forces token refresh, even if unexpired tokens are currently cached.
* @return A promise that resolves with the refreshed credential.
*/
async refreshAccessTokenAsync() {
const refreshResponse = await this.externalAccountAuthorizedUserHandler.refreshToken(this.refreshToken);
this.cachedAccessToken = {
access_token: refreshResponse.access_token,
expiry_date: (/* @__PURE__ */ new Date()).getTime() + refreshResponse.expires_in * 1e3,
res: refreshResponse.res
};
if (refreshResponse.refresh_token !== void 0) {
this.refreshToken = refreshResponse.refresh_token;
}
return this.cachedAccessToken;
}
/**
* Returns whether the provided credentials are expired or not.
* If there is no expiry time, assumes the token is not expired or expiring.
* @param credentials The credentials to check for expiration.
* @return Whether the credentials are expired or not.
*/
isExpired(credentials) {
const now = (/* @__PURE__ */ new Date()).getTime();
return credentials.expiry_date ? now >= credentials.expiry_date - this.eagerRefreshThresholdMillis : false;
}
};
exports.ExternalAccountAuthorizedUserClient = ExternalAccountAuthorizedUserClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/googleauth.js
var require_googleauth = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/googleauth.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GoogleAuth = exports.GoogleAuthExceptionMessages = void 0;
var child_process_1 = __require("child_process");
var fs11 = __require("fs");
var gaxios_1 = require_src();
var gcpMetadata = require_src3();
var os5 = __require("os");
var path10 = __require("path");
var crypto_1 = require_crypto3();
var computeclient_1 = require_computeclient();
var idtokenclient_1 = require_idtokenclient();
var envDetect_1 = require_envDetect();
var jwtclient_1 = require_jwtclient();
var refreshclient_1 = require_refreshclient();
var impersonated_1 = require_impersonated();
var externalclient_1 = require_externalclient();
var baseexternalclient_1 = require_baseexternalclient();
var authclient_1 = require_authclient();
var externalAccountAuthorizedUserClient_1 = require_externalAccountAuthorizedUserClient();
var util_1 = require_util4();
exports.GoogleAuthExceptionMessages = {
API_KEY_WITH_CREDENTIALS: "API Keys and Credentials are mutually exclusive authentication methods and cannot be used together.",
NO_PROJECT_ID_FOUND: "Unable to detect a Project Id in the current environment. \nTo learn more about authentication and Google APIs, visit: \nhttps://cloud.google.com/docs/authentication/getting-started",
NO_CREDENTIALS_FOUND: "Unable to find credentials in current environment. \nTo learn more about authentication and Google APIs, visit: \nhttps://cloud.google.com/docs/authentication/getting-started",
NO_ADC_FOUND: "Could not load the default credentials. Browse to https://cloud.google.com/docs/authentication/getting-started for more information.",
NO_UNIVERSE_DOMAIN_FOUND: "Unable to detect a Universe Domain in the current environment.\nTo learn more about Universe Domain retrieval, visit: \nhttps://cloud.google.com/compute/docs/metadata/predefined-metadata-keys"
};
var GoogleAuth2 = class {
/**
* Caches a value indicating whether the auth layer is running on Google
* Compute Engine.
* @private
*/
checkIsGCE = void 0;
useJWTAccessWithScope;
defaultServicePath;
// Note: this properly is only public to satisfy unit tests.
// https://github.com/Microsoft/TypeScript/issues/5228
get isGCE() {
return this.checkIsGCE;
}
_findProjectIdPromise;
_cachedProjectId;
// To save the contents of the JSON credential file
jsonContent = null;
apiKey;
cachedCredential = null;
/**
* A pending {@link AuthClient}. Used for concurrent {@link GoogleAuth.getClient} calls.
*/
#pendingAuthClient = null;
/**
* Scopes populated by the client library by default. We differentiate between
* these and user defined scopes when deciding whether to use a self-signed JWT.
*/
defaultScopes;
keyFilename;
scopes;
clientOptions = {};
/**
* Configuration is resolved in the following order of precedence:
* - {@link GoogleAuthOptions.credentials `credentials`}
* - {@link GoogleAuthOptions.keyFilename `keyFilename`}
* - {@link GoogleAuthOptions.keyFile `keyFile`}
*
* {@link GoogleAuthOptions.clientOptions `clientOptions`} are passed to the
* {@link AuthClient `AuthClient`s}.
*
* @param opts
*/
constructor(opts = {}) {
this._cachedProjectId = opts.projectId || null;
this.cachedCredential = opts.authClient || null;
this.keyFilename = opts.keyFilename || opts.keyFile;
this.scopes = opts.scopes;
this.clientOptions = opts.clientOptions || {};
this.jsonContent = opts.credentials || null;
this.apiKey = opts.apiKey || this.clientOptions.apiKey || null;
if (this.apiKey && (this.jsonContent || this.clientOptions.credentials)) {
throw new RangeError(exports.GoogleAuthExceptionMessages.API_KEY_WITH_CREDENTIALS);
}
if (opts.universeDomain) {
this.clientOptions.universeDomain = opts.universeDomain;
}
}
// GAPIC client libraries should always use self-signed JWTs. The following
// variables are set on the JWT client in order to indicate the type of library,
// and sign the JWT with the correct audience and scopes (if not supplied).
setGapicJWTValues(client) {
client.defaultServicePath = this.defaultServicePath;
client.useJWTAccessWithScope = this.useJWTAccessWithScope;
client.defaultScopes = this.defaultScopes;
}
getProjectId(callback) {
if (callback) {
this.getProjectIdAsync().then((r) => callback(null, r), callback);
} else {
return this.getProjectIdAsync();
}
}
/**
* A temporary method for internal `getProjectId` usages where `null` is
* acceptable. In a future major release, `getProjectId` should return `null`
* (as the `Promise<string | null>` base signature describes) and this private
* method should be removed.
*
* @returns Promise that resolves with project id (or `null`)
*/
async getProjectIdOptional() {
try {
return await this.getProjectId();
} catch (e) {
if (e instanceof Error && e.message === exports.GoogleAuthExceptionMessages.NO_PROJECT_ID_FOUND) {
return null;
} else {
throw e;
}
}
}
/**
* A private method for finding and caching a projectId.
*
* Supports environments in order of precedence:
* - GCLOUD_PROJECT or GOOGLE_CLOUD_PROJECT environment variable
* - GOOGLE_APPLICATION_CREDENTIALS JSON file
* - Cloud SDK: `gcloud config config-helper --format json`
* - GCE project ID from metadata server
*
* @returns projectId
*/
async findAndCacheProjectId() {
let projectId = null;
projectId ||= await this.getProductionProjectId();
projectId ||= await this.getFileProjectId();
projectId ||= await this.getDefaultServiceProjectId();
projectId ||= await this.getGCEProjectId();
projectId ||= await this.getExternalAccountClientProjectId();
if (projectId) {
this._cachedProjectId = projectId;
return projectId;
} else {
throw new Error(exports.GoogleAuthExceptionMessages.NO_PROJECT_ID_FOUND);
}
}
async getProjectIdAsync() {
if (this._cachedProjectId) {
return this._cachedProjectId;
}
if (!this._findProjectIdPromise) {
this._findProjectIdPromise = this.findAndCacheProjectId();
}
return this._findProjectIdPromise;
}
/**
* Retrieves a universe domain from the metadata server via
* {@link gcpMetadata.universe}.
*
* @returns a universe domain
*/
async getUniverseDomainFromMetadataServer() {
let universeDomain;
try {
universeDomain = await gcpMetadata.universe("universe-domain");
universeDomain ||= authclient_1.DEFAULT_UNIVERSE;
} catch (e) {
if (e && e?.response?.status === 404) {
universeDomain = authclient_1.DEFAULT_UNIVERSE;
} else {
throw e;
}
}
return universeDomain;
}
/**
* Retrieves, caches, and returns the universe domain in the following order
* of precedence:
* - The universe domain in {@link GoogleAuth.clientOptions}
* - An existing or ADC {@link AuthClient}'s universe domain
* - {@link gcpMetadata.universe}, if {@link Compute} client
*
* @returns The universe domain
*/
async getUniverseDomain() {
let universeDomain = (0, util_1.originalOrCamelOptions)(this.clientOptions).get("universe_domain");
try {
universeDomain ??= (await this.getClient()).universeDomain;
} catch {
universeDomain ??= authclient_1.DEFAULT_UNIVERSE;
}
return universeDomain;
}
/**
* @returns Any scopes (user-specified or default scopes specified by the
* client library) that need to be set on the current Auth client.
*/
getAnyScopes() {
return this.scopes || this.defaultScopes;
}
getApplicationDefault(optionsOrCallback = {}, callback) {
let options;
if (typeof optionsOrCallback === "function") {
callback = optionsOrCallback;
} else {
options = optionsOrCallback;
}
if (callback) {
this.getApplicationDefaultAsync(options).then((r) => callback(null, r.credential, r.projectId), callback);
} else {
return this.getApplicationDefaultAsync(options);
}
}
async getApplicationDefaultAsync(options = {}) {
if (this.cachedCredential) {
return await this.#prepareAndCacheClient(this.cachedCredential, null);
}
let credential;
credential = await this._tryGetApplicationCredentialsFromEnvironmentVariable(options);
if (credential) {
if (credential instanceof jwtclient_1.JWT) {
credential.scopes = this.scopes;
} else if (credential instanceof baseexternalclient_1.BaseExternalAccountClient) {
credential.scopes = this.getAnyScopes();
}
return await this.#prepareAndCacheClient(credential);
}
credential = await this._tryGetApplicationCredentialsFromWellKnownFile(options);
if (credential) {
if (credential instanceof jwtclient_1.JWT) {
credential.scopes = this.scopes;
} else if (credential instanceof baseexternalclient_1.BaseExternalAccountClient) {
credential.scopes = this.getAnyScopes();
}
return await this.#prepareAndCacheClient(credential);
}
if (await this._checkIsGCE()) {
options.scopes = this.getAnyScopes();
return await this.#prepareAndCacheClient(new computeclient_1.Compute(options));
}
throw new Error(exports.GoogleAuthExceptionMessages.NO_ADC_FOUND);
}
async #prepareAndCacheClient(credential, quotaProjectIdOverride = process.env["GOOGLE_CLOUD_QUOTA_PROJECT"] || null) {
const projectId = await this.getProjectIdOptional();
if (quotaProjectIdOverride) {
credential.quotaProjectId = quotaProjectIdOverride;
}
this.cachedCredential = credential;
return { credential, projectId };
}
/**
* Determines whether the auth layer is running on Google Compute Engine.
* Checks for GCP Residency, then fallback to checking if metadata server
* is available.
*
* @returns A promise that resolves with the boolean.
* @api private
*/
async _checkIsGCE() {
if (this.checkIsGCE === void 0) {
this.checkIsGCE = gcpMetadata.getGCPResidency() || await gcpMetadata.isAvailable();
}
return this.checkIsGCE;
}
/**
* Attempts to load default credentials from the environment variable path..
* @returns Promise that resolves with the OAuth2Client or null.
* @api private
*/
async _tryGetApplicationCredentialsFromEnvironmentVariable(options) {
const credentialsPath = process.env["GOOGLE_APPLICATION_CREDENTIALS"] || process.env["google_application_credentials"];
if (!credentialsPath || credentialsPath.length === 0) {
return null;
}
try {
return this._getApplicationCredentialsFromFilePath(credentialsPath, options);
} catch (e) {
if (e instanceof Error) {
e.message = `Unable to read the credential file specified by the GOOGLE_APPLICATION_CREDENTIALS environment variable: ${e.message}`;
}
throw e;
}
}
/**
* Attempts to load default credentials from a well-known file location
* @return Promise that resolves with the OAuth2Client or null.
* @api private
*/
async _tryGetApplicationCredentialsFromWellKnownFile(options) {
let location = null;
if (this._isWindows()) {
location = process.env["APPDATA"];
} else {
const home = process.env["HOME"];
if (home) {
location = path10.join(home, ".config");
}
}
if (location) {
location = path10.join(location, "gcloud", "application_default_credentials.json");
if (!fs11.existsSync(location)) {
location = null;
}
}
if (!location) {
return null;
}
const client = await this._getApplicationCredentialsFromFilePath(location, options);
return client;
}
/**
* Attempts to load default credentials from a file at the given path..
* @param filePath The path to the file to read.
* @returns Promise that resolves with the OAuth2Client
* @api private
*/
async _getApplicationCredentialsFromFilePath(filePath, options = {}) {
if (!filePath || filePath.length === 0) {
throw new Error("The file path is invalid.");
}
try {
filePath = fs11.realpathSync(filePath);
if (!fs11.lstatSync(filePath).isFile()) {
throw new Error();
}
} catch (err) {
if (err instanceof Error) {
err.message = `The file at ${filePath} does not exist, or it is not a file. ${err.message}`;
}
throw err;
}
const readStream = fs11.createReadStream(filePath);
return this.fromStream(readStream, options);
}
/**
* Create a credentials instance using a given impersonated input options.
* @param json The impersonated input object.
* @returns JWT or UserRefresh Client with data
*/
fromImpersonatedJSON(json) {
if (!json) {
throw new Error("Must pass in a JSON object containing an impersonated refresh token");
}
if (json.type !== impersonated_1.IMPERSONATED_ACCOUNT_TYPE) {
throw new Error(`The incoming JSON object does not have the "${impersonated_1.IMPERSONATED_ACCOUNT_TYPE}" type`);
}
if (!json.source_credentials) {
throw new Error("The incoming JSON object does not contain a source_credentials field");
}
if (!json.service_account_impersonation_url) {
throw new Error("The incoming JSON object does not contain a service_account_impersonation_url field");
}
const sourceClient = this.fromJSON(json.source_credentials);
if (json.service_account_impersonation_url?.length > 256) {
throw new RangeError(`Target principal is too long: ${json.service_account_impersonation_url}`);
}
const targetPrincipal = /(?<target>[^/]+):(generateAccessToken|generateIdToken)$/.exec(json.service_account_impersonation_url)?.groups?.target;
if (!targetPrincipal) {
throw new RangeError(`Cannot extract target principal from ${json.service_account_impersonation_url}`);
}
const targetScopes = (this.scopes || json.scopes || this.defaultScopes) ?? [];
return new impersonated_1.Impersonated({
...json,
sourceClient,
targetPrincipal,
targetScopes: Array.isArray(targetScopes) ? targetScopes : [targetScopes]
});
}
/**
* Create a credentials instance using the given input options.
* This client is not cached.
*
* **Important**: If you accept a credential configuration (credential JSON/File/Stream) from an external source for authentication to Google Cloud, you must validate it before providing it to any Google API or library. Providing an unvalidated credential configuration to Google APIs can compromise the security of your systems and data. For more information, refer to {@link https://cloud.google.com/docs/authentication/external/externally-sourced-credentials Validate credential configurations from external sources}.
*
* @deprecated This method is being deprecated because of a potential security risk.
*
* This method does not validate the credential configuration. The security
* risk occurs when a credential configuration is accepted from a source that
* is not under your control and used without validation on your side.
*
* If you know that you will be loading credential configurations of a
* specific type, it is recommended to use a credential-type-specific
* constructor. This will ensure that an unexpected credential type with
* potential for malicious intent is not loaded unintentionally. You might
* still have to do validation for certain credential types. Please follow
* the recommendation for that method. For example, if you want to load only
* service accounts, you can use the `JWT` constructor:
* ```
* const {JWT} = require('google-auth-library');
* const keys = require('/path/to/key.json');
* const client = new JWT({
* email: keys.client_email,
* key: keys.private_key,
* scopes: ['https://www.googleapis.com/auth/cloud-platform'],
* });
* ```
*
* If you are loading your credential configuration from an untrusted source and have
* not mitigated the risks (e.g. by validating the configuration yourself), make
* these changes as soon as possible to prevent security risks to your environment.
*
* Regardless of the method used, it is always your responsibility to validate
* configurations received from external sources.
*
* For more details, see https://cloud.google.com/docs/authentication/external/externally-sourced-credentials.
*
* @param json The input object.
* @param options The JWT or UserRefresh options for the client
* @returns JWT or UserRefresh Client with data
*/
fromJSON(json, options = {}) {
let client;
const preferredUniverseDomain = (0, util_1.originalOrCamelOptions)(options).get("universe_domain");
if (json.type === refreshclient_1.USER_REFRESH_ACCOUNT_TYPE) {
client = new refreshclient_1.UserRefreshClient(options);
client.fromJSON(json);
} else if (json.type === impersonated_1.IMPERSONATED_ACCOUNT_TYPE) {
client = this.fromImpersonatedJSON(json);
} else if (json.type === baseexternalclient_1.EXTERNAL_ACCOUNT_TYPE) {
client = externalclient_1.ExternalAccountClient.fromJSON({
...json,
...options
});
client.scopes = this.getAnyScopes();
} else if (json.type === externalAccountAuthorizedUserClient_1.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE) {
client = new externalAccountAuthorizedUserClient_1.ExternalAccountAuthorizedUserClient({
...json,
...options
});
} else {
options.scopes = this.scopes;
client = new jwtclient_1.JWT(options);
this.setGapicJWTValues(client);
client.fromJSON(json);
}
if (preferredUniverseDomain) {
client.universeDomain = preferredUniverseDomain;
}
return client;
}
/**
* Return a JWT or UserRefreshClient from JavaScript object, caching both the
* object used to instantiate and the client.
* @param json The input object.
* @param options The JWT or UserRefresh options for the client
* @returns JWT or UserRefresh Client with data
*/
_cacheClientFromJSON(json, options) {
const client = this.fromJSON(json, options);
this.jsonContent = json;
this.cachedCredential = client;
return client;
}
fromStream(inputStream, optionsOrCallback = {}, callback) {
let options = {};
if (typeof optionsOrCallback === "function") {
callback = optionsOrCallback;
} else {
options = optionsOrCallback;
}
if (callback) {
this.fromStreamAsync(inputStream, options).then((r) => callback(null, r), callback);
} else {
return this.fromStreamAsync(inputStream, options);
}
}
fromStreamAsync(inputStream, options) {
return new Promise((resolve5, reject) => {
if (!inputStream) {
throw new Error("Must pass in a stream containing the Google auth settings.");
}
const chunks = [];
inputStream.setEncoding("utf8").on("error", reject).on("data", (chunk) => chunks.push(chunk)).on("end", () => {
try {
try {
const data = JSON.parse(chunks.join(""));
const r = this._cacheClientFromJSON(data, options);
return resolve5(r);
} catch (err) {
if (!this.keyFilename)
throw err;
const client = new jwtclient_1.JWT({
...this.clientOptions,
keyFile: this.keyFilename
});
this.cachedCredential = client;
this.setGapicJWTValues(client);
return resolve5(client);
}
} catch (err) {
return reject(err);
}
});
});
}
/**
* Create a credentials instance using the given API key string.
* The created client is not cached. In order to create and cache it use the {@link GoogleAuth.getClient `getClient`} method after first providing an {@link GoogleAuth.apiKey `apiKey`}.
*
* @param apiKey The API key string
* @param options An optional options object.
* @returns A JWT loaded from the key
*/
fromAPIKey(apiKey, options = {}) {
return new jwtclient_1.JWT({ ...options, apiKey });
}
/**
* Determines whether the current operating system is Windows.
* @api private
*/
_isWindows() {
const sys = os5.platform();
if (sys && sys.length >= 3) {
if (sys.substring(0, 3).toLowerCase() === "win") {
return true;
}
}
return false;
}
/**
* Run the Google Cloud SDK command that prints the default project ID
*/
async getDefaultServiceProjectId() {
return new Promise((resolve5) => {
(0, child_process_1.exec)("gcloud config config-helper --format json", (err, stdout) => {
if (!err && stdout) {
try {
const projectId = JSON.parse(stdout).configuration.properties.core.project;
resolve5(projectId);
return;
} catch (e) {
}
}
resolve5(null);
});
});
}
/**
* Loads the project id from environment variables.
* @api private
*/
getProductionProjectId() {
return process.env["GCLOUD_PROJECT"] || process.env["GOOGLE_CLOUD_PROJECT"] || process.env["gcloud_project"] || process.env["google_cloud_project"];
}
/**
* Loads the project id from the GOOGLE_APPLICATION_CREDENTIALS json file.
* @api private
*/
async getFileProjectId() {
if (this.cachedCredential) {
return this.cachedCredential.projectId;
}
if (this.keyFilename) {
const creds = await this.getClient();
if (creds && creds.projectId) {
return creds.projectId;
}
}
const r = await this._tryGetApplicationCredentialsFromEnvironmentVariable();
if (r) {
return r.projectId;
} else {
return null;
}
}
/**
* Gets the project ID from external account client if available.
*/
async getExternalAccountClientProjectId() {
if (!this.jsonContent || this.jsonContent.type !== baseexternalclient_1.EXTERNAL_ACCOUNT_TYPE) {
return null;
}
const creds = await this.getClient();
return await creds.getProjectId();
}
/**
* Gets the Compute Engine project ID if it can be inferred.
*/
async getGCEProjectId() {
try {
const r = await gcpMetadata.project("project-id");
return r;
} catch (e) {
return null;
}
}
getCredentials(callback) {
if (callback) {
this.getCredentialsAsync().then((r) => callback(null, r), callback);
} else {
return this.getCredentialsAsync();
}
}
async getCredentialsAsync() {
const client = await this.getClient();
if (client instanceof impersonated_1.Impersonated) {
return { client_email: client.getTargetPrincipal() };
}
if (client instanceof baseexternalclient_1.BaseExternalAccountClient) {
const serviceAccountEmail = client.getServiceAccountEmail();
if (serviceAccountEmail) {
return {
client_email: serviceAccountEmail,
universe_domain: client.universeDomain
};
}
}
if (this.jsonContent) {
return {
client_email: this.jsonContent.client_email,
private_key: this.jsonContent.private_key,
universe_domain: this.jsonContent.universe_domain
};
}
if (await this._checkIsGCE()) {
const [client_email, universe_domain] = await Promise.all([
gcpMetadata.instance("service-accounts/default/email"),
this.getUniverseDomain()
]);
return { client_email, universe_domain };
}
throw new Error(exports.GoogleAuthExceptionMessages.NO_CREDENTIALS_FOUND);
}
/**
* Automatically obtain an {@link AuthClient `AuthClient`} based on the
* provided configuration. If no options were passed, use Application
* Default Credentials.
*/
async getClient() {
if (this.cachedCredential) {
return this.cachedCredential;
}
this.#pendingAuthClient = this.#pendingAuthClient || this.#determineClient();
try {
return await this.#pendingAuthClient;
} finally {
this.#pendingAuthClient = null;
}
}
async #determineClient() {
if (this.jsonContent) {
return this._cacheClientFromJSON(this.jsonContent, this.clientOptions);
} else if (this.keyFilename) {
const filePath = path10.resolve(this.keyFilename);
const stream = fs11.createReadStream(filePath);
return await this.fromStreamAsync(stream, this.clientOptions);
} else if (this.apiKey) {
const client = await this.fromAPIKey(this.apiKey, this.clientOptions);
client.scopes = this.scopes;
const { credential } = await this.#prepareAndCacheClient(client);
return credential;
} else {
const { credential } = await this.getApplicationDefaultAsync(this.clientOptions);
return credential;
}
}
/**
* Creates a client which will fetch an ID token for authorization.
* @param targetAudience the audience for the fetched ID token.
* @returns IdTokenClient for making HTTP calls authenticated with ID tokens.
*/
async getIdTokenClient(targetAudience) {
const client = await this.getClient();
if (!("fetchIdToken" in client)) {
throw new Error("Cannot fetch ID token in this environment, use GCE or set the GOOGLE_APPLICATION_CREDENTIALS environment variable to a service account credentials JSON file.");
}
return new idtokenclient_1.IdTokenClient({ targetAudience, idTokenProvider: client });
}
/**
* Automatically obtain application default credentials, and return
* an access token for making requests.
*/
async getAccessToken() {
const client = await this.getClient();
return (await client.getAccessToken()).token;
}
/**
* Obtain the HTTP headers that will provide authorization for a given
* request.
*/
async getRequestHeaders(url) {
const client = await this.getClient();
return client.getRequestHeaders(url);
}
/**
* Obtain credentials for a request, then attach the appropriate headers to
* the request options.
* @param opts Axios or Request options on which to attach the headers
*/
async authorizeRequest(opts = {}) {
const url = opts.url;
const client = await this.getClient();
const headers = await client.getRequestHeaders(url);
opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers, headers);
return opts;
}
/**
* A {@link fetch `fetch`} compliant API for {@link GoogleAuth}.
*
* @see {@link GoogleAuth.request} for the classic method.
*
* @remarks
*
* This is useful as a drop-in replacement for `fetch` API usage.
*
* @example
*
* ```ts
* const auth = new GoogleAuth();
* const fetchWithAuth: typeof fetch = (...args) => auth.fetch(...args);
* await fetchWithAuth('https://example.com');
* ```
*
* @param args `fetch` API or {@link Gaxios.fetch `Gaxios#fetch`} parameters
* @returns the {@link GaxiosResponse} with Gaxios-added properties
*/
async fetch(...args) {
const client = await this.getClient();
return client.fetch(...args);
}
/**
* Automatically obtain application default credentials, and make an
* HTTP request using the given options.
*
* @see {@link GoogleAuth.fetch} for the modern method.
*
* @param opts Axios request options for the HTTP request.
*/
async request(opts) {
const client = await this.getClient();
return client.request(opts);
}
/**
* Determine the compute environment in which the code is running.
*/
getEnv() {
return (0, envDetect_1.getEnv)();
}
/**
* Sign the given data with the current private key, or go out
* to the IAM API to sign it.
* @param data The data to be signed.
* @param endpoint A custom endpoint to use.
*
* @example
* ```
* sign('data', 'https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/');
* ```
*/
async sign(data, endpoint) {
const client = await this.getClient();
const universe = await this.getUniverseDomain();
endpoint = endpoint || `https://iamcredentials.${universe}/v1/projects/-/serviceAccounts/`;
if (client instanceof impersonated_1.Impersonated) {
const signed = await client.sign(data);
return signed.signedBlob;
}
const crypto4 = (0, crypto_1.createCrypto)();
if (client instanceof jwtclient_1.JWT && client.key) {
const sign = await crypto4.sign(client.key, data);
return sign;
}
const creds = await this.getCredentials();
if (!creds.client_email) {
throw new Error("Cannot sign data without `client_email`.");
}
return this.signBlob(crypto4, creds.client_email, data, endpoint);
}
async signBlob(crypto4, emailOrUniqueId, data, endpoint) {
const url = new URL(endpoint + `${emailOrUniqueId}:signBlob`);
const res = await this.request({
method: "POST",
url: url.href,
data: {
payload: crypto4.encodeBase64StringUtf8(data)
},
retry: true,
retryConfig: {
httpMethodsToRetry: ["POST"]
}
});
return res.data.signedBlob;
}
};
exports.GoogleAuth = GoogleAuth2;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/iam.js
var require_iam = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/iam.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.IAMAuth = void 0;
var IAMAuth = class {
selector;
token;
/**
* IAM credentials.
*
* @param selector the iam authority selector
* @param token the token
* @constructor
*/
constructor(selector, token) {
this.selector = selector;
this.token = token;
this.selector = selector;
this.token = token;
}
/**
* Acquire the HTTP headers required to make an authenticated request.
*/
getRequestHeaders() {
return {
"x-goog-iam-authority-selector": this.selector,
"x-goog-iam-authorization-token": this.token
};
}
};
exports.IAMAuth = IAMAuth;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/downscopedclient.js
var require_downscopedclient = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/downscopedclient.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DownscopedClient = exports.EXPIRATION_TIME_OFFSET = exports.MAX_ACCESS_BOUNDARY_RULES_COUNT = void 0;
var gaxios_1 = require_src();
var stream = __require("stream");
var authclient_1 = require_authclient();
var sts = require_stscredentials();
var STS_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:token-exchange";
var STS_REQUEST_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:access_token";
var STS_SUBJECT_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:access_token";
exports.MAX_ACCESS_BOUNDARY_RULES_COUNT = 10;
exports.EXPIRATION_TIME_OFFSET = 5 * 60 * 1e3;
var DownscopedClient = class extends authclient_1.AuthClient {
authClient;
credentialAccessBoundary;
cachedDownscopedAccessToken;
stsCredential;
/**
* Instantiates a downscoped client object using the provided source
* AuthClient and credential access boundary rules.
* To downscope permissions of a source AuthClient, a Credential Access
* Boundary that specifies which resources the new credential can access, as
* well as an upper bound on the permissions that are available on each
* resource, has to be defined. A downscoped client can then be instantiated
* using the source AuthClient and the Credential Access Boundary.
* @param options the {@link DownscopedClientOptions `DownscopedClientOptions`} to use. Passing an `AuthClient` directly is **@DEPRECATED**.
* @param credentialAccessBoundary **@DEPRECATED**. Provide a {@link DownscopedClientOptions `DownscopedClientOptions`} object in the first parameter instead.
*/
constructor(options, credentialAccessBoundary = {
accessBoundary: {
accessBoundaryRules: []
}
}) {
super(options instanceof authclient_1.AuthClient ? {} : options);
if (options instanceof authclient_1.AuthClient) {
this.authClient = options;
this.credentialAccessBoundary = credentialAccessBoundary;
} else {
this.authClient = options.authClient;
this.credentialAccessBoundary = options.credentialAccessBoundary;
}
if (this.credentialAccessBoundary.accessBoundary.accessBoundaryRules.length === 0) {
throw new Error("At least one access boundary rule needs to be defined.");
} else if (this.credentialAccessBoundary.accessBoundary.accessBoundaryRules.length > exports.MAX_ACCESS_BOUNDARY_RULES_COUNT) {
throw new Error(`The provided access boundary has more than ${exports.MAX_ACCESS_BOUNDARY_RULES_COUNT} access boundary rules.`);
}
for (const rule of this.credentialAccessBoundary.accessBoundary.accessBoundaryRules) {
if (rule.availablePermissions.length === 0) {
throw new Error("At least one permission should be defined in access boundary rules.");
}
}
this.stsCredential = new sts.StsCredentials({
tokenExchangeEndpoint: `https://sts.${this.universeDomain}/v1/token`
});
this.cachedDownscopedAccessToken = null;
}
/**
* Provides a mechanism to inject Downscoped access tokens directly.
* The expiry_date field is required to facilitate determination of the token
* expiration which would make it easier for the token consumer to handle.
* @param credentials The Credentials object to set on the current client.
*/
setCredentials(credentials) {
if (!credentials.expiry_date) {
throw new Error("The access token expiry_date field is missing in the provided credentials.");
}
super.setCredentials(credentials);
this.cachedDownscopedAccessToken = credentials;
}
async getAccessToken() {
if (!this.cachedDownscopedAccessToken || this.isExpired(this.cachedDownscopedAccessToken)) {
await this.refreshAccessTokenAsync();
}
return {
token: this.cachedDownscopedAccessToken.access_token,
expirationTime: this.cachedDownscopedAccessToken.expiry_date,
res: this.cachedDownscopedAccessToken.res
};
}
/**
* The main authentication interface. It takes an optional url which when
* present is the endpoint being accessed, and returns a Promise which
* resolves with authorization header fields.
*
* The result has the form:
* { authorization: 'Bearer <access_token_value>' }
*/
async getRequestHeaders() {
const accessTokenResponse = await this.getAccessToken();
const headers = new Headers({
authorization: `Bearer ${accessTokenResponse.token}`
});
return this.addSharedMetadataHeaders(headers);
}
request(opts, callback) {
if (callback) {
this.requestAsync(opts).then((r) => callback(null, r), (e) => {
return callback(e, e.response);
});
} else {
return this.requestAsync(opts);
}
}
/**
* Authenticates the provided HTTP request, processes it and resolves with the
* returned response.
* @param opts The HTTP request options.
* @param reAuthRetried Whether the current attempt is a retry after a failed attempt due to an auth failure
* @return A promise that resolves with the successful response.
*/
async requestAsync(opts, reAuthRetried = false) {
let response;
try {
const requestHeaders = await this.getRequestHeaders();
opts.headers = gaxios_1.Gaxios.mergeHeaders(opts.headers);
this.addUserProjectAndAuthHeaders(opts.headers, requestHeaders);
response = await this.transporter.request(opts);
} catch (e) {
const res = e.response;
if (res) {
const statusCode = res.status;
const isReadableStream = res.config.data instanceof stream.Readable;
const isAuthErr = statusCode === 401 || statusCode === 403;
if (!reAuthRetried && isAuthErr && !isReadableStream && this.forceRefreshOnFailure) {
await this.refreshAccessTokenAsync();
return await this.requestAsync(opts, true);
}
}
throw e;
}
return response;
}
/**
* Forces token refresh, even if unexpired tokens are currently cached.
* GCP access tokens are retrieved from authclient object/source credential.
* Then GCP access tokens are exchanged for downscoped access tokens via the
* token exchange endpoint.
* @return A promise that resolves with the fresh downscoped access token.
*/
async refreshAccessTokenAsync() {
const subjectToken = (await this.authClient.getAccessToken()).token;
const stsCredentialsOptions = {
grantType: STS_GRANT_TYPE,
requestedTokenType: STS_REQUEST_TOKEN_TYPE,
subjectToken,
subjectTokenType: STS_SUBJECT_TOKEN_TYPE
};
const stsResponse = await this.stsCredential.exchangeToken(stsCredentialsOptions, void 0, this.credentialAccessBoundary);
const sourceCredExpireDate = this.authClient.credentials?.expiry_date || null;
const expiryDate = stsResponse.expires_in ? (/* @__PURE__ */ new Date()).getTime() + stsResponse.expires_in * 1e3 : sourceCredExpireDate;
this.cachedDownscopedAccessToken = {
access_token: stsResponse.access_token,
expiry_date: expiryDate,
res: stsResponse.res
};
this.credentials = {};
Object.assign(this.credentials, this.cachedDownscopedAccessToken);
delete this.credentials.res;
this.emit("tokens", {
refresh_token: null,
expiry_date: this.cachedDownscopedAccessToken.expiry_date,
access_token: this.cachedDownscopedAccessToken.access_token,
token_type: "Bearer",
id_token: null
});
return this.cachedDownscopedAccessToken;
}
/**
* Returns whether the provided credentials are expired or not.
* If there is no expiry time, assumes the token is not expired or expiring.
* @param downscopedAccessToken The credentials to check for expiration.
* @return Whether the credentials are expired or not.
*/
isExpired(downscopedAccessToken) {
const now = (/* @__PURE__ */ new Date()).getTime();
return downscopedAccessToken.expiry_date ? now >= downscopedAccessToken.expiry_date - this.eagerRefreshThresholdMillis : false;
}
};
exports.DownscopedClient = DownscopedClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/passthrough.js
var require_passthrough = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/auth/passthrough.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PassThroughClient = void 0;
var authclient_1 = require_authclient();
var PassThroughClient = class extends authclient_1.AuthClient {
/**
* Creates a request without any authentication headers or checks.
*
* @remarks
*
* In testing environments it may be useful to change the provided
* {@link AuthClient.transporter} for any desired request overrides/handling.
*
* @param opts
* @returns The response of the request.
*/
async request(opts) {
return this.transporter.request(opts);
}
/**
* A required method of the base class.
* Always will return an empty object.
*
* @returns {}
*/
async getAccessToken() {
return {};
}
/**
* A required method of the base class.
* Always will return an empty object.
*
* @returns {}
*/
async getRequestHeaders() {
return new Headers();
}
};
exports.PassThroughClient = PassThroughClient;
}
});
// node_modules/@google/genai/node_modules/google-auth-library/build/src/index.js
var require_src5 = __commonJS({
"node_modules/@google/genai/node_modules/google-auth-library/build/src/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GoogleAuth = exports.auth = exports.PassThroughClient = exports.ExternalAccountAuthorizedUserClient = exports.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE = exports.ExecutableError = exports.PluggableAuthClient = exports.DownscopedClient = exports.BaseExternalAccountClient = exports.ExternalAccountClient = exports.IdentityPoolClient = exports.AwsRequestSigner = exports.AwsClient = exports.UserRefreshClient = exports.LoginTicket = exports.ClientAuthentication = exports.OAuth2Client = exports.CodeChallengeMethod = exports.Impersonated = exports.JWT = exports.JWTAccess = exports.IdTokenClient = exports.IAMAuth = exports.GCPEnv = exports.Compute = exports.DEFAULT_UNIVERSE = exports.AuthClient = exports.gaxios = exports.gcpMetadata = void 0;
var googleauth_1 = require_googleauth();
Object.defineProperty(exports, "GoogleAuth", { enumerable: true, get: function() {
return googleauth_1.GoogleAuth;
} });
exports.gcpMetadata = require_src3();
exports.gaxios = require_src();
var authclient_1 = require_authclient();
Object.defineProperty(exports, "AuthClient", { enumerable: true, get: function() {
return authclient_1.AuthClient;
} });
Object.defineProperty(exports, "DEFAULT_UNIVERSE", { enumerable: true, get: function() {
return authclient_1.DEFAULT_UNIVERSE;
} });
var computeclient_1 = require_computeclient();
Object.defineProperty(exports, "Compute", { enumerable: true, get: function() {
return computeclient_1.Compute;
} });
var envDetect_1 = require_envDetect();
Object.defineProperty(exports, "GCPEnv", { enumerable: true, get: function() {
return envDetect_1.GCPEnv;
} });
var iam_1 = require_iam();
Object.defineProperty(exports, "IAMAuth", { enumerable: true, get: function() {
return iam_1.IAMAuth;
} });
var idtokenclient_1 = require_idtokenclient();
Object.defineProperty(exports, "IdTokenClient", { enumerable: true, get: function() {
return idtokenclient_1.IdTokenClient;
} });
var jwtaccess_1 = require_jwtaccess();
Object.defineProperty(exports, "JWTAccess", { enumerable: true, get: function() {
return jwtaccess_1.JWTAccess;
} });
var jwtclient_1 = require_jwtclient();
Object.defineProperty(exports, "JWT", { enumerable: true, get: function() {
return jwtclient_1.JWT;
} });
var impersonated_1 = require_impersonated();
Object.defineProperty(exports, "Impersonated", { enumerable: true, get: function() {
return impersonated_1.Impersonated;
} });
var oauth2client_1 = require_oauth2client();
Object.defineProperty(exports, "CodeChallengeMethod", { enumerable: true, get: function() {
return oauth2client_1.CodeChallengeMethod;
} });
Object.defineProperty(exports, "OAuth2Client", { enumerable: true, get: function() {
return oauth2client_1.OAuth2Client;
} });
Object.defineProperty(exports, "ClientAuthentication", { enumerable: true, get: function() {
return oauth2client_1.ClientAuthentication;
} });
var loginticket_1 = require_loginticket();
Object.defineProperty(exports, "LoginTicket", { enumerable: true, get: function() {
return loginticket_1.LoginTicket;
} });
var refreshclient_1 = require_refreshclient();
Object.defineProperty(exports, "UserRefreshClient", { enumerable: true, get: function() {
return refreshclient_1.UserRefreshClient;
} });
var awsclient_1 = require_awsclient();
Object.defineProperty(exports, "AwsClient", { enumerable: true, get: function() {
return awsclient_1.AwsClient;
} });
var awsrequestsigner_1 = require_awsrequestsigner();
Object.defineProperty(exports, "AwsRequestSigner", { enumerable: true, get: function() {
return awsrequestsigner_1.AwsRequestSigner;
} });
var identitypoolclient_1 = require_identitypoolclient();
Object.defineProperty(exports, "IdentityPoolClient", { enumerable: true, get: function() {
return identitypoolclient_1.IdentityPoolClient;
} });
var externalclient_1 = require_externalclient();
Object.defineProperty(exports, "ExternalAccountClient", { enumerable: true, get: function() {
return externalclient_1.ExternalAccountClient;
} });
var baseexternalclient_1 = require_baseexternalclient();
Object.defineProperty(exports, "BaseExternalAccountClient", { enumerable: true, get: function() {
return baseexternalclient_1.BaseExternalAccountClient;
} });
var downscopedclient_1 = require_downscopedclient();
Object.defineProperty(exports, "DownscopedClient", { enumerable: true, get: function() {
return downscopedclient_1.DownscopedClient;
} });
var pluggable_auth_client_1 = require_pluggable_auth_client();
Object.defineProperty(exports, "PluggableAuthClient", { enumerable: true, get: function() {
return pluggable_auth_client_1.PluggableAuthClient;
} });
Object.defineProperty(exports, "ExecutableError", { enumerable: true, get: function() {
return pluggable_auth_client_1.ExecutableError;
} });
var externalAccountAuthorizedUserClient_1 = require_externalAccountAuthorizedUserClient();
Object.defineProperty(exports, "EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE", { enumerable: true, get: function() {
return externalAccountAuthorizedUserClient_1.EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE;
} });
Object.defineProperty(exports, "ExternalAccountAuthorizedUserClient", { enumerable: true, get: function() {
return externalAccountAuthorizedUserClient_1.ExternalAccountAuthorizedUserClient;
} });
var passthrough_1 = require_passthrough();
Object.defineProperty(exports, "PassThroughClient", { enumerable: true, get: function() {
return passthrough_1.PassThroughClient;
} });
var auth = new googleauth_1.GoogleAuth();
exports.auth = auth;
}
});
// node_modules/graceful-fs/polyfills.js
var require_polyfills = __commonJS({
"node_modules/graceful-fs/polyfills.js"(exports, module) {
var constants2 = __require("constants");
var origCwd = process.cwd;
var cwd = null;
var platform4 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
process.cwd = function() {
if (!cwd)
cwd = origCwd.call(process);
return cwd;
};
try {
process.cwd();
} catch (er) {
}
if (typeof process.chdir === "function") {
chdir = process.chdir;
process.chdir = function(d) {
cwd = null;
chdir.call(process, d);
};
if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
}
var chdir;
module.exports = patch;
function patch(fs11) {
if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
patchLchmod(fs11);
}
if (!fs11.lutimes) {
patchLutimes(fs11);
}
fs11.chown = chownFix(fs11.chown);
fs11.fchown = chownFix(fs11.fchown);
fs11.lchown = chownFix(fs11.lchown);
fs11.chmod = chmodFix(fs11.chmod);
fs11.fchmod = chmodFix(fs11.fchmod);
fs11.lchmod = chmodFix(fs11.lchmod);
fs11.chownSync = chownFixSync(fs11.chownSync);
fs11.fchownSync = chownFixSync(fs11.fchownSync);
fs11.lchownSync = chownFixSync(fs11.lchownSync);
fs11.chmodSync = chmodFixSync(fs11.chmodSync);
fs11.fchmodSync = chmodFixSync(fs11.fchmodSync);
fs11.lchmodSync = chmodFixSync(fs11.lchmodSync);
fs11.stat = statFix(fs11.stat);
fs11.fstat = statFix(fs11.fstat);
fs11.lstat = statFix(fs11.lstat);
fs11.statSync = statFixSync(fs11.statSync);
fs11.fstatSync = statFixSync(fs11.fstatSync);
fs11.lstatSync = statFixSync(fs11.lstatSync);
if (fs11.chmod && !fs11.lchmod) {
fs11.lchmod = function(path10, mode, cb) {
if (cb) process.nextTick(cb);
};
fs11.lchmodSync = function() {
};
}
if (fs11.chown && !fs11.lchown) {
fs11.lchown = function(path10, uid, gid, cb) {
if (cb) process.nextTick(cb);
};
fs11.lchownSync = function() {
};
}
if (platform4 === "win32") {
fs11.rename = typeof fs11.rename !== "function" ? fs11.rename : function(fs$rename) {
function rename(from, to, cb) {
var start = Date.now();
var backoff = 0;
fs$rename(from, to, function CB(er) {
if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
setTimeout(function() {
fs11.stat(to, function(stater, st) {
if (stater && stater.code === "ENOENT")
fs$rename(from, to, CB);
else
cb(er);
});
}, backoff);
if (backoff < 100)
backoff += 10;
return;
}
if (cb) cb(er);
});
}
if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
return rename;
}(fs11.rename);
}
fs11.read = typeof fs11.read !== "function" ? fs11.read : function(fs$read) {
function read(fd, buffer, offset, length, position, callback_) {
var callback;
if (callback_ && typeof callback_ === "function") {
var eagCounter = 0;
callback = function(er, _, __) {
if (er && er.code === "EAGAIN" && eagCounter < 10) {
eagCounter++;
return fs$read.call(fs11, fd, buffer, offset, length, position, callback);
}
callback_.apply(this, arguments);
};
}
return fs$read.call(fs11, fd, buffer, offset, length, position, callback);
}
if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
return read;
}(fs11.read);
fs11.readSync = typeof fs11.readSync !== "function" ? fs11.readSync : /* @__PURE__ */ function(fs$readSync) {
return function(fd, buffer, offset, length, position) {
var eagCounter = 0;
while (true) {
try {
return fs$readSync.call(fs11, fd, buffer, offset, length, position);
} catch (er) {
if (er.code === "EAGAIN" && eagCounter < 10) {
eagCounter++;
continue;
}
throw er;
}
}
};
}(fs11.readSync);
function patchLchmod(fs12) {
fs12.lchmod = function(path10, mode, callback) {
fs12.open(
path10,
constants2.O_WRONLY | constants2.O_SYMLINK,
mode,
function(err, fd) {
if (err) {
if (callback) callback(err);
return;
}
fs12.fchmod(fd, mode, function(err2) {
fs12.close(fd, function(err22) {
if (callback) callback(err2 || err22);
});
});
}
);
};
fs12.lchmodSync = function(path10, mode) {
var fd = fs12.openSync(path10, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
var threw = true;
var ret;
try {
ret = fs12.fchmodSync(fd, mode);
threw = false;
} finally {
if (threw) {
try {
fs12.closeSync(fd);
} catch (er) {
}
} else {
fs12.closeSync(fd);
}
}
return ret;
};
}
function patchLutimes(fs12) {
if (constants2.hasOwnProperty("O_SYMLINK") && fs12.futimes) {
fs12.lutimes = function(path10, at, mt, cb) {
fs12.open(path10, constants2.O_SYMLINK, function(er, fd) {
if (er) {
if (cb) cb(er);
return;
}
fs12.futimes(fd, at, mt, function(er2) {
fs12.close(fd, function(er22) {
if (cb) cb(er2 || er22);
});
});
});
};
fs12.lutimesSync = function(path10, at, mt) {
var fd = fs12.openSync(path10, constants2.O_SYMLINK);
var ret;
var threw = true;
try {
ret = fs12.futimesSync(fd, at, mt);
threw = false;
} finally {
if (threw) {
try {
fs12.closeSync(fd);
} catch (er) {
}
} else {
fs12.closeSync(fd);
}
}
return ret;
};
} else if (fs12.futimes) {
fs12.lutimes = function(_a, _b, _c, cb) {
if (cb) process.nextTick(cb);
};
fs12.lutimesSync = function() {
};
}
}
function chmodFix(orig) {
if (!orig) return orig;
return function(target, mode, cb) {
return orig.call(fs11, target, mode, function(er) {
if (chownErOk(er)) er = null;
if (cb) cb.apply(this, arguments);
});
};
}
function chmodFixSync(orig) {
if (!orig) return orig;
return function(target, mode) {
try {
return orig.call(fs11, target, mode);
} catch (er) {
if (!chownErOk(er)) throw er;
}
};
}
function chownFix(orig) {
if (!orig) return orig;
return function(target, uid, gid, cb) {
return orig.call(fs11, target, uid, gid, function(er) {
if (chownErOk(er)) er = null;
if (cb) cb.apply(this, arguments);
});
};
}
function chownFixSync(orig) {
if (!orig) return orig;
return function(target, uid, gid) {
try {
return orig.call(fs11, target, uid, gid);
} catch (er) {
if (!chownErOk(er)) throw er;
}
};
}
function statFix(orig) {
if (!orig) return orig;
return function(target, options, cb) {
if (typeof options === "function") {
cb = options;
options = null;
}
function callback(er, stats) {
if (stats) {
if (stats.uid < 0) stats.uid += 4294967296;
if (stats.gid < 0) stats.gid += 4294967296;
}
if (cb) cb.apply(this, arguments);
}
return options ? orig.call(fs11, target, options, callback) : orig.call(fs11, target, callback);
};
}
function statFixSync(orig) {
if (!orig) return orig;
return function(target, options) {
var stats = options ? orig.call(fs11, target, options) : orig.call(fs11, target);
if (stats) {
if (stats.uid < 0) stats.uid += 4294967296;
if (stats.gid < 0) stats.gid += 4294967296;
}
return stats;
};
}
function chownErOk(er) {
if (!er)
return true;
if (er.code === "ENOSYS")
return true;
var nonroot = !process.getuid || process.getuid() !== 0;
if (nonroot) {
if (er.code === "EINVAL" || er.code === "EPERM")
return true;
}
return false;
}
}
}
});
// node_modules/graceful-fs/legacy-streams.js
var require_legacy_streams = __commonJS({
"node_modules/graceful-fs/legacy-streams.js"(exports, module) {
var Stream = __require("stream").Stream;
module.exports = legacy;
function legacy(fs11) {
return {
ReadStream,
WriteStream
};
function ReadStream(path10, options) {
if (!(this instanceof ReadStream)) return new ReadStream(path10, options);
Stream.call(this);
var self2 = this;
this.path = path10;
this.fd = null;
this.readable = true;
this.paused = false;
this.flags = "r";
this.mode = 438;
this.bufferSize = 64 * 1024;
options = options || {};
var keys = Object.keys(options);
for (var index = 0, length = keys.length; index < length; index++) {
var key = keys[index];
this[key] = options[key];
}
if (this.encoding) this.setEncoding(this.encoding);
if (this.start !== void 0) {
if ("number" !== typeof this.start) {
throw TypeError("start must be a Number");
}
if (this.end === void 0) {
this.end = Infinity;
} else if ("number" !== typeof this.end) {
throw TypeError("end must be a Number");
}
if (this.start > this.end) {
throw new Error("start must be <= end");
}
this.pos = this.start;
}
if (this.fd !== null) {
process.nextTick(function() {
self2._read();
});
return;
}
fs11.open(this.path, this.flags, this.mode, function(err, fd) {
if (err) {
self2.emit("error", err);
self2.readable = false;
return;
}
self2.fd = fd;
self2.emit("open", fd);
self2._read();
});
}
function WriteStream(path10, options) {
if (!(this instanceof WriteStream)) return new WriteStream(path10, options);
Stream.call(this);
this.path = path10;
this.fd = null;
this.writable = true;
this.flags = "w";
this.encoding = "binary";
this.mode = 438;
this.bytesWritten = 0;
options = options || {};
var keys = Object.keys(options);
for (var index = 0, length = keys.length; index < length; index++) {
var key = keys[index];
this[key] = options[key];
}
if (this.start !== void 0) {
if ("number" !== typeof this.start) {
throw TypeError("start must be a Number");
}
if (this.start < 0) {
throw new Error("start must be >= zero");
}
this.pos = this.start;
}
this.busy = false;
this._queue = [];
if (this.fd === null) {
this._open = fs11.open;
this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
this.flush();
}
}
}
}
});
// node_modules/graceful-fs/clone.js
var require_clone = __commonJS({
"node_modules/graceful-fs/clone.js"(exports, module) {
"use strict";
module.exports = clone;
var getPrototypeOf = Object.getPrototypeOf || function(obj) {
return obj.__proto__;
};
function clone(obj) {
if (obj === null || typeof obj !== "object")
return obj;
if (obj instanceof Object)
var copy = { __proto__: getPrototypeOf(obj) };
else
var copy = /* @__PURE__ */ Object.create(null);
Object.getOwnPropertyNames(obj).forEach(function(key) {
Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
});
return copy;
}
}
});
// node_modules/graceful-fs/graceful-fs.js
var require_graceful_fs = __commonJS({
"node_modules/graceful-fs/graceful-fs.js"(exports, module) {
var fs11 = __require("fs");
var polyfills = require_polyfills();
var legacy = require_legacy_streams();
var clone = require_clone();
var util3 = __require("util");
var gracefulQueue;
var previousSymbol;
if (typeof Symbol === "function" && typeof Symbol.for === "function") {
gracefulQueue = Symbol.for("graceful-fs.queue");
previousSymbol = Symbol.for("graceful-fs.previous");
} else {
gracefulQueue = "___graceful-fs.queue";
previousSymbol = "___graceful-fs.previous";
}
function noop() {
}
function publishQueue(context, queue2) {
Object.defineProperty(context, gracefulQueue, {
get: function() {
return queue2;
}
});
}
var debug = noop;
if (util3.debuglog)
debug = util3.debuglog("gfs4");
else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
debug = function() {
var m = util3.format.apply(util3, arguments);
m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
console.error(m);
};
if (!fs11[gracefulQueue]) {
queue = global[gracefulQueue] || [];
publishQueue(fs11, queue);
fs11.close = function(fs$close) {
function close(fd, cb) {
return fs$close.call(fs11, fd, function(err) {
if (!err) {
resetQueue();
}
if (typeof cb === "function")
cb.apply(this, arguments);
});
}
Object.defineProperty(close, previousSymbol, {
value: fs$close
});
return close;
}(fs11.close);
fs11.closeSync = function(fs$closeSync) {
function closeSync(fd) {
fs$closeSync.apply(fs11, arguments);
resetQueue();
}
Object.defineProperty(closeSync, previousSymbol, {
value: fs$closeSync
});
return closeSync;
}(fs11.closeSync);
if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
process.on("exit", function() {
debug(fs11[gracefulQueue]);
__require("assert").equal(fs11[gracefulQueue].length, 0);
});
}
}
var queue;
if (!global[gracefulQueue]) {
publishQueue(global, fs11[gracefulQueue]);
}
module.exports = patch(clone(fs11));
if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs11.__patched) {
module.exports = patch(fs11);
fs11.__patched = true;
}
function patch(fs12) {
polyfills(fs12);
fs12.gracefulify = patch;
fs12.createReadStream = createReadStream;
fs12.createWriteStream = createWriteStream3;
var fs$readFile = fs12.readFile;
fs12.readFile = readFile4;
function readFile4(path10, options, cb) {
if (typeof options === "function")
cb = options, options = null;
return go$readFile(path10, options, cb);
function go$readFile(path11, options2, cb2, startTime) {
return fs$readFile(path11, options2, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$readFile, [path11, options2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$writeFile = fs12.writeFile;
fs12.writeFile = writeFile3;
function writeFile3(path10, data, options, cb) {
if (typeof options === "function")
cb = options, options = null;
return go$writeFile(path10, data, options, cb);
function go$writeFile(path11, data2, options2, cb2, startTime) {
return fs$writeFile(path11, data2, options2, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$writeFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$appendFile = fs12.appendFile;
if (fs$appendFile)
fs12.appendFile = appendFile;
function appendFile(path10, data, options, cb) {
if (typeof options === "function")
cb = options, options = null;
return go$appendFile(path10, data, options, cb);
function go$appendFile(path11, data2, options2, cb2, startTime) {
return fs$appendFile(path11, data2, options2, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$appendFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$copyFile = fs12.copyFile;
if (fs$copyFile)
fs12.copyFile = copyFile;
function copyFile(src, dest, flags, cb) {
if (typeof flags === "function") {
cb = flags;
flags = 0;
}
return go$copyFile(src, dest, flags, cb);
function go$copyFile(src2, dest2, flags2, cb2, startTime) {
return fs$copyFile(src2, dest2, flags2, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$readdir = fs12.readdir;
fs12.readdir = readdir2;
var noReaddirOptionVersions = /^v[0-5]\./;
function readdir2(path10, options, cb) {
if (typeof options === "function")
cb = options, options = null;
var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path11, options2, cb2, startTime) {
return fs$readdir(path11, fs$readdirCallback(
path11,
options2,
cb2,
startTime
));
} : function go$readdir2(path11, options2, cb2, startTime) {
return fs$readdir(path11, options2, fs$readdirCallback(
path11,
options2,
cb2,
startTime
));
};
return go$readdir(path10, options, cb);
function fs$readdirCallback(path11, options2, cb2, startTime) {
return function(err, files) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([
go$readdir,
[path11, options2, cb2],
err,
startTime || Date.now(),
Date.now()
]);
else {
if (files && files.sort)
files.sort();
if (typeof cb2 === "function")
cb2.call(this, err, files);
}
};
}
}
if (process.version.substr(0, 4) === "v0.8") {
var legStreams = legacy(fs12);
ReadStream = legStreams.ReadStream;
WriteStream = legStreams.WriteStream;
}
var fs$ReadStream = fs12.ReadStream;
if (fs$ReadStream) {
ReadStream.prototype = Object.create(fs$ReadStream.prototype);
ReadStream.prototype.open = ReadStream$open;
}
var fs$WriteStream = fs12.WriteStream;
if (fs$WriteStream) {
WriteStream.prototype = Object.create(fs$WriteStream.prototype);
WriteStream.prototype.open = WriteStream$open;
}
Object.defineProperty(fs12, "ReadStream", {
get: function() {
return ReadStream;
},
set: function(val) {
ReadStream = val;
},
enumerable: true,
configurable: true
});
Object.defineProperty(fs12, "WriteStream", {
get: function() {
return WriteStream;
},
set: function(val) {
WriteStream = val;
},
enumerable: true,
configurable: true
});
var FileReadStream = ReadStream;
Object.defineProperty(fs12, "FileReadStream", {
get: function() {
return FileReadStream;
},
set: function(val) {
FileReadStream = val;
},
enumerable: true,
configurable: true
});
var FileWriteStream = WriteStream;
Object.defineProperty(fs12, "FileWriteStream", {
get: function() {
return FileWriteStream;
},
set: function(val) {
FileWriteStream = val;
},
enumerable: true,
configurable: true
});
function ReadStream(path10, options) {
if (this instanceof ReadStream)
return fs$ReadStream.apply(this, arguments), this;
else
return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
}
function ReadStream$open() {
var that = this;
open2(that.path, that.flags, that.mode, function(err, fd) {
if (err) {
if (that.autoClose)
that.destroy();
that.emit("error", err);
} else {
that.fd = fd;
that.emit("open", fd);
that.read();
}
});
}
function WriteStream(path10, options) {
if (this instanceof WriteStream)
return fs$WriteStream.apply(this, arguments), this;
else
return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
}
function WriteStream$open() {
var that = this;
open2(that.path, that.flags, that.mode, function(err, fd) {
if (err) {
that.destroy();
that.emit("error", err);
} else {
that.fd = fd;
that.emit("open", fd);
}
});
}
function createReadStream(path10, options) {
return new fs12.ReadStream(path10, options);
}
function createWriteStream3(path10, options) {
return new fs12.WriteStream(path10, options);
}
var fs$open = fs12.open;
fs12.open = open2;
function open2(path10, flags, mode, cb) {
if (typeof mode === "function")
cb = mode, mode = null;
return go$open(path10, flags, mode, cb);
function go$open(path11, flags2, mode2, cb2, startTime) {
return fs$open(path11, flags2, mode2, function(err, fd) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$open, [path11, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
return fs12;
}
function enqueue(elem) {
debug("ENQUEUE", elem[0].name, elem[1]);
fs11[gracefulQueue].push(elem);
retry();
}
var retryTimer;
function resetQueue() {
var now = Date.now();
for (var i = 0; i < fs11[gracefulQueue].length; ++i) {
if (fs11[gracefulQueue][i].length > 2) {
fs11[gracefulQueue][i][3] = now;
fs11[gracefulQueue][i][4] = now;
}
}
retry();
}
function retry() {
clearTimeout(retryTimer);
retryTimer = void 0;
if (fs11[gracefulQueue].length === 0)
return;
var elem = fs11[gracefulQueue].shift();
var fn = elem[0];
var args = elem[1];
var err = elem[2];
var startTime = elem[3];
var lastTime = elem[4];
if (startTime === void 0) {
debug("RETRY", fn.name, args);
fn.apply(null, args);
} else if (Date.now() - startTime >= 6e4) {
debug("TIMEOUT", fn.name, args);
var cb = args.pop();
if (typeof cb === "function")
cb.call(null, err);
} else {
var sinceAttempt = Date.now() - lastTime;
var sinceStart = Math.max(lastTime - startTime, 1);
var desiredDelay = Math.min(sinceStart * 1.2, 100);
if (sinceAttempt >= desiredDelay) {
debug("RETRY", fn.name, args);
fn.apply(null, args.concat([startTime]));
} else {
fs11[gracefulQueue].push(elem);
}
}
if (retryTimer === void 0) {
retryTimer = setTimeout(retry, 0);
}
}
}
});
// node_modules/proper-lockfile/node_modules/retry/lib/retry_operation.js
var require_retry_operation = __commonJS({
"node_modules/proper-lockfile/node_modules/retry/lib/retry_operation.js"(exports, module) {
function RetryOperation(timeouts, options) {
if (typeof options === "boolean") {
options = { forever: options };
}
this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
this._timeouts = timeouts;
this._options = options || {};
this._maxRetryTime = options && options.maxRetryTime || Infinity;
this._fn = null;
this._errors = [];
this._attempts = 1;
this._operationTimeout = null;
this._operationTimeoutCb = null;
this._timeout = null;
this._operationStart = null;
if (this._options.forever) {
this._cachedTimeouts = this._timeouts.slice(0);
}
}
module.exports = RetryOperation;
RetryOperation.prototype.reset = function() {
this._attempts = 1;
this._timeouts = this._originalTimeouts;
};
RetryOperation.prototype.stop = function() {
if (this._timeout) {
clearTimeout(this._timeout);
}
this._timeouts = [];
this._cachedTimeouts = null;
};
RetryOperation.prototype.retry = function(err) {
if (this._timeout) {
clearTimeout(this._timeout);
}
if (!err) {
return false;
}
var currentTime = (/* @__PURE__ */ new Date()).getTime();
if (err && currentTime - this._operationStart >= this._maxRetryTime) {
this._errors.unshift(new Error("RetryOperation timeout occurred"));
return false;
}
this._errors.push(err);
var timeout = this._timeouts.shift();
if (timeout === void 0) {
if (this._cachedTimeouts) {
this._errors.splice(this._errors.length - 1, this._errors.length);
this._timeouts = this._cachedTimeouts.slice(0);
timeout = this._timeouts.shift();
} else {
return false;
}
}
var self2 = this;
var timer = setTimeout(function() {
self2._attempts++;
if (self2._operationTimeoutCb) {
self2._timeout = setTimeout(function() {
self2._operationTimeoutCb(self2._attempts);
}, self2._operationTimeout);
if (self2._options.unref) {
self2._timeout.unref();
}
}
self2._fn(self2._attempts);
}, timeout);
if (this._options.unref) {
timer.unref();
}
return true;
};
RetryOperation.prototype.attempt = function(fn, timeoutOps) {
this._fn = fn;
if (timeoutOps) {
if (timeoutOps.timeout) {
this._operationTimeout = timeoutOps.timeout;
}
if (timeoutOps.cb) {
this._operationTimeoutCb = timeoutOps.cb;
}
}
var self2 = this;
if (this._operationTimeoutCb) {
this._timeout = setTimeout(function() {
self2._operationTimeoutCb();
}, self2._operationTimeout);
}
this._operationStart = (/* @__PURE__ */ new Date()).getTime();
this._fn(this._attempts);
};
RetryOperation.prototype.try = function(fn) {
console.log("Using RetryOperation.try() is deprecated");
this.attempt(fn);
};
RetryOperation.prototype.start = function(fn) {
console.log("Using RetryOperation.start() is deprecated");
this.attempt(fn);
};
RetryOperation.prototype.start = RetryOperation.prototype.try;
RetryOperation.prototype.errors = function() {
return this._errors;
};
RetryOperation.prototype.attempts = function() {
return this._attempts;
};
RetryOperation.prototype.mainError = function() {
if (this._errors.length === 0) {
return null;
}
var counts = {};
var mainError = null;
var mainErrorCount = 0;
for (var i = 0; i < this._errors.length; i++) {
var error = this._errors[i];
var message = error.message;
var count = (counts[message] || 0) + 1;
counts[message] = count;
if (count >= mainErrorCount) {
mainError = error;
mainErrorCount = count;
}
}
return mainError;
};
}
});
// node_modules/proper-lockfile/node_modules/retry/lib/retry.js
var require_retry2 = __commonJS({
"node_modules/proper-lockfile/node_modules/retry/lib/retry.js"(exports) {
var RetryOperation = require_retry_operation();
exports.operation = function(options) {
var timeouts = exports.timeouts(options);
return new RetryOperation(timeouts, {
forever: options && options.forever,
unref: options && options.unref,
maxRetryTime: options && options.maxRetryTime
});
};
exports.timeouts = function(options) {
if (options instanceof Array) {
return [].concat(options);
}
var opts = {
retries: 10,
factor: 2,
minTimeout: 1 * 1e3,
maxTimeout: Infinity,
randomize: false
};
for (var key in options) {
opts[key] = options[key];
}
if (opts.minTimeout > opts.maxTimeout) {
throw new Error("minTimeout is greater than maxTimeout");
}
var timeouts = [];
for (var i = 0; i < opts.retries; i++) {
timeouts.push(this.createTimeout(i, opts));
}
if (options && options.forever && !timeouts.length) {
timeouts.push(this.createTimeout(i, opts));
}
timeouts.sort(function(a, b) {
return a - b;
});
return timeouts;
};
exports.createTimeout = function(attempt, opts) {
var random = opts.randomize ? Math.random() + 1 : 1;
var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
timeout = Math.min(timeout, opts.maxTimeout);
return timeout;
};
exports.wrap = function(obj, options, methods) {
if (options instanceof Array) {
methods = options;
options = null;
}
if (!methods) {
methods = [];
for (var key in obj) {
if (typeof obj[key] === "function") {
methods.push(key);
}
}
}
for (var i = 0; i < methods.length; i++) {
var method = methods[i];
var original = obj[method];
obj[method] = function retryWrapper(original2) {
var op = exports.operation(options);
var args = Array.prototype.slice.call(arguments, 1);
var callback = args.pop();
args.push(function(err) {
if (op.retry(err)) {
return;
}
if (err) {
arguments[0] = op.mainError();
}
callback.apply(this, arguments);
});
op.attempt(function() {
original2.apply(obj, args);
});
}.bind(obj, original);
obj[method].options = options;
}
};
}
});
// node_modules/proper-lockfile/node_modules/retry/index.js
var require_retry3 = __commonJS({
"node_modules/proper-lockfile/node_modules/retry/index.js"(exports, module) {
module.exports = require_retry2();
}
});
// node_modules/proper-lockfile/node_modules/signal-exit/signals.js
var require_signals = __commonJS({
"node_modules/proper-lockfile/node_modules/signal-exit/signals.js"(exports, module) {
module.exports = [
"SIGABRT",
"SIGALRM",
"SIGHUP",
"SIGINT",
"SIGTERM"
];
if (process.platform !== "win32") {
module.exports.push(
"SIGVTALRM",
"SIGXCPU",
"SIGXFSZ",
"SIGUSR2",
"SIGTRAP",
"SIGSYS",
"SIGQUIT",
"SIGIOT"
// should detect profiler and enable/disable accordingly.
// see #21
// 'SIGPROF'
);
}
if (process.platform === "linux") {
module.exports.push(
"SIGIO",
"SIGPOLL",
"SIGPWR",
"SIGSTKFLT",
"SIGUNUSED"
);
}
}
});
// node_modules/proper-lockfile/node_modules/signal-exit/index.js
var require_signal_exit = __commonJS({
"node_modules/proper-lockfile/node_modules/signal-exit/index.js"(exports, module) {
var process2 = global.process;
var processOk = function(process3) {
return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
};
if (!processOk(process2)) {
module.exports = function() {
return function() {
};
};
} else {
assert = __require("assert");
signals = require_signals();
isWin2 = /^win/i.test(process2.platform);
EE = __require("events");
if (typeof EE !== "function") {
EE = EE.EventEmitter;
}
if (process2.__signal_exit_emitter__) {
emitter = process2.__signal_exit_emitter__;
} else {
emitter = process2.__signal_exit_emitter__ = new EE();
emitter.count = 0;
emitter.emitted = {};
}
if (!emitter.infinite) {
emitter.setMaxListeners(Infinity);
emitter.infinite = true;
}
module.exports = function(cb, opts) {
if (!processOk(global.process)) {
return function() {
};
}
assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
if (loaded === false) {
load();
}
var ev = "exit";
if (opts && opts.alwaysLast) {
ev = "afterexit";
}
var remove = function() {
emitter.removeListener(ev, cb);
if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
unload();
}
};
emitter.on(ev, cb);
return remove;
};
unload = function unload2() {
if (!loaded || !processOk(global.process)) {
return;
}
loaded = false;
signals.forEach(function(sig) {
try {
process2.removeListener(sig, sigListeners[sig]);
} catch (er) {
}
});
process2.emit = originalProcessEmit;
process2.reallyExit = originalProcessReallyExit;
emitter.count -= 1;
};
module.exports.unload = unload;
emit = function emit2(event, code, signal) {
if (emitter.emitted[event]) {
return;
}
emitter.emitted[event] = true;
emitter.emit(event, code, signal);
};
sigListeners = {};
signals.forEach(function(sig) {
sigListeners[sig] = function listener() {
if (!processOk(global.process)) {
return;
}
var listeners = process2.listeners(sig);
if (listeners.length === emitter.count) {
unload();
emit("exit", null, sig);
emit("afterexit", null, sig);
if (isWin2 && sig === "SIGHUP") {
sig = "SIGINT";
}
process2.kill(process2.pid, sig);
}
};
});
module.exports.signals = function() {
return signals;
};
loaded = false;
load = function load2() {
if (loaded || !processOk(global.process)) {
return;
}
loaded = true;
emitter.count += 1;
signals = signals.filter(function(sig) {
try {
process2.on(sig, sigListeners[sig]);
return true;
} catch (er) {
return false;
}
});
process2.emit = processEmit;
process2.reallyExit = processReallyExit;
};
module.exports.load = load;
originalProcessReallyExit = process2.reallyExit;
processReallyExit = function processReallyExit2(code) {
if (!processOk(global.process)) {
return;
}
process2.exitCode = code || /* istanbul ignore next */
0;
emit("exit", process2.exitCode, null);
emit("afterexit", process2.exitCode, null);
originalProcessReallyExit.call(process2, process2.exitCode);
};
originalProcessEmit = process2.emit;
processEmit = function processEmit2(ev, arg) {
if (ev === "exit" && processOk(global.process)) {
if (arg !== void 0) {
process2.exitCode = arg;
}
var ret = originalProcessEmit.apply(this, arguments);
emit("exit", process2.exitCode, null);
emit("afterexit", process2.exitCode, null);
return ret;
} else {
return originalProcessEmit.apply(this, arguments);
}
};
}
var assert;
var signals;
var isWin2;
var EE;
var emitter;
var unload;
var emit;
var sigListeners;
var loaded;
var load;
var originalProcessReallyExit;
var processReallyExit;
var originalProcessEmit;
var processEmit;
}
});
// node_modules/proper-lockfile/lib/mtime-precision.js
var require_mtime_precision = __commonJS({
"node_modules/proper-lockfile/lib/mtime-precision.js"(exports, module) {
"use strict";
var cacheSymbol = Symbol();
function probe(file, fs11, callback) {
const cachedPrecision = fs11[cacheSymbol];
if (cachedPrecision) {
return fs11.stat(file, (err, stat3) => {
if (err) {
return callback(err);
}
callback(null, stat3.mtime, cachedPrecision);
});
}
const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
fs11.utimes(file, mtime, mtime, (err) => {
if (err) {
return callback(err);
}
fs11.stat(file, (err2, stat3) => {
if (err2) {
return callback(err2);
}
const precision = stat3.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
Object.defineProperty(fs11, cacheSymbol, { value: precision });
callback(null, stat3.mtime, precision);
});
});
}
function getMtime(precision) {
let now = Date.now();
if (precision === "s") {
now = Math.ceil(now / 1e3) * 1e3;
}
return new Date(now);
}
module.exports.probe = probe;
module.exports.getMtime = getMtime;
}
});
// node_modules/proper-lockfile/lib/lockfile.js
var require_lockfile = __commonJS({
"node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
"use strict";
var path10 = __require("path");
var fs11 = require_graceful_fs();
var retry = require_retry3();
var onExit = require_signal_exit();
var mtimePrecision = require_mtime_precision();
var locks = {};
function getLockFile(file, options) {
return options.lockfilePath || `${file}.lock`;
}
function resolveCanonicalPath(file, options, callback) {
if (!options.realpath) {
return callback(null, path10.resolve(file));
}
options.fs.realpath(file, callback);
}
function acquireLock(file, options, callback) {
const lockfilePath = getLockFile(file, options);
options.fs.mkdir(lockfilePath, (err) => {
if (!err) {
return mtimePrecision.probe(lockfilePath, options.fs, (err2, mtime, mtimePrecision2) => {
if (err2) {
options.fs.rmdir(lockfilePath, () => {
});
return callback(err2);
}
callback(null, mtime, mtimePrecision2);
});
}
if (err.code !== "EEXIST") {
return callback(err);
}
if (options.stale <= 0) {
return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
}
options.fs.stat(lockfilePath, (err2, stat3) => {
if (err2) {
if (err2.code === "ENOENT") {
return acquireLock(file, { ...options, stale: 0 }, callback);
}
return callback(err2);
}
if (!isLockStale(stat3, options)) {
return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
}
removeLock(file, options, (err3) => {
if (err3) {
return callback(err3);
}
acquireLock(file, { ...options, stale: 0 }, callback);
});
});
});
}
function isLockStale(stat3, options) {
return stat3.mtime.getTime() < Date.now() - options.stale;
}
function removeLock(file, options, callback) {
options.fs.rmdir(getLockFile(file, options), (err) => {
if (err && err.code !== "ENOENT") {
return callback(err);
}
callback();
});
}
function updateLock(file, options) {
const lock3 = locks[file];
if (lock3.updateTimeout) {
return;
}
lock3.updateDelay = lock3.updateDelay || options.update;
lock3.updateTimeout = setTimeout(() => {
lock3.updateTimeout = null;
options.fs.stat(lock3.lockfilePath, (err, stat3) => {
const isOverThreshold = lock3.lastUpdate + options.stale < Date.now();
if (err) {
if (err.code === "ENOENT" || isOverThreshold) {
return setLockAsCompromised(file, lock3, Object.assign(err, { code: "ECOMPROMISED" }));
}
lock3.updateDelay = 1e3;
return updateLock(file, options);
}
const isMtimeOurs = lock3.mtime.getTime() === stat3.mtime.getTime();
if (!isMtimeOurs) {
return setLockAsCompromised(
file,
lock3,
Object.assign(
new Error("Unable to update lock within the stale threshold"),
{ code: "ECOMPROMISED" }
)
);
}
const mtime = mtimePrecision.getMtime(lock3.mtimePrecision);
options.fs.utimes(lock3.lockfilePath, mtime, mtime, (err2) => {
const isOverThreshold2 = lock3.lastUpdate + options.stale < Date.now();
if (lock3.released) {
return;
}
if (err2) {
if (err2.code === "ENOENT" || isOverThreshold2) {
return setLockAsCompromised(file, lock3, Object.assign(err2, { code: "ECOMPROMISED" }));
}
lock3.updateDelay = 1e3;
return updateLock(file, options);
}
lock3.mtime = mtime;
lock3.lastUpdate = Date.now();
lock3.updateDelay = null;
updateLock(file, options);
});
});
}, lock3.updateDelay);
if (lock3.updateTimeout.unref) {
lock3.updateTimeout.unref();
}
}
function setLockAsCompromised(file, lock3, err) {
lock3.released = true;
if (lock3.updateTimeout) {
clearTimeout(lock3.updateTimeout);
}
if (locks[file] === lock3) {
delete locks[file];
}
lock3.options.onCompromised(err);
}
function lock2(file, options, callback) {
options = {
stale: 1e4,
update: null,
realpath: true,
retries: 0,
fs: fs11,
onCompromised: (err) => {
throw err;
},
...options
};
options.retries = options.retries || 0;
options.retries = typeof options.retries === "number" ? { retries: options.retries } : options.retries;
options.stale = Math.max(options.stale || 0, 2e3);
options.update = options.update == null ? options.stale / 2 : options.update || 0;
options.update = Math.max(Math.min(options.update, options.stale / 2), 1e3);
resolveCanonicalPath(file, options, (err, file2) => {
if (err) {
return callback(err);
}
const operation = retry.operation(options.retries);
operation.attempt(() => {
acquireLock(file2, options, (err2, mtime, mtimePrecision2) => {
if (operation.retry(err2)) {
return;
}
if (err2) {
return callback(operation.mainError());
}
const lock3 = locks[file2] = {
lockfilePath: getLockFile(file2, options),
mtime,
mtimePrecision: mtimePrecision2,
options,
lastUpdate: Date.now()
};
updateLock(file2, options);
callback(null, (releasedCallback) => {
if (lock3.released) {
return releasedCallback && releasedCallback(Object.assign(new Error("Lock is already released"), { code: "ERELEASED" }));
}
unlock(file2, { ...options, realpath: false }, releasedCallback);
});
});
});
});
}
function unlock(file, options, callback) {
options = {
fs: fs11,
realpath: true,
...options
};
resolveCanonicalPath(file, options, (err, file2) => {
if (err) {
return callback(err);
}
const lock3 = locks[file2];
if (!lock3) {
return callback(Object.assign(new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
}
lock3.updateTimeout && clearTimeout(lock3.updateTimeout);
lock3.released = true;
delete locks[file2];
removeLock(file2, options, callback);
});
}
function check(file, options, callback) {
options = {
stale: 1e4,
realpath: true,
fs: fs11,
...options
};
options.stale = Math.max(options.stale || 0, 2e3);
resolveCanonicalPath(file, options, (err, file2) => {
if (err) {
return callback(err);
}
options.fs.stat(getLockFile(file2, options), (err2, stat3) => {
if (err2) {
return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
}
return callback(null, !isLockStale(stat3, options));
});
});
}
function getLocks() {
return locks;
}
onExit(() => {
for (const file in locks) {
const options = locks[file].options;
try {
options.fs.rmdirSync(getLockFile(file, options));
} catch (e) {
}
}
});
module.exports.lock = lock2;
module.exports.unlock = unlock;
module.exports.check = check;
module.exports.getLocks = getLocks;
}
});
// node_modules/proper-lockfile/lib/adapter.js
var require_adapter = __commonJS({
"node_modules/proper-lockfile/lib/adapter.js"(exports, module) {
"use strict";
var fs11 = require_graceful_fs();
function createSyncFs(fs12) {
const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
const newFs = { ...fs12 };
methods.forEach((method) => {
newFs[method] = (...args) => {
const callback = args.pop();
let ret;
try {
ret = fs12[`${method}Sync`](...args);
} catch (err) {
return callback(err);
}
callback(null, ret);
};
});
return newFs;
}
function toPromise(method) {
return (...args) => new Promise((resolve5, reject) => {
args.push((err, result) => {
if (err) {
reject(err);
} else {
resolve5(result);
}
});
method(...args);
});
}
function toSync(method) {
return (...args) => {
let err;
let result;
args.push((_err, _result) => {
err = _err;
result = _result;
});
method(...args);
if (err) {
throw err;
}
return result;
};
}
function toSyncOptions(options) {
options = { ...options };
options.fs = createSyncFs(options.fs || fs11);
if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) {
throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
}
return options;
}
module.exports = {
toPromise,
toSync,
toSyncOptions
};
}
});
// node_modules/proper-lockfile/index.js
var require_proper_lockfile = __commonJS({
"node_modules/proper-lockfile/index.js"(exports, module) {
"use strict";
var lockfile = require_lockfile();
var { toPromise, toSync, toSyncOptions } = require_adapter();
async function lock2(file, options) {
const release = await toPromise(lockfile.lock)(file, options);
return toPromise(release);
}
function lockSync(file, options) {
const release = toSync(lockfile.lock)(file, toSyncOptions(options));
return toSync(release);
}
function unlock(file, options) {
return toPromise(lockfile.unlock)(file, options);
}
function unlockSync(file, options) {
return toSync(lockfile.unlock)(file, toSyncOptions(options));
}
function check(file, options) {
return toPromise(lockfile.check)(file, options);
}
function checkSync(file, options) {
return toSync(lockfile.check)(file, toSyncOptions(options));
}
module.exports = lock2;
module.exports.lock = lock2;
module.exports.unlock = unlock;
module.exports.lockSync = lockSync;
module.exports.unlockSync = unlockSync;
module.exports.check = check;
module.exports.checkSync = checkSync;
}
});
// packages/core/src/utils/memoryDiscovery.ts
import * as fs10 from "node:fs/promises";
import * as fsSync2 from "node:fs";
import * as path9 from "node:path";
// packages/core/src/utils/bfsFileSearch.ts
import * as fs2 from "node:fs/promises";
import * as fsSync from "node:fs";
import * as path from "node:path";
// packages/core/src/utils/debugLogger.ts
import * as fs from "node:fs";
import * as util from "node:util";
var DebugLogger = class {
logStream;
constructor() {
this.logStream = process.env["GEMINI_DEBUG_LOG_FILE"] ? fs.createWriteStream(process.env["GEMINI_DEBUG_LOG_FILE"], {
flags: "a"
}) : void 0;
this.logStream?.on("error", (err) => {
console.error("Error writing to debug log stream:", err);
});
}
writeToFile(level, args) {
if (this.logStream) {
const message = util.format(...args);
const timestamp = (/* @__PURE__ */ new Date()).toISOString();
const logEntry = `[${timestamp}] [${level}] ${message}
`;
this.logStream.write(logEntry);
}
}
log(...args) {
this.writeToFile("LOG", args);
console.log(...args);
}
warn(...args) {
this.writeToFile("WARN", args);
console.warn(...args);
}
error(...args) {
this.writeToFile("ERROR", args);
console.error(...args);
}
debug(...args) {
this.writeToFile("DEBUG", args);
console.debug(...args);
}
};
var debugLogger = new DebugLogger();
// packages/core/src/utils/googleErrors.ts
function sanitizeJsonString(jsonStr) {
let prev;
do {
prev = jsonStr;
jsonStr = jsonStr.replace(/,(\s*),/g, ",$1");
} while (jsonStr !== prev);
return jsonStr;
}
function parseGoogleApiError(error) {
if (!error) {
return null;
}
let errorObj = error;
if (typeof errorObj === "string") {
try {
errorObj = JSON.parse(sanitizeJsonString(errorObj));
} catch {
return null;
}
}
if (Array.isArray(errorObj) && errorObj.length > 0) {
errorObj = errorObj[0];
}
if (typeof errorObj !== "object" || errorObj === null) {
return null;
}
let currentError = fromGaxiosError(errorObj) ?? fromApiError(errorObj);
let depth = 0;
const maxDepth = 10;
while (currentError && typeof currentError.message === "string" && depth < maxDepth) {
try {
const parsedMessage = JSON.parse(
sanitizeJsonString(
currentError.message.replace(/\u00A0/g, "").replace(/\n/g, " ")
)
);
if (parsedMessage.error) {
currentError = parsedMessage.error;
depth++;
} else {
break;
}
} catch {
break;
}
}
if (!currentError) {
return null;
}
const code = currentError.code;
const message = currentError.message;
const errorDetails = currentError.details;
if (code && message) {
const details = [];
if (Array.isArray(errorDetails)) {
for (const detail of errorDetails) {
if (detail && typeof detail === "object") {
const detailObj = detail;
const typeKey = Object.keys(detailObj).find(
(key) => key.trim() === "@type"
);
if (typeKey) {
if (typeKey !== "@type") {
detailObj["@type"] = detailObj[typeKey];
delete detailObj[typeKey];
}
if (typeof detailObj["@type"] === "string") {
details.push(detailObj);
}
}
}
}
}
return {
code,
message,
details
};
}
return null;
}
function isErrorShape(obj) {
return typeof obj === "object" && obj !== null && ("message" in obj && typeof obj.message === "string" || "code" in obj && typeof obj.code === "number");
}
function fromGaxiosError(errorObj) {
const gaxiosError = errorObj;
let outerError;
if (gaxiosError.response?.data) {
let data = gaxiosError.response.data;
if (typeof data === "string") {
try {
data = JSON.parse(sanitizeJsonString(data));
} catch {
}
}
if (Array.isArray(data) && data.length > 0) {
data = data[0];
}
if (typeof data === "object" && data !== null) {
if ("error" in data) {
const potentialError = data.error;
if (isErrorShape(potentialError)) {
outerError = potentialError;
}
}
}
}
if (!outerError) {
if (gaxiosError.error) {
outerError = gaxiosError.error;
} else {
return void 0;
}
}
return outerError;
}
function fromApiError(errorObj) {
const apiError = errorObj;
let outerError;
if (apiError.message) {
let data = apiError.message;
if (typeof data === "string") {
try {
data = JSON.parse(sanitizeJsonString(data));
} catch {
if (typeof data === "string") {
const firstBrace = data.indexOf("{");
const lastBrace = data.lastIndexOf("}");
if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
try {
data = JSON.parse(
sanitizeJsonString(data.substring(firstBrace, lastBrace + 1))
);
} catch {
}
}
}
}
}
if (Array.isArray(data) && data.length > 0) {
data = data[0];
}
if (typeof data === "object" && data !== null) {
if ("error" in data) {
const potentialError = data.error;
if (isErrorShape(potentialError)) {
outerError = potentialError;
}
}
}
}
return outerError;
}
// packages/core/src/utils/errors.ts
function isGaxiosError(error) {
return typeof error === "object" && error !== null && "response" in error && typeof error.response === "object" && error.response !== null;
}
function isNodeError(error) {
return error instanceof Error && "code" in error;
}
function isAbortError(error) {
return error instanceof Error && error.name === "AbortError";
}
function getErrorMessage(error) {
const friendlyError = toFriendlyError(error);
if (friendlyError instanceof Error) {
return friendlyError.message;
}
if (typeof friendlyError === "object" && friendlyError !== null && "message" in friendlyError && typeof friendlyError.message === "string") {
return friendlyError.message;
}
try {
return String(friendlyError);
} catch {
return "Failed to get error details";
}
}
function getErrorType(error) {
if (!(error instanceof Error)) return "unknown";
const name = error.name && error.name !== "Error" ? error.name : error.constructor?.name ?? "Error";
return name.replace(/^_+/, "");
}
var FatalError = class extends Error {
constructor(message, exitCode) {
super(message);
this.exitCode = exitCode;
this.name = "FatalError";
}
};
var FatalAuthenticationError = class extends FatalError {
constructor(message) {
super(message, 41);
this.name = "FatalAuthenticationError";
}
};
var FatalInputError = class extends FatalError {
constructor(message) {
super(message, 42);
this.name = "FatalInputError";
}
};
var FatalSandboxError = class extends FatalError {
constructor(message) {
super(message, 44);
this.name = "FatalSandboxError";
}
};
var FatalConfigError = class extends FatalError {
constructor(message) {
super(message, 52);
this.name = "FatalConfigError";
}
};
var FatalTurnLimitedError = class extends FatalError {
constructor(message) {
super(message, 53);
this.name = "FatalTurnLimitedError";
}
};
var FatalToolExecutionError = class extends FatalError {
constructor(message) {
super(message, 54);
this.name = "FatalToolExecutionError";
}
};
var FatalUntrustedWorkspaceError = class extends FatalError {
constructor(message) {
super(message, 55);
this.name = "FatalUntrustedWorkspaceError";
}
};
var FatalCancellationError = class extends FatalError {
constructor(message) {
super(message, 130);
this.name = "FatalCancellationError";
}
};
var CanceledError = class extends Error {
constructor(message = "The operation was canceled.") {
super(message);
this.name = "CanceledError";
}
};
var ForbiddenError = class extends Error {
constructor(message) {
super(message);
this.name = "ForbiddenError";
}
};
var AccountSuspendedError = class extends ForbiddenError {
appealUrl;
appealLinkText;
constructor(message, metadata) {
super(message);
this.name = "AccountSuspendedError";
this.appealUrl = metadata?.["appeal_url"];
this.appealLinkText = metadata?.["appeal_url_link_text"];
}
};
var UnauthorizedError = class extends Error {
constructor(message) {
super(message);
this.name = "UnauthorizedError";
}
};
var BadRequestError = class extends Error {
constructor(message) {
super(message);
this.name = "BadRequestError";
}
};
var ChangeAuthRequestedError = class extends Error {
constructor() {
super("User requested to change authentication method");
this.name = "ChangeAuthRequestedError";
}
};
function isResponseData(data) {
if (typeof data !== "object" || data === null) {
return false;
}
const candidate = data;
if (!("error" in candidate)) {
return false;
}
const error = candidate.error;
if (typeof error !== "object" || error === null) {
return false;
}
if ("code" in error && typeof error.code !== "number" && error.code !== void 0) {
return false;
}
if ("message" in error && typeof error.message !== "string" && error.message !== void 0) {
return false;
}
return true;
}
function toFriendlyError(error) {
const googleApiError = parseGoogleApiError(error);
if (googleApiError && googleApiError.code === 403) {
const tosDetail = googleApiError.details.find(
(d) => d["@type"] === "type.googleapis.com/google.rpc.ErrorInfo" && "reason" in d && d.reason === "TOS_VIOLATION"
);
if (tosDetail) {
return new AccountSuspendedError(
googleApiError.message,
tosDetail.metadata
);
}
}
if (isGaxiosError(error)) {
const data = parseResponseData(error);
if (data && data.error && data.error.message && data.error.code) {
switch (data.error.code) {
case 400:
return new BadRequestError(data.error.message);
case 401:
return new UnauthorizedError(data.error.message);
case 403:
return new ForbiddenError(data.error.message);
default:
}
}
}
return error;
}
function isAccountSuspendedError(error) {
const friendly = toFriendlyError(error);
return friendly instanceof AccountSuspendedError ? friendly : null;
}
function parseResponseData(error) {
let data = error.response?.data;
if (typeof data === "string") {
try {
data = JSON.parse(data);
} catch {
return void 0;
}
}
if (isResponseData(data)) {
return data;
}
return void 0;
}
function isAuthenticationError(error) {
if (error && typeof error === "object" && "code" in error) {
const errorCode = error["code"];
if (typeof errorCode === "number" && errorCode === 401) {
return true;
}
}
if (error instanceof Error && error.name === "UnauthorizedError") {
return true;
}
if (error instanceof UnauthorizedError) {
return true;
}
const message = getErrorMessage(error);
if (message.includes("401")) {
return true;
}
return false;
}
// packages/core/src/utils/bfsFileSearch.ts
var logger = {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
debug: (...args) => debugLogger.debug("[DEBUG] [BfsFileSearch]", ...args)
};
async function bfsFileSearch(rootDir, options) {
const { ignoreDirs = [], maxDirs = Infinity, debug = false } = options;
const foundFiles = [];
const queue = [rootDir];
const visited = /* @__PURE__ */ new Set();
let scannedDirCount = 0;
let queueHead = 0;
const ignoreDirsSet = new Set(ignoreDirs);
const PARALLEL_BATCH_SIZE = 15;
while (queueHead < queue.length && scannedDirCount < maxDirs) {
const batchSize = Math.min(PARALLEL_BATCH_SIZE, maxDirs - scannedDirCount);
const currentBatch = [];
while (currentBatch.length < batchSize && queueHead < queue.length) {
const currentDir = queue[queueHead];
queueHead++;
if (!visited.has(currentDir)) {
visited.add(currentDir);
currentBatch.push(currentDir);
}
}
scannedDirCount += currentBatch.length;
if (currentBatch.length === 0) continue;
if (debug) {
logger.debug(
`Scanning [${scannedDirCount}/${maxDirs}]: batch of ${currentBatch.length}`
);
}
const readPromises = currentBatch.map(async (currentDir) => {
try {
const entries = await fs2.readdir(currentDir, { withFileTypes: true });
return { currentDir, entries };
} catch (error) {
debugLogger.warn(
`[WARN] Skipping unreadable directory: ${currentDir} (${getErrorMessage(error)})`
);
if (debug) {
logger.debug(`Full error for ${currentDir}:`, error);
}
return { currentDir, entries: [] };
}
});
const results = await Promise.all(readPromises);
for (const { currentDir, entries } of results) {
processDirEntries(
currentDir,
entries,
options,
ignoreDirsSet,
queue,
foundFiles
);
}
}
return foundFiles;
}
function bfsFileSearchSync(rootDir, options) {
const { ignoreDirs = [], maxDirs = Infinity, debug = false } = options;
const foundFiles = [];
const queue = [rootDir];
const visited = /* @__PURE__ */ new Set();
let scannedDirCount = 0;
let queueHead = 0;
const ignoreDirsSet = new Set(ignoreDirs);
while (queueHead < queue.length && scannedDirCount < maxDirs) {
const currentDir = queue[queueHead];
queueHead++;
if (!visited.has(currentDir)) {
visited.add(currentDir);
scannedDirCount++;
if (debug) {
logger.debug(
`Scanning Sync [${scannedDirCount}/${maxDirs}]: ${currentDir}`
);
}
try {
const entries = fsSync.readdirSync(currentDir, { withFileTypes: true });
processDirEntries(
currentDir,
entries,
options,
ignoreDirsSet,
queue,
foundFiles
);
} catch (error) {
debugLogger.warn(
`[WARN] Skipping unreadable directory: ${currentDir} (${getErrorMessage(error)})`
);
}
}
}
return foundFiles;
}
function processDirEntries(currentDir, entries, options, ignoreDirsSet, queue, foundFiles) {
for (const entry of entries) {
const fullPath = path.join(currentDir, entry.name);
const isDirectory = entry.isDirectory();
const isMatchingFile = entry.isFile() && entry.name === options.fileName;
if (!isDirectory && !isMatchingFile) {
continue;
}
if (isDirectory && ignoreDirsSet.has(entry.name)) {
continue;
}
if (options.fileService?.shouldIgnoreFile(fullPath, {
respectGitIgnore: options.fileFilteringOptions?.respectGitIgnore,
respectGeminiIgnore: options.fileFilteringOptions?.respectGeminiIgnore
})) {
continue;
}
if (isDirectory) {
queue.push(fullPath);
} else {
foundFiles.push(fullPath);
}
}
}
// packages/core/src/tools/tool-error.ts
var ToolErrorType = /* @__PURE__ */ ((ToolErrorType2) => {
ToolErrorType2["POLICY_VIOLATION"] = "policy_violation";
ToolErrorType2["INVALID_TOOL_PARAMS"] = "invalid_tool_params";
ToolErrorType2["UNKNOWN"] = "unknown";
ToolErrorType2["UNHANDLED_EXCEPTION"] = "unhandled_exception";
ToolErrorType2["TOOL_NOT_REGISTERED"] = "tool_not_registered";
ToolErrorType2["EXECUTION_FAILED"] = "execution_failed";
ToolErrorType2["FILE_NOT_FOUND"] = "file_not_found";
ToolErrorType2["FILE_WRITE_FAILURE"] = "file_write_failure";
ToolErrorType2["READ_CONTENT_FAILURE"] = "read_content_failure";
ToolErrorType2["ATTEMPT_TO_CREATE_EXISTING_FILE"] = "attempt_to_create_existing_file";
ToolErrorType2["FILE_TOO_LARGE"] = "file_too_large";
ToolErrorType2["PERMISSION_DENIED"] = "permission_denied";
ToolErrorType2["NO_SPACE_LEFT"] = "no_space_left";
ToolErrorType2["TARGET_IS_DIRECTORY"] = "target_is_directory";
ToolErrorType2["PATH_NOT_IN_WORKSPACE"] = "path_not_in_workspace";
ToolErrorType2["SEARCH_PATH_NOT_FOUND"] = "search_path_not_found";
ToolErrorType2["SEARCH_PATH_NOT_A_DIRECTORY"] = "search_path_not_a_directory";
ToolErrorType2["EDIT_PREPARATION_FAILURE"] = "edit_preparation_failure";
ToolErrorType2["EDIT_NO_OCCURRENCE_FOUND"] = "edit_no_occurrence_found";
ToolErrorType2["EDIT_EXPECTED_OCCURRENCE_MISMATCH"] = "edit_expected_occurrence_mismatch";
ToolErrorType2["EDIT_NO_CHANGE"] = "edit_no_change";
ToolErrorType2["EDIT_NO_CHANGE_LLM_JUDGEMENT"] = "edit_no_change_llm_judgement";
ToolErrorType2["GLOB_EXECUTION_ERROR"] = "glob_execution_error";
ToolErrorType2["GREP_EXECUTION_ERROR"] = "grep_execution_error";
ToolErrorType2["LS_EXECUTION_ERROR"] = "ls_execution_error";
ToolErrorType2["PATH_IS_NOT_A_DIRECTORY"] = "path_is_not_a_directory";
ToolErrorType2["MCP_TOOL_ERROR"] = "mcp_tool_error";
ToolErrorType2["MCP_RESOURCE_NOT_FOUND"] = "mcp_resource_not_found";
ToolErrorType2["MEMORY_TOOL_EXECUTION_ERROR"] = "memory_tool_execution_error";
ToolErrorType2["READ_MANY_FILES_SEARCH_ERROR"] = "read_many_files_search_error";
ToolErrorType2["SHELL_EXECUTE_ERROR"] = "shell_execute_error";
ToolErrorType2["SANDBOX_EXPANSION_REQUIRED"] = "sandbox_expansion_required";
ToolErrorType2["DISCOVERED_TOOL_EXECUTION_ERROR"] = "discovered_tool_execution_error";
ToolErrorType2["WEB_FETCH_NO_URL_IN_PROMPT"] = "web_fetch_no_url_in_prompt";
ToolErrorType2["WEB_FETCH_FALLBACK_FAILED"] = "web_fetch_fallback_failed";
ToolErrorType2["WEB_FETCH_PROCESSING_ERROR"] = "web_fetch_processing_error";
ToolErrorType2["WEB_SEARCH_FAILED"] = "web_search_failed";
ToolErrorType2["STOP_EXECUTION"] = "stop_execution";
return ToolErrorType2;
})(ToolErrorType || {});
function isFatalToolError(errorType) {
if (!errorType) {
return false;
}
const fatalErrors = /* @__PURE__ */ new Set(["no_space_left" /* NO_SPACE_LEFT */]);
return fatalErrors.has(errorType);
}
// packages/core/src/utils/schemaValidator.ts
var import_ajv = __toESM(require_ajv(), 1);
var import__ = __toESM(require__(), 1);
var addFormats = __toESM(require_dist(), 1);
var AjvClass = import_ajv.default.default || import_ajv.default;
var Ajv2020Class = import__.default.default || import__.default;
var ajvOptions = {
// See: https://ajv.js.org/options.html#strict-mode-options
// strictSchema defaults to true and prevents use of JSON schemas that
// include unrecognized keywords. The JSON schema spec specifically allows
// for the use of non-standard keywords and the spec-compliant behavior
// is to ignore those keywords. Note that setting this to false also
// allows use of non-standard or custom formats (the unknown format value
// will be logged but the schema will still be considered valid).
strictSchema: false
};
var ajvDefault = new AjvClass(ajvOptions);
var ajv2020 = new Ajv2020Class(ajvOptions);
var addFormatsFunc = addFormats.default || addFormats;
addFormatsFunc(ajvDefault);
addFormatsFunc(ajv2020);
var DRAFT_2020_12_SCHEMA = "https://json-schema.org/draft/2020-12/schema";
function getValidator(schema) {
if (typeof schema === "object" && schema !== null && "$schema" in schema && schema.$schema === DRAFT_2020_12_SCHEMA) {
return ajv2020;
}
return ajvDefault;
}
var SchemaValidator = class {
/**
* Returns null if the data conforms to the schema described by schema (or if schema
* is null). Otherwise, returns a string describing the error.
*/
static validate(schema, data) {
if (!schema) {
return null;
}
if (typeof data !== "object" || data === null) {
return "Value of params must be an object";
}
const anySchema = schema;
const validator = getValidator(anySchema);
let validate;
try {
validate = validator.compile(anySchema);
} catch (error) {
debugLogger.warn(
`Failed to compile schema (${// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
schema?.["$schema"] ?? "<no $schema>"}): ${error instanceof Error ? error.message : String(error)}. Skipping parameter validation.`
);
return null;
}
const valid = validate(data);
if (!valid && validate.errors) {
return validator.errorsText(validate.errors, { dataVar: "params" });
}
return null;
}
/**
* Validates a JSON schema itself. Returns null if the schema is valid,
* otherwise returns a string describing the validation errors.
*/
static validateSchema(schema) {
if (!schema) {
return null;
}
const validator = getValidator(schema);
try {
const isValid2 = validator.validateSchema(schema);
return isValid2 ? null : validator.errorsText(validator.errors);
} catch (error) {
debugLogger.warn(
`Failed to validate schema (${// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
schema?.["$schema"] ?? "<no $schema>"}): ${error instanceof Error ? error.message : String(error)}. Skipping schema validation.`
);
return null;
}
}
};
// packages/core/src/utils/markdownUtils.ts
function camelToSpace(text) {
const result = text.replace(/([A-Z])/g, " $1");
return result.charAt(0).toUpperCase() + result.slice(1).trim();
}
function jsonToMarkdown(data, indent = 0) {
const spacing = " ".repeat(indent);
if (data === null) {
return "null";
}
if (data === void 0) {
return "undefined";
}
if (Array.isArray(data)) {
if (data.length === 0) {
return "[]";
}
if (isArrayOfSimilarObjects(data)) {
return renderTable(data, indent);
}
return data.map((item) => {
if (typeof item === "object" && item !== null && Object.keys(item).length > 0) {
const rendered2 = jsonToMarkdown(item, indent + 1);
return `${spacing}-
${rendered2}`;
}
const rendered = jsonToMarkdown(item, indent + 1).trimStart();
return `${spacing}- ${rendered}`;
}).join("\n");
}
if (typeof data === "object") {
const entries = Object.entries(data);
if (entries.length === 0) {
return "{}";
}
return entries.map(([key, value]) => {
const displayKey = camelToSpace(key);
if (typeof value === "object" && value !== null && Object.keys(value).length > 0) {
const renderedValue2 = jsonToMarkdown(value, indent + 1);
return `${spacing}- **${displayKey}**:
${renderedValue2}`;
}
const renderedValue = jsonToMarkdown(value, indent + 1).trimStart();
return `${spacing}- **${displayKey}**: ${renderedValue}`;
}).join("\n");
}
if (typeof data === "string") {
return data.split("\n").map((line, i) => i === 0 ? line : spacing + line).join("\n");
}
return String(data);
}
function safeJsonToMarkdown(text) {
try {
const parsed = JSON.parse(text);
return jsonToMarkdown(parsed);
} catch {
return text;
}
}
function isRecord(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function isArrayOfSimilarObjects(data) {
if (data.length === 0) {
return false;
}
if (!data.every(isRecord)) return false;
const firstKeys = Object.keys(data[0]).sort().join(",");
return data.every((item) => Object.keys(item).sort().join(",") === firstKeys);
}
function renderTable(data, indent = 0) {
const spacing = " ".repeat(indent);
const keys = Object.keys(data[0]);
const displayKeys = keys.map(camelToSpace);
const header = `${spacing}| ${displayKeys.join(" | ")} |`;
const separator = `${spacing}| ${keys.map(() => "---").join(" | ")} |`;
const rows = data.map(
(item) => `${spacing}| ${keys.map((key) => {
const val = item[key];
if (typeof val === "object" && val !== null) {
return JSON.stringify(val).replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
}
return String(val).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\n/g, " ");
}).join(" | ")} |`
);
return [header, separator, ...rows].join("\n");
}
// packages/core/src/tools/tools.ts
import { randomUUID } from "node:crypto";
// node_modules/@google/genai/dist/node/index.mjs
var import_google_auth_library = __toESM(require_src5(), 1);
import { createWriteStream as createWriteStream2 } from "fs";
import * as fs3 from "fs/promises";
import { writeFile } from "fs/promises";
import { Readable } from "node:stream";
import { finished } from "node:stream/promises";
import * as path2 from "path";
var _defaultBaseGeminiUrl = void 0;
var _defaultBaseVertexUrl = void 0;
function getDefaultBaseUrls() {
return {
geminiUrl: _defaultBaseGeminiUrl,
vertexUrl: _defaultBaseVertexUrl
};
}
function getBaseUrl(httpOptions, vertexai, vertexBaseUrlFromEnv, geminiBaseUrlFromEnv) {
var _a, _b;
if (!(httpOptions === null || httpOptions === void 0 ? void 0 : httpOptions.baseUrl)) {
const defaultBaseUrls = getDefaultBaseUrls();
if (vertexai) {
return (_a = defaultBaseUrls.vertexUrl) !== null && _a !== void 0 ? _a : vertexBaseUrlFromEnv;
} else {
return (_b = defaultBaseUrls.geminiUrl) !== null && _b !== void 0 ? _b : geminiBaseUrlFromEnv;
}
}
return httpOptions.baseUrl;
}
var BaseModule = class {
};
function formatMap(templateString, valueMap) {
const regex = /\{([^}]+)\}/g;
return templateString.replace(regex, (match, key) => {
if (Object.prototype.hasOwnProperty.call(valueMap, key)) {
const value = valueMap[key];
return value !== void 0 && value !== null ? String(value) : "";
} else {
throw new Error(`Key '${key}' not found in valueMap.`);
}
});
}
function setValueByPath(data, keys, value) {
for (let i = 0; i < keys.length - 1; i++) {
const key = keys[i];
if (key.endsWith("[]")) {
const keyName = key.slice(0, -2);
if (!(keyName in data)) {
if (Array.isArray(value)) {
data[keyName] = Array.from({ length: value.length }, () => ({}));
} else {
throw new Error(`Value must be a list given an array path ${key}`);
}
}
if (Array.isArray(data[keyName])) {
const arrayData = data[keyName];
if (Array.isArray(value)) {
for (let j = 0; j < arrayData.length; j++) {
const entry = arrayData[j];
setValueByPath(entry, keys.slice(i + 1), value[j]);
}
} else {
for (const d of arrayData) {
setValueByPath(d, keys.slice(i + 1), value);
}
}
}
return;
} else if (key.endsWith("[0]")) {
const keyName = key.slice(0, -3);
if (!(keyName in data)) {
data[keyName] = [{}];
}
const arrayData = data[keyName];
setValueByPath(arrayData[0], keys.slice(i + 1), value);
return;
}
if (!data[key] || typeof data[key] !== "object") {
data[key] = {};
}
data = data[key];
}
const keyToSet = keys[keys.length - 1];
const existingData = data[keyToSet];
if (existingData !== void 0) {
if (!value || typeof value === "object" && Object.keys(value).length === 0) {
return;
}
if (value === existingData) {
return;
}
if (typeof existingData === "object" && typeof value === "object" && existingData !== null && value !== null) {
Object.assign(existingData, value);
} else {
throw new Error(`Cannot set value for an existing key. Key: ${keyToSet}`);
}
} else {
if (keyToSet === "_self" && typeof value === "object" && value !== null && !Array.isArray(value)) {
const valueAsRecord = value;
Object.assign(data, valueAsRecord);
} else {
data[keyToSet] = value;
}
}
}
function getValueByPath(data, keys, defaultValue = void 0) {
try {
if (keys.length === 1 && keys[0] === "_self") {
return data;
}
for (let i = 0; i < keys.length; i++) {
if (typeof data !== "object" || data === null) {
return defaultValue;
}
const key = keys[i];
if (key.endsWith("[]")) {
const keyName = key.slice(0, -2);
if (keyName in data) {
const arrayData = data[keyName];
if (!Array.isArray(arrayData)) {
return defaultValue;
}
return arrayData.map((d) => getValueByPath(d, keys.slice(i + 1), defaultValue));
} else {
return defaultValue;
}
} else {
data = data[key];
}
}
return data;
} catch (error) {
if (error instanceof TypeError) {
return defaultValue;
}
throw error;
}
}
function moveValueByPath(data, paths) {
for (const [sourcePath, destPath] of Object.entries(paths)) {
const sourceKeys = sourcePath.split(".");
const destKeys = destPath.split(".");
const excludeKeys = /* @__PURE__ */ new Set();
let wildcardIdx = -1;
for (let i = 0; i < sourceKeys.length; i++) {
if (sourceKeys[i] === "*") {
wildcardIdx = i;
break;
}
}
if (wildcardIdx !== -1 && destKeys.length > wildcardIdx) {
for (let i = wildcardIdx; i < destKeys.length; i++) {
const key = destKeys[i];
if (key !== "*" && !key.endsWith("[]") && !key.endsWith("[0]")) {
excludeKeys.add(key);
}
}
}
_moveValueRecursive(data, sourceKeys, destKeys, 0, excludeKeys);
}
}
function _moveValueRecursive(data, sourceKeys, destKeys, keyIdx, excludeKeys) {
if (keyIdx >= sourceKeys.length) {
return;
}
if (typeof data !== "object" || data === null) {
return;
}
const key = sourceKeys[keyIdx];
if (key.endsWith("[]")) {
const keyName = key.slice(0, -2);
const dataRecord = data;
if (keyName in dataRecord && Array.isArray(dataRecord[keyName])) {
for (const item of dataRecord[keyName]) {
_moveValueRecursive(item, sourceKeys, destKeys, keyIdx + 1, excludeKeys);
}
}
} else if (key === "*") {
if (typeof data === "object" && data !== null && !Array.isArray(data)) {
const dataRecord = data;
const keysToMove = Object.keys(dataRecord).filter((k) => !k.startsWith("_") && !excludeKeys.has(k));
const valuesToMove = {};
for (const k of keysToMove) {
valuesToMove[k] = dataRecord[k];
}
for (const [k, v] of Object.entries(valuesToMove)) {
const newDestKeys = [];
for (const dk of destKeys.slice(keyIdx)) {
if (dk === "*") {
newDestKeys.push(k);
} else {
newDestKeys.push(dk);
}
}
setValueByPath(dataRecord, newDestKeys, v);
}
for (const k of keysToMove) {
delete dataRecord[k];
}
}
} else {
const dataRecord = data;
if (key in dataRecord) {
_moveValueRecursive(dataRecord[key], sourceKeys, destKeys, keyIdx + 1, excludeKeys);
}
}
}
function tBytes$1(fromBytes) {
if (typeof fromBytes !== "string") {
throw new Error("fromImageBytes must be a string");
}
return fromBytes;
}
function fetchPredictOperationParametersToVertex(fromObject) {
const toObject = {};
const fromOperationName = getValueByPath(fromObject, [
"operationName"
]);
if (fromOperationName != null) {
setValueByPath(toObject, ["operationName"], fromOperationName);
}
const fromResourceName = getValueByPath(fromObject, ["resourceName"]);
if (fromResourceName != null) {
setValueByPath(toObject, ["_url", "resourceName"], fromResourceName);
}
return toObject;
}
function generateVideosOperationFromMldev$1(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
const fromResponse = getValueByPath(fromObject, [
"response",
"generateVideoResponse"
]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], generateVideosResponseFromMldev$1(fromResponse));
}
return toObject;
}
function generateVideosOperationFromVertex$1(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
const fromResponse = getValueByPath(fromObject, ["response"]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], generateVideosResponseFromVertex$1(fromResponse));
}
return toObject;
}
function generateVideosResponseFromMldev$1(fromObject) {
const toObject = {};
const fromGeneratedVideos = getValueByPath(fromObject, [
"generatedSamples"
]);
if (fromGeneratedVideos != null) {
let transformedList = fromGeneratedVideos;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedVideoFromMldev$1(item);
});
}
setValueByPath(toObject, ["generatedVideos"], transformedList);
}
const fromRaiMediaFilteredCount = getValueByPath(fromObject, [
"raiMediaFilteredCount"
]);
if (fromRaiMediaFilteredCount != null) {
setValueByPath(toObject, ["raiMediaFilteredCount"], fromRaiMediaFilteredCount);
}
const fromRaiMediaFilteredReasons = getValueByPath(fromObject, [
"raiMediaFilteredReasons"
]);
if (fromRaiMediaFilteredReasons != null) {
setValueByPath(toObject, ["raiMediaFilteredReasons"], fromRaiMediaFilteredReasons);
}
return toObject;
}
function generateVideosResponseFromVertex$1(fromObject) {
const toObject = {};
const fromGeneratedVideos = getValueByPath(fromObject, ["videos"]);
if (fromGeneratedVideos != null) {
let transformedList = fromGeneratedVideos;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedVideoFromVertex$1(item);
});
}
setValueByPath(toObject, ["generatedVideos"], transformedList);
}
const fromRaiMediaFilteredCount = getValueByPath(fromObject, [
"raiMediaFilteredCount"
]);
if (fromRaiMediaFilteredCount != null) {
setValueByPath(toObject, ["raiMediaFilteredCount"], fromRaiMediaFilteredCount);
}
const fromRaiMediaFilteredReasons = getValueByPath(fromObject, [
"raiMediaFilteredReasons"
]);
if (fromRaiMediaFilteredReasons != null) {
setValueByPath(toObject, ["raiMediaFilteredReasons"], fromRaiMediaFilteredReasons);
}
return toObject;
}
function generatedVideoFromMldev$1(fromObject) {
const toObject = {};
const fromVideo = getValueByPath(fromObject, ["video"]);
if (fromVideo != null) {
setValueByPath(toObject, ["video"], videoFromMldev$1(fromVideo));
}
return toObject;
}
function generatedVideoFromVertex$1(fromObject) {
const toObject = {};
const fromVideo = getValueByPath(fromObject, ["_self"]);
if (fromVideo != null) {
setValueByPath(toObject, ["video"], videoFromVertex$1(fromVideo));
}
return toObject;
}
function getOperationParametersToMldev(fromObject) {
const toObject = {};
const fromOperationName = getValueByPath(fromObject, [
"operationName"
]);
if (fromOperationName != null) {
setValueByPath(toObject, ["_url", "operationName"], fromOperationName);
}
return toObject;
}
function getOperationParametersToVertex(fromObject) {
const toObject = {};
const fromOperationName = getValueByPath(fromObject, [
"operationName"
]);
if (fromOperationName != null) {
setValueByPath(toObject, ["_url", "operationName"], fromOperationName);
}
return toObject;
}
function importFileOperationFromMldev$1(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
const fromResponse = getValueByPath(fromObject, ["response"]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], importFileResponseFromMldev$1(fromResponse));
}
return toObject;
}
function importFileResponseFromMldev$1(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromParent = getValueByPath(fromObject, ["parent"]);
if (fromParent != null) {
setValueByPath(toObject, ["parent"], fromParent);
}
const fromDocumentName = getValueByPath(fromObject, ["documentName"]);
if (fromDocumentName != null) {
setValueByPath(toObject, ["documentName"], fromDocumentName);
}
return toObject;
}
function uploadToFileSearchStoreOperationFromMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
const fromResponse = getValueByPath(fromObject, ["response"]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], uploadToFileSearchStoreResponseFromMldev(fromResponse));
}
return toObject;
}
function uploadToFileSearchStoreResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromParent = getValueByPath(fromObject, ["parent"]);
if (fromParent != null) {
setValueByPath(toObject, ["parent"], fromParent);
}
const fromDocumentName = getValueByPath(fromObject, ["documentName"]);
if (fromDocumentName != null) {
setValueByPath(toObject, ["documentName"], fromDocumentName);
}
return toObject;
}
function videoFromMldev$1(fromObject) {
const toObject = {};
const fromUri = getValueByPath(fromObject, ["uri"]);
if (fromUri != null) {
setValueByPath(toObject, ["uri"], fromUri);
}
const fromVideoBytes = getValueByPath(fromObject, ["encodedVideo"]);
if (fromVideoBytes != null) {
setValueByPath(toObject, ["videoBytes"], tBytes$1(fromVideoBytes));
}
const fromMimeType = getValueByPath(fromObject, ["encoding"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function videoFromVertex$1(fromObject) {
const toObject = {};
const fromUri = getValueByPath(fromObject, ["gcsUri"]);
if (fromUri != null) {
setValueByPath(toObject, ["uri"], fromUri);
}
const fromVideoBytes = getValueByPath(fromObject, [
"bytesBase64Encoded"
]);
if (fromVideoBytes != null) {
setValueByPath(toObject, ["videoBytes"], tBytes$1(fromVideoBytes));
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
var Outcome;
(function(Outcome2) {
Outcome2["OUTCOME_UNSPECIFIED"] = "OUTCOME_UNSPECIFIED";
Outcome2["OUTCOME_OK"] = "OUTCOME_OK";
Outcome2["OUTCOME_FAILED"] = "OUTCOME_FAILED";
Outcome2["OUTCOME_DEADLINE_EXCEEDED"] = "OUTCOME_DEADLINE_EXCEEDED";
})(Outcome || (Outcome = {}));
var Language;
(function(Language2) {
Language2["LANGUAGE_UNSPECIFIED"] = "LANGUAGE_UNSPECIFIED";
Language2["PYTHON"] = "PYTHON";
})(Language || (Language = {}));
var FunctionResponseScheduling;
(function(FunctionResponseScheduling2) {
FunctionResponseScheduling2["SCHEDULING_UNSPECIFIED"] = "SCHEDULING_UNSPECIFIED";
FunctionResponseScheduling2["SILENT"] = "SILENT";
FunctionResponseScheduling2["WHEN_IDLE"] = "WHEN_IDLE";
FunctionResponseScheduling2["INTERRUPT"] = "INTERRUPT";
})(FunctionResponseScheduling || (FunctionResponseScheduling = {}));
var Type;
(function(Type2) {
Type2["TYPE_UNSPECIFIED"] = "TYPE_UNSPECIFIED";
Type2["STRING"] = "STRING";
Type2["NUMBER"] = "NUMBER";
Type2["INTEGER"] = "INTEGER";
Type2["BOOLEAN"] = "BOOLEAN";
Type2["ARRAY"] = "ARRAY";
Type2["OBJECT"] = "OBJECT";
Type2["NULL"] = "NULL";
})(Type || (Type = {}));
var Mode;
(function(Mode2) {
Mode2["MODE_UNSPECIFIED"] = "MODE_UNSPECIFIED";
Mode2["MODE_DYNAMIC"] = "MODE_DYNAMIC";
})(Mode || (Mode = {}));
var ApiSpec;
(function(ApiSpec2) {
ApiSpec2["API_SPEC_UNSPECIFIED"] = "API_SPEC_UNSPECIFIED";
ApiSpec2["SIMPLE_SEARCH"] = "SIMPLE_SEARCH";
ApiSpec2["ELASTIC_SEARCH"] = "ELASTIC_SEARCH";
})(ApiSpec || (ApiSpec = {}));
var AuthType;
(function(AuthType2) {
AuthType2["AUTH_TYPE_UNSPECIFIED"] = "AUTH_TYPE_UNSPECIFIED";
AuthType2["NO_AUTH"] = "NO_AUTH";
AuthType2["API_KEY_AUTH"] = "API_KEY_AUTH";
AuthType2["HTTP_BASIC_AUTH"] = "HTTP_BASIC_AUTH";
AuthType2["GOOGLE_SERVICE_ACCOUNT_AUTH"] = "GOOGLE_SERVICE_ACCOUNT_AUTH";
AuthType2["OAUTH"] = "OAUTH";
AuthType2["OIDC_AUTH"] = "OIDC_AUTH";
})(AuthType || (AuthType = {}));
var HttpElementLocation;
(function(HttpElementLocation2) {
HttpElementLocation2["HTTP_IN_UNSPECIFIED"] = "HTTP_IN_UNSPECIFIED";
HttpElementLocation2["HTTP_IN_QUERY"] = "HTTP_IN_QUERY";
HttpElementLocation2["HTTP_IN_HEADER"] = "HTTP_IN_HEADER";
HttpElementLocation2["HTTP_IN_PATH"] = "HTTP_IN_PATH";
HttpElementLocation2["HTTP_IN_BODY"] = "HTTP_IN_BODY";
HttpElementLocation2["HTTP_IN_COOKIE"] = "HTTP_IN_COOKIE";
})(HttpElementLocation || (HttpElementLocation = {}));
var PhishBlockThreshold;
(function(PhishBlockThreshold2) {
PhishBlockThreshold2["PHISH_BLOCK_THRESHOLD_UNSPECIFIED"] = "PHISH_BLOCK_THRESHOLD_UNSPECIFIED";
PhishBlockThreshold2["BLOCK_LOW_AND_ABOVE"] = "BLOCK_LOW_AND_ABOVE";
PhishBlockThreshold2["BLOCK_MEDIUM_AND_ABOVE"] = "BLOCK_MEDIUM_AND_ABOVE";
PhishBlockThreshold2["BLOCK_HIGH_AND_ABOVE"] = "BLOCK_HIGH_AND_ABOVE";
PhishBlockThreshold2["BLOCK_HIGHER_AND_ABOVE"] = "BLOCK_HIGHER_AND_ABOVE";
PhishBlockThreshold2["BLOCK_VERY_HIGH_AND_ABOVE"] = "BLOCK_VERY_HIGH_AND_ABOVE";
PhishBlockThreshold2["BLOCK_ONLY_EXTREMELY_HIGH"] = "BLOCK_ONLY_EXTREMELY_HIGH";
})(PhishBlockThreshold || (PhishBlockThreshold = {}));
var ThinkingLevel;
(function(ThinkingLevel2) {
ThinkingLevel2["THINKING_LEVEL_UNSPECIFIED"] = "THINKING_LEVEL_UNSPECIFIED";
ThinkingLevel2["LOW"] = "LOW";
ThinkingLevel2["HIGH"] = "HIGH";
})(ThinkingLevel || (ThinkingLevel = {}));
var HarmCategory;
(function(HarmCategory2) {
HarmCategory2["HARM_CATEGORY_UNSPECIFIED"] = "HARM_CATEGORY_UNSPECIFIED";
HarmCategory2["HARM_CATEGORY_HARASSMENT"] = "HARM_CATEGORY_HARASSMENT";
HarmCategory2["HARM_CATEGORY_HATE_SPEECH"] = "HARM_CATEGORY_HATE_SPEECH";
HarmCategory2["HARM_CATEGORY_SEXUALLY_EXPLICIT"] = "HARM_CATEGORY_SEXUALLY_EXPLICIT";
HarmCategory2["HARM_CATEGORY_DANGEROUS_CONTENT"] = "HARM_CATEGORY_DANGEROUS_CONTENT";
HarmCategory2["HARM_CATEGORY_CIVIC_INTEGRITY"] = "HARM_CATEGORY_CIVIC_INTEGRITY";
HarmCategory2["HARM_CATEGORY_IMAGE_HATE"] = "HARM_CATEGORY_IMAGE_HATE";
HarmCategory2["HARM_CATEGORY_IMAGE_DANGEROUS_CONTENT"] = "HARM_CATEGORY_IMAGE_DANGEROUS_CONTENT";
HarmCategory2["HARM_CATEGORY_IMAGE_HARASSMENT"] = "HARM_CATEGORY_IMAGE_HARASSMENT";
HarmCategory2["HARM_CATEGORY_IMAGE_SEXUALLY_EXPLICIT"] = "HARM_CATEGORY_IMAGE_SEXUALLY_EXPLICIT";
HarmCategory2["HARM_CATEGORY_JAILBREAK"] = "HARM_CATEGORY_JAILBREAK";
})(HarmCategory || (HarmCategory = {}));
var HarmBlockMethod;
(function(HarmBlockMethod2) {
HarmBlockMethod2["HARM_BLOCK_METHOD_UNSPECIFIED"] = "HARM_BLOCK_METHOD_UNSPECIFIED";
HarmBlockMethod2["SEVERITY"] = "SEVERITY";
HarmBlockMethod2["PROBABILITY"] = "PROBABILITY";
})(HarmBlockMethod || (HarmBlockMethod = {}));
var HarmBlockThreshold;
(function(HarmBlockThreshold2) {
HarmBlockThreshold2["HARM_BLOCK_THRESHOLD_UNSPECIFIED"] = "HARM_BLOCK_THRESHOLD_UNSPECIFIED";
HarmBlockThreshold2["BLOCK_LOW_AND_ABOVE"] = "BLOCK_LOW_AND_ABOVE";
HarmBlockThreshold2["BLOCK_MEDIUM_AND_ABOVE"] = "BLOCK_MEDIUM_AND_ABOVE";
HarmBlockThreshold2["BLOCK_ONLY_HIGH"] = "BLOCK_ONLY_HIGH";
HarmBlockThreshold2["BLOCK_NONE"] = "BLOCK_NONE";
HarmBlockThreshold2["OFF"] = "OFF";
})(HarmBlockThreshold || (HarmBlockThreshold = {}));
var FinishReason;
(function(FinishReason2) {
FinishReason2["FINISH_REASON_UNSPECIFIED"] = "FINISH_REASON_UNSPECIFIED";
FinishReason2["STOP"] = "STOP";
FinishReason2["MAX_TOKENS"] = "MAX_TOKENS";
FinishReason2["SAFETY"] = "SAFETY";
FinishReason2["RECITATION"] = "RECITATION";
FinishReason2["LANGUAGE"] = "LANGUAGE";
FinishReason2["OTHER"] = "OTHER";
FinishReason2["BLOCKLIST"] = "BLOCKLIST";
FinishReason2["PROHIBITED_CONTENT"] = "PROHIBITED_CONTENT";
FinishReason2["SPII"] = "SPII";
FinishReason2["MALFORMED_FUNCTION_CALL"] = "MALFORMED_FUNCTION_CALL";
FinishReason2["IMAGE_SAFETY"] = "IMAGE_SAFETY";
FinishReason2["UNEXPECTED_TOOL_CALL"] = "UNEXPECTED_TOOL_CALL";
FinishReason2["IMAGE_PROHIBITED_CONTENT"] = "IMAGE_PROHIBITED_CONTENT";
FinishReason2["NO_IMAGE"] = "NO_IMAGE";
})(FinishReason || (FinishReason = {}));
var HarmProbability;
(function(HarmProbability2) {
HarmProbability2["HARM_PROBABILITY_UNSPECIFIED"] = "HARM_PROBABILITY_UNSPECIFIED";
HarmProbability2["NEGLIGIBLE"] = "NEGLIGIBLE";
HarmProbability2["LOW"] = "LOW";
HarmProbability2["MEDIUM"] = "MEDIUM";
HarmProbability2["HIGH"] = "HIGH";
})(HarmProbability || (HarmProbability = {}));
var HarmSeverity;
(function(HarmSeverity2) {
HarmSeverity2["HARM_SEVERITY_UNSPECIFIED"] = "HARM_SEVERITY_UNSPECIFIED";
HarmSeverity2["HARM_SEVERITY_NEGLIGIBLE"] = "HARM_SEVERITY_NEGLIGIBLE";
HarmSeverity2["HARM_SEVERITY_LOW"] = "HARM_SEVERITY_LOW";
HarmSeverity2["HARM_SEVERITY_MEDIUM"] = "HARM_SEVERITY_MEDIUM";
HarmSeverity2["HARM_SEVERITY_HIGH"] = "HARM_SEVERITY_HIGH";
})(HarmSeverity || (HarmSeverity = {}));
var UrlRetrievalStatus;
(function(UrlRetrievalStatus2) {
UrlRetrievalStatus2["URL_RETRIEVAL_STATUS_UNSPECIFIED"] = "URL_RETRIEVAL_STATUS_UNSPECIFIED";
UrlRetrievalStatus2["URL_RETRIEVAL_STATUS_SUCCESS"] = "URL_RETRIEVAL_STATUS_SUCCESS";
UrlRetrievalStatus2["URL_RETRIEVAL_STATUS_ERROR"] = "URL_RETRIEVAL_STATUS_ERROR";
UrlRetrievalStatus2["URL_RETRIEVAL_STATUS_PAYWALL"] = "URL_RETRIEVAL_STATUS_PAYWALL";
UrlRetrievalStatus2["URL_RETRIEVAL_STATUS_UNSAFE"] = "URL_RETRIEVAL_STATUS_UNSAFE";
})(UrlRetrievalStatus || (UrlRetrievalStatus = {}));
var BlockedReason;
(function(BlockedReason2) {
BlockedReason2["BLOCKED_REASON_UNSPECIFIED"] = "BLOCKED_REASON_UNSPECIFIED";
BlockedReason2["SAFETY"] = "SAFETY";
BlockedReason2["OTHER"] = "OTHER";
BlockedReason2["BLOCKLIST"] = "BLOCKLIST";
BlockedReason2["PROHIBITED_CONTENT"] = "PROHIBITED_CONTENT";
BlockedReason2["IMAGE_SAFETY"] = "IMAGE_SAFETY";
BlockedReason2["MODEL_ARMOR"] = "MODEL_ARMOR";
BlockedReason2["JAILBREAK"] = "JAILBREAK";
})(BlockedReason || (BlockedReason = {}));
var TrafficType;
(function(TrafficType2) {
TrafficType2["TRAFFIC_TYPE_UNSPECIFIED"] = "TRAFFIC_TYPE_UNSPECIFIED";
TrafficType2["ON_DEMAND"] = "ON_DEMAND";
TrafficType2["PROVISIONED_THROUGHPUT"] = "PROVISIONED_THROUGHPUT";
})(TrafficType || (TrafficType = {}));
var Modality;
(function(Modality2) {
Modality2["MODALITY_UNSPECIFIED"] = "MODALITY_UNSPECIFIED";
Modality2["TEXT"] = "TEXT";
Modality2["IMAGE"] = "IMAGE";
Modality2["AUDIO"] = "AUDIO";
})(Modality || (Modality = {}));
var MediaResolution;
(function(MediaResolution2) {
MediaResolution2["MEDIA_RESOLUTION_UNSPECIFIED"] = "MEDIA_RESOLUTION_UNSPECIFIED";
MediaResolution2["MEDIA_RESOLUTION_LOW"] = "MEDIA_RESOLUTION_LOW";
MediaResolution2["MEDIA_RESOLUTION_MEDIUM"] = "MEDIA_RESOLUTION_MEDIUM";
MediaResolution2["MEDIA_RESOLUTION_HIGH"] = "MEDIA_RESOLUTION_HIGH";
})(MediaResolution || (MediaResolution = {}));
var TuningMode;
(function(TuningMode2) {
TuningMode2["TUNING_MODE_UNSPECIFIED"] = "TUNING_MODE_UNSPECIFIED";
TuningMode2["TUNING_MODE_FULL"] = "TUNING_MODE_FULL";
TuningMode2["TUNING_MODE_PEFT_ADAPTER"] = "TUNING_MODE_PEFT_ADAPTER";
})(TuningMode || (TuningMode = {}));
var AdapterSize;
(function(AdapterSize2) {
AdapterSize2["ADAPTER_SIZE_UNSPECIFIED"] = "ADAPTER_SIZE_UNSPECIFIED";
AdapterSize2["ADAPTER_SIZE_ONE"] = "ADAPTER_SIZE_ONE";
AdapterSize2["ADAPTER_SIZE_TWO"] = "ADAPTER_SIZE_TWO";
AdapterSize2["ADAPTER_SIZE_FOUR"] = "ADAPTER_SIZE_FOUR";
AdapterSize2["ADAPTER_SIZE_EIGHT"] = "ADAPTER_SIZE_EIGHT";
AdapterSize2["ADAPTER_SIZE_SIXTEEN"] = "ADAPTER_SIZE_SIXTEEN";
AdapterSize2["ADAPTER_SIZE_THIRTY_TWO"] = "ADAPTER_SIZE_THIRTY_TWO";
})(AdapterSize || (AdapterSize = {}));
var JobState;
(function(JobState2) {
JobState2["JOB_STATE_UNSPECIFIED"] = "JOB_STATE_UNSPECIFIED";
JobState2["JOB_STATE_QUEUED"] = "JOB_STATE_QUEUED";
JobState2["JOB_STATE_PENDING"] = "JOB_STATE_PENDING";
JobState2["JOB_STATE_RUNNING"] = "JOB_STATE_RUNNING";
JobState2["JOB_STATE_SUCCEEDED"] = "JOB_STATE_SUCCEEDED";
JobState2["JOB_STATE_FAILED"] = "JOB_STATE_FAILED";
JobState2["JOB_STATE_CANCELLING"] = "JOB_STATE_CANCELLING";
JobState2["JOB_STATE_CANCELLED"] = "JOB_STATE_CANCELLED";
JobState2["JOB_STATE_PAUSED"] = "JOB_STATE_PAUSED";
JobState2["JOB_STATE_EXPIRED"] = "JOB_STATE_EXPIRED";
JobState2["JOB_STATE_UPDATING"] = "JOB_STATE_UPDATING";
JobState2["JOB_STATE_PARTIALLY_SUCCEEDED"] = "JOB_STATE_PARTIALLY_SUCCEEDED";
})(JobState || (JobState = {}));
var TuningTask;
(function(TuningTask2) {
TuningTask2["TUNING_TASK_UNSPECIFIED"] = "TUNING_TASK_UNSPECIFIED";
TuningTask2["TUNING_TASK_I2V"] = "TUNING_TASK_I2V";
TuningTask2["TUNING_TASK_T2V"] = "TUNING_TASK_T2V";
TuningTask2["TUNING_TASK_R2V"] = "TUNING_TASK_R2V";
})(TuningTask || (TuningTask = {}));
var PartMediaResolutionLevel;
(function(PartMediaResolutionLevel2) {
PartMediaResolutionLevel2["MEDIA_RESOLUTION_UNSPECIFIED"] = "MEDIA_RESOLUTION_UNSPECIFIED";
PartMediaResolutionLevel2["MEDIA_RESOLUTION_LOW"] = "MEDIA_RESOLUTION_LOW";
PartMediaResolutionLevel2["MEDIA_RESOLUTION_MEDIUM"] = "MEDIA_RESOLUTION_MEDIUM";
PartMediaResolutionLevel2["MEDIA_RESOLUTION_HIGH"] = "MEDIA_RESOLUTION_HIGH";
})(PartMediaResolutionLevel || (PartMediaResolutionLevel = {}));
var FeatureSelectionPreference;
(function(FeatureSelectionPreference2) {
FeatureSelectionPreference2["FEATURE_SELECTION_PREFERENCE_UNSPECIFIED"] = "FEATURE_SELECTION_PREFERENCE_UNSPECIFIED";
FeatureSelectionPreference2["PRIORITIZE_QUALITY"] = "PRIORITIZE_QUALITY";
FeatureSelectionPreference2["BALANCED"] = "BALANCED";
FeatureSelectionPreference2["PRIORITIZE_COST"] = "PRIORITIZE_COST";
})(FeatureSelectionPreference || (FeatureSelectionPreference = {}));
var Behavior;
(function(Behavior2) {
Behavior2["UNSPECIFIED"] = "UNSPECIFIED";
Behavior2["BLOCKING"] = "BLOCKING";
Behavior2["NON_BLOCKING"] = "NON_BLOCKING";
})(Behavior || (Behavior = {}));
var DynamicRetrievalConfigMode;
(function(DynamicRetrievalConfigMode2) {
DynamicRetrievalConfigMode2["MODE_UNSPECIFIED"] = "MODE_UNSPECIFIED";
DynamicRetrievalConfigMode2["MODE_DYNAMIC"] = "MODE_DYNAMIC";
})(DynamicRetrievalConfigMode || (DynamicRetrievalConfigMode = {}));
var Environment;
(function(Environment2) {
Environment2["ENVIRONMENT_UNSPECIFIED"] = "ENVIRONMENT_UNSPECIFIED";
Environment2["ENVIRONMENT_BROWSER"] = "ENVIRONMENT_BROWSER";
})(Environment || (Environment = {}));
var FunctionCallingConfigMode;
(function(FunctionCallingConfigMode2) {
FunctionCallingConfigMode2["MODE_UNSPECIFIED"] = "MODE_UNSPECIFIED";
FunctionCallingConfigMode2["AUTO"] = "AUTO";
FunctionCallingConfigMode2["ANY"] = "ANY";
FunctionCallingConfigMode2["NONE"] = "NONE";
FunctionCallingConfigMode2["VALIDATED"] = "VALIDATED";
})(FunctionCallingConfigMode || (FunctionCallingConfigMode = {}));
var SafetyFilterLevel;
(function(SafetyFilterLevel2) {
SafetyFilterLevel2["BLOCK_LOW_AND_ABOVE"] = "BLOCK_LOW_AND_ABOVE";
SafetyFilterLevel2["BLOCK_MEDIUM_AND_ABOVE"] = "BLOCK_MEDIUM_AND_ABOVE";
SafetyFilterLevel2["BLOCK_ONLY_HIGH"] = "BLOCK_ONLY_HIGH";
SafetyFilterLevel2["BLOCK_NONE"] = "BLOCK_NONE";
})(SafetyFilterLevel || (SafetyFilterLevel = {}));
var PersonGeneration;
(function(PersonGeneration2) {
PersonGeneration2["DONT_ALLOW"] = "DONT_ALLOW";
PersonGeneration2["ALLOW_ADULT"] = "ALLOW_ADULT";
PersonGeneration2["ALLOW_ALL"] = "ALLOW_ALL";
})(PersonGeneration || (PersonGeneration = {}));
var ImagePromptLanguage;
(function(ImagePromptLanguage2) {
ImagePromptLanguage2["auto"] = "auto";
ImagePromptLanguage2["en"] = "en";
ImagePromptLanguage2["ja"] = "ja";
ImagePromptLanguage2["ko"] = "ko";
ImagePromptLanguage2["hi"] = "hi";
ImagePromptLanguage2["zh"] = "zh";
ImagePromptLanguage2["pt"] = "pt";
ImagePromptLanguage2["es"] = "es";
})(ImagePromptLanguage || (ImagePromptLanguage = {}));
var MaskReferenceMode;
(function(MaskReferenceMode2) {
MaskReferenceMode2["MASK_MODE_DEFAULT"] = "MASK_MODE_DEFAULT";
MaskReferenceMode2["MASK_MODE_USER_PROVIDED"] = "MASK_MODE_USER_PROVIDED";
MaskReferenceMode2["MASK_MODE_BACKGROUND"] = "MASK_MODE_BACKGROUND";
MaskReferenceMode2["MASK_MODE_FOREGROUND"] = "MASK_MODE_FOREGROUND";
MaskReferenceMode2["MASK_MODE_SEMANTIC"] = "MASK_MODE_SEMANTIC";
})(MaskReferenceMode || (MaskReferenceMode = {}));
var ControlReferenceType;
(function(ControlReferenceType2) {
ControlReferenceType2["CONTROL_TYPE_DEFAULT"] = "CONTROL_TYPE_DEFAULT";
ControlReferenceType2["CONTROL_TYPE_CANNY"] = "CONTROL_TYPE_CANNY";
ControlReferenceType2["CONTROL_TYPE_SCRIBBLE"] = "CONTROL_TYPE_SCRIBBLE";
ControlReferenceType2["CONTROL_TYPE_FACE_MESH"] = "CONTROL_TYPE_FACE_MESH";
})(ControlReferenceType || (ControlReferenceType = {}));
var SubjectReferenceType;
(function(SubjectReferenceType2) {
SubjectReferenceType2["SUBJECT_TYPE_DEFAULT"] = "SUBJECT_TYPE_DEFAULT";
SubjectReferenceType2["SUBJECT_TYPE_PERSON"] = "SUBJECT_TYPE_PERSON";
SubjectReferenceType2["SUBJECT_TYPE_ANIMAL"] = "SUBJECT_TYPE_ANIMAL";
SubjectReferenceType2["SUBJECT_TYPE_PRODUCT"] = "SUBJECT_TYPE_PRODUCT";
})(SubjectReferenceType || (SubjectReferenceType = {}));
var EditMode;
(function(EditMode2) {
EditMode2["EDIT_MODE_DEFAULT"] = "EDIT_MODE_DEFAULT";
EditMode2["EDIT_MODE_INPAINT_REMOVAL"] = "EDIT_MODE_INPAINT_REMOVAL";
EditMode2["EDIT_MODE_INPAINT_INSERTION"] = "EDIT_MODE_INPAINT_INSERTION";
EditMode2["EDIT_MODE_OUTPAINT"] = "EDIT_MODE_OUTPAINT";
EditMode2["EDIT_MODE_CONTROLLED_EDITING"] = "EDIT_MODE_CONTROLLED_EDITING";
EditMode2["EDIT_MODE_STYLE"] = "EDIT_MODE_STYLE";
EditMode2["EDIT_MODE_BGSWAP"] = "EDIT_MODE_BGSWAP";
EditMode2["EDIT_MODE_PRODUCT_IMAGE"] = "EDIT_MODE_PRODUCT_IMAGE";
})(EditMode || (EditMode = {}));
var SegmentMode;
(function(SegmentMode2) {
SegmentMode2["FOREGROUND"] = "FOREGROUND";
SegmentMode2["BACKGROUND"] = "BACKGROUND";
SegmentMode2["PROMPT"] = "PROMPT";
SegmentMode2["SEMANTIC"] = "SEMANTIC";
SegmentMode2["INTERACTIVE"] = "INTERACTIVE";
})(SegmentMode || (SegmentMode = {}));
var VideoGenerationReferenceType;
(function(VideoGenerationReferenceType2) {
VideoGenerationReferenceType2["ASSET"] = "ASSET";
VideoGenerationReferenceType2["STYLE"] = "STYLE";
})(VideoGenerationReferenceType || (VideoGenerationReferenceType = {}));
var VideoGenerationMaskMode;
(function(VideoGenerationMaskMode2) {
VideoGenerationMaskMode2["INSERT"] = "INSERT";
VideoGenerationMaskMode2["REMOVE"] = "REMOVE";
VideoGenerationMaskMode2["REMOVE_STATIC"] = "REMOVE_STATIC";
VideoGenerationMaskMode2["OUTPAINT"] = "OUTPAINT";
})(VideoGenerationMaskMode || (VideoGenerationMaskMode = {}));
var VideoCompressionQuality;
(function(VideoCompressionQuality2) {
VideoCompressionQuality2["OPTIMIZED"] = "OPTIMIZED";
VideoCompressionQuality2["LOSSLESS"] = "LOSSLESS";
})(VideoCompressionQuality || (VideoCompressionQuality = {}));
var TuningMethod;
(function(TuningMethod2) {
TuningMethod2["SUPERVISED_FINE_TUNING"] = "SUPERVISED_FINE_TUNING";
TuningMethod2["PREFERENCE_TUNING"] = "PREFERENCE_TUNING";
})(TuningMethod || (TuningMethod = {}));
var DocumentState;
(function(DocumentState2) {
DocumentState2["STATE_UNSPECIFIED"] = "STATE_UNSPECIFIED";
DocumentState2["STATE_PENDING"] = "STATE_PENDING";
DocumentState2["STATE_ACTIVE"] = "STATE_ACTIVE";
DocumentState2["STATE_FAILED"] = "STATE_FAILED";
})(DocumentState || (DocumentState = {}));
var FileState;
(function(FileState2) {
FileState2["STATE_UNSPECIFIED"] = "STATE_UNSPECIFIED";
FileState2["PROCESSING"] = "PROCESSING";
FileState2["ACTIVE"] = "ACTIVE";
FileState2["FAILED"] = "FAILED";
})(FileState || (FileState = {}));
var FileSource;
(function(FileSource2) {
FileSource2["SOURCE_UNSPECIFIED"] = "SOURCE_UNSPECIFIED";
FileSource2["UPLOADED"] = "UPLOADED";
FileSource2["GENERATED"] = "GENERATED";
})(FileSource || (FileSource = {}));
var TurnCompleteReason;
(function(TurnCompleteReason2) {
TurnCompleteReason2["TURN_COMPLETE_REASON_UNSPECIFIED"] = "TURN_COMPLETE_REASON_UNSPECIFIED";
TurnCompleteReason2["MALFORMED_FUNCTION_CALL"] = "MALFORMED_FUNCTION_CALL";
TurnCompleteReason2["RESPONSE_REJECTED"] = "RESPONSE_REJECTED";
TurnCompleteReason2["NEED_MORE_INPUT"] = "NEED_MORE_INPUT";
})(TurnCompleteReason || (TurnCompleteReason = {}));
var MediaModality;
(function(MediaModality2) {
MediaModality2["MODALITY_UNSPECIFIED"] = "MODALITY_UNSPECIFIED";
MediaModality2["TEXT"] = "TEXT";
MediaModality2["IMAGE"] = "IMAGE";
MediaModality2["VIDEO"] = "VIDEO";
MediaModality2["AUDIO"] = "AUDIO";
MediaModality2["DOCUMENT"] = "DOCUMENT";
})(MediaModality || (MediaModality = {}));
var StartSensitivity;
(function(StartSensitivity2) {
StartSensitivity2["START_SENSITIVITY_UNSPECIFIED"] = "START_SENSITIVITY_UNSPECIFIED";
StartSensitivity2["START_SENSITIVITY_HIGH"] = "START_SENSITIVITY_HIGH";
StartSensitivity2["START_SENSITIVITY_LOW"] = "START_SENSITIVITY_LOW";
})(StartSensitivity || (StartSensitivity = {}));
var EndSensitivity;
(function(EndSensitivity2) {
EndSensitivity2["END_SENSITIVITY_UNSPECIFIED"] = "END_SENSITIVITY_UNSPECIFIED";
EndSensitivity2["END_SENSITIVITY_HIGH"] = "END_SENSITIVITY_HIGH";
EndSensitivity2["END_SENSITIVITY_LOW"] = "END_SENSITIVITY_LOW";
})(EndSensitivity || (EndSensitivity = {}));
var ActivityHandling;
(function(ActivityHandling2) {
ActivityHandling2["ACTIVITY_HANDLING_UNSPECIFIED"] = "ACTIVITY_HANDLING_UNSPECIFIED";
ActivityHandling2["START_OF_ACTIVITY_INTERRUPTS"] = "START_OF_ACTIVITY_INTERRUPTS";
ActivityHandling2["NO_INTERRUPTION"] = "NO_INTERRUPTION";
})(ActivityHandling || (ActivityHandling = {}));
var TurnCoverage;
(function(TurnCoverage2) {
TurnCoverage2["TURN_COVERAGE_UNSPECIFIED"] = "TURN_COVERAGE_UNSPECIFIED";
TurnCoverage2["TURN_INCLUDES_ONLY_ACTIVITY"] = "TURN_INCLUDES_ONLY_ACTIVITY";
TurnCoverage2["TURN_INCLUDES_ALL_INPUT"] = "TURN_INCLUDES_ALL_INPUT";
})(TurnCoverage || (TurnCoverage = {}));
var Scale;
(function(Scale2) {
Scale2["SCALE_UNSPECIFIED"] = "SCALE_UNSPECIFIED";
Scale2["C_MAJOR_A_MINOR"] = "C_MAJOR_A_MINOR";
Scale2["D_FLAT_MAJOR_B_FLAT_MINOR"] = "D_FLAT_MAJOR_B_FLAT_MINOR";
Scale2["D_MAJOR_B_MINOR"] = "D_MAJOR_B_MINOR";
Scale2["E_FLAT_MAJOR_C_MINOR"] = "E_FLAT_MAJOR_C_MINOR";
Scale2["E_MAJOR_D_FLAT_MINOR"] = "E_MAJOR_D_FLAT_MINOR";
Scale2["F_MAJOR_D_MINOR"] = "F_MAJOR_D_MINOR";
Scale2["G_FLAT_MAJOR_E_FLAT_MINOR"] = "G_FLAT_MAJOR_E_FLAT_MINOR";
Scale2["G_MAJOR_E_MINOR"] = "G_MAJOR_E_MINOR";
Scale2["A_FLAT_MAJOR_F_MINOR"] = "A_FLAT_MAJOR_F_MINOR";
Scale2["A_MAJOR_G_FLAT_MINOR"] = "A_MAJOR_G_FLAT_MINOR";
Scale2["B_FLAT_MAJOR_G_MINOR"] = "B_FLAT_MAJOR_G_MINOR";
Scale2["B_MAJOR_A_FLAT_MINOR"] = "B_MAJOR_A_FLAT_MINOR";
})(Scale || (Scale = {}));
var MusicGenerationMode;
(function(MusicGenerationMode2) {
MusicGenerationMode2["MUSIC_GENERATION_MODE_UNSPECIFIED"] = "MUSIC_GENERATION_MODE_UNSPECIFIED";
MusicGenerationMode2["QUALITY"] = "QUALITY";
MusicGenerationMode2["DIVERSITY"] = "DIVERSITY";
MusicGenerationMode2["VOCALIZATION"] = "VOCALIZATION";
})(MusicGenerationMode || (MusicGenerationMode = {}));
var LiveMusicPlaybackControl;
(function(LiveMusicPlaybackControl2) {
LiveMusicPlaybackControl2["PLAYBACK_CONTROL_UNSPECIFIED"] = "PLAYBACK_CONTROL_UNSPECIFIED";
LiveMusicPlaybackControl2["PLAY"] = "PLAY";
LiveMusicPlaybackControl2["PAUSE"] = "PAUSE";
LiveMusicPlaybackControl2["STOP"] = "STOP";
LiveMusicPlaybackControl2["RESET_CONTEXT"] = "RESET_CONTEXT";
})(LiveMusicPlaybackControl || (LiveMusicPlaybackControl = {}));
function createPartFromText(text) {
return {
text
};
}
function _isPart(obj) {
if (typeof obj === "object" && obj !== null) {
return "fileData" in obj || "text" in obj || "functionCall" in obj || "functionResponse" in obj || "inlineData" in obj || "videoMetadata" in obj || "codeExecutionResult" in obj || "executableCode" in obj;
}
return false;
}
function _toParts(partOrString) {
const parts = [];
if (typeof partOrString === "string") {
parts.push(createPartFromText(partOrString));
} else if (_isPart(partOrString)) {
parts.push(partOrString);
} else if (Array.isArray(partOrString)) {
if (partOrString.length === 0) {
throw new Error("partOrString cannot be an empty array");
}
for (const part of partOrString) {
if (typeof part === "string") {
parts.push(createPartFromText(part));
} else if (_isPart(part)) {
parts.push(part);
} else {
throw new Error("element in PartUnion must be a Part object or string");
}
}
} else {
throw new Error("partOrString must be a Part object, string, or array");
}
return parts;
}
function createUserContent(partOrString) {
return {
role: "user",
parts: _toParts(partOrString)
};
}
var HttpResponse = class {
constructor(response) {
const headers = {};
for (const pair of response.headers.entries()) {
headers[pair[0]] = pair[1];
}
this.headers = headers;
this.responseInternal = response;
}
json() {
return this.responseInternal.json();
}
};
var GenerateContentResponse = class {
/**
* Returns the concatenation of all text parts from the first candidate in the response.
*
* @remarks
* If there are multiple candidates in the response, the text from the first
* one will be returned.
* If there are non-text parts in the response, the concatenation of all text
* parts will be returned, and a warning will be logged.
* If there are thought parts in the response, the concatenation of all text
* parts excluding the thought parts will be returned.
*
* @example
* ```ts
* const response = await ai.models.generateContent({
* model: 'gemini-2.0-flash',
* contents:
* 'Why is the sky blue?',
* });
*
* console.debug(response.text);
* ```
*/
get text() {
var _a, _b, _c, _d, _e, _f, _g, _h;
if (((_d = (_c = (_b = (_a = this.candidates) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.content) === null || _c === void 0 ? void 0 : _c.parts) === null || _d === void 0 ? void 0 : _d.length) === 0) {
return void 0;
}
if (this.candidates && this.candidates.length > 1) {
console.warn("there are multiple candidates in the response, returning text from the first one.");
}
let text = "";
let anyTextPartText = false;
const nonTextParts = [];
for (const part of (_h = (_g = (_f = (_e = this.candidates) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.content) === null || _g === void 0 ? void 0 : _g.parts) !== null && _h !== void 0 ? _h : []) {
for (const [fieldName, fieldValue] of Object.entries(part)) {
if (fieldName !== "text" && fieldName !== "thought" && fieldName !== "thoughtSignature" && (fieldValue !== null || fieldValue !== void 0)) {
nonTextParts.push(fieldName);
}
}
if (typeof part.text === "string") {
if (typeof part.thought === "boolean" && part.thought) {
continue;
}
anyTextPartText = true;
text += part.text;
}
}
if (nonTextParts.length > 0) {
console.warn(`there are non-text parts ${nonTextParts} in the response, returning concatenation of all text parts. Please refer to the non text parts for a full response from model.`);
}
return anyTextPartText ? text : void 0;
}
/**
* Returns the concatenation of all inline data parts from the first candidate
* in the response.
*
* @remarks
* If there are multiple candidates in the response, the inline data from the
* first one will be returned. If there are non-inline data parts in the
* response, the concatenation of all inline data parts will be returned, and
* a warning will be logged.
*/
get data() {
var _a, _b, _c, _d, _e, _f, _g, _h;
if (((_d = (_c = (_b = (_a = this.candidates) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.content) === null || _c === void 0 ? void 0 : _c.parts) === null || _d === void 0 ? void 0 : _d.length) === 0) {
return void 0;
}
if (this.candidates && this.candidates.length > 1) {
console.warn("there are multiple candidates in the response, returning data from the first one.");
}
let data = "";
const nonDataParts = [];
for (const part of (_h = (_g = (_f = (_e = this.candidates) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.content) === null || _g === void 0 ? void 0 : _g.parts) !== null && _h !== void 0 ? _h : []) {
for (const [fieldName, fieldValue] of Object.entries(part)) {
if (fieldName !== "inlineData" && (fieldValue !== null || fieldValue !== void 0)) {
nonDataParts.push(fieldName);
}
}
if (part.inlineData && typeof part.inlineData.data === "string") {
data += atob(part.inlineData.data);
}
}
if (nonDataParts.length > 0) {
console.warn(`there are non-data parts ${nonDataParts} in the response, returning concatenation of all data parts. Please refer to the non data parts for a full response from model.`);
}
return data.length > 0 ? btoa(data) : void 0;
}
/**
* Returns the function calls from the first candidate in the response.
*
* @remarks
* If there are multiple candidates in the response, the function calls from
* the first one will be returned.
* If there are no function calls in the response, undefined will be returned.
*
* @example
* ```ts
* const controlLightFunctionDeclaration: FunctionDeclaration = {
* name: 'controlLight',
* parameters: {
* type: Type.OBJECT,
* description: 'Set the brightness and color temperature of a room light.',
* properties: {
* brightness: {
* type: Type.NUMBER,
* description:
* 'Light level from 0 to 100. Zero is off and 100 is full brightness.',
* },
* colorTemperature: {
* type: Type.STRING,
* description:
* 'Color temperature of the light fixture which can be `daylight`, `cool` or `warm`.',
* },
* },
* required: ['brightness', 'colorTemperature'],
* };
* const response = await ai.models.generateContent({
* model: 'gemini-2.0-flash',
* contents: 'Dim the lights so the room feels cozy and warm.',
* config: {
* tools: [{functionDeclarations: [controlLightFunctionDeclaration]}],
* toolConfig: {
* functionCallingConfig: {
* mode: FunctionCallingConfigMode.ANY,
* allowedFunctionNames: ['controlLight'],
* },
* },
* },
* });
* console.debug(JSON.stringify(response.functionCalls));
* ```
*/
get functionCalls() {
var _a, _b, _c, _d, _e, _f, _g, _h;
if (((_d = (_c = (_b = (_a = this.candidates) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.content) === null || _c === void 0 ? void 0 : _c.parts) === null || _d === void 0 ? void 0 : _d.length) === 0) {
return void 0;
}
if (this.candidates && this.candidates.length > 1) {
console.warn("there are multiple candidates in the response, returning function calls from the first one.");
}
const functionCalls = (_h = (_g = (_f = (_e = this.candidates) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.content) === null || _g === void 0 ? void 0 : _g.parts) === null || _h === void 0 ? void 0 : _h.filter((part) => part.functionCall).map((part) => part.functionCall).filter((functionCall) => functionCall !== void 0);
if ((functionCalls === null || functionCalls === void 0 ? void 0 : functionCalls.length) === 0) {
return void 0;
}
return functionCalls;
}
/**
* Returns the first executable code from the first candidate in the response.
*
* @remarks
* If there are multiple candidates in the response, the executable code from
* the first one will be returned.
* If there are no executable code in the response, undefined will be
* returned.
*
* @example
* ```ts
* const response = await ai.models.generateContent({
* model: 'gemini-2.0-flash',
* contents:
* 'What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50.'
* config: {
* tools: [{codeExecution: {}}],
* },
* });
*
* console.debug(response.executableCode);
* ```
*/
get executableCode() {
var _a, _b, _c, _d, _e, _f, _g, _h, _j;
if (((_d = (_c = (_b = (_a = this.candidates) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.content) === null || _c === void 0 ? void 0 : _c.parts) === null || _d === void 0 ? void 0 : _d.length) === 0) {
return void 0;
}
if (this.candidates && this.candidates.length > 1) {
console.warn("there are multiple candidates in the response, returning executable code from the first one.");
}
const executableCode = (_h = (_g = (_f = (_e = this.candidates) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.content) === null || _g === void 0 ? void 0 : _g.parts) === null || _h === void 0 ? void 0 : _h.filter((part) => part.executableCode).map((part) => part.executableCode).filter((executableCode2) => executableCode2 !== void 0);
if ((executableCode === null || executableCode === void 0 ? void 0 : executableCode.length) === 0) {
return void 0;
}
return (_j = executableCode === null || executableCode === void 0 ? void 0 : executableCode[0]) === null || _j === void 0 ? void 0 : _j.code;
}
/**
* Returns the first code execution result from the first candidate in the response.
*
* @remarks
* If there are multiple candidates in the response, the code execution result from
* the first one will be returned.
* If there are no code execution result in the response, undefined will be returned.
*
* @example
* ```ts
* const response = await ai.models.generateContent({
* model: 'gemini-2.0-flash',
* contents:
* 'What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50.'
* config: {
* tools: [{codeExecution: {}}],
* },
* });
*
* console.debug(response.codeExecutionResult);
* ```
*/
get codeExecutionResult() {
var _a, _b, _c, _d, _e, _f, _g, _h, _j;
if (((_d = (_c = (_b = (_a = this.candidates) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.content) === null || _c === void 0 ? void 0 : _c.parts) === null || _d === void 0 ? void 0 : _d.length) === 0) {
return void 0;
}
if (this.candidates && this.candidates.length > 1) {
console.warn("there are multiple candidates in the response, returning code execution result from the first one.");
}
const codeExecutionResult = (_h = (_g = (_f = (_e = this.candidates) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.content) === null || _g === void 0 ? void 0 : _g.parts) === null || _h === void 0 ? void 0 : _h.filter((part) => part.codeExecutionResult).map((part) => part.codeExecutionResult).filter((codeExecutionResult2) => codeExecutionResult2 !== void 0);
if ((codeExecutionResult === null || codeExecutionResult === void 0 ? void 0 : codeExecutionResult.length) === 0) {
return void 0;
}
return (_j = codeExecutionResult === null || codeExecutionResult === void 0 ? void 0 : codeExecutionResult[0]) === null || _j === void 0 ? void 0 : _j.output;
}
};
var EmbedContentResponse = class {
};
var GenerateImagesResponse = class {
};
var EditImageResponse = class {
};
var UpscaleImageResponse = class {
};
var RecontextImageResponse = class {
};
var SegmentImageResponse = class {
};
var ListModelsResponse = class {
};
var DeleteModelResponse = class {
};
var CountTokensResponse = class {
};
var ComputeTokensResponse = class {
};
var GenerateVideosOperation = class _GenerateVideosOperation {
/**
* Instantiates an Operation of the same type as the one being called with the fields set from the API response.
* @internal
*/
_fromAPIResponse({ apiResponse, _isVertexAI }) {
const operation = new _GenerateVideosOperation();
let response;
const op = apiResponse;
if (_isVertexAI) {
response = generateVideosOperationFromVertex$1(op);
} else {
response = generateVideosOperationFromMldev$1(op);
}
Object.assign(operation, response);
return operation;
}
};
var ListTuningJobsResponse = class {
};
var DeleteCachedContentResponse = class {
};
var ListCachedContentsResponse = class {
};
var ListDocumentsResponse = class {
};
var ListFileSearchStoresResponse = class {
};
var UploadToFileSearchStoreResumableResponse = class {
};
var ImportFileOperation = class _ImportFileOperation {
/**
* Instantiates an Operation of the same type as the one being called with the fields set from the API response.
* @internal
*/
_fromAPIResponse({ apiResponse, _isVertexAI }) {
const operation = new _ImportFileOperation();
const op = apiResponse;
const response = importFileOperationFromMldev$1(op);
Object.assign(operation, response);
return operation;
}
};
var ListFilesResponse = class {
};
var CreateFileResponse = class {
};
var DeleteFileResponse = class {
};
var ListBatchJobsResponse = class {
};
var LiveServerMessage = class {
/**
* Returns the concatenation of all text parts from the server content if present.
*
* @remarks
* If there are non-text parts in the response, the concatenation of all text
* parts will be returned, and a warning will be logged.
*/
get text() {
var _a, _b, _c;
let text = "";
let anyTextPartFound = false;
const nonTextParts = [];
for (const part of (_c = (_b = (_a = this.serverContent) === null || _a === void 0 ? void 0 : _a.modelTurn) === null || _b === void 0 ? void 0 : _b.parts) !== null && _c !== void 0 ? _c : []) {
for (const [fieldName, fieldValue] of Object.entries(part)) {
if (fieldName !== "text" && fieldName !== "thought" && fieldValue !== null) {
nonTextParts.push(fieldName);
}
}
if (typeof part.text === "string") {
if (typeof part.thought === "boolean" && part.thought) {
continue;
}
anyTextPartFound = true;
text += part.text;
}
}
if (nonTextParts.length > 0) {
console.warn(`there are non-text parts ${nonTextParts} in the response, returning concatenation of all text parts. Please refer to the non text parts for a full response from model.`);
}
return anyTextPartFound ? text : void 0;
}
/**
* Returns the concatenation of all inline data parts from the server content if present.
*
* @remarks
* If there are non-inline data parts in the
* response, the concatenation of all inline data parts will be returned, and
* a warning will be logged.
*/
get data() {
var _a, _b, _c;
let data = "";
const nonDataParts = [];
for (const part of (_c = (_b = (_a = this.serverContent) === null || _a === void 0 ? void 0 : _a.modelTurn) === null || _b === void 0 ? void 0 : _b.parts) !== null && _c !== void 0 ? _c : []) {
for (const [fieldName, fieldValue] of Object.entries(part)) {
if (fieldName !== "inlineData" && fieldValue !== null) {
nonDataParts.push(fieldName);
}
}
if (part.inlineData && typeof part.inlineData.data === "string") {
data += atob(part.inlineData.data);
}
}
if (nonDataParts.length > 0) {
console.warn(`there are non-data parts ${nonDataParts} in the response, returning concatenation of all data parts. Please refer to the non data parts for a full response from model.`);
}
return data.length > 0 ? btoa(data) : void 0;
}
};
var LiveMusicServerMessage = class {
/**
* Returns the first audio chunk from the server content, if present.
*
* @remarks
* If there are no audio chunks in the response, undefined will be returned.
*/
get audioChunk() {
if (this.serverContent && this.serverContent.audioChunks && this.serverContent.audioChunks.length > 0) {
return this.serverContent.audioChunks[0];
}
return void 0;
}
};
var UploadToFileSearchStoreOperation = class _UploadToFileSearchStoreOperation {
/**
* Instantiates an Operation of the same type as the one being called with the fields set from the API response.
* @internal
*/
_fromAPIResponse({ apiResponse, _isVertexAI }) {
const operation = new _UploadToFileSearchStoreOperation();
const op = apiResponse;
const response = uploadToFileSearchStoreOperationFromMldev(op);
Object.assign(operation, response);
return operation;
}
};
function tModel(apiClient, model) {
if (!model || typeof model !== "string") {
throw new Error("model is required and must be a string");
}
if (model.includes("..") || model.includes("?") || model.includes("&")) {
throw new Error("invalid model parameter");
}
if (apiClient.isVertexAI()) {
if (model.startsWith("publishers/") || model.startsWith("projects/") || model.startsWith("models/")) {
return model;
} else if (model.indexOf("/") >= 0) {
const parts = model.split("/", 2);
return `publishers/${parts[0]}/models/${parts[1]}`;
} else {
return `publishers/google/models/${model}`;
}
} else {
if (model.startsWith("models/") || model.startsWith("tunedModels/")) {
return model;
} else {
return `models/${model}`;
}
}
}
function tCachesModel(apiClient, model) {
const transformedModel = tModel(apiClient, model);
if (!transformedModel) {
return "";
}
if (transformedModel.startsWith("publishers/") && apiClient.isVertexAI()) {
return `projects/${apiClient.getProject()}/locations/${apiClient.getLocation()}/${transformedModel}`;
} else if (transformedModel.startsWith("models/") && apiClient.isVertexAI()) {
return `projects/${apiClient.getProject()}/locations/${apiClient.getLocation()}/publishers/google/${transformedModel}`;
} else {
return transformedModel;
}
}
function tBlobs(blobs) {
if (Array.isArray(blobs)) {
return blobs.map((blob) => tBlob(blob));
} else {
return [tBlob(blobs)];
}
}
function tBlob(blob) {
if (typeof blob === "object" && blob !== null) {
return blob;
}
throw new Error(`Could not parse input as Blob. Unsupported blob type: ${typeof blob}`);
}
function tImageBlob(blob) {
const transformedBlob = tBlob(blob);
if (transformedBlob.mimeType && transformedBlob.mimeType.startsWith("image/")) {
return transformedBlob;
}
throw new Error(`Unsupported mime type: ${transformedBlob.mimeType}`);
}
function tAudioBlob(blob) {
const transformedBlob = tBlob(blob);
if (transformedBlob.mimeType && transformedBlob.mimeType.startsWith("audio/")) {
return transformedBlob;
}
throw new Error(`Unsupported mime type: ${transformedBlob.mimeType}`);
}
function tPart(origin) {
if (origin === null || origin === void 0) {
throw new Error("PartUnion is required");
}
if (typeof origin === "object") {
return origin;
}
if (typeof origin === "string") {
return { text: origin };
}
throw new Error(`Unsupported part type: ${typeof origin}`);
}
function tParts(origin) {
if (origin === null || origin === void 0 || Array.isArray(origin) && origin.length === 0) {
throw new Error("PartListUnion is required");
}
if (Array.isArray(origin)) {
return origin.map((item) => tPart(item));
}
return [tPart(origin)];
}
function _isContent(origin) {
return origin !== null && origin !== void 0 && typeof origin === "object" && "parts" in origin && Array.isArray(origin.parts);
}
function _isFunctionCallPart(origin) {
return origin !== null && origin !== void 0 && typeof origin === "object" && "functionCall" in origin;
}
function _isFunctionResponsePart(origin) {
return origin !== null && origin !== void 0 && typeof origin === "object" && "functionResponse" in origin;
}
function tContent(origin) {
if (origin === null || origin === void 0) {
throw new Error("ContentUnion is required");
}
if (_isContent(origin)) {
return origin;
}
return {
role: "user",
parts: tParts(origin)
};
}
function tContentsForEmbed(apiClient, origin) {
if (!origin) {
return [];
}
if (apiClient.isVertexAI() && Array.isArray(origin)) {
return origin.flatMap((item) => {
const content = tContent(item);
if (content.parts && content.parts.length > 0 && content.parts[0].text !== void 0) {
return [content.parts[0].text];
}
return [];
});
} else if (apiClient.isVertexAI()) {
const content = tContent(origin);
if (content.parts && content.parts.length > 0 && content.parts[0].text !== void 0) {
return [content.parts[0].text];
}
return [];
}
if (Array.isArray(origin)) {
return origin.map((item) => tContent(item));
}
return [tContent(origin)];
}
function tContents(origin) {
if (origin === null || origin === void 0 || Array.isArray(origin) && origin.length === 0) {
throw new Error("contents are required");
}
if (!Array.isArray(origin)) {
if (_isFunctionCallPart(origin) || _isFunctionResponsePart(origin)) {
throw new Error("To specify functionCall or functionResponse parts, please wrap them in a Content object, specifying the role for them");
}
return [tContent(origin)];
}
const result = [];
const accumulatedParts = [];
const isContentArray = _isContent(origin[0]);
for (const item of origin) {
const isContent = _isContent(item);
if (isContent != isContentArray) {
throw new Error("Mixing Content and Parts is not supported, please group the parts into a the appropriate Content objects and specify the roles for them");
}
if (isContent) {
result.push(item);
} else if (_isFunctionCallPart(item) || _isFunctionResponsePart(item)) {
throw new Error("To specify functionCall or functionResponse parts, please wrap them, and any other parts, in Content objects as appropriate, specifying the role for them");
} else {
accumulatedParts.push(item);
}
}
if (!isContentArray) {
result.push({ role: "user", parts: tParts(accumulatedParts) });
}
return result;
}
function flattenTypeArrayToAnyOf(typeList, resultingSchema) {
if (typeList.includes("null")) {
resultingSchema["nullable"] = true;
}
const listWithoutNull = typeList.filter((type) => type !== "null");
if (listWithoutNull.length === 1) {
resultingSchema["type"] = Object.values(Type).includes(listWithoutNull[0].toUpperCase()) ? listWithoutNull[0].toUpperCase() : Type.TYPE_UNSPECIFIED;
} else {
resultingSchema["anyOf"] = [];
for (const i of listWithoutNull) {
resultingSchema["anyOf"].push({
"type": Object.values(Type).includes(i.toUpperCase()) ? i.toUpperCase() : Type.TYPE_UNSPECIFIED
});
}
}
}
function processJsonSchema(_jsonSchema) {
const genAISchema = {};
const schemaFieldNames = ["items"];
const listSchemaFieldNames = ["anyOf"];
const dictSchemaFieldNames = ["properties"];
if (_jsonSchema["type"] && _jsonSchema["anyOf"]) {
throw new Error("type and anyOf cannot be both populated.");
}
const incomingAnyOf = _jsonSchema["anyOf"];
if (incomingAnyOf != null && incomingAnyOf.length == 2) {
if (incomingAnyOf[0]["type"] === "null") {
genAISchema["nullable"] = true;
_jsonSchema = incomingAnyOf[1];
} else if (incomingAnyOf[1]["type"] === "null") {
genAISchema["nullable"] = true;
_jsonSchema = incomingAnyOf[0];
}
}
if (_jsonSchema["type"] instanceof Array) {
flattenTypeArrayToAnyOf(_jsonSchema["type"], genAISchema);
}
for (const [fieldName, fieldValue] of Object.entries(_jsonSchema)) {
if (fieldValue == null) {
continue;
}
if (fieldName == "type") {
if (fieldValue === "null") {
throw new Error("type: null can not be the only possible type for the field.");
}
if (fieldValue instanceof Array) {
continue;
}
genAISchema["type"] = Object.values(Type).includes(fieldValue.toUpperCase()) ? fieldValue.toUpperCase() : Type.TYPE_UNSPECIFIED;
} else if (schemaFieldNames.includes(fieldName)) {
genAISchema[fieldName] = processJsonSchema(fieldValue);
} else if (listSchemaFieldNames.includes(fieldName)) {
const listSchemaFieldValue = [];
for (const item of fieldValue) {
if (item["type"] == "null") {
genAISchema["nullable"] = true;
continue;
}
listSchemaFieldValue.push(processJsonSchema(item));
}
genAISchema[fieldName] = listSchemaFieldValue;
} else if (dictSchemaFieldNames.includes(fieldName)) {
const dictSchemaFieldValue = {};
for (const [key, value] of Object.entries(fieldValue)) {
dictSchemaFieldValue[key] = processJsonSchema(value);
}
genAISchema[fieldName] = dictSchemaFieldValue;
} else {
if (fieldName === "additionalProperties") {
continue;
}
genAISchema[fieldName] = fieldValue;
}
}
return genAISchema;
}
function tSchema(schema) {
return processJsonSchema(schema);
}
function tSpeechConfig(speechConfig) {
if (typeof speechConfig === "object") {
return speechConfig;
} else if (typeof speechConfig === "string") {
return {
voiceConfig: {
prebuiltVoiceConfig: {
voiceName: speechConfig
}
}
};
} else {
throw new Error(`Unsupported speechConfig type: ${typeof speechConfig}`);
}
}
function tLiveSpeechConfig(speechConfig) {
if ("multiSpeakerVoiceConfig" in speechConfig) {
throw new Error("multiSpeakerVoiceConfig is not supported in the live API.");
}
return speechConfig;
}
function tTool(tool) {
if (tool.functionDeclarations) {
for (const functionDeclaration of tool.functionDeclarations) {
if (functionDeclaration.parameters) {
if (!Object.keys(functionDeclaration.parameters).includes("$schema")) {
functionDeclaration.parameters = processJsonSchema(functionDeclaration.parameters);
} else {
if (!functionDeclaration.parametersJsonSchema) {
functionDeclaration.parametersJsonSchema = functionDeclaration.parameters;
delete functionDeclaration.parameters;
}
}
}
if (functionDeclaration.response) {
if (!Object.keys(functionDeclaration.response).includes("$schema")) {
functionDeclaration.response = processJsonSchema(functionDeclaration.response);
} else {
if (!functionDeclaration.responseJsonSchema) {
functionDeclaration.responseJsonSchema = functionDeclaration.response;
delete functionDeclaration.response;
}
}
}
}
}
return tool;
}
function tTools(tools) {
if (tools === void 0 || tools === null) {
throw new Error("tools is required");
}
if (!Array.isArray(tools)) {
throw new Error("tools is required and must be an array of Tools");
}
const result = [];
for (const tool of tools) {
result.push(tool);
}
return result;
}
function resourceName(client, resourceName2, resourcePrefix, splitsAfterPrefix = 1) {
const shouldAppendPrefix = !resourceName2.startsWith(`${resourcePrefix}/`) && resourceName2.split("/").length === splitsAfterPrefix;
if (client.isVertexAI()) {
if (resourceName2.startsWith("projects/")) {
return resourceName2;
} else if (resourceName2.startsWith("locations/")) {
return `projects/${client.getProject()}/${resourceName2}`;
} else if (resourceName2.startsWith(`${resourcePrefix}/`)) {
return `projects/${client.getProject()}/locations/${client.getLocation()}/${resourceName2}`;
} else if (shouldAppendPrefix) {
return `projects/${client.getProject()}/locations/${client.getLocation()}/${resourcePrefix}/${resourceName2}`;
} else {
return resourceName2;
}
}
if (shouldAppendPrefix) {
return `${resourcePrefix}/${resourceName2}`;
}
return resourceName2;
}
function tCachedContentName(apiClient, name) {
if (typeof name !== "string") {
throw new Error("name must be a string");
}
return resourceName(apiClient, name, "cachedContents");
}
function tTuningJobStatus(status) {
switch (status) {
case "STATE_UNSPECIFIED":
return "JOB_STATE_UNSPECIFIED";
case "CREATING":
return "JOB_STATE_RUNNING";
case "ACTIVE":
return "JOB_STATE_SUCCEEDED";
case "FAILED":
return "JOB_STATE_FAILED";
default:
return status;
}
}
function tBytes(fromImageBytes) {
return tBytes$1(fromImageBytes);
}
function _isFile(origin) {
return origin !== null && origin !== void 0 && typeof origin === "object" && "name" in origin;
}
function isGeneratedVideo(origin) {
return origin !== null && origin !== void 0 && typeof origin === "object" && "video" in origin;
}
function isVideo(origin) {
return origin !== null && origin !== void 0 && typeof origin === "object" && "uri" in origin;
}
function tFileName(fromName) {
var _a;
let name;
if (_isFile(fromName)) {
name = fromName.name;
}
if (isVideo(fromName)) {
name = fromName.uri;
if (name === void 0) {
return void 0;
}
}
if (isGeneratedVideo(fromName)) {
name = (_a = fromName.video) === null || _a === void 0 ? void 0 : _a.uri;
if (name === void 0) {
return void 0;
}
}
if (typeof fromName === "string") {
name = fromName;
}
if (name === void 0) {
throw new Error("Could not extract file name from the provided input.");
}
if (name.startsWith("https://")) {
const suffix = name.split("files/")[1];
const match = suffix.match(/[a-z0-9]+/);
if (match === null) {
throw new Error(`Could not extract file name from URI ${name}`);
}
name = match[0];
} else if (name.startsWith("files/")) {
name = name.split("files/")[1];
}
return name;
}
function tModelsUrl(apiClient, baseModels) {
let res;
if (apiClient.isVertexAI()) {
res = baseModels ? "publishers/google/models" : "models";
} else {
res = baseModels ? "models" : "tunedModels";
}
return res;
}
function tExtractModels(response) {
for (const key of ["models", "tunedModels", "publisherModels"]) {
if (hasField(response, key)) {
return response[key];
}
}
return [];
}
function hasField(data, fieldName) {
return data !== null && typeof data === "object" && fieldName in data;
}
function mcpToGeminiTool(mcpTool, config = {}) {
const mcpToolSchema = mcpTool;
const functionDeclaration = {
name: mcpToolSchema["name"],
description: mcpToolSchema["description"],
parametersJsonSchema: mcpToolSchema["inputSchema"]
};
if (mcpToolSchema["outputSchema"]) {
functionDeclaration["responseJsonSchema"] = mcpToolSchema["outputSchema"];
}
if (config.behavior) {
functionDeclaration["behavior"] = config.behavior;
}
const geminiTool = {
functionDeclarations: [
functionDeclaration
]
};
return geminiTool;
}
function mcpToolsToGeminiTool(mcpTools, config = {}) {
const functionDeclarations = [];
const toolNames = /* @__PURE__ */ new Set();
for (const mcpTool of mcpTools) {
const mcpToolName = mcpTool.name;
if (toolNames.has(mcpToolName)) {
throw new Error(`Duplicate function name ${mcpToolName} found in MCP tools. Please ensure function names are unique.`);
}
toolNames.add(mcpToolName);
const geminiTool = mcpToGeminiTool(mcpTool, config);
if (geminiTool.functionDeclarations) {
functionDeclarations.push(...geminiTool.functionDeclarations);
}
}
return { functionDeclarations };
}
function tBatchJobSource(client, src) {
let sourceObj;
if (typeof src === "string") {
if (client.isVertexAI()) {
if (src.startsWith("gs://")) {
sourceObj = { format: "jsonl", gcsUri: [src] };
} else if (src.startsWith("bq://")) {
sourceObj = { format: "bigquery", bigqueryUri: src };
} else {
throw new Error(`Unsupported string source for Vertex AI: ${src}`);
}
} else {
if (src.startsWith("files/")) {
sourceObj = { fileName: src };
} else {
throw new Error(`Unsupported string source for Gemini API: ${src}`);
}
}
} else if (Array.isArray(src)) {
if (client.isVertexAI()) {
throw new Error("InlinedRequest[] is not supported in Vertex AI.");
}
sourceObj = { inlinedRequests: src };
} else {
sourceObj = src;
}
const vertexSourcesCount = [sourceObj.gcsUri, sourceObj.bigqueryUri].filter(Boolean).length;
const mldevSourcesCount = [
sourceObj.inlinedRequests,
sourceObj.fileName
].filter(Boolean).length;
if (client.isVertexAI()) {
if (mldevSourcesCount > 0 || vertexSourcesCount !== 1) {
throw new Error("Exactly one of `gcsUri` or `bigqueryUri` must be set for Vertex AI.");
}
} else {
if (vertexSourcesCount > 0 || mldevSourcesCount !== 1) {
throw new Error("Exactly one of `inlinedRequests`, `fileName`, must be set for Gemini API.");
}
}
return sourceObj;
}
function tBatchJobDestination(dest) {
if (typeof dest !== "string") {
return dest;
}
const destString = dest;
if (destString.startsWith("gs://")) {
return {
format: "jsonl",
gcsUri: destString
};
} else if (destString.startsWith("bq://")) {
return {
format: "bigquery",
bigqueryUri: destString
};
} else {
throw new Error(`Unsupported destination: ${destString}`);
}
}
function tRecvBatchJobDestination(dest) {
if (typeof dest !== "object" || dest === null) {
return {};
}
const obj = dest;
const inlineResponsesVal = obj["inlinedResponses"];
if (typeof inlineResponsesVal !== "object" || inlineResponsesVal === null) {
return dest;
}
const inlineResponsesObj = inlineResponsesVal;
const responsesArray = inlineResponsesObj["inlinedResponses"];
if (!Array.isArray(responsesArray) || responsesArray.length === 0) {
return dest;
}
let hasEmbedding = false;
for (const responseItem of responsesArray) {
if (typeof responseItem !== "object" || responseItem === null) {
continue;
}
const responseItemObj = responseItem;
const responseVal = responseItemObj["response"];
if (typeof responseVal !== "object" || responseVal === null) {
continue;
}
const responseObj = responseVal;
if (responseObj["embedding"] !== void 0) {
hasEmbedding = true;
break;
}
}
if (hasEmbedding) {
obj["inlinedEmbedContentResponses"] = obj["inlinedResponses"];
delete obj["inlinedResponses"];
}
return dest;
}
function tBatchJobName(apiClient, name) {
const nameString = name;
if (!apiClient.isVertexAI()) {
const mldevPattern = /batches\/[^/]+$/;
if (mldevPattern.test(nameString)) {
return nameString.split("/").pop();
} else {
throw new Error(`Invalid batch job name: ${nameString}.`);
}
}
const vertexPattern = /^projects\/[^/]+\/locations\/[^/]+\/batchPredictionJobs\/[^/]+$/;
if (vertexPattern.test(nameString)) {
return nameString.split("/").pop();
} else if (/^\d+$/.test(nameString)) {
return nameString;
} else {
throw new Error(`Invalid batch job name: ${nameString}.`);
}
}
function tJobState(state) {
const stateString = state;
if (stateString === "BATCH_STATE_UNSPECIFIED") {
return "JOB_STATE_UNSPECIFIED";
} else if (stateString === "BATCH_STATE_PENDING") {
return "JOB_STATE_PENDING";
} else if (stateString === "BATCH_STATE_RUNNING") {
return "JOB_STATE_RUNNING";
} else if (stateString === "BATCH_STATE_SUCCEEDED") {
return "JOB_STATE_SUCCEEDED";
} else if (stateString === "BATCH_STATE_FAILED") {
return "JOB_STATE_FAILED";
} else if (stateString === "BATCH_STATE_CANCELLED") {
return "JOB_STATE_CANCELLED";
} else if (stateString === "BATCH_STATE_EXPIRED") {
return "JOB_STATE_EXPIRED";
} else {
return stateString;
}
}
function batchJobDestinationFromMldev(fromObject) {
const toObject = {};
const fromFileName = getValueByPath(fromObject, ["responsesFile"]);
if (fromFileName != null) {
setValueByPath(toObject, ["fileName"], fromFileName);
}
const fromInlinedResponses = getValueByPath(fromObject, [
"inlinedResponses",
"inlinedResponses"
]);
if (fromInlinedResponses != null) {
let transformedList = fromInlinedResponses;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return inlinedResponseFromMldev(item);
});
}
setValueByPath(toObject, ["inlinedResponses"], transformedList);
}
const fromInlinedEmbedContentResponses = getValueByPath(fromObject, [
"inlinedEmbedContentResponses",
"inlinedResponses"
]);
if (fromInlinedEmbedContentResponses != null) {
let transformedList = fromInlinedEmbedContentResponses;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["inlinedEmbedContentResponses"], transformedList);
}
return toObject;
}
function batchJobDestinationFromVertex(fromObject) {
const toObject = {};
const fromFormat = getValueByPath(fromObject, ["predictionsFormat"]);
if (fromFormat != null) {
setValueByPath(toObject, ["format"], fromFormat);
}
const fromGcsUri = getValueByPath(fromObject, [
"gcsDestination",
"outputUriPrefix"
]);
if (fromGcsUri != null) {
setValueByPath(toObject, ["gcsUri"], fromGcsUri);
}
const fromBigqueryUri = getValueByPath(fromObject, [
"bigqueryDestination",
"outputUri"
]);
if (fromBigqueryUri != null) {
setValueByPath(toObject, ["bigqueryUri"], fromBigqueryUri);
}
return toObject;
}
function batchJobDestinationToVertex(fromObject) {
const toObject = {};
const fromFormat = getValueByPath(fromObject, ["format"]);
if (fromFormat != null) {
setValueByPath(toObject, ["predictionsFormat"], fromFormat);
}
const fromGcsUri = getValueByPath(fromObject, ["gcsUri"]);
if (fromGcsUri != null) {
setValueByPath(toObject, ["gcsDestination", "outputUriPrefix"], fromGcsUri);
}
const fromBigqueryUri = getValueByPath(fromObject, ["bigqueryUri"]);
if (fromBigqueryUri != null) {
setValueByPath(toObject, ["bigqueryDestination", "outputUri"], fromBigqueryUri);
}
if (getValueByPath(fromObject, ["fileName"]) !== void 0) {
throw new Error("fileName parameter is not supported in Vertex AI.");
}
if (getValueByPath(fromObject, ["inlinedResponses"]) !== void 0) {
throw new Error("inlinedResponses parameter is not supported in Vertex AI.");
}
if (getValueByPath(fromObject, ["inlinedEmbedContentResponses"]) !== void 0) {
throw new Error("inlinedEmbedContentResponses parameter is not supported in Vertex AI.");
}
return toObject;
}
function batchJobFromMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromDisplayName = getValueByPath(fromObject, [
"metadata",
"displayName"
]);
if (fromDisplayName != null) {
setValueByPath(toObject, ["displayName"], fromDisplayName);
}
const fromState = getValueByPath(fromObject, ["metadata", "state"]);
if (fromState != null) {
setValueByPath(toObject, ["state"], tJobState(fromState));
}
const fromCreateTime = getValueByPath(fromObject, [
"metadata",
"createTime"
]);
if (fromCreateTime != null) {
setValueByPath(toObject, ["createTime"], fromCreateTime);
}
const fromEndTime = getValueByPath(fromObject, [
"metadata",
"endTime"
]);
if (fromEndTime != null) {
setValueByPath(toObject, ["endTime"], fromEndTime);
}
const fromUpdateTime = getValueByPath(fromObject, [
"metadata",
"updateTime"
]);
if (fromUpdateTime != null) {
setValueByPath(toObject, ["updateTime"], fromUpdateTime);
}
const fromModel = getValueByPath(fromObject, ["metadata", "model"]);
if (fromModel != null) {
setValueByPath(toObject, ["model"], fromModel);
}
const fromDest = getValueByPath(fromObject, ["metadata", "output"]);
if (fromDest != null) {
setValueByPath(toObject, ["dest"], batchJobDestinationFromMldev(tRecvBatchJobDestination(fromDest)));
}
return toObject;
}
function batchJobFromVertex(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (fromDisplayName != null) {
setValueByPath(toObject, ["displayName"], fromDisplayName);
}
const fromState = getValueByPath(fromObject, ["state"]);
if (fromState != null) {
setValueByPath(toObject, ["state"], tJobState(fromState));
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
const fromCreateTime = getValueByPath(fromObject, ["createTime"]);
if (fromCreateTime != null) {
setValueByPath(toObject, ["createTime"], fromCreateTime);
}
const fromStartTime = getValueByPath(fromObject, ["startTime"]);
if (fromStartTime != null) {
setValueByPath(toObject, ["startTime"], fromStartTime);
}
const fromEndTime = getValueByPath(fromObject, ["endTime"]);
if (fromEndTime != null) {
setValueByPath(toObject, ["endTime"], fromEndTime);
}
const fromUpdateTime = getValueByPath(fromObject, ["updateTime"]);
if (fromUpdateTime != null) {
setValueByPath(toObject, ["updateTime"], fromUpdateTime);
}
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["model"], fromModel);
}
const fromSrc = getValueByPath(fromObject, ["inputConfig"]);
if (fromSrc != null) {
setValueByPath(toObject, ["src"], batchJobSourceFromVertex(fromSrc));
}
const fromDest = getValueByPath(fromObject, ["outputConfig"]);
if (fromDest != null) {
setValueByPath(toObject, ["dest"], batchJobDestinationFromVertex(tRecvBatchJobDestination(fromDest)));
}
const fromCompletionStats = getValueByPath(fromObject, [
"completionStats"
]);
if (fromCompletionStats != null) {
setValueByPath(toObject, ["completionStats"], fromCompletionStats);
}
return toObject;
}
function batchJobSourceFromVertex(fromObject) {
const toObject = {};
const fromFormat = getValueByPath(fromObject, ["instancesFormat"]);
if (fromFormat != null) {
setValueByPath(toObject, ["format"], fromFormat);
}
const fromGcsUri = getValueByPath(fromObject, ["gcsSource", "uris"]);
if (fromGcsUri != null) {
setValueByPath(toObject, ["gcsUri"], fromGcsUri);
}
const fromBigqueryUri = getValueByPath(fromObject, [
"bigquerySource",
"inputUri"
]);
if (fromBigqueryUri != null) {
setValueByPath(toObject, ["bigqueryUri"], fromBigqueryUri);
}
return toObject;
}
function batchJobSourceToMldev(apiClient, fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["format"]) !== void 0) {
throw new Error("format parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["gcsUri"]) !== void 0) {
throw new Error("gcsUri parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["bigqueryUri"]) !== void 0) {
throw new Error("bigqueryUri parameter is not supported in Gemini API.");
}
const fromFileName = getValueByPath(fromObject, ["fileName"]);
if (fromFileName != null) {
setValueByPath(toObject, ["fileName"], fromFileName);
}
const fromInlinedRequests = getValueByPath(fromObject, [
"inlinedRequests"
]);
if (fromInlinedRequests != null) {
let transformedList = fromInlinedRequests;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return inlinedRequestToMldev(apiClient, item);
});
}
setValueByPath(toObject, ["requests", "requests"], transformedList);
}
return toObject;
}
function batchJobSourceToVertex(fromObject) {
const toObject = {};
const fromFormat = getValueByPath(fromObject, ["format"]);
if (fromFormat != null) {
setValueByPath(toObject, ["instancesFormat"], fromFormat);
}
const fromGcsUri = getValueByPath(fromObject, ["gcsUri"]);
if (fromGcsUri != null) {
setValueByPath(toObject, ["gcsSource", "uris"], fromGcsUri);
}
const fromBigqueryUri = getValueByPath(fromObject, ["bigqueryUri"]);
if (fromBigqueryUri != null) {
setValueByPath(toObject, ["bigquerySource", "inputUri"], fromBigqueryUri);
}
if (getValueByPath(fromObject, ["fileName"]) !== void 0) {
throw new Error("fileName parameter is not supported in Vertex AI.");
}
if (getValueByPath(fromObject, ["inlinedRequests"]) !== void 0) {
throw new Error("inlinedRequests parameter is not supported in Vertex AI.");
}
return toObject;
}
function blobToMldev$4(fromObject) {
const toObject = {};
const fromData = getValueByPath(fromObject, ["data"]);
if (fromData != null) {
setValueByPath(toObject, ["data"], fromData);
}
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function cancelBatchJobParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tBatchJobName(apiClient, fromName));
}
return toObject;
}
function cancelBatchJobParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tBatchJobName(apiClient, fromName));
}
return toObject;
}
function candidateFromMldev$1(fromObject) {
const toObject = {};
const fromContent = getValueByPath(fromObject, ["content"]);
if (fromContent != null) {
setValueByPath(toObject, ["content"], fromContent);
}
const fromCitationMetadata = getValueByPath(fromObject, [
"citationMetadata"
]);
if (fromCitationMetadata != null) {
setValueByPath(toObject, ["citationMetadata"], citationMetadataFromMldev$1(fromCitationMetadata));
}
const fromTokenCount = getValueByPath(fromObject, ["tokenCount"]);
if (fromTokenCount != null) {
setValueByPath(toObject, ["tokenCount"], fromTokenCount);
}
const fromFinishReason = getValueByPath(fromObject, ["finishReason"]);
if (fromFinishReason != null) {
setValueByPath(toObject, ["finishReason"], fromFinishReason);
}
const fromAvgLogprobs = getValueByPath(fromObject, ["avgLogprobs"]);
if (fromAvgLogprobs != null) {
setValueByPath(toObject, ["avgLogprobs"], fromAvgLogprobs);
}
const fromGroundingMetadata = getValueByPath(fromObject, [
"groundingMetadata"
]);
if (fromGroundingMetadata != null) {
setValueByPath(toObject, ["groundingMetadata"], fromGroundingMetadata);
}
const fromIndex = getValueByPath(fromObject, ["index"]);
if (fromIndex != null) {
setValueByPath(toObject, ["index"], fromIndex);
}
const fromLogprobsResult = getValueByPath(fromObject, [
"logprobsResult"
]);
if (fromLogprobsResult != null) {
setValueByPath(toObject, ["logprobsResult"], fromLogprobsResult);
}
const fromSafetyRatings = getValueByPath(fromObject, [
"safetyRatings"
]);
if (fromSafetyRatings != null) {
let transformedList = fromSafetyRatings;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["safetyRatings"], transformedList);
}
const fromUrlContextMetadata = getValueByPath(fromObject, [
"urlContextMetadata"
]);
if (fromUrlContextMetadata != null) {
setValueByPath(toObject, ["urlContextMetadata"], fromUrlContextMetadata);
}
return toObject;
}
function citationMetadataFromMldev$1(fromObject) {
const toObject = {};
const fromCitations = getValueByPath(fromObject, ["citationSources"]);
if (fromCitations != null) {
let transformedList = fromCitations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["citations"], transformedList);
}
return toObject;
}
function contentToMldev$4(fromObject) {
const toObject = {};
const fromParts = getValueByPath(fromObject, ["parts"]);
if (fromParts != null) {
let transformedList = fromParts;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return partToMldev$4(item);
});
}
setValueByPath(toObject, ["parts"], transformedList);
}
const fromRole = getValueByPath(fromObject, ["role"]);
if (fromRole != null) {
setValueByPath(toObject, ["role"], fromRole);
}
return toObject;
}
function createBatchJobConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (parentObject !== void 0 && fromDisplayName != null) {
setValueByPath(parentObject, ["batch", "displayName"], fromDisplayName);
}
if (getValueByPath(fromObject, ["dest"]) !== void 0) {
throw new Error("dest parameter is not supported in Gemini API.");
}
return toObject;
}
function createBatchJobConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (parentObject !== void 0 && fromDisplayName != null) {
setValueByPath(parentObject, ["displayName"], fromDisplayName);
}
const fromDest = getValueByPath(fromObject, ["dest"]);
if (parentObject !== void 0 && fromDest != null) {
setValueByPath(parentObject, ["outputConfig"], batchJobDestinationToVertex(tBatchJobDestination(fromDest)));
}
return toObject;
}
function createBatchJobParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromSrc = getValueByPath(fromObject, ["src"]);
if (fromSrc != null) {
setValueByPath(toObject, ["batch", "inputConfig"], batchJobSourceToMldev(apiClient, tBatchJobSource(apiClient, fromSrc)));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
createBatchJobConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function createBatchJobParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["model"], tModel(apiClient, fromModel));
}
const fromSrc = getValueByPath(fromObject, ["src"]);
if (fromSrc != null) {
setValueByPath(toObject, ["inputConfig"], batchJobSourceToVertex(tBatchJobSource(apiClient, fromSrc)));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
createBatchJobConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function createEmbeddingsBatchJobConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (parentObject !== void 0 && fromDisplayName != null) {
setValueByPath(parentObject, ["batch", "displayName"], fromDisplayName);
}
return toObject;
}
function createEmbeddingsBatchJobParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromSrc = getValueByPath(fromObject, ["src"]);
if (fromSrc != null) {
setValueByPath(toObject, ["batch", "inputConfig"], embeddingsBatchJobSourceToMldev(apiClient, fromSrc));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
createEmbeddingsBatchJobConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function deleteBatchJobParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tBatchJobName(apiClient, fromName));
}
return toObject;
}
function deleteBatchJobParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tBatchJobName(apiClient, fromName));
}
return toObject;
}
function deleteResourceJobFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
return toObject;
}
function deleteResourceJobFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
return toObject;
}
function embedContentBatchToMldev(apiClient, fromObject) {
const toObject = {};
const fromContents = getValueByPath(fromObject, ["contents"]);
if (fromContents != null) {
let transformedList = tContentsForEmbed(apiClient, fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["requests[]", "request", "content"], transformedList);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
setValueByPath(toObject, ["_self"], embedContentConfigToMldev$1(fromConfig, toObject));
moveValueByPath(toObject, { "requests[].*": "requests[].request.*" });
}
return toObject;
}
function embedContentConfigToMldev$1(fromObject, parentObject) {
const toObject = {};
const fromTaskType = getValueByPath(fromObject, ["taskType"]);
if (parentObject !== void 0 && fromTaskType != null) {
setValueByPath(parentObject, ["requests[]", "taskType"], fromTaskType);
}
const fromTitle = getValueByPath(fromObject, ["title"]);
if (parentObject !== void 0 && fromTitle != null) {
setValueByPath(parentObject, ["requests[]", "title"], fromTitle);
}
const fromOutputDimensionality = getValueByPath(fromObject, [
"outputDimensionality"
]);
if (parentObject !== void 0 && fromOutputDimensionality != null) {
setValueByPath(parentObject, ["requests[]", "outputDimensionality"], fromOutputDimensionality);
}
if (getValueByPath(fromObject, ["mimeType"]) !== void 0) {
throw new Error("mimeType parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["autoTruncate"]) !== void 0) {
throw new Error("autoTruncate parameter is not supported in Gemini API.");
}
return toObject;
}
function embeddingsBatchJobSourceToMldev(apiClient, fromObject) {
const toObject = {};
const fromFileName = getValueByPath(fromObject, ["fileName"]);
if (fromFileName != null) {
setValueByPath(toObject, ["file_name"], fromFileName);
}
const fromInlinedRequests = getValueByPath(fromObject, [
"inlinedRequests"
]);
if (fromInlinedRequests != null) {
setValueByPath(toObject, ["requests"], embedContentBatchToMldev(apiClient, fromInlinedRequests));
}
return toObject;
}
function fileDataToMldev$4(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromFileUri = getValueByPath(fromObject, ["fileUri"]);
if (fromFileUri != null) {
setValueByPath(toObject, ["fileUri"], fromFileUri);
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function functionCallToMldev$4(fromObject) {
const toObject = {};
const fromId = getValueByPath(fromObject, ["id"]);
if (fromId != null) {
setValueByPath(toObject, ["id"], fromId);
}
const fromArgs = getValueByPath(fromObject, ["args"]);
if (fromArgs != null) {
setValueByPath(toObject, ["args"], fromArgs);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
if (getValueByPath(fromObject, ["partialArgs"]) !== void 0) {
throw new Error("partialArgs parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["willContinue"]) !== void 0) {
throw new Error("willContinue parameter is not supported in Gemini API.");
}
return toObject;
}
function functionCallingConfigToMldev$2(fromObject) {
const toObject = {};
const fromMode = getValueByPath(fromObject, ["mode"]);
if (fromMode != null) {
setValueByPath(toObject, ["mode"], fromMode);
}
const fromAllowedFunctionNames = getValueByPath(fromObject, [
"allowedFunctionNames"
]);
if (fromAllowedFunctionNames != null) {
setValueByPath(toObject, ["allowedFunctionNames"], fromAllowedFunctionNames);
}
if (getValueByPath(fromObject, ["streamFunctionCallArguments"]) !== void 0) {
throw new Error("streamFunctionCallArguments parameter is not supported in Gemini API.");
}
return toObject;
}
function generateContentConfigToMldev$1(apiClient, fromObject, parentObject) {
const toObject = {};
const fromSystemInstruction = getValueByPath(fromObject, [
"systemInstruction"
]);
if (parentObject !== void 0 && fromSystemInstruction != null) {
setValueByPath(parentObject, ["systemInstruction"], contentToMldev$4(tContent(fromSystemInstruction)));
}
const fromTemperature = getValueByPath(fromObject, ["temperature"]);
if (fromTemperature != null) {
setValueByPath(toObject, ["temperature"], fromTemperature);
}
const fromTopP = getValueByPath(fromObject, ["topP"]);
if (fromTopP != null) {
setValueByPath(toObject, ["topP"], fromTopP);
}
const fromTopK = getValueByPath(fromObject, ["topK"]);
if (fromTopK != null) {
setValueByPath(toObject, ["topK"], fromTopK);
}
const fromCandidateCount = getValueByPath(fromObject, [
"candidateCount"
]);
if (fromCandidateCount != null) {
setValueByPath(toObject, ["candidateCount"], fromCandidateCount);
}
const fromMaxOutputTokens = getValueByPath(fromObject, [
"maxOutputTokens"
]);
if (fromMaxOutputTokens != null) {
setValueByPath(toObject, ["maxOutputTokens"], fromMaxOutputTokens);
}
const fromStopSequences = getValueByPath(fromObject, [
"stopSequences"
]);
if (fromStopSequences != null) {
setValueByPath(toObject, ["stopSequences"], fromStopSequences);
}
const fromResponseLogprobs = getValueByPath(fromObject, [
"responseLogprobs"
]);
if (fromResponseLogprobs != null) {
setValueByPath(toObject, ["responseLogprobs"], fromResponseLogprobs);
}
const fromLogprobs = getValueByPath(fromObject, ["logprobs"]);
if (fromLogprobs != null) {
setValueByPath(toObject, ["logprobs"], fromLogprobs);
}
const fromPresencePenalty = getValueByPath(fromObject, [
"presencePenalty"
]);
if (fromPresencePenalty != null) {
setValueByPath(toObject, ["presencePenalty"], fromPresencePenalty);
}
const fromFrequencyPenalty = getValueByPath(fromObject, [
"frequencyPenalty"
]);
if (fromFrequencyPenalty != null) {
setValueByPath(toObject, ["frequencyPenalty"], fromFrequencyPenalty);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (fromSeed != null) {
setValueByPath(toObject, ["seed"], fromSeed);
}
const fromResponseMimeType = getValueByPath(fromObject, [
"responseMimeType"
]);
if (fromResponseMimeType != null) {
setValueByPath(toObject, ["responseMimeType"], fromResponseMimeType);
}
const fromResponseSchema = getValueByPath(fromObject, [
"responseSchema"
]);
if (fromResponseSchema != null) {
setValueByPath(toObject, ["responseSchema"], tSchema(fromResponseSchema));
}
const fromResponseJsonSchema = getValueByPath(fromObject, [
"responseJsonSchema"
]);
if (fromResponseJsonSchema != null) {
setValueByPath(toObject, ["responseJsonSchema"], fromResponseJsonSchema);
}
if (getValueByPath(fromObject, ["routingConfig"]) !== void 0) {
throw new Error("routingConfig parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["modelSelectionConfig"]) !== void 0) {
throw new Error("modelSelectionConfig parameter is not supported in Gemini API.");
}
const fromSafetySettings = getValueByPath(fromObject, [
"safetySettings"
]);
if (parentObject !== void 0 && fromSafetySettings != null) {
let transformedList = fromSafetySettings;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return safetySettingToMldev$1(item);
});
}
setValueByPath(parentObject, ["safetySettings"], transformedList);
}
const fromTools = getValueByPath(fromObject, ["tools"]);
if (parentObject !== void 0 && fromTools != null) {
let transformedList = tTools(fromTools);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return toolToMldev$4(tTool(item));
});
}
setValueByPath(parentObject, ["tools"], transformedList);
}
const fromToolConfig = getValueByPath(fromObject, ["toolConfig"]);
if (parentObject !== void 0 && fromToolConfig != null) {
setValueByPath(parentObject, ["toolConfig"], toolConfigToMldev$2(fromToolConfig));
}
if (getValueByPath(fromObject, ["labels"]) !== void 0) {
throw new Error("labels parameter is not supported in Gemini API.");
}
const fromCachedContent = getValueByPath(fromObject, [
"cachedContent"
]);
if (parentObject !== void 0 && fromCachedContent != null) {
setValueByPath(parentObject, ["cachedContent"], tCachedContentName(apiClient, fromCachedContent));
}
const fromResponseModalities = getValueByPath(fromObject, [
"responseModalities"
]);
if (fromResponseModalities != null) {
setValueByPath(toObject, ["responseModalities"], fromResponseModalities);
}
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromSpeechConfig = getValueByPath(fromObject, ["speechConfig"]);
if (fromSpeechConfig != null) {
setValueByPath(toObject, ["speechConfig"], tSpeechConfig(fromSpeechConfig));
}
if (getValueByPath(fromObject, ["audioTimestamp"]) !== void 0) {
throw new Error("audioTimestamp parameter is not supported in Gemini API.");
}
const fromThinkingConfig = getValueByPath(fromObject, [
"thinkingConfig"
]);
if (fromThinkingConfig != null) {
setValueByPath(toObject, ["thinkingConfig"], fromThinkingConfig);
}
const fromImageConfig = getValueByPath(fromObject, ["imageConfig"]);
if (fromImageConfig != null) {
setValueByPath(toObject, ["imageConfig"], imageConfigToMldev$1(fromImageConfig));
}
return toObject;
}
function generateContentResponseFromMldev$1(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromCandidates = getValueByPath(fromObject, ["candidates"]);
if (fromCandidates != null) {
let transformedList = fromCandidates;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return candidateFromMldev$1(item);
});
}
setValueByPath(toObject, ["candidates"], transformedList);
}
const fromModelVersion = getValueByPath(fromObject, ["modelVersion"]);
if (fromModelVersion != null) {
setValueByPath(toObject, ["modelVersion"], fromModelVersion);
}
const fromPromptFeedback = getValueByPath(fromObject, [
"promptFeedback"
]);
if (fromPromptFeedback != null) {
setValueByPath(toObject, ["promptFeedback"], fromPromptFeedback);
}
const fromResponseId = getValueByPath(fromObject, ["responseId"]);
if (fromResponseId != null) {
setValueByPath(toObject, ["responseId"], fromResponseId);
}
const fromUsageMetadata = getValueByPath(fromObject, [
"usageMetadata"
]);
if (fromUsageMetadata != null) {
setValueByPath(toObject, ["usageMetadata"], fromUsageMetadata);
}
return toObject;
}
function getBatchJobParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tBatchJobName(apiClient, fromName));
}
return toObject;
}
function getBatchJobParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tBatchJobName(apiClient, fromName));
}
return toObject;
}
function googleMapsToMldev$4(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["authConfig"]) !== void 0) {
throw new Error("authConfig parameter is not supported in Gemini API.");
}
const fromEnableWidget = getValueByPath(fromObject, ["enableWidget"]);
if (fromEnableWidget != null) {
setValueByPath(toObject, ["enableWidget"], fromEnableWidget);
}
return toObject;
}
function googleSearchToMldev$4(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["excludeDomains"]) !== void 0) {
throw new Error("excludeDomains parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["blockingConfidence"]) !== void 0) {
throw new Error("blockingConfidence parameter is not supported in Gemini API.");
}
const fromTimeRangeFilter = getValueByPath(fromObject, [
"timeRangeFilter"
]);
if (fromTimeRangeFilter != null) {
setValueByPath(toObject, ["timeRangeFilter"], fromTimeRangeFilter);
}
return toObject;
}
function imageConfigToMldev$1(fromObject) {
const toObject = {};
const fromAspectRatio = getValueByPath(fromObject, ["aspectRatio"]);
if (fromAspectRatio != null) {
setValueByPath(toObject, ["aspectRatio"], fromAspectRatio);
}
const fromImageSize = getValueByPath(fromObject, ["imageSize"]);
if (fromImageSize != null) {
setValueByPath(toObject, ["imageSize"], fromImageSize);
}
if (getValueByPath(fromObject, ["outputMimeType"]) !== void 0) {
throw new Error("outputMimeType parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["outputCompressionQuality"]) !== void 0) {
throw new Error("outputCompressionQuality parameter is not supported in Gemini API.");
}
return toObject;
}
function inlinedRequestToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["request", "model"], tModel(apiClient, fromModel));
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (fromContents != null) {
let transformedList = tContents(fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return contentToMldev$4(item);
});
}
setValueByPath(toObject, ["request", "contents"], transformedList);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
setValueByPath(toObject, ["request", "generationConfig"], generateContentConfigToMldev$1(apiClient, fromConfig, getValueByPath(toObject, ["request"], {})));
}
return toObject;
}
function inlinedResponseFromMldev(fromObject) {
const toObject = {};
const fromResponse = getValueByPath(fromObject, ["response"]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], generateContentResponseFromMldev$1(fromResponse));
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
return toObject;
}
function listBatchJobsConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
if (getValueByPath(fromObject, ["filter"]) !== void 0) {
throw new Error("filter parameter is not supported in Gemini API.");
}
return toObject;
}
function listBatchJobsConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
const fromFilter = getValueByPath(fromObject, ["filter"]);
if (parentObject !== void 0 && fromFilter != null) {
setValueByPath(parentObject, ["_query", "filter"], fromFilter);
}
return toObject;
}
function listBatchJobsParametersToMldev(fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listBatchJobsConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function listBatchJobsParametersToVertex(fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listBatchJobsConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function listBatchJobsResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromBatchJobs = getValueByPath(fromObject, ["operations"]);
if (fromBatchJobs != null) {
let transformedList = fromBatchJobs;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return batchJobFromMldev(item);
});
}
setValueByPath(toObject, ["batchJobs"], transformedList);
}
return toObject;
}
function listBatchJobsResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromBatchJobs = getValueByPath(fromObject, [
"batchPredictionJobs"
]);
if (fromBatchJobs != null) {
let transformedList = fromBatchJobs;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return batchJobFromVertex(item);
});
}
setValueByPath(toObject, ["batchJobs"], transformedList);
}
return toObject;
}
function partToMldev$4(fromObject) {
const toObject = {};
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromCodeExecutionResult = getValueByPath(fromObject, [
"codeExecutionResult"
]);
if (fromCodeExecutionResult != null) {
setValueByPath(toObject, ["codeExecutionResult"], fromCodeExecutionResult);
}
const fromExecutableCode = getValueByPath(fromObject, [
"executableCode"
]);
if (fromExecutableCode != null) {
setValueByPath(toObject, ["executableCode"], fromExecutableCode);
}
const fromFileData = getValueByPath(fromObject, ["fileData"]);
if (fromFileData != null) {
setValueByPath(toObject, ["fileData"], fileDataToMldev$4(fromFileData));
}
const fromFunctionCall = getValueByPath(fromObject, ["functionCall"]);
if (fromFunctionCall != null) {
setValueByPath(toObject, ["functionCall"], functionCallToMldev$4(fromFunctionCall));
}
const fromFunctionResponse = getValueByPath(fromObject, [
"functionResponse"
]);
if (fromFunctionResponse != null) {
setValueByPath(toObject, ["functionResponse"], fromFunctionResponse);
}
const fromInlineData = getValueByPath(fromObject, ["inlineData"]);
if (fromInlineData != null) {
setValueByPath(toObject, ["inlineData"], blobToMldev$4(fromInlineData));
}
const fromText = getValueByPath(fromObject, ["text"]);
if (fromText != null) {
setValueByPath(toObject, ["text"], fromText);
}
const fromThought = getValueByPath(fromObject, ["thought"]);
if (fromThought != null) {
setValueByPath(toObject, ["thought"], fromThought);
}
const fromThoughtSignature = getValueByPath(fromObject, [
"thoughtSignature"
]);
if (fromThoughtSignature != null) {
setValueByPath(toObject, ["thoughtSignature"], fromThoughtSignature);
}
const fromVideoMetadata = getValueByPath(fromObject, [
"videoMetadata"
]);
if (fromVideoMetadata != null) {
setValueByPath(toObject, ["videoMetadata"], fromVideoMetadata);
}
return toObject;
}
function safetySettingToMldev$1(fromObject) {
const toObject = {};
const fromCategory = getValueByPath(fromObject, ["category"]);
if (fromCategory != null) {
setValueByPath(toObject, ["category"], fromCategory);
}
if (getValueByPath(fromObject, ["method"]) !== void 0) {
throw new Error("method parameter is not supported in Gemini API.");
}
const fromThreshold = getValueByPath(fromObject, ["threshold"]);
if (fromThreshold != null) {
setValueByPath(toObject, ["threshold"], fromThreshold);
}
return toObject;
}
function toolConfigToMldev$2(fromObject) {
const toObject = {};
const fromFunctionCallingConfig = getValueByPath(fromObject, [
"functionCallingConfig"
]);
if (fromFunctionCallingConfig != null) {
setValueByPath(toObject, ["functionCallingConfig"], functionCallingConfigToMldev$2(fromFunctionCallingConfig));
}
const fromRetrievalConfig = getValueByPath(fromObject, [
"retrievalConfig"
]);
if (fromRetrievalConfig != null) {
setValueByPath(toObject, ["retrievalConfig"], fromRetrievalConfig);
}
return toObject;
}
function toolToMldev$4(fromObject) {
const toObject = {};
const fromFunctionDeclarations = getValueByPath(fromObject, [
"functionDeclarations"
]);
if (fromFunctionDeclarations != null) {
let transformedList = fromFunctionDeclarations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["functionDeclarations"], transformedList);
}
if (getValueByPath(fromObject, ["retrieval"]) !== void 0) {
throw new Error("retrieval parameter is not supported in Gemini API.");
}
const fromGoogleSearchRetrieval = getValueByPath(fromObject, [
"googleSearchRetrieval"
]);
if (fromGoogleSearchRetrieval != null) {
setValueByPath(toObject, ["googleSearchRetrieval"], fromGoogleSearchRetrieval);
}
const fromComputerUse = getValueByPath(fromObject, ["computerUse"]);
if (fromComputerUse != null) {
setValueByPath(toObject, ["computerUse"], fromComputerUse);
}
const fromFileSearch = getValueByPath(fromObject, ["fileSearch"]);
if (fromFileSearch != null) {
setValueByPath(toObject, ["fileSearch"], fromFileSearch);
}
const fromCodeExecution = getValueByPath(fromObject, [
"codeExecution"
]);
if (fromCodeExecution != null) {
setValueByPath(toObject, ["codeExecution"], fromCodeExecution);
}
if (getValueByPath(fromObject, ["enterpriseWebSearch"]) !== void 0) {
throw new Error("enterpriseWebSearch parameter is not supported in Gemini API.");
}
const fromGoogleMaps = getValueByPath(fromObject, ["googleMaps"]);
if (fromGoogleMaps != null) {
setValueByPath(toObject, ["googleMaps"], googleMapsToMldev$4(fromGoogleMaps));
}
const fromGoogleSearch = getValueByPath(fromObject, ["googleSearch"]);
if (fromGoogleSearch != null) {
setValueByPath(toObject, ["googleSearch"], googleSearchToMldev$4(fromGoogleSearch));
}
const fromUrlContext = getValueByPath(fromObject, ["urlContext"]);
if (fromUrlContext != null) {
setValueByPath(toObject, ["urlContext"], fromUrlContext);
}
return toObject;
}
var PagedItem;
(function(PagedItem2) {
PagedItem2["PAGED_ITEM_BATCH_JOBS"] = "batchJobs";
PagedItem2["PAGED_ITEM_MODELS"] = "models";
PagedItem2["PAGED_ITEM_TUNING_JOBS"] = "tuningJobs";
PagedItem2["PAGED_ITEM_FILES"] = "files";
PagedItem2["PAGED_ITEM_CACHED_CONTENTS"] = "cachedContents";
PagedItem2["PAGED_ITEM_FILE_SEARCH_STORES"] = "fileSearchStores";
PagedItem2["PAGED_ITEM_DOCUMENTS"] = "documents";
})(PagedItem || (PagedItem = {}));
var Pager = class {
constructor(name, request, response, params) {
this.pageInternal = [];
this.paramsInternal = {};
this.requestInternal = request;
this.init(name, response, params);
}
init(name, response, params) {
var _a, _b;
this.nameInternal = name;
this.pageInternal = response[this.nameInternal] || [];
this.sdkHttpResponseInternal = response === null || response === void 0 ? void 0 : response.sdkHttpResponse;
this.idxInternal = 0;
let requestParams = { config: {} };
if (!params || Object.keys(params).length === 0) {
requestParams = { config: {} };
} else if (typeof params === "object") {
requestParams = Object.assign({}, params);
} else {
requestParams = params;
}
if (requestParams["config"]) {
requestParams["config"]["pageToken"] = response["nextPageToken"];
}
this.paramsInternal = requestParams;
this.pageInternalSize = (_b = (_a = requestParams["config"]) === null || _a === void 0 ? void 0 : _a["pageSize"]) !== null && _b !== void 0 ? _b : this.pageInternal.length;
}
initNextPage(response) {
this.init(this.nameInternal, response, this.paramsInternal);
}
/**
* Returns the current page, which is a list of items.
*
* @remarks
* The first page is retrieved when the pager is created. The returned list of
* items could be a subset of the entire list.
*/
get page() {
return this.pageInternal;
}
/**
* Returns the type of paged item (for example, ``batch_jobs``).
*/
get name() {
return this.nameInternal;
}
/**
* Returns the length of the page fetched each time by this pager.
*
* @remarks
* The number of items in the page is less than or equal to the page length.
*/
get pageSize() {
return this.pageInternalSize;
}
/**
* Returns the headers of the API response.
*/
get sdkHttpResponse() {
return this.sdkHttpResponseInternal;
}
/**
* Returns the parameters when making the API request for the next page.
*
* @remarks
* Parameters contain a set of optional configs that can be
* used to customize the API request. For example, the `pageToken` parameter
* contains the token to request the next page.
*/
get params() {
return this.paramsInternal;
}
/**
* Returns the total number of items in the current page.
*/
get pageLength() {
return this.pageInternal.length;
}
/**
* Returns the item at the given index.
*/
getItem(index) {
return this.pageInternal[index];
}
/**
* Returns an async iterator that support iterating through all items
* retrieved from the API.
*
* @remarks
* The iterator will automatically fetch the next page if there are more items
* to fetch from the API.
*
* @example
*
* ```ts
* const pager = await ai.files.list({config: {pageSize: 10}});
* for await (const file of pager) {
* console.log(file.name);
* }
* ```
*/
[Symbol.asyncIterator]() {
return {
next: async () => {
if (this.idxInternal >= this.pageLength) {
if (this.hasNextPage()) {
await this.nextPage();
} else {
return { value: void 0, done: true };
}
}
const item = this.getItem(this.idxInternal);
this.idxInternal += 1;
return { value: item, done: false };
},
return: async () => {
return { value: void 0, done: true };
}
};
}
/**
* Fetches the next page of items. This makes a new API request.
*
* @throws {Error} If there are no more pages to fetch.
*
* @example
*
* ```ts
* const pager = await ai.files.list({config: {pageSize: 10}});
* let page = pager.page;
* while (true) {
* for (const file of page) {
* console.log(file.name);
* }
* if (!pager.hasNextPage()) {
* break;
* }
* page = await pager.nextPage();
* }
* ```
*/
async nextPage() {
if (!this.hasNextPage()) {
throw new Error("No more pages to fetch.");
}
const response = await this.requestInternal(this.params);
this.initNextPage(response);
return this.page;
}
/**
* Returns true if there are more pages to fetch from the API.
*/
hasNextPage() {
var _a;
if (((_a = this.params["config"]) === null || _a === void 0 ? void 0 : _a["pageToken"]) !== void 0) {
return true;
}
return false;
}
};
var Batches = class extends BaseModule {
constructor(apiClient) {
super();
this.apiClient = apiClient;
this.create = async (params) => {
if (this.apiClient.isVertexAI()) {
params.config = this.formatDestination(params.src, params.config);
}
return this.createInternal(params);
};
this.createEmbeddings = async (params) => {
console.warn("batches.createEmbeddings() is experimental and may change without notice.");
if (this.apiClient.isVertexAI()) {
throw new Error("Vertex AI does not support batches.createEmbeddings.");
}
return this.createEmbeddingsInternal(params);
};
this.list = async (params = {}) => {
return new Pager(PagedItem.PAGED_ITEM_BATCH_JOBS, (x) => this.listInternal(x), await this.listInternal(params), params);
};
}
// Helper function to handle inlined generate content requests
createInlinedGenerateContentRequest(params) {
const body = createBatchJobParametersToMldev(
this.apiClient,
// Use instance apiClient
params
);
const urlParams = body["_url"];
const path10 = formatMap("{model}:batchGenerateContent", urlParams);
const batch = body["batch"];
const inputConfig = batch["inputConfig"];
const requestsWrapper = inputConfig["requests"];
const requests = requestsWrapper["requests"];
const newRequests = [];
for (const request of requests) {
const requestDict = Object.assign({}, request);
if (requestDict["systemInstruction"]) {
const systemInstructionValue = requestDict["systemInstruction"];
delete requestDict["systemInstruction"];
const requestContent = requestDict["request"];
requestContent["systemInstruction"] = systemInstructionValue;
requestDict["request"] = requestContent;
}
newRequests.push(requestDict);
}
requestsWrapper["requests"] = newRequests;
delete body["config"];
delete body["_url"];
delete body["_query"];
return { path: path10, body };
}
// Helper function to get the first GCS URI
getGcsUri(src) {
if (typeof src === "string") {
return src.startsWith("gs://") ? src : void 0;
}
if (!Array.isArray(src) && src.gcsUri && src.gcsUri.length > 0) {
return src.gcsUri[0];
}
return void 0;
}
// Helper function to get the BigQuery URI
getBigqueryUri(src) {
if (typeof src === "string") {
return src.startsWith("bq://") ? src : void 0;
}
if (!Array.isArray(src)) {
return src.bigqueryUri;
}
return void 0;
}
// Function to format the destination configuration for Vertex AI
formatDestination(src, config) {
const newConfig = config ? Object.assign({}, config) : {};
const timestampStr = Date.now().toString();
if (!newConfig.displayName) {
newConfig.displayName = `genaiBatchJob_${timestampStr}`;
}
if (newConfig.dest === void 0) {
const gcsUri = this.getGcsUri(src);
const bigqueryUri = this.getBigqueryUri(src);
if (gcsUri) {
if (gcsUri.endsWith(".jsonl")) {
newConfig.dest = `${gcsUri.slice(0, -6)}/dest`;
} else {
newConfig.dest = `${gcsUri}_dest_${timestampStr}`;
}
} else if (bigqueryUri) {
newConfig.dest = `${bigqueryUri}_dest_${timestampStr}`;
} else {
throw new Error("Unsupported source for Vertex AI: No GCS or BigQuery URI found.");
}
}
return newConfig;
}
/**
* Internal method to create batch job.
*
* @param params - The parameters for create batch job request.
* @return The created batch job.
*
*/
async createInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = createBatchJobParametersToVertex(this.apiClient, params);
path10 = formatMap("batchPredictionJobs", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = batchJobFromVertex(apiResponse);
return resp;
});
} else {
const body = createBatchJobParametersToMldev(this.apiClient, params);
path10 = formatMap("{model}:batchGenerateContent", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = batchJobFromMldev(apiResponse);
return resp;
});
}
}
/**
* Internal method to create batch job.
*
* @param params - The parameters for create batch job request.
* @return The created batch job.
*
*/
async createEmbeddingsInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = createEmbeddingsBatchJobParametersToMldev(this.apiClient, params);
path10 = formatMap("{model}:asyncBatchEmbedContent", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = batchJobFromMldev(apiResponse);
return resp;
});
}
}
/**
* Gets batch job configurations.
*
* @param params - The parameters for the get request.
* @return The batch job.
*
* @example
* ```ts
* await ai.batches.get({name: '...'}); // The server-generated resource name.
* ```
*/
async get(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = getBatchJobParametersToVertex(this.apiClient, params);
path10 = formatMap("batchPredictionJobs/{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = batchJobFromVertex(apiResponse);
return resp;
});
} else {
const body = getBatchJobParametersToMldev(this.apiClient, params);
path10 = formatMap("batches/{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = batchJobFromMldev(apiResponse);
return resp;
});
}
}
/**
* Cancels a batch job.
*
* @param params - The parameters for the cancel request.
* @return The empty response returned by the API.
*
* @example
* ```ts
* await ai.batches.cancel({name: '...'}); // The server-generated resource name.
* ```
*/
async cancel(params) {
var _a, _b, _c, _d;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = cancelBatchJobParametersToVertex(this.apiClient, params);
path10 = formatMap("batchPredictionJobs/{name}:cancel", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
await this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
});
} else {
const body = cancelBatchJobParametersToMldev(this.apiClient, params);
path10 = formatMap("batches/{name}:cancel", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
await this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
});
}
}
async listInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = listBatchJobsParametersToVertex(params);
path10 = formatMap("batchPredictionJobs", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = listBatchJobsResponseFromVertex(apiResponse);
const typedResp = new ListBatchJobsResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = listBatchJobsParametersToMldev(params);
path10 = formatMap("batches", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = listBatchJobsResponseFromMldev(apiResponse);
const typedResp = new ListBatchJobsResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Deletes a batch job.
*
* @param params - The parameters for the delete request.
* @return The empty response returned by the API.
*
* @example
* ```ts
* await ai.batches.delete({name: '...'}); // The server-generated resource name.
* ```
*/
async delete(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = deleteBatchJobParametersToVertex(this.apiClient, params);
path10 = formatMap("batchPredictionJobs/{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "DELETE",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = deleteResourceJobFromVertex(apiResponse);
return resp;
});
} else {
const body = deleteBatchJobParametersToMldev(this.apiClient, params);
path10 = formatMap("batches/{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "DELETE",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = deleteResourceJobFromMldev(apiResponse);
return resp;
});
}
}
};
function blobToMldev$3(fromObject) {
const toObject = {};
const fromData = getValueByPath(fromObject, ["data"]);
if (fromData != null) {
setValueByPath(toObject, ["data"], fromData);
}
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function contentToMldev$3(fromObject) {
const toObject = {};
const fromParts = getValueByPath(fromObject, ["parts"]);
if (fromParts != null) {
let transformedList = fromParts;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return partToMldev$3(item);
});
}
setValueByPath(toObject, ["parts"], transformedList);
}
const fromRole = getValueByPath(fromObject, ["role"]);
if (fromRole != null) {
setValueByPath(toObject, ["role"], fromRole);
}
return toObject;
}
function createCachedContentConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromTtl = getValueByPath(fromObject, ["ttl"]);
if (parentObject !== void 0 && fromTtl != null) {
setValueByPath(parentObject, ["ttl"], fromTtl);
}
const fromExpireTime = getValueByPath(fromObject, ["expireTime"]);
if (parentObject !== void 0 && fromExpireTime != null) {
setValueByPath(parentObject, ["expireTime"], fromExpireTime);
}
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (parentObject !== void 0 && fromDisplayName != null) {
setValueByPath(parentObject, ["displayName"], fromDisplayName);
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (parentObject !== void 0 && fromContents != null) {
let transformedList = tContents(fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return contentToMldev$3(item);
});
}
setValueByPath(parentObject, ["contents"], transformedList);
}
const fromSystemInstruction = getValueByPath(fromObject, [
"systemInstruction"
]);
if (parentObject !== void 0 && fromSystemInstruction != null) {
setValueByPath(parentObject, ["systemInstruction"], contentToMldev$3(tContent(fromSystemInstruction)));
}
const fromTools = getValueByPath(fromObject, ["tools"]);
if (parentObject !== void 0 && fromTools != null) {
let transformedList = fromTools;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return toolToMldev$3(item);
});
}
setValueByPath(parentObject, ["tools"], transformedList);
}
const fromToolConfig = getValueByPath(fromObject, ["toolConfig"]);
if (parentObject !== void 0 && fromToolConfig != null) {
setValueByPath(parentObject, ["toolConfig"], toolConfigToMldev$1(fromToolConfig));
}
if (getValueByPath(fromObject, ["kmsKeyName"]) !== void 0) {
throw new Error("kmsKeyName parameter is not supported in Gemini API.");
}
return toObject;
}
function createCachedContentConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromTtl = getValueByPath(fromObject, ["ttl"]);
if (parentObject !== void 0 && fromTtl != null) {
setValueByPath(parentObject, ["ttl"], fromTtl);
}
const fromExpireTime = getValueByPath(fromObject, ["expireTime"]);
if (parentObject !== void 0 && fromExpireTime != null) {
setValueByPath(parentObject, ["expireTime"], fromExpireTime);
}
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (parentObject !== void 0 && fromDisplayName != null) {
setValueByPath(parentObject, ["displayName"], fromDisplayName);
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (parentObject !== void 0 && fromContents != null) {
let transformedList = tContents(fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(parentObject, ["contents"], transformedList);
}
const fromSystemInstruction = getValueByPath(fromObject, [
"systemInstruction"
]);
if (parentObject !== void 0 && fromSystemInstruction != null) {
setValueByPath(parentObject, ["systemInstruction"], tContent(fromSystemInstruction));
}
const fromTools = getValueByPath(fromObject, ["tools"]);
if (parentObject !== void 0 && fromTools != null) {
let transformedList = fromTools;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return toolToVertex$2(item);
});
}
setValueByPath(parentObject, ["tools"], transformedList);
}
const fromToolConfig = getValueByPath(fromObject, ["toolConfig"]);
if (parentObject !== void 0 && fromToolConfig != null) {
setValueByPath(parentObject, ["toolConfig"], fromToolConfig);
}
const fromKmsKeyName = getValueByPath(fromObject, ["kmsKeyName"]);
if (parentObject !== void 0 && fromKmsKeyName != null) {
setValueByPath(parentObject, ["encryption_spec", "kmsKeyName"], fromKmsKeyName);
}
return toObject;
}
function createCachedContentParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["model"], tCachesModel(apiClient, fromModel));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
createCachedContentConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function createCachedContentParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["model"], tCachesModel(apiClient, fromModel));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
createCachedContentConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function deleteCachedContentParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tCachedContentName(apiClient, fromName));
}
return toObject;
}
function deleteCachedContentParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tCachedContentName(apiClient, fromName));
}
return toObject;
}
function deleteCachedContentResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
return toObject;
}
function deleteCachedContentResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
return toObject;
}
function fileDataToMldev$3(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromFileUri = getValueByPath(fromObject, ["fileUri"]);
if (fromFileUri != null) {
setValueByPath(toObject, ["fileUri"], fromFileUri);
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function functionCallToMldev$3(fromObject) {
const toObject = {};
const fromId = getValueByPath(fromObject, ["id"]);
if (fromId != null) {
setValueByPath(toObject, ["id"], fromId);
}
const fromArgs = getValueByPath(fromObject, ["args"]);
if (fromArgs != null) {
setValueByPath(toObject, ["args"], fromArgs);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
if (getValueByPath(fromObject, ["partialArgs"]) !== void 0) {
throw new Error("partialArgs parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["willContinue"]) !== void 0) {
throw new Error("willContinue parameter is not supported in Gemini API.");
}
return toObject;
}
function functionCallingConfigToMldev$1(fromObject) {
const toObject = {};
const fromMode = getValueByPath(fromObject, ["mode"]);
if (fromMode != null) {
setValueByPath(toObject, ["mode"], fromMode);
}
const fromAllowedFunctionNames = getValueByPath(fromObject, [
"allowedFunctionNames"
]);
if (fromAllowedFunctionNames != null) {
setValueByPath(toObject, ["allowedFunctionNames"], fromAllowedFunctionNames);
}
if (getValueByPath(fromObject, ["streamFunctionCallArguments"]) !== void 0) {
throw new Error("streamFunctionCallArguments parameter is not supported in Gemini API.");
}
return toObject;
}
function functionDeclarationToVertex$2(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["behavior"]) !== void 0) {
throw new Error("behavior parameter is not supported in Vertex AI.");
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (fromDescription != null) {
setValueByPath(toObject, ["description"], fromDescription);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromParameters = getValueByPath(fromObject, ["parameters"]);
if (fromParameters != null) {
setValueByPath(toObject, ["parameters"], fromParameters);
}
const fromParametersJsonSchema = getValueByPath(fromObject, [
"parametersJsonSchema"
]);
if (fromParametersJsonSchema != null) {
setValueByPath(toObject, ["parametersJsonSchema"], fromParametersJsonSchema);
}
const fromResponse = getValueByPath(fromObject, ["response"]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], fromResponse);
}
const fromResponseJsonSchema = getValueByPath(fromObject, [
"responseJsonSchema"
]);
if (fromResponseJsonSchema != null) {
setValueByPath(toObject, ["responseJsonSchema"], fromResponseJsonSchema);
}
return toObject;
}
function getCachedContentParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tCachedContentName(apiClient, fromName));
}
return toObject;
}
function getCachedContentParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tCachedContentName(apiClient, fromName));
}
return toObject;
}
function googleMapsToMldev$3(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["authConfig"]) !== void 0) {
throw new Error("authConfig parameter is not supported in Gemini API.");
}
const fromEnableWidget = getValueByPath(fromObject, ["enableWidget"]);
if (fromEnableWidget != null) {
setValueByPath(toObject, ["enableWidget"], fromEnableWidget);
}
return toObject;
}
function googleSearchToMldev$3(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["excludeDomains"]) !== void 0) {
throw new Error("excludeDomains parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["blockingConfidence"]) !== void 0) {
throw new Error("blockingConfidence parameter is not supported in Gemini API.");
}
const fromTimeRangeFilter = getValueByPath(fromObject, [
"timeRangeFilter"
]);
if (fromTimeRangeFilter != null) {
setValueByPath(toObject, ["timeRangeFilter"], fromTimeRangeFilter);
}
return toObject;
}
function listCachedContentsConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
return toObject;
}
function listCachedContentsConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
return toObject;
}
function listCachedContentsParametersToMldev(fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listCachedContentsConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function listCachedContentsParametersToVertex(fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listCachedContentsConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function listCachedContentsResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromCachedContents = getValueByPath(fromObject, [
"cachedContents"
]);
if (fromCachedContents != null) {
let transformedList = fromCachedContents;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["cachedContents"], transformedList);
}
return toObject;
}
function listCachedContentsResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromCachedContents = getValueByPath(fromObject, [
"cachedContents"
]);
if (fromCachedContents != null) {
let transformedList = fromCachedContents;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["cachedContents"], transformedList);
}
return toObject;
}
function partToMldev$3(fromObject) {
const toObject = {};
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromCodeExecutionResult = getValueByPath(fromObject, [
"codeExecutionResult"
]);
if (fromCodeExecutionResult != null) {
setValueByPath(toObject, ["codeExecutionResult"], fromCodeExecutionResult);
}
const fromExecutableCode = getValueByPath(fromObject, [
"executableCode"
]);
if (fromExecutableCode != null) {
setValueByPath(toObject, ["executableCode"], fromExecutableCode);
}
const fromFileData = getValueByPath(fromObject, ["fileData"]);
if (fromFileData != null) {
setValueByPath(toObject, ["fileData"], fileDataToMldev$3(fromFileData));
}
const fromFunctionCall = getValueByPath(fromObject, ["functionCall"]);
if (fromFunctionCall != null) {
setValueByPath(toObject, ["functionCall"], functionCallToMldev$3(fromFunctionCall));
}
const fromFunctionResponse = getValueByPath(fromObject, [
"functionResponse"
]);
if (fromFunctionResponse != null) {
setValueByPath(toObject, ["functionResponse"], fromFunctionResponse);
}
const fromInlineData = getValueByPath(fromObject, ["inlineData"]);
if (fromInlineData != null) {
setValueByPath(toObject, ["inlineData"], blobToMldev$3(fromInlineData));
}
const fromText = getValueByPath(fromObject, ["text"]);
if (fromText != null) {
setValueByPath(toObject, ["text"], fromText);
}
const fromThought = getValueByPath(fromObject, ["thought"]);
if (fromThought != null) {
setValueByPath(toObject, ["thought"], fromThought);
}
const fromThoughtSignature = getValueByPath(fromObject, [
"thoughtSignature"
]);
if (fromThoughtSignature != null) {
setValueByPath(toObject, ["thoughtSignature"], fromThoughtSignature);
}
const fromVideoMetadata = getValueByPath(fromObject, [
"videoMetadata"
]);
if (fromVideoMetadata != null) {
setValueByPath(toObject, ["videoMetadata"], fromVideoMetadata);
}
return toObject;
}
function toolConfigToMldev$1(fromObject) {
const toObject = {};
const fromFunctionCallingConfig = getValueByPath(fromObject, [
"functionCallingConfig"
]);
if (fromFunctionCallingConfig != null) {
setValueByPath(toObject, ["functionCallingConfig"], functionCallingConfigToMldev$1(fromFunctionCallingConfig));
}
const fromRetrievalConfig = getValueByPath(fromObject, [
"retrievalConfig"
]);
if (fromRetrievalConfig != null) {
setValueByPath(toObject, ["retrievalConfig"], fromRetrievalConfig);
}
return toObject;
}
function toolToMldev$3(fromObject) {
const toObject = {};
const fromFunctionDeclarations = getValueByPath(fromObject, [
"functionDeclarations"
]);
if (fromFunctionDeclarations != null) {
let transformedList = fromFunctionDeclarations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["functionDeclarations"], transformedList);
}
if (getValueByPath(fromObject, ["retrieval"]) !== void 0) {
throw new Error("retrieval parameter is not supported in Gemini API.");
}
const fromGoogleSearchRetrieval = getValueByPath(fromObject, [
"googleSearchRetrieval"
]);
if (fromGoogleSearchRetrieval != null) {
setValueByPath(toObject, ["googleSearchRetrieval"], fromGoogleSearchRetrieval);
}
const fromComputerUse = getValueByPath(fromObject, ["computerUse"]);
if (fromComputerUse != null) {
setValueByPath(toObject, ["computerUse"], fromComputerUse);
}
const fromFileSearch = getValueByPath(fromObject, ["fileSearch"]);
if (fromFileSearch != null) {
setValueByPath(toObject, ["fileSearch"], fromFileSearch);
}
const fromCodeExecution = getValueByPath(fromObject, [
"codeExecution"
]);
if (fromCodeExecution != null) {
setValueByPath(toObject, ["codeExecution"], fromCodeExecution);
}
if (getValueByPath(fromObject, ["enterpriseWebSearch"]) !== void 0) {
throw new Error("enterpriseWebSearch parameter is not supported in Gemini API.");
}
const fromGoogleMaps = getValueByPath(fromObject, ["googleMaps"]);
if (fromGoogleMaps != null) {
setValueByPath(toObject, ["googleMaps"], googleMapsToMldev$3(fromGoogleMaps));
}
const fromGoogleSearch = getValueByPath(fromObject, ["googleSearch"]);
if (fromGoogleSearch != null) {
setValueByPath(toObject, ["googleSearch"], googleSearchToMldev$3(fromGoogleSearch));
}
const fromUrlContext = getValueByPath(fromObject, ["urlContext"]);
if (fromUrlContext != null) {
setValueByPath(toObject, ["urlContext"], fromUrlContext);
}
return toObject;
}
function toolToVertex$2(fromObject) {
const toObject = {};
const fromFunctionDeclarations = getValueByPath(fromObject, [
"functionDeclarations"
]);
if (fromFunctionDeclarations != null) {
let transformedList = fromFunctionDeclarations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return functionDeclarationToVertex$2(item);
});
}
setValueByPath(toObject, ["functionDeclarations"], transformedList);
}
const fromRetrieval = getValueByPath(fromObject, ["retrieval"]);
if (fromRetrieval != null) {
setValueByPath(toObject, ["retrieval"], fromRetrieval);
}
const fromGoogleSearchRetrieval = getValueByPath(fromObject, [
"googleSearchRetrieval"
]);
if (fromGoogleSearchRetrieval != null) {
setValueByPath(toObject, ["googleSearchRetrieval"], fromGoogleSearchRetrieval);
}
const fromComputerUse = getValueByPath(fromObject, ["computerUse"]);
if (fromComputerUse != null) {
setValueByPath(toObject, ["computerUse"], fromComputerUse);
}
if (getValueByPath(fromObject, ["fileSearch"]) !== void 0) {
throw new Error("fileSearch parameter is not supported in Vertex AI.");
}
const fromCodeExecution = getValueByPath(fromObject, [
"codeExecution"
]);
if (fromCodeExecution != null) {
setValueByPath(toObject, ["codeExecution"], fromCodeExecution);
}
const fromEnterpriseWebSearch = getValueByPath(fromObject, [
"enterpriseWebSearch"
]);
if (fromEnterpriseWebSearch != null) {
setValueByPath(toObject, ["enterpriseWebSearch"], fromEnterpriseWebSearch);
}
const fromGoogleMaps = getValueByPath(fromObject, ["googleMaps"]);
if (fromGoogleMaps != null) {
setValueByPath(toObject, ["googleMaps"], fromGoogleMaps);
}
const fromGoogleSearch = getValueByPath(fromObject, ["googleSearch"]);
if (fromGoogleSearch != null) {
setValueByPath(toObject, ["googleSearch"], fromGoogleSearch);
}
const fromUrlContext = getValueByPath(fromObject, ["urlContext"]);
if (fromUrlContext != null) {
setValueByPath(toObject, ["urlContext"], fromUrlContext);
}
return toObject;
}
function updateCachedContentConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromTtl = getValueByPath(fromObject, ["ttl"]);
if (parentObject !== void 0 && fromTtl != null) {
setValueByPath(parentObject, ["ttl"], fromTtl);
}
const fromExpireTime = getValueByPath(fromObject, ["expireTime"]);
if (parentObject !== void 0 && fromExpireTime != null) {
setValueByPath(parentObject, ["expireTime"], fromExpireTime);
}
return toObject;
}
function updateCachedContentConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromTtl = getValueByPath(fromObject, ["ttl"]);
if (parentObject !== void 0 && fromTtl != null) {
setValueByPath(parentObject, ["ttl"], fromTtl);
}
const fromExpireTime = getValueByPath(fromObject, ["expireTime"]);
if (parentObject !== void 0 && fromExpireTime != null) {
setValueByPath(parentObject, ["expireTime"], fromExpireTime);
}
return toObject;
}
function updateCachedContentParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tCachedContentName(apiClient, fromName));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
updateCachedContentConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function updateCachedContentParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], tCachedContentName(apiClient, fromName));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
updateCachedContentConfigToVertex(fromConfig, toObject);
}
return toObject;
}
var Caches = class extends BaseModule {
constructor(apiClient) {
super();
this.apiClient = apiClient;
this.list = async (params = {}) => {
return new Pager(PagedItem.PAGED_ITEM_CACHED_CONTENTS, (x) => this.listInternal(x), await this.listInternal(params), params);
};
}
/**
* Creates a cached contents resource.
*
* @remarks
* Context caching is only supported for specific models. See [Gemini
* Developer API reference](https://ai.google.dev/gemini-api/docs/caching?lang=node/context-cac)
* and [Vertex AI reference](https://cloud.google.com/vertex-ai/generative-ai/docs/context-cache/context-cache-overview#supported_models)
* for more information.
*
* @param params - The parameters for the create request.
* @return The created cached content.
*
* @example
* ```ts
* const contents = ...; // Initialize the content to cache.
* const response = await ai.caches.create({
* model: 'gemini-2.0-flash-001',
* config: {
* 'contents': contents,
* 'displayName': 'test cache',
* 'systemInstruction': 'What is the sum of the two pdfs?',
* 'ttl': '86400s',
* }
* });
* ```
*/
async create(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = createCachedContentParametersToVertex(this.apiClient, params);
path10 = formatMap("cachedContents", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
} else {
const body = createCachedContentParametersToMldev(this.apiClient, params);
path10 = formatMap("cachedContents", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
}
}
/**
* Gets cached content configurations.
*
* @param params - The parameters for the get request.
* @return The cached content.
*
* @example
* ```ts
* await ai.caches.get({name: '...'}); // The server-generated resource name.
* ```
*/
async get(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = getCachedContentParametersToVertex(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
} else {
const body = getCachedContentParametersToMldev(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
}
}
/**
* Deletes cached content.
*
* @param params - The parameters for the delete request.
* @return The empty response returned by the API.
*
* @example
* ```ts
* await ai.caches.delete({name: '...'}); // The server-generated resource name.
* ```
*/
async delete(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = deleteCachedContentParametersToVertex(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "DELETE",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = deleteCachedContentResponseFromVertex(apiResponse);
const typedResp = new DeleteCachedContentResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = deleteCachedContentParametersToMldev(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "DELETE",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = deleteCachedContentResponseFromMldev(apiResponse);
const typedResp = new DeleteCachedContentResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Updates cached content configurations.
*
* @param params - The parameters for the update request.
* @return The updated cached content.
*
* @example
* ```ts
* const response = await ai.caches.update({
* name: '...', // The server-generated resource name.
* config: {'ttl': '7600s'}
* });
* ```
*/
async update(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = updateCachedContentParametersToVertex(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "PATCH",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
} else {
const body = updateCachedContentParametersToMldev(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "PATCH",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
}
}
async listInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = listCachedContentsParametersToVertex(params);
path10 = formatMap("cachedContents", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = listCachedContentsResponseFromVertex(apiResponse);
const typedResp = new ListCachedContentsResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = listCachedContentsParametersToMldev(params);
path10 = formatMap("cachedContents", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = listCachedContentsResponseFromMldev(apiResponse);
const typedResp = new ListCachedContentsResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
};
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function() {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
return this;
}, i;
function awaitReturn(f) {
return function(v) {
return Promise.resolve(v).then(f, reject);
};
}
function verb(n, f) {
if (g[n]) {
i[n] = function(v) {
return new Promise(function(a, b) {
q.push([n, v, a, b]) > 1 || resume(n, v);
});
};
if (f) i[n] = f(i[n]);
}
}
function resume(n, v) {
try {
step(g[n](v));
} catch (e) {
settle(q[0][3], e);
}
}
function step(r) {
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
}
function fulfill(value) {
resume("next", value);
}
function reject(value) {
resume("throw", value);
}
function settle(f, v) {
if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
}
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i);
function verb(n) {
i[n] = o[n] && function(v) {
return new Promise(function(resolve5, reject) {
v = o[n](v), settle(resolve5, reject, v.done, v.value);
});
};
}
function settle(resolve5, reject, d, v) {
Promise.resolve(v).then(function(v2) {
resolve5({ value: v2, done: d });
}, reject);
}
}
function isValidResponse(response) {
var _a;
if (response.candidates == void 0 || response.candidates.length === 0) {
return false;
}
const content = (_a = response.candidates[0]) === null || _a === void 0 ? void 0 : _a.content;
if (content === void 0) {
return false;
}
return isValidContent(content);
}
function isValidContent(content) {
if (content.parts === void 0 || content.parts.length === 0) {
return false;
}
for (const part of content.parts) {
if (part === void 0 || Object.keys(part).length === 0) {
return false;
}
}
return true;
}
function validateHistory(history) {
if (history.length === 0) {
return;
}
for (const content of history) {
if (content.role !== "user" && content.role !== "model") {
throw new Error(`Role must be user or model, but got ${content.role}.`);
}
}
}
function extractCuratedHistory(comprehensiveHistory) {
if (comprehensiveHistory === void 0 || comprehensiveHistory.length === 0) {
return [];
}
const curatedHistory = [];
const length = comprehensiveHistory.length;
let i = 0;
while (i < length) {
if (comprehensiveHistory[i].role === "user") {
curatedHistory.push(comprehensiveHistory[i]);
i++;
} else {
const modelOutput = [];
let isValid2 = true;
while (i < length && comprehensiveHistory[i].role === "model") {
modelOutput.push(comprehensiveHistory[i]);
if (isValid2 && !isValidContent(comprehensiveHistory[i])) {
isValid2 = false;
}
i++;
}
if (isValid2) {
curatedHistory.push(...modelOutput);
} else {
curatedHistory.pop();
}
}
}
return curatedHistory;
}
var Chats = class {
constructor(modelsModule, apiClient) {
this.modelsModule = modelsModule;
this.apiClient = apiClient;
}
/**
* Creates a new chat session.
*
* @remarks
* The config in the params will be used for all requests within the chat
* session unless overridden by a per-request `config` in
* @see {@link types.SendMessageParameters#config}.
*
* @param params - Parameters for creating a chat session.
* @returns A new chat session.
*
* @example
* ```ts
* const chat = ai.chats.create({
* model: 'gemini-2.0-flash'
* config: {
* temperature: 0.5,
* maxOutputTokens: 1024,
* }
* });
* ```
*/
create(params) {
return new Chat(
this.apiClient,
this.modelsModule,
params.model,
params.config,
// Deep copy the history to avoid mutating the history outside of the
// chat session.
structuredClone(params.history)
);
}
};
var Chat = class {
constructor(apiClient, modelsModule, model, config = {}, history = []) {
this.apiClient = apiClient;
this.modelsModule = modelsModule;
this.model = model;
this.config = config;
this.history = history;
this.sendPromise = Promise.resolve();
validateHistory(history);
}
/**
* Sends a message to the model and returns the response.
*
* @remarks
* This method will wait for the previous message to be processed before
* sending the next message.
*
* @see {@link Chat#sendMessageStream} for streaming method.
* @param params - parameters for sending messages within a chat session.
* @returns The model's response.
*
* @example
* ```ts
* const chat = ai.chats.create({model: 'gemini-2.0-flash'});
* const response = await chat.sendMessage({
* message: 'Why is the sky blue?'
* });
* console.log(response.text);
* ```
*/
async sendMessage(params) {
var _a;
await this.sendPromise;
const inputContent = tContent(params.message);
const responsePromise = this.modelsModule.generateContent({
model: this.model,
contents: this.getHistory(true).concat(inputContent),
config: (_a = params.config) !== null && _a !== void 0 ? _a : this.config
});
this.sendPromise = (async () => {
var _a2, _b, _c;
const response = await responsePromise;
const outputContent = (_b = (_a2 = response.candidates) === null || _a2 === void 0 ? void 0 : _a2[0]) === null || _b === void 0 ? void 0 : _b.content;
const fullAutomaticFunctionCallingHistory = response.automaticFunctionCallingHistory;
const index = this.getHistory(true).length;
let automaticFunctionCallingHistory = [];
if (fullAutomaticFunctionCallingHistory != null) {
automaticFunctionCallingHistory = (_c = fullAutomaticFunctionCallingHistory.slice(index)) !== null && _c !== void 0 ? _c : [];
}
const modelOutput = outputContent ? [outputContent] : [];
this.recordHistory(inputContent, modelOutput, automaticFunctionCallingHistory);
return;
})();
await this.sendPromise.catch(() => {
this.sendPromise = Promise.resolve();
});
return responsePromise;
}
/**
* Sends a message to the model and returns the response in chunks.
*
* @remarks
* This method will wait for the previous message to be processed before
* sending the next message.
*
* @see {@link Chat#sendMessage} for non-streaming method.
* @param params - parameters for sending the message.
* @return The model's response.
*
* @example
* ```ts
* const chat = ai.chats.create({model: 'gemini-2.0-flash'});
* const response = await chat.sendMessageStream({
* message: 'Why is the sky blue?'
* });
* for await (const chunk of response) {
* console.log(chunk.text);
* }
* ```
*/
async sendMessageStream(params) {
var _a;
await this.sendPromise;
const inputContent = tContent(params.message);
const streamResponse = this.modelsModule.generateContentStream({
model: this.model,
contents: this.getHistory(true).concat(inputContent),
config: (_a = params.config) !== null && _a !== void 0 ? _a : this.config
});
this.sendPromise = streamResponse.then(() => void 0).catch(() => void 0);
const response = await streamResponse;
const result = this.processStreamResponse(response, inputContent);
return result;
}
/**
* Returns the chat history.
*
* @remarks
* The history is a list of contents alternating between user and model.
*
* There are two types of history:
* - The `curated history` contains only the valid turns between user and
* model, which will be included in the subsequent requests sent to the model.
* - The `comprehensive history` contains all turns, including invalid or
* empty model outputs, providing a complete record of the history.
*
* The history is updated after receiving the response from the model,
* for streaming response, it means receiving the last chunk of the response.
*
* The `comprehensive history` is returned by default. To get the `curated
* history`, set the `curated` parameter to `true`.
*
* @param curated - whether to return the curated history or the comprehensive
* history.
* @return History contents alternating between user and model for the entire
* chat session.
*/
getHistory(curated = false) {
const history = curated ? extractCuratedHistory(this.history) : this.history;
return structuredClone(history);
}
processStreamResponse(streamResponse, inputContent) {
var _a, _b;
return __asyncGenerator(this, arguments, function* processStreamResponse_1() {
var _c, e_1, _d, _e;
const outputContent = [];
try {
for (var _f = true, streamResponse_1 = __asyncValues(streamResponse), streamResponse_1_1; streamResponse_1_1 = yield __await(streamResponse_1.next()), _c = streamResponse_1_1.done, !_c; _f = true) {
_e = streamResponse_1_1.value;
_f = false;
const chunk = _e;
if (isValidResponse(chunk)) {
const content = (_b = (_a = chunk.candidates) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.content;
if (content !== void 0) {
outputContent.push(content);
}
}
yield yield __await(chunk);
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (!_f && !_c && (_d = streamResponse_1.return)) yield __await(_d.call(streamResponse_1));
} finally {
if (e_1) throw e_1.error;
}
}
this.recordHistory(inputContent, outputContent);
});
}
recordHistory(userInput, modelOutput, automaticFunctionCallingHistory) {
let outputContents = [];
if (modelOutput.length > 0 && modelOutput.every((content) => content.role !== void 0)) {
outputContents = modelOutput;
} else {
outputContents.push({
role: "model",
parts: []
});
}
if (automaticFunctionCallingHistory && automaticFunctionCallingHistory.length > 0) {
this.history.push(...extractCuratedHistory(automaticFunctionCallingHistory));
} else {
this.history.push(userInput);
}
this.history.push(...outputContents);
}
};
var ApiError = class _ApiError extends Error {
constructor(options) {
super(options.message);
this.name = "ApiError";
this.status = options.status;
Object.setPrototypeOf(this, _ApiError.prototype);
}
};
function createFileParametersToMldev(fromObject) {
const toObject = {};
const fromFile = getValueByPath(fromObject, ["file"]);
if (fromFile != null) {
setValueByPath(toObject, ["file"], fromFile);
}
return toObject;
}
function createFileResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
return toObject;
}
function deleteFileParametersToMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "file"], tFileName(fromName));
}
return toObject;
}
function deleteFileResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
return toObject;
}
function getFileParametersToMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "file"], tFileName(fromName));
}
return toObject;
}
function listFilesConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
return toObject;
}
function listFilesParametersToMldev(fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listFilesConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function listFilesResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromFiles = getValueByPath(fromObject, ["files"]);
if (fromFiles != null) {
let transformedList = fromFiles;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["files"], transformedList);
}
return toObject;
}
var Files = class extends BaseModule {
constructor(apiClient) {
super();
this.apiClient = apiClient;
this.list = async (params = {}) => {
return new Pager(PagedItem.PAGED_ITEM_FILES, (x) => this.listInternal(x), await this.listInternal(params), params);
};
}
/**
* Uploads a file asynchronously to the Gemini API.
* This method is not available in Vertex AI.
* Supported upload sources:
* - Node.js: File path (string) or Blob object.
* - Browser: Blob object (e.g., File).
*
* @remarks
* The `mimeType` can be specified in the `config` parameter. If omitted:
* - For file path (string) inputs, the `mimeType` will be inferred from the
* file extension.
* - For Blob object inputs, the `mimeType` will be set to the Blob's `type`
* property.
* Somex eamples for file extension to mimeType mapping:
* .txt -> text/plain
* .json -> application/json
* .jpg -> image/jpeg
* .png -> image/png
* .mp3 -> audio/mpeg
* .mp4 -> video/mp4
*
* This section can contain multiple paragraphs and code examples.
*
* @param params - Optional parameters specified in the
* `types.UploadFileParameters` interface.
* @see {@link types.UploadFileParameters#config} for the optional
* config in the parameters.
* @return A promise that resolves to a `types.File` object.
* @throws An error if called on a Vertex AI client.
* @throws An error if the `mimeType` is not provided and can not be inferred,
* the `mimeType` can be provided in the `params.config` parameter.
* @throws An error occurs if a suitable upload location cannot be established.
*
* @example
* The following code uploads a file to Gemini API.
*
* ```ts
* const file = await ai.files.upload({file: 'file.txt', config: {
* mimeType: 'text/plain',
* }});
* console.log(file.name);
* ```
*/
async upload(params) {
if (this.apiClient.isVertexAI()) {
throw new Error("Vertex AI does not support uploading files. You can share files through a GCS bucket.");
}
return this.apiClient.uploadFile(params.file, params.config).then((resp) => {
return resp;
});
}
/**
* Downloads a remotely stored file asynchronously to a location specified in
* the `params` object. This method only works on Node environment, to
* download files in the browser, use a browser compliant method like an <a>
* tag.
*
* @param params - The parameters for the download request.
*
* @example
* The following code downloads an example file named "files/mehozpxf877d" as
* "file.txt".
*
* ```ts
* await ai.files.download({file: file.name, downloadPath: 'file.txt'});
* ```
*/
async download(params) {
await this.apiClient.downloadFile(params);
}
async listInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = listFilesParametersToMldev(params);
path10 = formatMap("files", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = listFilesResponseFromMldev(apiResponse);
const typedResp = new ListFilesResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
async createInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = createFileParametersToMldev(params);
path10 = formatMap("upload/v1beta/files", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = createFileResponseFromMldev(apiResponse);
const typedResp = new CreateFileResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Retrieves the file information from the service.
*
* @param params - The parameters for the get request
* @return The Promise that resolves to the types.File object requested.
*
* @example
* ```ts
* const config: GetFileParameters = {
* name: fileName,
* };
* file = await ai.files.get(config);
* console.log(file.name);
* ```
*/
async get(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = getFileParametersToMldev(params);
path10 = formatMap("files/{file}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
}
}
/**
* Deletes a remotely stored file.
*
* @param params - The parameters for the delete request.
* @return The DeleteFileResponse, the response for the delete method.
*
* @example
* The following code deletes an example file named "files/mehozpxf877d".
*
* ```ts
* await ai.files.delete({name: file.name});
* ```
*/
async delete(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = deleteFileParametersToMldev(params);
path10 = formatMap("files/{file}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "DELETE",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = deleteFileResponseFromMldev(apiResponse);
const typedResp = new DeleteFileResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
};
function blobToMldev$2(fromObject) {
const toObject = {};
const fromData = getValueByPath(fromObject, ["data"]);
if (fromData != null) {
setValueByPath(toObject, ["data"], fromData);
}
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function contentToMldev$2(fromObject) {
const toObject = {};
const fromParts = getValueByPath(fromObject, ["parts"]);
if (fromParts != null) {
let transformedList = fromParts;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return partToMldev$2(item);
});
}
setValueByPath(toObject, ["parts"], transformedList);
}
const fromRole = getValueByPath(fromObject, ["role"]);
if (fromRole != null) {
setValueByPath(toObject, ["role"], fromRole);
}
return toObject;
}
function fileDataToMldev$2(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromFileUri = getValueByPath(fromObject, ["fileUri"]);
if (fromFileUri != null) {
setValueByPath(toObject, ["fileUri"], fromFileUri);
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function functionCallToMldev$2(fromObject) {
const toObject = {};
const fromId = getValueByPath(fromObject, ["id"]);
if (fromId != null) {
setValueByPath(toObject, ["id"], fromId);
}
const fromArgs = getValueByPath(fromObject, ["args"]);
if (fromArgs != null) {
setValueByPath(toObject, ["args"], fromArgs);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
if (getValueByPath(fromObject, ["partialArgs"]) !== void 0) {
throw new Error("partialArgs parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["willContinue"]) !== void 0) {
throw new Error("willContinue parameter is not supported in Gemini API.");
}
return toObject;
}
function functionDeclarationToVertex$1(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["behavior"]) !== void 0) {
throw new Error("behavior parameter is not supported in Vertex AI.");
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (fromDescription != null) {
setValueByPath(toObject, ["description"], fromDescription);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromParameters = getValueByPath(fromObject, ["parameters"]);
if (fromParameters != null) {
setValueByPath(toObject, ["parameters"], fromParameters);
}
const fromParametersJsonSchema = getValueByPath(fromObject, [
"parametersJsonSchema"
]);
if (fromParametersJsonSchema != null) {
setValueByPath(toObject, ["parametersJsonSchema"], fromParametersJsonSchema);
}
const fromResponse = getValueByPath(fromObject, ["response"]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], fromResponse);
}
const fromResponseJsonSchema = getValueByPath(fromObject, [
"responseJsonSchema"
]);
if (fromResponseJsonSchema != null) {
setValueByPath(toObject, ["responseJsonSchema"], fromResponseJsonSchema);
}
return toObject;
}
function generationConfigToVertex$1(fromObject) {
const toObject = {};
const fromModelSelectionConfig = getValueByPath(fromObject, [
"modelSelectionConfig"
]);
if (fromModelSelectionConfig != null) {
setValueByPath(toObject, ["modelConfig"], fromModelSelectionConfig);
}
const fromResponseJsonSchema = getValueByPath(fromObject, [
"responseJsonSchema"
]);
if (fromResponseJsonSchema != null) {
setValueByPath(toObject, ["responseJsonSchema"], fromResponseJsonSchema);
}
const fromAudioTimestamp = getValueByPath(fromObject, [
"audioTimestamp"
]);
if (fromAudioTimestamp != null) {
setValueByPath(toObject, ["audioTimestamp"], fromAudioTimestamp);
}
const fromCandidateCount = getValueByPath(fromObject, [
"candidateCount"
]);
if (fromCandidateCount != null) {
setValueByPath(toObject, ["candidateCount"], fromCandidateCount);
}
const fromEnableAffectiveDialog = getValueByPath(fromObject, [
"enableAffectiveDialog"
]);
if (fromEnableAffectiveDialog != null) {
setValueByPath(toObject, ["enableAffectiveDialog"], fromEnableAffectiveDialog);
}
const fromFrequencyPenalty = getValueByPath(fromObject, [
"frequencyPenalty"
]);
if (fromFrequencyPenalty != null) {
setValueByPath(toObject, ["frequencyPenalty"], fromFrequencyPenalty);
}
const fromLogprobs = getValueByPath(fromObject, ["logprobs"]);
if (fromLogprobs != null) {
setValueByPath(toObject, ["logprobs"], fromLogprobs);
}
const fromMaxOutputTokens = getValueByPath(fromObject, [
"maxOutputTokens"
]);
if (fromMaxOutputTokens != null) {
setValueByPath(toObject, ["maxOutputTokens"], fromMaxOutputTokens);
}
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromPresencePenalty = getValueByPath(fromObject, [
"presencePenalty"
]);
if (fromPresencePenalty != null) {
setValueByPath(toObject, ["presencePenalty"], fromPresencePenalty);
}
const fromResponseLogprobs = getValueByPath(fromObject, [
"responseLogprobs"
]);
if (fromResponseLogprobs != null) {
setValueByPath(toObject, ["responseLogprobs"], fromResponseLogprobs);
}
const fromResponseMimeType = getValueByPath(fromObject, [
"responseMimeType"
]);
if (fromResponseMimeType != null) {
setValueByPath(toObject, ["responseMimeType"], fromResponseMimeType);
}
const fromResponseModalities = getValueByPath(fromObject, [
"responseModalities"
]);
if (fromResponseModalities != null) {
setValueByPath(toObject, ["responseModalities"], fromResponseModalities);
}
const fromResponseSchema = getValueByPath(fromObject, [
"responseSchema"
]);
if (fromResponseSchema != null) {
setValueByPath(toObject, ["responseSchema"], fromResponseSchema);
}
const fromRoutingConfig = getValueByPath(fromObject, [
"routingConfig"
]);
if (fromRoutingConfig != null) {
setValueByPath(toObject, ["routingConfig"], fromRoutingConfig);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (fromSeed != null) {
setValueByPath(toObject, ["seed"], fromSeed);
}
const fromSpeechConfig = getValueByPath(fromObject, ["speechConfig"]);
if (fromSpeechConfig != null) {
setValueByPath(toObject, ["speechConfig"], speechConfigToVertex$1(fromSpeechConfig));
}
const fromStopSequences = getValueByPath(fromObject, [
"stopSequences"
]);
if (fromStopSequences != null) {
setValueByPath(toObject, ["stopSequences"], fromStopSequences);
}
const fromTemperature = getValueByPath(fromObject, ["temperature"]);
if (fromTemperature != null) {
setValueByPath(toObject, ["temperature"], fromTemperature);
}
const fromThinkingConfig = getValueByPath(fromObject, [
"thinkingConfig"
]);
if (fromThinkingConfig != null) {
setValueByPath(toObject, ["thinkingConfig"], fromThinkingConfig);
}
const fromTopK = getValueByPath(fromObject, ["topK"]);
if (fromTopK != null) {
setValueByPath(toObject, ["topK"], fromTopK);
}
const fromTopP = getValueByPath(fromObject, ["topP"]);
if (fromTopP != null) {
setValueByPath(toObject, ["topP"], fromTopP);
}
if (getValueByPath(fromObject, ["enableEnhancedCivicAnswers"]) !== void 0) {
throw new Error("enableEnhancedCivicAnswers parameter is not supported in Vertex AI.");
}
return toObject;
}
function googleMapsToMldev$2(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["authConfig"]) !== void 0) {
throw new Error("authConfig parameter is not supported in Gemini API.");
}
const fromEnableWidget = getValueByPath(fromObject, ["enableWidget"]);
if (fromEnableWidget != null) {
setValueByPath(toObject, ["enableWidget"], fromEnableWidget);
}
return toObject;
}
function googleSearchToMldev$2(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["excludeDomains"]) !== void 0) {
throw new Error("excludeDomains parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["blockingConfidence"]) !== void 0) {
throw new Error("blockingConfidence parameter is not supported in Gemini API.");
}
const fromTimeRangeFilter = getValueByPath(fromObject, [
"timeRangeFilter"
]);
if (fromTimeRangeFilter != null) {
setValueByPath(toObject, ["timeRangeFilter"], fromTimeRangeFilter);
}
return toObject;
}
function liveConnectConfigToMldev$1(fromObject, parentObject) {
const toObject = {};
const fromGenerationConfig = getValueByPath(fromObject, [
"generationConfig"
]);
if (parentObject !== void 0 && fromGenerationConfig != null) {
setValueByPath(parentObject, ["setup", "generationConfig"], fromGenerationConfig);
}
const fromResponseModalities = getValueByPath(fromObject, [
"responseModalities"
]);
if (parentObject !== void 0 && fromResponseModalities != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "responseModalities"], fromResponseModalities);
}
const fromTemperature = getValueByPath(fromObject, ["temperature"]);
if (parentObject !== void 0 && fromTemperature != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "temperature"], fromTemperature);
}
const fromTopP = getValueByPath(fromObject, ["topP"]);
if (parentObject !== void 0 && fromTopP != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "topP"], fromTopP);
}
const fromTopK = getValueByPath(fromObject, ["topK"]);
if (parentObject !== void 0 && fromTopK != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "topK"], fromTopK);
}
const fromMaxOutputTokens = getValueByPath(fromObject, [
"maxOutputTokens"
]);
if (parentObject !== void 0 && fromMaxOutputTokens != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "maxOutputTokens"], fromMaxOutputTokens);
}
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (parentObject !== void 0 && fromMediaResolution != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "mediaResolution"], fromMediaResolution);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (parentObject !== void 0 && fromSeed != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "seed"], fromSeed);
}
const fromSpeechConfig = getValueByPath(fromObject, ["speechConfig"]);
if (parentObject !== void 0 && fromSpeechConfig != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "speechConfig"], tLiveSpeechConfig(fromSpeechConfig));
}
const fromThinkingConfig = getValueByPath(fromObject, [
"thinkingConfig"
]);
if (parentObject !== void 0 && fromThinkingConfig != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "thinkingConfig"], fromThinkingConfig);
}
const fromEnableAffectiveDialog = getValueByPath(fromObject, [
"enableAffectiveDialog"
]);
if (parentObject !== void 0 && fromEnableAffectiveDialog != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "enableAffectiveDialog"], fromEnableAffectiveDialog);
}
const fromSystemInstruction = getValueByPath(fromObject, [
"systemInstruction"
]);
if (parentObject !== void 0 && fromSystemInstruction != null) {
setValueByPath(parentObject, ["setup", "systemInstruction"], contentToMldev$2(tContent(fromSystemInstruction)));
}
const fromTools = getValueByPath(fromObject, ["tools"]);
if (parentObject !== void 0 && fromTools != null) {
let transformedList = tTools(fromTools);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return toolToMldev$2(tTool(item));
});
}
setValueByPath(parentObject, ["setup", "tools"], transformedList);
}
const fromSessionResumption = getValueByPath(fromObject, [
"sessionResumption"
]);
if (parentObject !== void 0 && fromSessionResumption != null) {
setValueByPath(parentObject, ["setup", "sessionResumption"], sessionResumptionConfigToMldev$1(fromSessionResumption));
}
const fromInputAudioTranscription = getValueByPath(fromObject, [
"inputAudioTranscription"
]);
if (parentObject !== void 0 && fromInputAudioTranscription != null) {
setValueByPath(parentObject, ["setup", "inputAudioTranscription"], fromInputAudioTranscription);
}
const fromOutputAudioTranscription = getValueByPath(fromObject, [
"outputAudioTranscription"
]);
if (parentObject !== void 0 && fromOutputAudioTranscription != null) {
setValueByPath(parentObject, ["setup", "outputAudioTranscription"], fromOutputAudioTranscription);
}
const fromRealtimeInputConfig = getValueByPath(fromObject, [
"realtimeInputConfig"
]);
if (parentObject !== void 0 && fromRealtimeInputConfig != null) {
setValueByPath(parentObject, ["setup", "realtimeInputConfig"], fromRealtimeInputConfig);
}
const fromContextWindowCompression = getValueByPath(fromObject, [
"contextWindowCompression"
]);
if (parentObject !== void 0 && fromContextWindowCompression != null) {
setValueByPath(parentObject, ["setup", "contextWindowCompression"], fromContextWindowCompression);
}
const fromProactivity = getValueByPath(fromObject, ["proactivity"]);
if (parentObject !== void 0 && fromProactivity != null) {
setValueByPath(parentObject, ["setup", "proactivity"], fromProactivity);
}
return toObject;
}
function liveConnectConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromGenerationConfig = getValueByPath(fromObject, [
"generationConfig"
]);
if (parentObject !== void 0 && fromGenerationConfig != null) {
setValueByPath(parentObject, ["setup", "generationConfig"], generationConfigToVertex$1(fromGenerationConfig));
}
const fromResponseModalities = getValueByPath(fromObject, [
"responseModalities"
]);
if (parentObject !== void 0 && fromResponseModalities != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "responseModalities"], fromResponseModalities);
}
const fromTemperature = getValueByPath(fromObject, ["temperature"]);
if (parentObject !== void 0 && fromTemperature != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "temperature"], fromTemperature);
}
const fromTopP = getValueByPath(fromObject, ["topP"]);
if (parentObject !== void 0 && fromTopP != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "topP"], fromTopP);
}
const fromTopK = getValueByPath(fromObject, ["topK"]);
if (parentObject !== void 0 && fromTopK != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "topK"], fromTopK);
}
const fromMaxOutputTokens = getValueByPath(fromObject, [
"maxOutputTokens"
]);
if (parentObject !== void 0 && fromMaxOutputTokens != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "maxOutputTokens"], fromMaxOutputTokens);
}
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (parentObject !== void 0 && fromMediaResolution != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "mediaResolution"], fromMediaResolution);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (parentObject !== void 0 && fromSeed != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "seed"], fromSeed);
}
const fromSpeechConfig = getValueByPath(fromObject, ["speechConfig"]);
if (parentObject !== void 0 && fromSpeechConfig != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "speechConfig"], speechConfigToVertex$1(tLiveSpeechConfig(fromSpeechConfig)));
}
const fromThinkingConfig = getValueByPath(fromObject, [
"thinkingConfig"
]);
if (parentObject !== void 0 && fromThinkingConfig != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "thinkingConfig"], fromThinkingConfig);
}
const fromEnableAffectiveDialog = getValueByPath(fromObject, [
"enableAffectiveDialog"
]);
if (parentObject !== void 0 && fromEnableAffectiveDialog != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "enableAffectiveDialog"], fromEnableAffectiveDialog);
}
const fromSystemInstruction = getValueByPath(fromObject, [
"systemInstruction"
]);
if (parentObject !== void 0 && fromSystemInstruction != null) {
setValueByPath(parentObject, ["setup", "systemInstruction"], tContent(fromSystemInstruction));
}
const fromTools = getValueByPath(fromObject, ["tools"]);
if (parentObject !== void 0 && fromTools != null) {
let transformedList = tTools(fromTools);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return toolToVertex$1(tTool(item));
});
}
setValueByPath(parentObject, ["setup", "tools"], transformedList);
}
const fromSessionResumption = getValueByPath(fromObject, [
"sessionResumption"
]);
if (parentObject !== void 0 && fromSessionResumption != null) {
setValueByPath(parentObject, ["setup", "sessionResumption"], fromSessionResumption);
}
const fromInputAudioTranscription = getValueByPath(fromObject, [
"inputAudioTranscription"
]);
if (parentObject !== void 0 && fromInputAudioTranscription != null) {
setValueByPath(parentObject, ["setup", "inputAudioTranscription"], fromInputAudioTranscription);
}
const fromOutputAudioTranscription = getValueByPath(fromObject, [
"outputAudioTranscription"
]);
if (parentObject !== void 0 && fromOutputAudioTranscription != null) {
setValueByPath(parentObject, ["setup", "outputAudioTranscription"], fromOutputAudioTranscription);
}
const fromRealtimeInputConfig = getValueByPath(fromObject, [
"realtimeInputConfig"
]);
if (parentObject !== void 0 && fromRealtimeInputConfig != null) {
setValueByPath(parentObject, ["setup", "realtimeInputConfig"], fromRealtimeInputConfig);
}
const fromContextWindowCompression = getValueByPath(fromObject, [
"contextWindowCompression"
]);
if (parentObject !== void 0 && fromContextWindowCompression != null) {
setValueByPath(parentObject, ["setup", "contextWindowCompression"], fromContextWindowCompression);
}
const fromProactivity = getValueByPath(fromObject, ["proactivity"]);
if (parentObject !== void 0 && fromProactivity != null) {
setValueByPath(parentObject, ["setup", "proactivity"], fromProactivity);
}
return toObject;
}
function liveConnectParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["setup", "model"], tModel(apiClient, fromModel));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
setValueByPath(toObject, ["config"], liveConnectConfigToMldev$1(fromConfig, toObject));
}
return toObject;
}
function liveConnectParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["setup", "model"], tModel(apiClient, fromModel));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
setValueByPath(toObject, ["config"], liveConnectConfigToVertex(fromConfig, toObject));
}
return toObject;
}
function liveMusicSetConfigParametersToMldev(fromObject) {
const toObject = {};
const fromMusicGenerationConfig = getValueByPath(fromObject, [
"musicGenerationConfig"
]);
if (fromMusicGenerationConfig != null) {
setValueByPath(toObject, ["musicGenerationConfig"], fromMusicGenerationConfig);
}
return toObject;
}
function liveMusicSetWeightedPromptsParametersToMldev(fromObject) {
const toObject = {};
const fromWeightedPrompts = getValueByPath(fromObject, [
"weightedPrompts"
]);
if (fromWeightedPrompts != null) {
let transformedList = fromWeightedPrompts;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["weightedPrompts"], transformedList);
}
return toObject;
}
function liveSendRealtimeInputParametersToMldev(fromObject) {
const toObject = {};
const fromMedia = getValueByPath(fromObject, ["media"]);
if (fromMedia != null) {
let transformedList = tBlobs(fromMedia);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return blobToMldev$2(item);
});
}
setValueByPath(toObject, ["mediaChunks"], transformedList);
}
const fromAudio = getValueByPath(fromObject, ["audio"]);
if (fromAudio != null) {
setValueByPath(toObject, ["audio"], blobToMldev$2(tAudioBlob(fromAudio)));
}
const fromAudioStreamEnd = getValueByPath(fromObject, [
"audioStreamEnd"
]);
if (fromAudioStreamEnd != null) {
setValueByPath(toObject, ["audioStreamEnd"], fromAudioStreamEnd);
}
const fromVideo = getValueByPath(fromObject, ["video"]);
if (fromVideo != null) {
setValueByPath(toObject, ["video"], blobToMldev$2(tImageBlob(fromVideo)));
}
const fromText = getValueByPath(fromObject, ["text"]);
if (fromText != null) {
setValueByPath(toObject, ["text"], fromText);
}
const fromActivityStart = getValueByPath(fromObject, [
"activityStart"
]);
if (fromActivityStart != null) {
setValueByPath(toObject, ["activityStart"], fromActivityStart);
}
const fromActivityEnd = getValueByPath(fromObject, ["activityEnd"]);
if (fromActivityEnd != null) {
setValueByPath(toObject, ["activityEnd"], fromActivityEnd);
}
return toObject;
}
function liveSendRealtimeInputParametersToVertex(fromObject) {
const toObject = {};
const fromMedia = getValueByPath(fromObject, ["media"]);
if (fromMedia != null) {
let transformedList = tBlobs(fromMedia);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["mediaChunks"], transformedList);
}
const fromAudio = getValueByPath(fromObject, ["audio"]);
if (fromAudio != null) {
setValueByPath(toObject, ["audio"], tAudioBlob(fromAudio));
}
const fromAudioStreamEnd = getValueByPath(fromObject, [
"audioStreamEnd"
]);
if (fromAudioStreamEnd != null) {
setValueByPath(toObject, ["audioStreamEnd"], fromAudioStreamEnd);
}
const fromVideo = getValueByPath(fromObject, ["video"]);
if (fromVideo != null) {
setValueByPath(toObject, ["video"], tImageBlob(fromVideo));
}
const fromText = getValueByPath(fromObject, ["text"]);
if (fromText != null) {
setValueByPath(toObject, ["text"], fromText);
}
const fromActivityStart = getValueByPath(fromObject, [
"activityStart"
]);
if (fromActivityStart != null) {
setValueByPath(toObject, ["activityStart"], fromActivityStart);
}
const fromActivityEnd = getValueByPath(fromObject, ["activityEnd"]);
if (fromActivityEnd != null) {
setValueByPath(toObject, ["activityEnd"], fromActivityEnd);
}
return toObject;
}
function liveServerMessageFromVertex(fromObject) {
const toObject = {};
const fromSetupComplete = getValueByPath(fromObject, [
"setupComplete"
]);
if (fromSetupComplete != null) {
setValueByPath(toObject, ["setupComplete"], fromSetupComplete);
}
const fromServerContent = getValueByPath(fromObject, [
"serverContent"
]);
if (fromServerContent != null) {
setValueByPath(toObject, ["serverContent"], fromServerContent);
}
const fromToolCall = getValueByPath(fromObject, ["toolCall"]);
if (fromToolCall != null) {
setValueByPath(toObject, ["toolCall"], fromToolCall);
}
const fromToolCallCancellation = getValueByPath(fromObject, [
"toolCallCancellation"
]);
if (fromToolCallCancellation != null) {
setValueByPath(toObject, ["toolCallCancellation"], fromToolCallCancellation);
}
const fromUsageMetadata = getValueByPath(fromObject, [
"usageMetadata"
]);
if (fromUsageMetadata != null) {
setValueByPath(toObject, ["usageMetadata"], usageMetadataFromVertex(fromUsageMetadata));
}
const fromGoAway = getValueByPath(fromObject, ["goAway"]);
if (fromGoAway != null) {
setValueByPath(toObject, ["goAway"], fromGoAway);
}
const fromSessionResumptionUpdate = getValueByPath(fromObject, [
"sessionResumptionUpdate"
]);
if (fromSessionResumptionUpdate != null) {
setValueByPath(toObject, ["sessionResumptionUpdate"], fromSessionResumptionUpdate);
}
return toObject;
}
function partToMldev$2(fromObject) {
const toObject = {};
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromCodeExecutionResult = getValueByPath(fromObject, [
"codeExecutionResult"
]);
if (fromCodeExecutionResult != null) {
setValueByPath(toObject, ["codeExecutionResult"], fromCodeExecutionResult);
}
const fromExecutableCode = getValueByPath(fromObject, [
"executableCode"
]);
if (fromExecutableCode != null) {
setValueByPath(toObject, ["executableCode"], fromExecutableCode);
}
const fromFileData = getValueByPath(fromObject, ["fileData"]);
if (fromFileData != null) {
setValueByPath(toObject, ["fileData"], fileDataToMldev$2(fromFileData));
}
const fromFunctionCall = getValueByPath(fromObject, ["functionCall"]);
if (fromFunctionCall != null) {
setValueByPath(toObject, ["functionCall"], functionCallToMldev$2(fromFunctionCall));
}
const fromFunctionResponse = getValueByPath(fromObject, [
"functionResponse"
]);
if (fromFunctionResponse != null) {
setValueByPath(toObject, ["functionResponse"], fromFunctionResponse);
}
const fromInlineData = getValueByPath(fromObject, ["inlineData"]);
if (fromInlineData != null) {
setValueByPath(toObject, ["inlineData"], blobToMldev$2(fromInlineData));
}
const fromText = getValueByPath(fromObject, ["text"]);
if (fromText != null) {
setValueByPath(toObject, ["text"], fromText);
}
const fromThought = getValueByPath(fromObject, ["thought"]);
if (fromThought != null) {
setValueByPath(toObject, ["thought"], fromThought);
}
const fromThoughtSignature = getValueByPath(fromObject, [
"thoughtSignature"
]);
if (fromThoughtSignature != null) {
setValueByPath(toObject, ["thoughtSignature"], fromThoughtSignature);
}
const fromVideoMetadata = getValueByPath(fromObject, [
"videoMetadata"
]);
if (fromVideoMetadata != null) {
setValueByPath(toObject, ["videoMetadata"], fromVideoMetadata);
}
return toObject;
}
function sessionResumptionConfigToMldev$1(fromObject) {
const toObject = {};
const fromHandle = getValueByPath(fromObject, ["handle"]);
if (fromHandle != null) {
setValueByPath(toObject, ["handle"], fromHandle);
}
if (getValueByPath(fromObject, ["transparent"]) !== void 0) {
throw new Error("transparent parameter is not supported in Gemini API.");
}
return toObject;
}
function speechConfigToVertex$1(fromObject) {
const toObject = {};
const fromLanguageCode = getValueByPath(fromObject, ["languageCode"]);
if (fromLanguageCode != null) {
setValueByPath(toObject, ["languageCode"], fromLanguageCode);
}
const fromVoiceConfig = getValueByPath(fromObject, ["voiceConfig"]);
if (fromVoiceConfig != null) {
setValueByPath(toObject, ["voiceConfig"], fromVoiceConfig);
}
if (getValueByPath(fromObject, ["multiSpeakerVoiceConfig"]) !== void 0) {
throw new Error("multiSpeakerVoiceConfig parameter is not supported in Vertex AI.");
}
return toObject;
}
function toolToMldev$2(fromObject) {
const toObject = {};
const fromFunctionDeclarations = getValueByPath(fromObject, [
"functionDeclarations"
]);
if (fromFunctionDeclarations != null) {
let transformedList = fromFunctionDeclarations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["functionDeclarations"], transformedList);
}
if (getValueByPath(fromObject, ["retrieval"]) !== void 0) {
throw new Error("retrieval parameter is not supported in Gemini API.");
}
const fromGoogleSearchRetrieval = getValueByPath(fromObject, [
"googleSearchRetrieval"
]);
if (fromGoogleSearchRetrieval != null) {
setValueByPath(toObject, ["googleSearchRetrieval"], fromGoogleSearchRetrieval);
}
const fromComputerUse = getValueByPath(fromObject, ["computerUse"]);
if (fromComputerUse != null) {
setValueByPath(toObject, ["computerUse"], fromComputerUse);
}
const fromFileSearch = getValueByPath(fromObject, ["fileSearch"]);
if (fromFileSearch != null) {
setValueByPath(toObject, ["fileSearch"], fromFileSearch);
}
const fromCodeExecution = getValueByPath(fromObject, [
"codeExecution"
]);
if (fromCodeExecution != null) {
setValueByPath(toObject, ["codeExecution"], fromCodeExecution);
}
if (getValueByPath(fromObject, ["enterpriseWebSearch"]) !== void 0) {
throw new Error("enterpriseWebSearch parameter is not supported in Gemini API.");
}
const fromGoogleMaps = getValueByPath(fromObject, ["googleMaps"]);
if (fromGoogleMaps != null) {
setValueByPath(toObject, ["googleMaps"], googleMapsToMldev$2(fromGoogleMaps));
}
const fromGoogleSearch = getValueByPath(fromObject, ["googleSearch"]);
if (fromGoogleSearch != null) {
setValueByPath(toObject, ["googleSearch"], googleSearchToMldev$2(fromGoogleSearch));
}
const fromUrlContext = getValueByPath(fromObject, ["urlContext"]);
if (fromUrlContext != null) {
setValueByPath(toObject, ["urlContext"], fromUrlContext);
}
return toObject;
}
function toolToVertex$1(fromObject) {
const toObject = {};
const fromFunctionDeclarations = getValueByPath(fromObject, [
"functionDeclarations"
]);
if (fromFunctionDeclarations != null) {
let transformedList = fromFunctionDeclarations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return functionDeclarationToVertex$1(item);
});
}
setValueByPath(toObject, ["functionDeclarations"], transformedList);
}
const fromRetrieval = getValueByPath(fromObject, ["retrieval"]);
if (fromRetrieval != null) {
setValueByPath(toObject, ["retrieval"], fromRetrieval);
}
const fromGoogleSearchRetrieval = getValueByPath(fromObject, [
"googleSearchRetrieval"
]);
if (fromGoogleSearchRetrieval != null) {
setValueByPath(toObject, ["googleSearchRetrieval"], fromGoogleSearchRetrieval);
}
const fromComputerUse = getValueByPath(fromObject, ["computerUse"]);
if (fromComputerUse != null) {
setValueByPath(toObject, ["computerUse"], fromComputerUse);
}
if (getValueByPath(fromObject, ["fileSearch"]) !== void 0) {
throw new Error("fileSearch parameter is not supported in Vertex AI.");
}
const fromCodeExecution = getValueByPath(fromObject, [
"codeExecution"
]);
if (fromCodeExecution != null) {
setValueByPath(toObject, ["codeExecution"], fromCodeExecution);
}
const fromEnterpriseWebSearch = getValueByPath(fromObject, [
"enterpriseWebSearch"
]);
if (fromEnterpriseWebSearch != null) {
setValueByPath(toObject, ["enterpriseWebSearch"], fromEnterpriseWebSearch);
}
const fromGoogleMaps = getValueByPath(fromObject, ["googleMaps"]);
if (fromGoogleMaps != null) {
setValueByPath(toObject, ["googleMaps"], fromGoogleMaps);
}
const fromGoogleSearch = getValueByPath(fromObject, ["googleSearch"]);
if (fromGoogleSearch != null) {
setValueByPath(toObject, ["googleSearch"], fromGoogleSearch);
}
const fromUrlContext = getValueByPath(fromObject, ["urlContext"]);
if (fromUrlContext != null) {
setValueByPath(toObject, ["urlContext"], fromUrlContext);
}
return toObject;
}
function usageMetadataFromVertex(fromObject) {
const toObject = {};
const fromPromptTokenCount = getValueByPath(fromObject, [
"promptTokenCount"
]);
if (fromPromptTokenCount != null) {
setValueByPath(toObject, ["promptTokenCount"], fromPromptTokenCount);
}
const fromCachedContentTokenCount = getValueByPath(fromObject, [
"cachedContentTokenCount"
]);
if (fromCachedContentTokenCount != null) {
setValueByPath(toObject, ["cachedContentTokenCount"], fromCachedContentTokenCount);
}
const fromResponseTokenCount = getValueByPath(fromObject, [
"candidatesTokenCount"
]);
if (fromResponseTokenCount != null) {
setValueByPath(toObject, ["responseTokenCount"], fromResponseTokenCount);
}
const fromToolUsePromptTokenCount = getValueByPath(fromObject, [
"toolUsePromptTokenCount"
]);
if (fromToolUsePromptTokenCount != null) {
setValueByPath(toObject, ["toolUsePromptTokenCount"], fromToolUsePromptTokenCount);
}
const fromThoughtsTokenCount = getValueByPath(fromObject, [
"thoughtsTokenCount"
]);
if (fromThoughtsTokenCount != null) {
setValueByPath(toObject, ["thoughtsTokenCount"], fromThoughtsTokenCount);
}
const fromTotalTokenCount = getValueByPath(fromObject, [
"totalTokenCount"
]);
if (fromTotalTokenCount != null) {
setValueByPath(toObject, ["totalTokenCount"], fromTotalTokenCount);
}
const fromPromptTokensDetails = getValueByPath(fromObject, [
"promptTokensDetails"
]);
if (fromPromptTokensDetails != null) {
let transformedList = fromPromptTokensDetails;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["promptTokensDetails"], transformedList);
}
const fromCacheTokensDetails = getValueByPath(fromObject, [
"cacheTokensDetails"
]);
if (fromCacheTokensDetails != null) {
let transformedList = fromCacheTokensDetails;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["cacheTokensDetails"], transformedList);
}
const fromResponseTokensDetails = getValueByPath(fromObject, [
"candidatesTokensDetails"
]);
if (fromResponseTokensDetails != null) {
let transformedList = fromResponseTokensDetails;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["responseTokensDetails"], transformedList);
}
const fromToolUsePromptTokensDetails = getValueByPath(fromObject, [
"toolUsePromptTokensDetails"
]);
if (fromToolUsePromptTokensDetails != null) {
let transformedList = fromToolUsePromptTokensDetails;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["toolUsePromptTokensDetails"], transformedList);
}
const fromTrafficType = getValueByPath(fromObject, ["trafficType"]);
if (fromTrafficType != null) {
setValueByPath(toObject, ["trafficType"], fromTrafficType);
}
return toObject;
}
function blobToMldev$1(fromObject) {
const toObject = {};
const fromData = getValueByPath(fromObject, ["data"]);
if (fromData != null) {
setValueByPath(toObject, ["data"], fromData);
}
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function candidateFromMldev(fromObject) {
const toObject = {};
const fromContent = getValueByPath(fromObject, ["content"]);
if (fromContent != null) {
setValueByPath(toObject, ["content"], fromContent);
}
const fromCitationMetadata = getValueByPath(fromObject, [
"citationMetadata"
]);
if (fromCitationMetadata != null) {
setValueByPath(toObject, ["citationMetadata"], citationMetadataFromMldev(fromCitationMetadata));
}
const fromTokenCount = getValueByPath(fromObject, ["tokenCount"]);
if (fromTokenCount != null) {
setValueByPath(toObject, ["tokenCount"], fromTokenCount);
}
const fromFinishReason = getValueByPath(fromObject, ["finishReason"]);
if (fromFinishReason != null) {
setValueByPath(toObject, ["finishReason"], fromFinishReason);
}
const fromAvgLogprobs = getValueByPath(fromObject, ["avgLogprobs"]);
if (fromAvgLogprobs != null) {
setValueByPath(toObject, ["avgLogprobs"], fromAvgLogprobs);
}
const fromGroundingMetadata = getValueByPath(fromObject, [
"groundingMetadata"
]);
if (fromGroundingMetadata != null) {
setValueByPath(toObject, ["groundingMetadata"], fromGroundingMetadata);
}
const fromIndex = getValueByPath(fromObject, ["index"]);
if (fromIndex != null) {
setValueByPath(toObject, ["index"], fromIndex);
}
const fromLogprobsResult = getValueByPath(fromObject, [
"logprobsResult"
]);
if (fromLogprobsResult != null) {
setValueByPath(toObject, ["logprobsResult"], fromLogprobsResult);
}
const fromSafetyRatings = getValueByPath(fromObject, [
"safetyRatings"
]);
if (fromSafetyRatings != null) {
let transformedList = fromSafetyRatings;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["safetyRatings"], transformedList);
}
const fromUrlContextMetadata = getValueByPath(fromObject, [
"urlContextMetadata"
]);
if (fromUrlContextMetadata != null) {
setValueByPath(toObject, ["urlContextMetadata"], fromUrlContextMetadata);
}
return toObject;
}
function citationMetadataFromMldev(fromObject) {
const toObject = {};
const fromCitations = getValueByPath(fromObject, ["citationSources"]);
if (fromCitations != null) {
let transformedList = fromCitations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["citations"], transformedList);
}
return toObject;
}
function computeTokensParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (fromContents != null) {
let transformedList = tContents(fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["contents"], transformedList);
}
return toObject;
}
function computeTokensResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromTokensInfo = getValueByPath(fromObject, ["tokensInfo"]);
if (fromTokensInfo != null) {
let transformedList = fromTokensInfo;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["tokensInfo"], transformedList);
}
return toObject;
}
function contentEmbeddingFromVertex(fromObject) {
const toObject = {};
const fromValues = getValueByPath(fromObject, ["values"]);
if (fromValues != null) {
setValueByPath(toObject, ["values"], fromValues);
}
const fromStatistics = getValueByPath(fromObject, ["statistics"]);
if (fromStatistics != null) {
setValueByPath(toObject, ["statistics"], contentEmbeddingStatisticsFromVertex(fromStatistics));
}
return toObject;
}
function contentEmbeddingStatisticsFromVertex(fromObject) {
const toObject = {};
const fromTruncated = getValueByPath(fromObject, ["truncated"]);
if (fromTruncated != null) {
setValueByPath(toObject, ["truncated"], fromTruncated);
}
const fromTokenCount = getValueByPath(fromObject, ["token_count"]);
if (fromTokenCount != null) {
setValueByPath(toObject, ["tokenCount"], fromTokenCount);
}
return toObject;
}
function contentToMldev$1(fromObject) {
const toObject = {};
const fromParts = getValueByPath(fromObject, ["parts"]);
if (fromParts != null) {
let transformedList = fromParts;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return partToMldev$1(item);
});
}
setValueByPath(toObject, ["parts"], transformedList);
}
const fromRole = getValueByPath(fromObject, ["role"]);
if (fromRole != null) {
setValueByPath(toObject, ["role"], fromRole);
}
return toObject;
}
function controlReferenceConfigToVertex(fromObject) {
const toObject = {};
const fromControlType = getValueByPath(fromObject, ["controlType"]);
if (fromControlType != null) {
setValueByPath(toObject, ["controlType"], fromControlType);
}
const fromEnableControlImageComputation = getValueByPath(fromObject, [
"enableControlImageComputation"
]);
if (fromEnableControlImageComputation != null) {
setValueByPath(toObject, ["computeControl"], fromEnableControlImageComputation);
}
return toObject;
}
function countTokensConfigToMldev(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["systemInstruction"]) !== void 0) {
throw new Error("systemInstruction parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["tools"]) !== void 0) {
throw new Error("tools parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["generationConfig"]) !== void 0) {
throw new Error("generationConfig parameter is not supported in Gemini API.");
}
return toObject;
}
function countTokensConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromSystemInstruction = getValueByPath(fromObject, [
"systemInstruction"
]);
if (parentObject !== void 0 && fromSystemInstruction != null) {
setValueByPath(parentObject, ["systemInstruction"], tContent(fromSystemInstruction));
}
const fromTools = getValueByPath(fromObject, ["tools"]);
if (parentObject !== void 0 && fromTools != null) {
let transformedList = fromTools;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return toolToVertex(item);
});
}
setValueByPath(parentObject, ["tools"], transformedList);
}
const fromGenerationConfig = getValueByPath(fromObject, [
"generationConfig"
]);
if (parentObject !== void 0 && fromGenerationConfig != null) {
setValueByPath(parentObject, ["generationConfig"], generationConfigToVertex(fromGenerationConfig));
}
return toObject;
}
function countTokensParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (fromContents != null) {
let transformedList = tContents(fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return contentToMldev$1(item);
});
}
setValueByPath(toObject, ["contents"], transformedList);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
countTokensConfigToMldev(fromConfig);
}
return toObject;
}
function countTokensParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (fromContents != null) {
let transformedList = tContents(fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["contents"], transformedList);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
countTokensConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function countTokensResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromTotalTokens = getValueByPath(fromObject, ["totalTokens"]);
if (fromTotalTokens != null) {
setValueByPath(toObject, ["totalTokens"], fromTotalTokens);
}
const fromCachedContentTokenCount = getValueByPath(fromObject, [
"cachedContentTokenCount"
]);
if (fromCachedContentTokenCount != null) {
setValueByPath(toObject, ["cachedContentTokenCount"], fromCachedContentTokenCount);
}
return toObject;
}
function countTokensResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromTotalTokens = getValueByPath(fromObject, ["totalTokens"]);
if (fromTotalTokens != null) {
setValueByPath(toObject, ["totalTokens"], fromTotalTokens);
}
return toObject;
}
function deleteModelParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "name"], tModel(apiClient, fromModel));
}
return toObject;
}
function deleteModelParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "name"], tModel(apiClient, fromModel));
}
return toObject;
}
function deleteModelResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
return toObject;
}
function deleteModelResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
return toObject;
}
function editImageConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromOutputGcsUri = getValueByPath(fromObject, ["outputGcsUri"]);
if (parentObject !== void 0 && fromOutputGcsUri != null) {
setValueByPath(parentObject, ["parameters", "storageUri"], fromOutputGcsUri);
}
const fromNegativePrompt = getValueByPath(fromObject, [
"negativePrompt"
]);
if (parentObject !== void 0 && fromNegativePrompt != null) {
setValueByPath(parentObject, ["parameters", "negativePrompt"], fromNegativePrompt);
}
const fromNumberOfImages = getValueByPath(fromObject, [
"numberOfImages"
]);
if (parentObject !== void 0 && fromNumberOfImages != null) {
setValueByPath(parentObject, ["parameters", "sampleCount"], fromNumberOfImages);
}
const fromAspectRatio = getValueByPath(fromObject, ["aspectRatio"]);
if (parentObject !== void 0 && fromAspectRatio != null) {
setValueByPath(parentObject, ["parameters", "aspectRatio"], fromAspectRatio);
}
const fromGuidanceScale = getValueByPath(fromObject, [
"guidanceScale"
]);
if (parentObject !== void 0 && fromGuidanceScale != null) {
setValueByPath(parentObject, ["parameters", "guidanceScale"], fromGuidanceScale);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (parentObject !== void 0 && fromSeed != null) {
setValueByPath(parentObject, ["parameters", "seed"], fromSeed);
}
const fromSafetyFilterLevel = getValueByPath(fromObject, [
"safetyFilterLevel"
]);
if (parentObject !== void 0 && fromSafetyFilterLevel != null) {
setValueByPath(parentObject, ["parameters", "safetySetting"], fromSafetyFilterLevel);
}
const fromPersonGeneration = getValueByPath(fromObject, [
"personGeneration"
]);
if (parentObject !== void 0 && fromPersonGeneration != null) {
setValueByPath(parentObject, ["parameters", "personGeneration"], fromPersonGeneration);
}
const fromIncludeSafetyAttributes = getValueByPath(fromObject, [
"includeSafetyAttributes"
]);
if (parentObject !== void 0 && fromIncludeSafetyAttributes != null) {
setValueByPath(parentObject, ["parameters", "includeSafetyAttributes"], fromIncludeSafetyAttributes);
}
const fromIncludeRaiReason = getValueByPath(fromObject, [
"includeRaiReason"
]);
if (parentObject !== void 0 && fromIncludeRaiReason != null) {
setValueByPath(parentObject, ["parameters", "includeRaiReason"], fromIncludeRaiReason);
}
const fromLanguage = getValueByPath(fromObject, ["language"]);
if (parentObject !== void 0 && fromLanguage != null) {
setValueByPath(parentObject, ["parameters", "language"], fromLanguage);
}
const fromOutputMimeType = getValueByPath(fromObject, [
"outputMimeType"
]);
if (parentObject !== void 0 && fromOutputMimeType != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "mimeType"], fromOutputMimeType);
}
const fromOutputCompressionQuality = getValueByPath(fromObject, [
"outputCompressionQuality"
]);
if (parentObject !== void 0 && fromOutputCompressionQuality != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "compressionQuality"], fromOutputCompressionQuality);
}
const fromAddWatermark = getValueByPath(fromObject, ["addWatermark"]);
if (parentObject !== void 0 && fromAddWatermark != null) {
setValueByPath(parentObject, ["parameters", "addWatermark"], fromAddWatermark);
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (parentObject !== void 0 && fromLabels != null) {
setValueByPath(parentObject, ["labels"], fromLabels);
}
const fromEditMode = getValueByPath(fromObject, ["editMode"]);
if (parentObject !== void 0 && fromEditMode != null) {
setValueByPath(parentObject, ["parameters", "editMode"], fromEditMode);
}
const fromBaseSteps = getValueByPath(fromObject, ["baseSteps"]);
if (parentObject !== void 0 && fromBaseSteps != null) {
setValueByPath(parentObject, ["parameters", "editConfig", "baseSteps"], fromBaseSteps);
}
return toObject;
}
function editImageParametersInternalToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromPrompt = getValueByPath(fromObject, ["prompt"]);
if (fromPrompt != null) {
setValueByPath(toObject, ["instances[0]", "prompt"], fromPrompt);
}
const fromReferenceImages = getValueByPath(fromObject, [
"referenceImages"
]);
if (fromReferenceImages != null) {
let transformedList = fromReferenceImages;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return referenceImageAPIInternalToVertex(item);
});
}
setValueByPath(toObject, ["instances[0]", "referenceImages"], transformedList);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
editImageConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function editImageResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromGeneratedImages = getValueByPath(fromObject, [
"predictions"
]);
if (fromGeneratedImages != null) {
let transformedList = fromGeneratedImages;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedImageFromVertex(item);
});
}
setValueByPath(toObject, ["generatedImages"], transformedList);
}
return toObject;
}
function embedContentConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromTaskType = getValueByPath(fromObject, ["taskType"]);
if (parentObject !== void 0 && fromTaskType != null) {
setValueByPath(parentObject, ["requests[]", "taskType"], fromTaskType);
}
const fromTitle = getValueByPath(fromObject, ["title"]);
if (parentObject !== void 0 && fromTitle != null) {
setValueByPath(parentObject, ["requests[]", "title"], fromTitle);
}
const fromOutputDimensionality = getValueByPath(fromObject, [
"outputDimensionality"
]);
if (parentObject !== void 0 && fromOutputDimensionality != null) {
setValueByPath(parentObject, ["requests[]", "outputDimensionality"], fromOutputDimensionality);
}
if (getValueByPath(fromObject, ["mimeType"]) !== void 0) {
throw new Error("mimeType parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["autoTruncate"]) !== void 0) {
throw new Error("autoTruncate parameter is not supported in Gemini API.");
}
return toObject;
}
function embedContentConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromTaskType = getValueByPath(fromObject, ["taskType"]);
if (parentObject !== void 0 && fromTaskType != null) {
setValueByPath(parentObject, ["instances[]", "task_type"], fromTaskType);
}
const fromTitle = getValueByPath(fromObject, ["title"]);
if (parentObject !== void 0 && fromTitle != null) {
setValueByPath(parentObject, ["instances[]", "title"], fromTitle);
}
const fromOutputDimensionality = getValueByPath(fromObject, [
"outputDimensionality"
]);
if (parentObject !== void 0 && fromOutputDimensionality != null) {
setValueByPath(parentObject, ["parameters", "outputDimensionality"], fromOutputDimensionality);
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (parentObject !== void 0 && fromMimeType != null) {
setValueByPath(parentObject, ["instances[]", "mimeType"], fromMimeType);
}
const fromAutoTruncate = getValueByPath(fromObject, ["autoTruncate"]);
if (parentObject !== void 0 && fromAutoTruncate != null) {
setValueByPath(parentObject, ["parameters", "autoTruncate"], fromAutoTruncate);
}
return toObject;
}
function embedContentParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (fromContents != null) {
let transformedList = tContentsForEmbed(apiClient, fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["requests[]", "content"], transformedList);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
embedContentConfigToMldev(fromConfig, toObject);
}
const fromModelForEmbedContent = getValueByPath(fromObject, ["model"]);
if (fromModelForEmbedContent !== void 0) {
setValueByPath(toObject, ["requests[]", "model"], tModel(apiClient, fromModelForEmbedContent));
}
return toObject;
}
function embedContentParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (fromContents != null) {
let transformedList = tContentsForEmbed(apiClient, fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["instances[]", "content"], transformedList);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
embedContentConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function embedContentResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromEmbeddings = getValueByPath(fromObject, ["embeddings"]);
if (fromEmbeddings != null) {
let transformedList = fromEmbeddings;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["embeddings"], transformedList);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
return toObject;
}
function embedContentResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromEmbeddings = getValueByPath(fromObject, [
"predictions[]",
"embeddings"
]);
if (fromEmbeddings != null) {
let transformedList = fromEmbeddings;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return contentEmbeddingFromVertex(item);
});
}
setValueByPath(toObject, ["embeddings"], transformedList);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
return toObject;
}
function endpointFromVertex(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["endpoint"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromDeployedModelId = getValueByPath(fromObject, [
"deployedModelId"
]);
if (fromDeployedModelId != null) {
setValueByPath(toObject, ["deployedModelId"], fromDeployedModelId);
}
return toObject;
}
function fileDataToMldev$1(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromFileUri = getValueByPath(fromObject, ["fileUri"]);
if (fromFileUri != null) {
setValueByPath(toObject, ["fileUri"], fromFileUri);
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function functionCallToMldev$1(fromObject) {
const toObject = {};
const fromId = getValueByPath(fromObject, ["id"]);
if (fromId != null) {
setValueByPath(toObject, ["id"], fromId);
}
const fromArgs = getValueByPath(fromObject, ["args"]);
if (fromArgs != null) {
setValueByPath(toObject, ["args"], fromArgs);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
if (getValueByPath(fromObject, ["partialArgs"]) !== void 0) {
throw new Error("partialArgs parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["willContinue"]) !== void 0) {
throw new Error("willContinue parameter is not supported in Gemini API.");
}
return toObject;
}
function functionCallingConfigToMldev(fromObject) {
const toObject = {};
const fromMode = getValueByPath(fromObject, ["mode"]);
if (fromMode != null) {
setValueByPath(toObject, ["mode"], fromMode);
}
const fromAllowedFunctionNames = getValueByPath(fromObject, [
"allowedFunctionNames"
]);
if (fromAllowedFunctionNames != null) {
setValueByPath(toObject, ["allowedFunctionNames"], fromAllowedFunctionNames);
}
if (getValueByPath(fromObject, ["streamFunctionCallArguments"]) !== void 0) {
throw new Error("streamFunctionCallArguments parameter is not supported in Gemini API.");
}
return toObject;
}
function functionDeclarationToVertex(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["behavior"]) !== void 0) {
throw new Error("behavior parameter is not supported in Vertex AI.");
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (fromDescription != null) {
setValueByPath(toObject, ["description"], fromDescription);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromParameters = getValueByPath(fromObject, ["parameters"]);
if (fromParameters != null) {
setValueByPath(toObject, ["parameters"], fromParameters);
}
const fromParametersJsonSchema = getValueByPath(fromObject, [
"parametersJsonSchema"
]);
if (fromParametersJsonSchema != null) {
setValueByPath(toObject, ["parametersJsonSchema"], fromParametersJsonSchema);
}
const fromResponse = getValueByPath(fromObject, ["response"]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], fromResponse);
}
const fromResponseJsonSchema = getValueByPath(fromObject, [
"responseJsonSchema"
]);
if (fromResponseJsonSchema != null) {
setValueByPath(toObject, ["responseJsonSchema"], fromResponseJsonSchema);
}
return toObject;
}
function generateContentConfigToMldev(apiClient, fromObject, parentObject) {
const toObject = {};
const fromSystemInstruction = getValueByPath(fromObject, [
"systemInstruction"
]);
if (parentObject !== void 0 && fromSystemInstruction != null) {
setValueByPath(parentObject, ["systemInstruction"], contentToMldev$1(tContent(fromSystemInstruction)));
}
const fromTemperature = getValueByPath(fromObject, ["temperature"]);
if (fromTemperature != null) {
setValueByPath(toObject, ["temperature"], fromTemperature);
}
const fromTopP = getValueByPath(fromObject, ["topP"]);
if (fromTopP != null) {
setValueByPath(toObject, ["topP"], fromTopP);
}
const fromTopK = getValueByPath(fromObject, ["topK"]);
if (fromTopK != null) {
setValueByPath(toObject, ["topK"], fromTopK);
}
const fromCandidateCount = getValueByPath(fromObject, [
"candidateCount"
]);
if (fromCandidateCount != null) {
setValueByPath(toObject, ["candidateCount"], fromCandidateCount);
}
const fromMaxOutputTokens = getValueByPath(fromObject, [
"maxOutputTokens"
]);
if (fromMaxOutputTokens != null) {
setValueByPath(toObject, ["maxOutputTokens"], fromMaxOutputTokens);
}
const fromStopSequences = getValueByPath(fromObject, [
"stopSequences"
]);
if (fromStopSequences != null) {
setValueByPath(toObject, ["stopSequences"], fromStopSequences);
}
const fromResponseLogprobs = getValueByPath(fromObject, [
"responseLogprobs"
]);
if (fromResponseLogprobs != null) {
setValueByPath(toObject, ["responseLogprobs"], fromResponseLogprobs);
}
const fromLogprobs = getValueByPath(fromObject, ["logprobs"]);
if (fromLogprobs != null) {
setValueByPath(toObject, ["logprobs"], fromLogprobs);
}
const fromPresencePenalty = getValueByPath(fromObject, [
"presencePenalty"
]);
if (fromPresencePenalty != null) {
setValueByPath(toObject, ["presencePenalty"], fromPresencePenalty);
}
const fromFrequencyPenalty = getValueByPath(fromObject, [
"frequencyPenalty"
]);
if (fromFrequencyPenalty != null) {
setValueByPath(toObject, ["frequencyPenalty"], fromFrequencyPenalty);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (fromSeed != null) {
setValueByPath(toObject, ["seed"], fromSeed);
}
const fromResponseMimeType = getValueByPath(fromObject, [
"responseMimeType"
]);
if (fromResponseMimeType != null) {
setValueByPath(toObject, ["responseMimeType"], fromResponseMimeType);
}
const fromResponseSchema = getValueByPath(fromObject, [
"responseSchema"
]);
if (fromResponseSchema != null) {
setValueByPath(toObject, ["responseSchema"], tSchema(fromResponseSchema));
}
const fromResponseJsonSchema = getValueByPath(fromObject, [
"responseJsonSchema"
]);
if (fromResponseJsonSchema != null) {
setValueByPath(toObject, ["responseJsonSchema"], fromResponseJsonSchema);
}
if (getValueByPath(fromObject, ["routingConfig"]) !== void 0) {
throw new Error("routingConfig parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["modelSelectionConfig"]) !== void 0) {
throw new Error("modelSelectionConfig parameter is not supported in Gemini API.");
}
const fromSafetySettings = getValueByPath(fromObject, [
"safetySettings"
]);
if (parentObject !== void 0 && fromSafetySettings != null) {
let transformedList = fromSafetySettings;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return safetySettingToMldev(item);
});
}
setValueByPath(parentObject, ["safetySettings"], transformedList);
}
const fromTools = getValueByPath(fromObject, ["tools"]);
if (parentObject !== void 0 && fromTools != null) {
let transformedList = tTools(fromTools);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return toolToMldev$1(tTool(item));
});
}
setValueByPath(parentObject, ["tools"], transformedList);
}
const fromToolConfig = getValueByPath(fromObject, ["toolConfig"]);
if (parentObject !== void 0 && fromToolConfig != null) {
setValueByPath(parentObject, ["toolConfig"], toolConfigToMldev(fromToolConfig));
}
if (getValueByPath(fromObject, ["labels"]) !== void 0) {
throw new Error("labels parameter is not supported in Gemini API.");
}
const fromCachedContent = getValueByPath(fromObject, [
"cachedContent"
]);
if (parentObject !== void 0 && fromCachedContent != null) {
setValueByPath(parentObject, ["cachedContent"], tCachedContentName(apiClient, fromCachedContent));
}
const fromResponseModalities = getValueByPath(fromObject, [
"responseModalities"
]);
if (fromResponseModalities != null) {
setValueByPath(toObject, ["responseModalities"], fromResponseModalities);
}
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromSpeechConfig = getValueByPath(fromObject, ["speechConfig"]);
if (fromSpeechConfig != null) {
setValueByPath(toObject, ["speechConfig"], tSpeechConfig(fromSpeechConfig));
}
if (getValueByPath(fromObject, ["audioTimestamp"]) !== void 0) {
throw new Error("audioTimestamp parameter is not supported in Gemini API.");
}
const fromThinkingConfig = getValueByPath(fromObject, [
"thinkingConfig"
]);
if (fromThinkingConfig != null) {
setValueByPath(toObject, ["thinkingConfig"], fromThinkingConfig);
}
const fromImageConfig = getValueByPath(fromObject, ["imageConfig"]);
if (fromImageConfig != null) {
setValueByPath(toObject, ["imageConfig"], imageConfigToMldev(fromImageConfig));
}
return toObject;
}
function generateContentConfigToVertex(apiClient, fromObject, parentObject) {
const toObject = {};
const fromSystemInstruction = getValueByPath(fromObject, [
"systemInstruction"
]);
if (parentObject !== void 0 && fromSystemInstruction != null) {
setValueByPath(parentObject, ["systemInstruction"], tContent(fromSystemInstruction));
}
const fromTemperature = getValueByPath(fromObject, ["temperature"]);
if (fromTemperature != null) {
setValueByPath(toObject, ["temperature"], fromTemperature);
}
const fromTopP = getValueByPath(fromObject, ["topP"]);
if (fromTopP != null) {
setValueByPath(toObject, ["topP"], fromTopP);
}
const fromTopK = getValueByPath(fromObject, ["topK"]);
if (fromTopK != null) {
setValueByPath(toObject, ["topK"], fromTopK);
}
const fromCandidateCount = getValueByPath(fromObject, [
"candidateCount"
]);
if (fromCandidateCount != null) {
setValueByPath(toObject, ["candidateCount"], fromCandidateCount);
}
const fromMaxOutputTokens = getValueByPath(fromObject, [
"maxOutputTokens"
]);
if (fromMaxOutputTokens != null) {
setValueByPath(toObject, ["maxOutputTokens"], fromMaxOutputTokens);
}
const fromStopSequences = getValueByPath(fromObject, [
"stopSequences"
]);
if (fromStopSequences != null) {
setValueByPath(toObject, ["stopSequences"], fromStopSequences);
}
const fromResponseLogprobs = getValueByPath(fromObject, [
"responseLogprobs"
]);
if (fromResponseLogprobs != null) {
setValueByPath(toObject, ["responseLogprobs"], fromResponseLogprobs);
}
const fromLogprobs = getValueByPath(fromObject, ["logprobs"]);
if (fromLogprobs != null) {
setValueByPath(toObject, ["logprobs"], fromLogprobs);
}
const fromPresencePenalty = getValueByPath(fromObject, [
"presencePenalty"
]);
if (fromPresencePenalty != null) {
setValueByPath(toObject, ["presencePenalty"], fromPresencePenalty);
}
const fromFrequencyPenalty = getValueByPath(fromObject, [
"frequencyPenalty"
]);
if (fromFrequencyPenalty != null) {
setValueByPath(toObject, ["frequencyPenalty"], fromFrequencyPenalty);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (fromSeed != null) {
setValueByPath(toObject, ["seed"], fromSeed);
}
const fromResponseMimeType = getValueByPath(fromObject, [
"responseMimeType"
]);
if (fromResponseMimeType != null) {
setValueByPath(toObject, ["responseMimeType"], fromResponseMimeType);
}
const fromResponseSchema = getValueByPath(fromObject, [
"responseSchema"
]);
if (fromResponseSchema != null) {
setValueByPath(toObject, ["responseSchema"], tSchema(fromResponseSchema));
}
const fromResponseJsonSchema = getValueByPath(fromObject, [
"responseJsonSchema"
]);
if (fromResponseJsonSchema != null) {
setValueByPath(toObject, ["responseJsonSchema"], fromResponseJsonSchema);
}
const fromRoutingConfig = getValueByPath(fromObject, [
"routingConfig"
]);
if (fromRoutingConfig != null) {
setValueByPath(toObject, ["routingConfig"], fromRoutingConfig);
}
const fromModelSelectionConfig = getValueByPath(fromObject, [
"modelSelectionConfig"
]);
if (fromModelSelectionConfig != null) {
setValueByPath(toObject, ["modelConfig"], fromModelSelectionConfig);
}
const fromSafetySettings = getValueByPath(fromObject, [
"safetySettings"
]);
if (parentObject !== void 0 && fromSafetySettings != null) {
let transformedList = fromSafetySettings;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(parentObject, ["safetySettings"], transformedList);
}
const fromTools = getValueByPath(fromObject, ["tools"]);
if (parentObject !== void 0 && fromTools != null) {
let transformedList = tTools(fromTools);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return toolToVertex(tTool(item));
});
}
setValueByPath(parentObject, ["tools"], transformedList);
}
const fromToolConfig = getValueByPath(fromObject, ["toolConfig"]);
if (parentObject !== void 0 && fromToolConfig != null) {
setValueByPath(parentObject, ["toolConfig"], fromToolConfig);
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (parentObject !== void 0 && fromLabels != null) {
setValueByPath(parentObject, ["labels"], fromLabels);
}
const fromCachedContent = getValueByPath(fromObject, [
"cachedContent"
]);
if (parentObject !== void 0 && fromCachedContent != null) {
setValueByPath(parentObject, ["cachedContent"], tCachedContentName(apiClient, fromCachedContent));
}
const fromResponseModalities = getValueByPath(fromObject, [
"responseModalities"
]);
if (fromResponseModalities != null) {
setValueByPath(toObject, ["responseModalities"], fromResponseModalities);
}
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromSpeechConfig = getValueByPath(fromObject, ["speechConfig"]);
if (fromSpeechConfig != null) {
setValueByPath(toObject, ["speechConfig"], speechConfigToVertex(tSpeechConfig(fromSpeechConfig)));
}
const fromAudioTimestamp = getValueByPath(fromObject, [
"audioTimestamp"
]);
if (fromAudioTimestamp != null) {
setValueByPath(toObject, ["audioTimestamp"], fromAudioTimestamp);
}
const fromThinkingConfig = getValueByPath(fromObject, [
"thinkingConfig"
]);
if (fromThinkingConfig != null) {
setValueByPath(toObject, ["thinkingConfig"], fromThinkingConfig);
}
const fromImageConfig = getValueByPath(fromObject, ["imageConfig"]);
if (fromImageConfig != null) {
setValueByPath(toObject, ["imageConfig"], imageConfigToVertex(fromImageConfig));
}
return toObject;
}
function generateContentParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (fromContents != null) {
let transformedList = tContents(fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return contentToMldev$1(item);
});
}
setValueByPath(toObject, ["contents"], transformedList);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
setValueByPath(toObject, ["generationConfig"], generateContentConfigToMldev(apiClient, fromConfig, toObject));
}
return toObject;
}
function generateContentParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromContents = getValueByPath(fromObject, ["contents"]);
if (fromContents != null) {
let transformedList = tContents(fromContents);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["contents"], transformedList);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
setValueByPath(toObject, ["generationConfig"], generateContentConfigToVertex(apiClient, fromConfig, toObject));
}
return toObject;
}
function generateContentResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromCandidates = getValueByPath(fromObject, ["candidates"]);
if (fromCandidates != null) {
let transformedList = fromCandidates;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return candidateFromMldev(item);
});
}
setValueByPath(toObject, ["candidates"], transformedList);
}
const fromModelVersion = getValueByPath(fromObject, ["modelVersion"]);
if (fromModelVersion != null) {
setValueByPath(toObject, ["modelVersion"], fromModelVersion);
}
const fromPromptFeedback = getValueByPath(fromObject, [
"promptFeedback"
]);
if (fromPromptFeedback != null) {
setValueByPath(toObject, ["promptFeedback"], fromPromptFeedback);
}
const fromResponseId = getValueByPath(fromObject, ["responseId"]);
if (fromResponseId != null) {
setValueByPath(toObject, ["responseId"], fromResponseId);
}
const fromUsageMetadata = getValueByPath(fromObject, [
"usageMetadata"
]);
if (fromUsageMetadata != null) {
setValueByPath(toObject, ["usageMetadata"], fromUsageMetadata);
}
return toObject;
}
function generateContentResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromCandidates = getValueByPath(fromObject, ["candidates"]);
if (fromCandidates != null) {
let transformedList = fromCandidates;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["candidates"], transformedList);
}
const fromCreateTime = getValueByPath(fromObject, ["createTime"]);
if (fromCreateTime != null) {
setValueByPath(toObject, ["createTime"], fromCreateTime);
}
const fromModelVersion = getValueByPath(fromObject, ["modelVersion"]);
if (fromModelVersion != null) {
setValueByPath(toObject, ["modelVersion"], fromModelVersion);
}
const fromPromptFeedback = getValueByPath(fromObject, [
"promptFeedback"
]);
if (fromPromptFeedback != null) {
setValueByPath(toObject, ["promptFeedback"], fromPromptFeedback);
}
const fromResponseId = getValueByPath(fromObject, ["responseId"]);
if (fromResponseId != null) {
setValueByPath(toObject, ["responseId"], fromResponseId);
}
const fromUsageMetadata = getValueByPath(fromObject, [
"usageMetadata"
]);
if (fromUsageMetadata != null) {
setValueByPath(toObject, ["usageMetadata"], fromUsageMetadata);
}
return toObject;
}
function generateImagesConfigToMldev(fromObject, parentObject) {
const toObject = {};
if (getValueByPath(fromObject, ["outputGcsUri"]) !== void 0) {
throw new Error("outputGcsUri parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["negativePrompt"]) !== void 0) {
throw new Error("negativePrompt parameter is not supported in Gemini API.");
}
const fromNumberOfImages = getValueByPath(fromObject, [
"numberOfImages"
]);
if (parentObject !== void 0 && fromNumberOfImages != null) {
setValueByPath(parentObject, ["parameters", "sampleCount"], fromNumberOfImages);
}
const fromAspectRatio = getValueByPath(fromObject, ["aspectRatio"]);
if (parentObject !== void 0 && fromAspectRatio != null) {
setValueByPath(parentObject, ["parameters", "aspectRatio"], fromAspectRatio);
}
const fromGuidanceScale = getValueByPath(fromObject, [
"guidanceScale"
]);
if (parentObject !== void 0 && fromGuidanceScale != null) {
setValueByPath(parentObject, ["parameters", "guidanceScale"], fromGuidanceScale);
}
if (getValueByPath(fromObject, ["seed"]) !== void 0) {
throw new Error("seed parameter is not supported in Gemini API.");
}
const fromSafetyFilterLevel = getValueByPath(fromObject, [
"safetyFilterLevel"
]);
if (parentObject !== void 0 && fromSafetyFilterLevel != null) {
setValueByPath(parentObject, ["parameters", "safetySetting"], fromSafetyFilterLevel);
}
const fromPersonGeneration = getValueByPath(fromObject, [
"personGeneration"
]);
if (parentObject !== void 0 && fromPersonGeneration != null) {
setValueByPath(parentObject, ["parameters", "personGeneration"], fromPersonGeneration);
}
const fromIncludeSafetyAttributes = getValueByPath(fromObject, [
"includeSafetyAttributes"
]);
if (parentObject !== void 0 && fromIncludeSafetyAttributes != null) {
setValueByPath(parentObject, ["parameters", "includeSafetyAttributes"], fromIncludeSafetyAttributes);
}
const fromIncludeRaiReason = getValueByPath(fromObject, [
"includeRaiReason"
]);
if (parentObject !== void 0 && fromIncludeRaiReason != null) {
setValueByPath(parentObject, ["parameters", "includeRaiReason"], fromIncludeRaiReason);
}
const fromLanguage = getValueByPath(fromObject, ["language"]);
if (parentObject !== void 0 && fromLanguage != null) {
setValueByPath(parentObject, ["parameters", "language"], fromLanguage);
}
const fromOutputMimeType = getValueByPath(fromObject, [
"outputMimeType"
]);
if (parentObject !== void 0 && fromOutputMimeType != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "mimeType"], fromOutputMimeType);
}
const fromOutputCompressionQuality = getValueByPath(fromObject, [
"outputCompressionQuality"
]);
if (parentObject !== void 0 && fromOutputCompressionQuality != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "compressionQuality"], fromOutputCompressionQuality);
}
if (getValueByPath(fromObject, ["addWatermark"]) !== void 0) {
throw new Error("addWatermark parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["labels"]) !== void 0) {
throw new Error("labels parameter is not supported in Gemini API.");
}
const fromImageSize = getValueByPath(fromObject, ["imageSize"]);
if (parentObject !== void 0 && fromImageSize != null) {
setValueByPath(parentObject, ["parameters", "sampleImageSize"], fromImageSize);
}
if (getValueByPath(fromObject, ["enhancePrompt"]) !== void 0) {
throw new Error("enhancePrompt parameter is not supported in Gemini API.");
}
return toObject;
}
function generateImagesConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromOutputGcsUri = getValueByPath(fromObject, ["outputGcsUri"]);
if (parentObject !== void 0 && fromOutputGcsUri != null) {
setValueByPath(parentObject, ["parameters", "storageUri"], fromOutputGcsUri);
}
const fromNegativePrompt = getValueByPath(fromObject, [
"negativePrompt"
]);
if (parentObject !== void 0 && fromNegativePrompt != null) {
setValueByPath(parentObject, ["parameters", "negativePrompt"], fromNegativePrompt);
}
const fromNumberOfImages = getValueByPath(fromObject, [
"numberOfImages"
]);
if (parentObject !== void 0 && fromNumberOfImages != null) {
setValueByPath(parentObject, ["parameters", "sampleCount"], fromNumberOfImages);
}
const fromAspectRatio = getValueByPath(fromObject, ["aspectRatio"]);
if (parentObject !== void 0 && fromAspectRatio != null) {
setValueByPath(parentObject, ["parameters", "aspectRatio"], fromAspectRatio);
}
const fromGuidanceScale = getValueByPath(fromObject, [
"guidanceScale"
]);
if (parentObject !== void 0 && fromGuidanceScale != null) {
setValueByPath(parentObject, ["parameters", "guidanceScale"], fromGuidanceScale);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (parentObject !== void 0 && fromSeed != null) {
setValueByPath(parentObject, ["parameters", "seed"], fromSeed);
}
const fromSafetyFilterLevel = getValueByPath(fromObject, [
"safetyFilterLevel"
]);
if (parentObject !== void 0 && fromSafetyFilterLevel != null) {
setValueByPath(parentObject, ["parameters", "safetySetting"], fromSafetyFilterLevel);
}
const fromPersonGeneration = getValueByPath(fromObject, [
"personGeneration"
]);
if (parentObject !== void 0 && fromPersonGeneration != null) {
setValueByPath(parentObject, ["parameters", "personGeneration"], fromPersonGeneration);
}
const fromIncludeSafetyAttributes = getValueByPath(fromObject, [
"includeSafetyAttributes"
]);
if (parentObject !== void 0 && fromIncludeSafetyAttributes != null) {
setValueByPath(parentObject, ["parameters", "includeSafetyAttributes"], fromIncludeSafetyAttributes);
}
const fromIncludeRaiReason = getValueByPath(fromObject, [
"includeRaiReason"
]);
if (parentObject !== void 0 && fromIncludeRaiReason != null) {
setValueByPath(parentObject, ["parameters", "includeRaiReason"], fromIncludeRaiReason);
}
const fromLanguage = getValueByPath(fromObject, ["language"]);
if (parentObject !== void 0 && fromLanguage != null) {
setValueByPath(parentObject, ["parameters", "language"], fromLanguage);
}
const fromOutputMimeType = getValueByPath(fromObject, [
"outputMimeType"
]);
if (parentObject !== void 0 && fromOutputMimeType != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "mimeType"], fromOutputMimeType);
}
const fromOutputCompressionQuality = getValueByPath(fromObject, [
"outputCompressionQuality"
]);
if (parentObject !== void 0 && fromOutputCompressionQuality != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "compressionQuality"], fromOutputCompressionQuality);
}
const fromAddWatermark = getValueByPath(fromObject, ["addWatermark"]);
if (parentObject !== void 0 && fromAddWatermark != null) {
setValueByPath(parentObject, ["parameters", "addWatermark"], fromAddWatermark);
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (parentObject !== void 0 && fromLabels != null) {
setValueByPath(parentObject, ["labels"], fromLabels);
}
const fromImageSize = getValueByPath(fromObject, ["imageSize"]);
if (parentObject !== void 0 && fromImageSize != null) {
setValueByPath(parentObject, ["parameters", "sampleImageSize"], fromImageSize);
}
const fromEnhancePrompt = getValueByPath(fromObject, [
"enhancePrompt"
]);
if (parentObject !== void 0 && fromEnhancePrompt != null) {
setValueByPath(parentObject, ["parameters", "enhancePrompt"], fromEnhancePrompt);
}
return toObject;
}
function generateImagesParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromPrompt = getValueByPath(fromObject, ["prompt"]);
if (fromPrompt != null) {
setValueByPath(toObject, ["instances[0]", "prompt"], fromPrompt);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
generateImagesConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function generateImagesParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromPrompt = getValueByPath(fromObject, ["prompt"]);
if (fromPrompt != null) {
setValueByPath(toObject, ["instances[0]", "prompt"], fromPrompt);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
generateImagesConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function generateImagesResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromGeneratedImages = getValueByPath(fromObject, [
"predictions"
]);
if (fromGeneratedImages != null) {
let transformedList = fromGeneratedImages;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedImageFromMldev(item);
});
}
setValueByPath(toObject, ["generatedImages"], transformedList);
}
const fromPositivePromptSafetyAttributes = getValueByPath(fromObject, [
"positivePromptSafetyAttributes"
]);
if (fromPositivePromptSafetyAttributes != null) {
setValueByPath(toObject, ["positivePromptSafetyAttributes"], safetyAttributesFromMldev(fromPositivePromptSafetyAttributes));
}
return toObject;
}
function generateImagesResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromGeneratedImages = getValueByPath(fromObject, [
"predictions"
]);
if (fromGeneratedImages != null) {
let transformedList = fromGeneratedImages;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedImageFromVertex(item);
});
}
setValueByPath(toObject, ["generatedImages"], transformedList);
}
const fromPositivePromptSafetyAttributes = getValueByPath(fromObject, [
"positivePromptSafetyAttributes"
]);
if (fromPositivePromptSafetyAttributes != null) {
setValueByPath(toObject, ["positivePromptSafetyAttributes"], safetyAttributesFromVertex(fromPositivePromptSafetyAttributes));
}
return toObject;
}
function generateVideosConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromNumberOfVideos = getValueByPath(fromObject, [
"numberOfVideos"
]);
if (parentObject !== void 0 && fromNumberOfVideos != null) {
setValueByPath(parentObject, ["parameters", "sampleCount"], fromNumberOfVideos);
}
if (getValueByPath(fromObject, ["outputGcsUri"]) !== void 0) {
throw new Error("outputGcsUri parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["fps"]) !== void 0) {
throw new Error("fps parameter is not supported in Gemini API.");
}
const fromDurationSeconds = getValueByPath(fromObject, [
"durationSeconds"
]);
if (parentObject !== void 0 && fromDurationSeconds != null) {
setValueByPath(parentObject, ["parameters", "durationSeconds"], fromDurationSeconds);
}
if (getValueByPath(fromObject, ["seed"]) !== void 0) {
throw new Error("seed parameter is not supported in Gemini API.");
}
const fromAspectRatio = getValueByPath(fromObject, ["aspectRatio"]);
if (parentObject !== void 0 && fromAspectRatio != null) {
setValueByPath(parentObject, ["parameters", "aspectRatio"], fromAspectRatio);
}
const fromResolution = getValueByPath(fromObject, ["resolution"]);
if (parentObject !== void 0 && fromResolution != null) {
setValueByPath(parentObject, ["parameters", "resolution"], fromResolution);
}
const fromPersonGeneration = getValueByPath(fromObject, [
"personGeneration"
]);
if (parentObject !== void 0 && fromPersonGeneration != null) {
setValueByPath(parentObject, ["parameters", "personGeneration"], fromPersonGeneration);
}
if (getValueByPath(fromObject, ["pubsubTopic"]) !== void 0) {
throw new Error("pubsubTopic parameter is not supported in Gemini API.");
}
const fromNegativePrompt = getValueByPath(fromObject, [
"negativePrompt"
]);
if (parentObject !== void 0 && fromNegativePrompt != null) {
setValueByPath(parentObject, ["parameters", "negativePrompt"], fromNegativePrompt);
}
const fromEnhancePrompt = getValueByPath(fromObject, [
"enhancePrompt"
]);
if (parentObject !== void 0 && fromEnhancePrompt != null) {
setValueByPath(parentObject, ["parameters", "enhancePrompt"], fromEnhancePrompt);
}
if (getValueByPath(fromObject, ["generateAudio"]) !== void 0) {
throw new Error("generateAudio parameter is not supported in Gemini API.");
}
const fromLastFrame = getValueByPath(fromObject, ["lastFrame"]);
if (parentObject !== void 0 && fromLastFrame != null) {
setValueByPath(parentObject, ["instances[0]", "lastFrame"], imageToMldev(fromLastFrame));
}
const fromReferenceImages = getValueByPath(fromObject, [
"referenceImages"
]);
if (parentObject !== void 0 && fromReferenceImages != null) {
let transformedList = fromReferenceImages;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return videoGenerationReferenceImageToMldev(item);
});
}
setValueByPath(parentObject, ["instances[0]", "referenceImages"], transformedList);
}
if (getValueByPath(fromObject, ["mask"]) !== void 0) {
throw new Error("mask parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["compressionQuality"]) !== void 0) {
throw new Error("compressionQuality parameter is not supported in Gemini API.");
}
return toObject;
}
function generateVideosConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromNumberOfVideos = getValueByPath(fromObject, [
"numberOfVideos"
]);
if (parentObject !== void 0 && fromNumberOfVideos != null) {
setValueByPath(parentObject, ["parameters", "sampleCount"], fromNumberOfVideos);
}
const fromOutputGcsUri = getValueByPath(fromObject, ["outputGcsUri"]);
if (parentObject !== void 0 && fromOutputGcsUri != null) {
setValueByPath(parentObject, ["parameters", "storageUri"], fromOutputGcsUri);
}
const fromFps = getValueByPath(fromObject, ["fps"]);
if (parentObject !== void 0 && fromFps != null) {
setValueByPath(parentObject, ["parameters", "fps"], fromFps);
}
const fromDurationSeconds = getValueByPath(fromObject, [
"durationSeconds"
]);
if (parentObject !== void 0 && fromDurationSeconds != null) {
setValueByPath(parentObject, ["parameters", "durationSeconds"], fromDurationSeconds);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (parentObject !== void 0 && fromSeed != null) {
setValueByPath(parentObject, ["parameters", "seed"], fromSeed);
}
const fromAspectRatio = getValueByPath(fromObject, ["aspectRatio"]);
if (parentObject !== void 0 && fromAspectRatio != null) {
setValueByPath(parentObject, ["parameters", "aspectRatio"], fromAspectRatio);
}
const fromResolution = getValueByPath(fromObject, ["resolution"]);
if (parentObject !== void 0 && fromResolution != null) {
setValueByPath(parentObject, ["parameters", "resolution"], fromResolution);
}
const fromPersonGeneration = getValueByPath(fromObject, [
"personGeneration"
]);
if (parentObject !== void 0 && fromPersonGeneration != null) {
setValueByPath(parentObject, ["parameters", "personGeneration"], fromPersonGeneration);
}
const fromPubsubTopic = getValueByPath(fromObject, ["pubsubTopic"]);
if (parentObject !== void 0 && fromPubsubTopic != null) {
setValueByPath(parentObject, ["parameters", "pubsubTopic"], fromPubsubTopic);
}
const fromNegativePrompt = getValueByPath(fromObject, [
"negativePrompt"
]);
if (parentObject !== void 0 && fromNegativePrompt != null) {
setValueByPath(parentObject, ["parameters", "negativePrompt"], fromNegativePrompt);
}
const fromEnhancePrompt = getValueByPath(fromObject, [
"enhancePrompt"
]);
if (parentObject !== void 0 && fromEnhancePrompt != null) {
setValueByPath(parentObject, ["parameters", "enhancePrompt"], fromEnhancePrompt);
}
const fromGenerateAudio = getValueByPath(fromObject, [
"generateAudio"
]);
if (parentObject !== void 0 && fromGenerateAudio != null) {
setValueByPath(parentObject, ["parameters", "generateAudio"], fromGenerateAudio);
}
const fromLastFrame = getValueByPath(fromObject, ["lastFrame"]);
if (parentObject !== void 0 && fromLastFrame != null) {
setValueByPath(parentObject, ["instances[0]", "lastFrame"], imageToVertex(fromLastFrame));
}
const fromReferenceImages = getValueByPath(fromObject, [
"referenceImages"
]);
if (parentObject !== void 0 && fromReferenceImages != null) {
let transformedList = fromReferenceImages;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return videoGenerationReferenceImageToVertex(item);
});
}
setValueByPath(parentObject, ["instances[0]", "referenceImages"], transformedList);
}
const fromMask = getValueByPath(fromObject, ["mask"]);
if (parentObject !== void 0 && fromMask != null) {
setValueByPath(parentObject, ["instances[0]", "mask"], videoGenerationMaskToVertex(fromMask));
}
const fromCompressionQuality = getValueByPath(fromObject, [
"compressionQuality"
]);
if (parentObject !== void 0 && fromCompressionQuality != null) {
setValueByPath(parentObject, ["parameters", "compressionQuality"], fromCompressionQuality);
}
return toObject;
}
function generateVideosOperationFromMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
const fromResponse = getValueByPath(fromObject, [
"response",
"generateVideoResponse"
]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], generateVideosResponseFromMldev(fromResponse));
}
return toObject;
}
function generateVideosOperationFromVertex(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
const fromResponse = getValueByPath(fromObject, ["response"]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], generateVideosResponseFromVertex(fromResponse));
}
return toObject;
}
function generateVideosParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromPrompt = getValueByPath(fromObject, ["prompt"]);
if (fromPrompt != null) {
setValueByPath(toObject, ["instances[0]", "prompt"], fromPrompt);
}
const fromImage = getValueByPath(fromObject, ["image"]);
if (fromImage != null) {
setValueByPath(toObject, ["instances[0]", "image"], imageToMldev(fromImage));
}
const fromVideo = getValueByPath(fromObject, ["video"]);
if (fromVideo != null) {
setValueByPath(toObject, ["instances[0]", "video"], videoToMldev(fromVideo));
}
const fromSource = getValueByPath(fromObject, ["source"]);
if (fromSource != null) {
generateVideosSourceToMldev(fromSource, toObject);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
generateVideosConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function generateVideosParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromPrompt = getValueByPath(fromObject, ["prompt"]);
if (fromPrompt != null) {
setValueByPath(toObject, ["instances[0]", "prompt"], fromPrompt);
}
const fromImage = getValueByPath(fromObject, ["image"]);
if (fromImage != null) {
setValueByPath(toObject, ["instances[0]", "image"], imageToVertex(fromImage));
}
const fromVideo = getValueByPath(fromObject, ["video"]);
if (fromVideo != null) {
setValueByPath(toObject, ["instances[0]", "video"], videoToVertex(fromVideo));
}
const fromSource = getValueByPath(fromObject, ["source"]);
if (fromSource != null) {
generateVideosSourceToVertex(fromSource, toObject);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
generateVideosConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function generateVideosResponseFromMldev(fromObject) {
const toObject = {};
const fromGeneratedVideos = getValueByPath(fromObject, [
"generatedSamples"
]);
if (fromGeneratedVideos != null) {
let transformedList = fromGeneratedVideos;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedVideoFromMldev(item);
});
}
setValueByPath(toObject, ["generatedVideos"], transformedList);
}
const fromRaiMediaFilteredCount = getValueByPath(fromObject, [
"raiMediaFilteredCount"
]);
if (fromRaiMediaFilteredCount != null) {
setValueByPath(toObject, ["raiMediaFilteredCount"], fromRaiMediaFilteredCount);
}
const fromRaiMediaFilteredReasons = getValueByPath(fromObject, [
"raiMediaFilteredReasons"
]);
if (fromRaiMediaFilteredReasons != null) {
setValueByPath(toObject, ["raiMediaFilteredReasons"], fromRaiMediaFilteredReasons);
}
return toObject;
}
function generateVideosResponseFromVertex(fromObject) {
const toObject = {};
const fromGeneratedVideos = getValueByPath(fromObject, ["videos"]);
if (fromGeneratedVideos != null) {
let transformedList = fromGeneratedVideos;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedVideoFromVertex(item);
});
}
setValueByPath(toObject, ["generatedVideos"], transformedList);
}
const fromRaiMediaFilteredCount = getValueByPath(fromObject, [
"raiMediaFilteredCount"
]);
if (fromRaiMediaFilteredCount != null) {
setValueByPath(toObject, ["raiMediaFilteredCount"], fromRaiMediaFilteredCount);
}
const fromRaiMediaFilteredReasons = getValueByPath(fromObject, [
"raiMediaFilteredReasons"
]);
if (fromRaiMediaFilteredReasons != null) {
setValueByPath(toObject, ["raiMediaFilteredReasons"], fromRaiMediaFilteredReasons);
}
return toObject;
}
function generateVideosSourceToMldev(fromObject, parentObject) {
const toObject = {};
const fromPrompt = getValueByPath(fromObject, ["prompt"]);
if (parentObject !== void 0 && fromPrompt != null) {
setValueByPath(parentObject, ["instances[0]", "prompt"], fromPrompt);
}
const fromImage = getValueByPath(fromObject, ["image"]);
if (parentObject !== void 0 && fromImage != null) {
setValueByPath(parentObject, ["instances[0]", "image"], imageToMldev(fromImage));
}
const fromVideo = getValueByPath(fromObject, ["video"]);
if (parentObject !== void 0 && fromVideo != null) {
setValueByPath(parentObject, ["instances[0]", "video"], videoToMldev(fromVideo));
}
return toObject;
}
function generateVideosSourceToVertex(fromObject, parentObject) {
const toObject = {};
const fromPrompt = getValueByPath(fromObject, ["prompt"]);
if (parentObject !== void 0 && fromPrompt != null) {
setValueByPath(parentObject, ["instances[0]", "prompt"], fromPrompt);
}
const fromImage = getValueByPath(fromObject, ["image"]);
if (parentObject !== void 0 && fromImage != null) {
setValueByPath(parentObject, ["instances[0]", "image"], imageToVertex(fromImage));
}
const fromVideo = getValueByPath(fromObject, ["video"]);
if (parentObject !== void 0 && fromVideo != null) {
setValueByPath(parentObject, ["instances[0]", "video"], videoToVertex(fromVideo));
}
return toObject;
}
function generatedImageFromMldev(fromObject) {
const toObject = {};
const fromImage = getValueByPath(fromObject, ["_self"]);
if (fromImage != null) {
setValueByPath(toObject, ["image"], imageFromMldev(fromImage));
}
const fromRaiFilteredReason = getValueByPath(fromObject, [
"raiFilteredReason"
]);
if (fromRaiFilteredReason != null) {
setValueByPath(toObject, ["raiFilteredReason"], fromRaiFilteredReason);
}
const fromSafetyAttributes = getValueByPath(fromObject, ["_self"]);
if (fromSafetyAttributes != null) {
setValueByPath(toObject, ["safetyAttributes"], safetyAttributesFromMldev(fromSafetyAttributes));
}
return toObject;
}
function generatedImageFromVertex(fromObject) {
const toObject = {};
const fromImage = getValueByPath(fromObject, ["_self"]);
if (fromImage != null) {
setValueByPath(toObject, ["image"], imageFromVertex(fromImage));
}
const fromRaiFilteredReason = getValueByPath(fromObject, [
"raiFilteredReason"
]);
if (fromRaiFilteredReason != null) {
setValueByPath(toObject, ["raiFilteredReason"], fromRaiFilteredReason);
}
const fromSafetyAttributes = getValueByPath(fromObject, ["_self"]);
if (fromSafetyAttributes != null) {
setValueByPath(toObject, ["safetyAttributes"], safetyAttributesFromVertex(fromSafetyAttributes));
}
const fromEnhancedPrompt = getValueByPath(fromObject, ["prompt"]);
if (fromEnhancedPrompt != null) {
setValueByPath(toObject, ["enhancedPrompt"], fromEnhancedPrompt);
}
return toObject;
}
function generatedImageMaskFromVertex(fromObject) {
const toObject = {};
const fromMask = getValueByPath(fromObject, ["_self"]);
if (fromMask != null) {
setValueByPath(toObject, ["mask"], imageFromVertex(fromMask));
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (fromLabels != null) {
let transformedList = fromLabels;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["labels"], transformedList);
}
return toObject;
}
function generatedVideoFromMldev(fromObject) {
const toObject = {};
const fromVideo = getValueByPath(fromObject, ["video"]);
if (fromVideo != null) {
setValueByPath(toObject, ["video"], videoFromMldev(fromVideo));
}
return toObject;
}
function generatedVideoFromVertex(fromObject) {
const toObject = {};
const fromVideo = getValueByPath(fromObject, ["_self"]);
if (fromVideo != null) {
setValueByPath(toObject, ["video"], videoFromVertex(fromVideo));
}
return toObject;
}
function generationConfigToVertex(fromObject) {
const toObject = {};
const fromModelSelectionConfig = getValueByPath(fromObject, [
"modelSelectionConfig"
]);
if (fromModelSelectionConfig != null) {
setValueByPath(toObject, ["modelConfig"], fromModelSelectionConfig);
}
const fromResponseJsonSchema = getValueByPath(fromObject, [
"responseJsonSchema"
]);
if (fromResponseJsonSchema != null) {
setValueByPath(toObject, ["responseJsonSchema"], fromResponseJsonSchema);
}
const fromAudioTimestamp = getValueByPath(fromObject, [
"audioTimestamp"
]);
if (fromAudioTimestamp != null) {
setValueByPath(toObject, ["audioTimestamp"], fromAudioTimestamp);
}
const fromCandidateCount = getValueByPath(fromObject, [
"candidateCount"
]);
if (fromCandidateCount != null) {
setValueByPath(toObject, ["candidateCount"], fromCandidateCount);
}
const fromEnableAffectiveDialog = getValueByPath(fromObject, [
"enableAffectiveDialog"
]);
if (fromEnableAffectiveDialog != null) {
setValueByPath(toObject, ["enableAffectiveDialog"], fromEnableAffectiveDialog);
}
const fromFrequencyPenalty = getValueByPath(fromObject, [
"frequencyPenalty"
]);
if (fromFrequencyPenalty != null) {
setValueByPath(toObject, ["frequencyPenalty"], fromFrequencyPenalty);
}
const fromLogprobs = getValueByPath(fromObject, ["logprobs"]);
if (fromLogprobs != null) {
setValueByPath(toObject, ["logprobs"], fromLogprobs);
}
const fromMaxOutputTokens = getValueByPath(fromObject, [
"maxOutputTokens"
]);
if (fromMaxOutputTokens != null) {
setValueByPath(toObject, ["maxOutputTokens"], fromMaxOutputTokens);
}
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromPresencePenalty = getValueByPath(fromObject, [
"presencePenalty"
]);
if (fromPresencePenalty != null) {
setValueByPath(toObject, ["presencePenalty"], fromPresencePenalty);
}
const fromResponseLogprobs = getValueByPath(fromObject, [
"responseLogprobs"
]);
if (fromResponseLogprobs != null) {
setValueByPath(toObject, ["responseLogprobs"], fromResponseLogprobs);
}
const fromResponseMimeType = getValueByPath(fromObject, [
"responseMimeType"
]);
if (fromResponseMimeType != null) {
setValueByPath(toObject, ["responseMimeType"], fromResponseMimeType);
}
const fromResponseModalities = getValueByPath(fromObject, [
"responseModalities"
]);
if (fromResponseModalities != null) {
setValueByPath(toObject, ["responseModalities"], fromResponseModalities);
}
const fromResponseSchema = getValueByPath(fromObject, [
"responseSchema"
]);
if (fromResponseSchema != null) {
setValueByPath(toObject, ["responseSchema"], fromResponseSchema);
}
const fromRoutingConfig = getValueByPath(fromObject, [
"routingConfig"
]);
if (fromRoutingConfig != null) {
setValueByPath(toObject, ["routingConfig"], fromRoutingConfig);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (fromSeed != null) {
setValueByPath(toObject, ["seed"], fromSeed);
}
const fromSpeechConfig = getValueByPath(fromObject, ["speechConfig"]);
if (fromSpeechConfig != null) {
setValueByPath(toObject, ["speechConfig"], speechConfigToVertex(fromSpeechConfig));
}
const fromStopSequences = getValueByPath(fromObject, [
"stopSequences"
]);
if (fromStopSequences != null) {
setValueByPath(toObject, ["stopSequences"], fromStopSequences);
}
const fromTemperature = getValueByPath(fromObject, ["temperature"]);
if (fromTemperature != null) {
setValueByPath(toObject, ["temperature"], fromTemperature);
}
const fromThinkingConfig = getValueByPath(fromObject, [
"thinkingConfig"
]);
if (fromThinkingConfig != null) {
setValueByPath(toObject, ["thinkingConfig"], fromThinkingConfig);
}
const fromTopK = getValueByPath(fromObject, ["topK"]);
if (fromTopK != null) {
setValueByPath(toObject, ["topK"], fromTopK);
}
const fromTopP = getValueByPath(fromObject, ["topP"]);
if (fromTopP != null) {
setValueByPath(toObject, ["topP"], fromTopP);
}
if (getValueByPath(fromObject, ["enableEnhancedCivicAnswers"]) !== void 0) {
throw new Error("enableEnhancedCivicAnswers parameter is not supported in Vertex AI.");
}
return toObject;
}
function getModelParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "name"], tModel(apiClient, fromModel));
}
return toObject;
}
function getModelParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "name"], tModel(apiClient, fromModel));
}
return toObject;
}
function googleMapsToMldev$1(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["authConfig"]) !== void 0) {
throw new Error("authConfig parameter is not supported in Gemini API.");
}
const fromEnableWidget = getValueByPath(fromObject, ["enableWidget"]);
if (fromEnableWidget != null) {
setValueByPath(toObject, ["enableWidget"], fromEnableWidget);
}
return toObject;
}
function googleSearchToMldev$1(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["excludeDomains"]) !== void 0) {
throw new Error("excludeDomains parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["blockingConfidence"]) !== void 0) {
throw new Error("blockingConfidence parameter is not supported in Gemini API.");
}
const fromTimeRangeFilter = getValueByPath(fromObject, [
"timeRangeFilter"
]);
if (fromTimeRangeFilter != null) {
setValueByPath(toObject, ["timeRangeFilter"], fromTimeRangeFilter);
}
return toObject;
}
function imageConfigToMldev(fromObject) {
const toObject = {};
const fromAspectRatio = getValueByPath(fromObject, ["aspectRatio"]);
if (fromAspectRatio != null) {
setValueByPath(toObject, ["aspectRatio"], fromAspectRatio);
}
const fromImageSize = getValueByPath(fromObject, ["imageSize"]);
if (fromImageSize != null) {
setValueByPath(toObject, ["imageSize"], fromImageSize);
}
if (getValueByPath(fromObject, ["outputMimeType"]) !== void 0) {
throw new Error("outputMimeType parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["outputCompressionQuality"]) !== void 0) {
throw new Error("outputCompressionQuality parameter is not supported in Gemini API.");
}
return toObject;
}
function imageConfigToVertex(fromObject) {
const toObject = {};
const fromAspectRatio = getValueByPath(fromObject, ["aspectRatio"]);
if (fromAspectRatio != null) {
setValueByPath(toObject, ["aspectRatio"], fromAspectRatio);
}
const fromImageSize = getValueByPath(fromObject, ["imageSize"]);
if (fromImageSize != null) {
setValueByPath(toObject, ["imageSize"], fromImageSize);
}
const fromOutputMimeType = getValueByPath(fromObject, [
"outputMimeType"
]);
if (fromOutputMimeType != null) {
setValueByPath(toObject, ["imageOutputOptions", "mimeType"], fromOutputMimeType);
}
const fromOutputCompressionQuality = getValueByPath(fromObject, [
"outputCompressionQuality"
]);
if (fromOutputCompressionQuality != null) {
setValueByPath(toObject, ["imageOutputOptions", "compressionQuality"], fromOutputCompressionQuality);
}
return toObject;
}
function imageFromMldev(fromObject) {
const toObject = {};
const fromImageBytes = getValueByPath(fromObject, [
"bytesBase64Encoded"
]);
if (fromImageBytes != null) {
setValueByPath(toObject, ["imageBytes"], tBytes(fromImageBytes));
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function imageFromVertex(fromObject) {
const toObject = {};
const fromGcsUri = getValueByPath(fromObject, ["gcsUri"]);
if (fromGcsUri != null) {
setValueByPath(toObject, ["gcsUri"], fromGcsUri);
}
const fromImageBytes = getValueByPath(fromObject, [
"bytesBase64Encoded"
]);
if (fromImageBytes != null) {
setValueByPath(toObject, ["imageBytes"], tBytes(fromImageBytes));
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function imageToMldev(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["gcsUri"]) !== void 0) {
throw new Error("gcsUri parameter is not supported in Gemini API.");
}
const fromImageBytes = getValueByPath(fromObject, ["imageBytes"]);
if (fromImageBytes != null) {
setValueByPath(toObject, ["bytesBase64Encoded"], tBytes(fromImageBytes));
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function imageToVertex(fromObject) {
const toObject = {};
const fromGcsUri = getValueByPath(fromObject, ["gcsUri"]);
if (fromGcsUri != null) {
setValueByPath(toObject, ["gcsUri"], fromGcsUri);
}
const fromImageBytes = getValueByPath(fromObject, ["imageBytes"]);
if (fromImageBytes != null) {
setValueByPath(toObject, ["bytesBase64Encoded"], tBytes(fromImageBytes));
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function listModelsConfigToMldev(apiClient, fromObject, parentObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
const fromFilter = getValueByPath(fromObject, ["filter"]);
if (parentObject !== void 0 && fromFilter != null) {
setValueByPath(parentObject, ["_query", "filter"], fromFilter);
}
const fromQueryBase = getValueByPath(fromObject, ["queryBase"]);
if (parentObject !== void 0 && fromQueryBase != null) {
setValueByPath(parentObject, ["_url", "models_url"], tModelsUrl(apiClient, fromQueryBase));
}
return toObject;
}
function listModelsConfigToVertex(apiClient, fromObject, parentObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
const fromFilter = getValueByPath(fromObject, ["filter"]);
if (parentObject !== void 0 && fromFilter != null) {
setValueByPath(parentObject, ["_query", "filter"], fromFilter);
}
const fromQueryBase = getValueByPath(fromObject, ["queryBase"]);
if (parentObject !== void 0 && fromQueryBase != null) {
setValueByPath(parentObject, ["_url", "models_url"], tModelsUrl(apiClient, fromQueryBase));
}
return toObject;
}
function listModelsParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listModelsConfigToMldev(apiClient, fromConfig, toObject);
}
return toObject;
}
function listModelsParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listModelsConfigToVertex(apiClient, fromConfig, toObject);
}
return toObject;
}
function listModelsResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromModels = getValueByPath(fromObject, ["_self"]);
if (fromModels != null) {
let transformedList = tExtractModels(fromModels);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return modelFromMldev(item);
});
}
setValueByPath(toObject, ["models"], transformedList);
}
return toObject;
}
function listModelsResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromModels = getValueByPath(fromObject, ["_self"]);
if (fromModels != null) {
let transformedList = tExtractModels(fromModels);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return modelFromVertex(item);
});
}
setValueByPath(toObject, ["models"], transformedList);
}
return toObject;
}
function maskReferenceConfigToVertex(fromObject) {
const toObject = {};
const fromMaskMode = getValueByPath(fromObject, ["maskMode"]);
if (fromMaskMode != null) {
setValueByPath(toObject, ["maskMode"], fromMaskMode);
}
const fromSegmentationClasses = getValueByPath(fromObject, [
"segmentationClasses"
]);
if (fromSegmentationClasses != null) {
setValueByPath(toObject, ["maskClasses"], fromSegmentationClasses);
}
const fromMaskDilation = getValueByPath(fromObject, ["maskDilation"]);
if (fromMaskDilation != null) {
setValueByPath(toObject, ["dilation"], fromMaskDilation);
}
return toObject;
}
function modelFromMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (fromDisplayName != null) {
setValueByPath(toObject, ["displayName"], fromDisplayName);
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (fromDescription != null) {
setValueByPath(toObject, ["description"], fromDescription);
}
const fromVersion = getValueByPath(fromObject, ["version"]);
if (fromVersion != null) {
setValueByPath(toObject, ["version"], fromVersion);
}
const fromTunedModelInfo = getValueByPath(fromObject, ["_self"]);
if (fromTunedModelInfo != null) {
setValueByPath(toObject, ["tunedModelInfo"], tunedModelInfoFromMldev(fromTunedModelInfo));
}
const fromInputTokenLimit = getValueByPath(fromObject, [
"inputTokenLimit"
]);
if (fromInputTokenLimit != null) {
setValueByPath(toObject, ["inputTokenLimit"], fromInputTokenLimit);
}
const fromOutputTokenLimit = getValueByPath(fromObject, [
"outputTokenLimit"
]);
if (fromOutputTokenLimit != null) {
setValueByPath(toObject, ["outputTokenLimit"], fromOutputTokenLimit);
}
const fromSupportedActions = getValueByPath(fromObject, [
"supportedGenerationMethods"
]);
if (fromSupportedActions != null) {
setValueByPath(toObject, ["supportedActions"], fromSupportedActions);
}
const fromTemperature = getValueByPath(fromObject, ["temperature"]);
if (fromTemperature != null) {
setValueByPath(toObject, ["temperature"], fromTemperature);
}
const fromMaxTemperature = getValueByPath(fromObject, [
"maxTemperature"
]);
if (fromMaxTemperature != null) {
setValueByPath(toObject, ["maxTemperature"], fromMaxTemperature);
}
const fromTopP = getValueByPath(fromObject, ["topP"]);
if (fromTopP != null) {
setValueByPath(toObject, ["topP"], fromTopP);
}
const fromTopK = getValueByPath(fromObject, ["topK"]);
if (fromTopK != null) {
setValueByPath(toObject, ["topK"], fromTopK);
}
const fromThinking = getValueByPath(fromObject, ["thinking"]);
if (fromThinking != null) {
setValueByPath(toObject, ["thinking"], fromThinking);
}
return toObject;
}
function modelFromVertex(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (fromDisplayName != null) {
setValueByPath(toObject, ["displayName"], fromDisplayName);
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (fromDescription != null) {
setValueByPath(toObject, ["description"], fromDescription);
}
const fromVersion = getValueByPath(fromObject, ["versionId"]);
if (fromVersion != null) {
setValueByPath(toObject, ["version"], fromVersion);
}
const fromEndpoints = getValueByPath(fromObject, ["deployedModels"]);
if (fromEndpoints != null) {
let transformedList = fromEndpoints;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return endpointFromVertex(item);
});
}
setValueByPath(toObject, ["endpoints"], transformedList);
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (fromLabels != null) {
setValueByPath(toObject, ["labels"], fromLabels);
}
const fromTunedModelInfo = getValueByPath(fromObject, ["_self"]);
if (fromTunedModelInfo != null) {
setValueByPath(toObject, ["tunedModelInfo"], tunedModelInfoFromVertex(fromTunedModelInfo));
}
const fromDefaultCheckpointId = getValueByPath(fromObject, [
"defaultCheckpointId"
]);
if (fromDefaultCheckpointId != null) {
setValueByPath(toObject, ["defaultCheckpointId"], fromDefaultCheckpointId);
}
const fromCheckpoints = getValueByPath(fromObject, ["checkpoints"]);
if (fromCheckpoints != null) {
let transformedList = fromCheckpoints;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["checkpoints"], transformedList);
}
return toObject;
}
function partToMldev$1(fromObject) {
const toObject = {};
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromCodeExecutionResult = getValueByPath(fromObject, [
"codeExecutionResult"
]);
if (fromCodeExecutionResult != null) {
setValueByPath(toObject, ["codeExecutionResult"], fromCodeExecutionResult);
}
const fromExecutableCode = getValueByPath(fromObject, [
"executableCode"
]);
if (fromExecutableCode != null) {
setValueByPath(toObject, ["executableCode"], fromExecutableCode);
}
const fromFileData = getValueByPath(fromObject, ["fileData"]);
if (fromFileData != null) {
setValueByPath(toObject, ["fileData"], fileDataToMldev$1(fromFileData));
}
const fromFunctionCall = getValueByPath(fromObject, ["functionCall"]);
if (fromFunctionCall != null) {
setValueByPath(toObject, ["functionCall"], functionCallToMldev$1(fromFunctionCall));
}
const fromFunctionResponse = getValueByPath(fromObject, [
"functionResponse"
]);
if (fromFunctionResponse != null) {
setValueByPath(toObject, ["functionResponse"], fromFunctionResponse);
}
const fromInlineData = getValueByPath(fromObject, ["inlineData"]);
if (fromInlineData != null) {
setValueByPath(toObject, ["inlineData"], blobToMldev$1(fromInlineData));
}
const fromText = getValueByPath(fromObject, ["text"]);
if (fromText != null) {
setValueByPath(toObject, ["text"], fromText);
}
const fromThought = getValueByPath(fromObject, ["thought"]);
if (fromThought != null) {
setValueByPath(toObject, ["thought"], fromThought);
}
const fromThoughtSignature = getValueByPath(fromObject, [
"thoughtSignature"
]);
if (fromThoughtSignature != null) {
setValueByPath(toObject, ["thoughtSignature"], fromThoughtSignature);
}
const fromVideoMetadata = getValueByPath(fromObject, [
"videoMetadata"
]);
if (fromVideoMetadata != null) {
setValueByPath(toObject, ["videoMetadata"], fromVideoMetadata);
}
return toObject;
}
function productImageToVertex(fromObject) {
const toObject = {};
const fromProductImage = getValueByPath(fromObject, ["productImage"]);
if (fromProductImage != null) {
setValueByPath(toObject, ["image"], imageToVertex(fromProductImage));
}
return toObject;
}
function recontextImageConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromNumberOfImages = getValueByPath(fromObject, [
"numberOfImages"
]);
if (parentObject !== void 0 && fromNumberOfImages != null) {
setValueByPath(parentObject, ["parameters", "sampleCount"], fromNumberOfImages);
}
const fromBaseSteps = getValueByPath(fromObject, ["baseSteps"]);
if (parentObject !== void 0 && fromBaseSteps != null) {
setValueByPath(parentObject, ["parameters", "baseSteps"], fromBaseSteps);
}
const fromOutputGcsUri = getValueByPath(fromObject, ["outputGcsUri"]);
if (parentObject !== void 0 && fromOutputGcsUri != null) {
setValueByPath(parentObject, ["parameters", "storageUri"], fromOutputGcsUri);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (parentObject !== void 0 && fromSeed != null) {
setValueByPath(parentObject, ["parameters", "seed"], fromSeed);
}
const fromSafetyFilterLevel = getValueByPath(fromObject, [
"safetyFilterLevel"
]);
if (parentObject !== void 0 && fromSafetyFilterLevel != null) {
setValueByPath(parentObject, ["parameters", "safetySetting"], fromSafetyFilterLevel);
}
const fromPersonGeneration = getValueByPath(fromObject, [
"personGeneration"
]);
if (parentObject !== void 0 && fromPersonGeneration != null) {
setValueByPath(parentObject, ["parameters", "personGeneration"], fromPersonGeneration);
}
const fromAddWatermark = getValueByPath(fromObject, ["addWatermark"]);
if (parentObject !== void 0 && fromAddWatermark != null) {
setValueByPath(parentObject, ["parameters", "addWatermark"], fromAddWatermark);
}
const fromOutputMimeType = getValueByPath(fromObject, [
"outputMimeType"
]);
if (parentObject !== void 0 && fromOutputMimeType != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "mimeType"], fromOutputMimeType);
}
const fromOutputCompressionQuality = getValueByPath(fromObject, [
"outputCompressionQuality"
]);
if (parentObject !== void 0 && fromOutputCompressionQuality != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "compressionQuality"], fromOutputCompressionQuality);
}
const fromEnhancePrompt = getValueByPath(fromObject, [
"enhancePrompt"
]);
if (parentObject !== void 0 && fromEnhancePrompt != null) {
setValueByPath(parentObject, ["parameters", "enhancePrompt"], fromEnhancePrompt);
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (parentObject !== void 0 && fromLabels != null) {
setValueByPath(parentObject, ["labels"], fromLabels);
}
return toObject;
}
function recontextImageParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromSource = getValueByPath(fromObject, ["source"]);
if (fromSource != null) {
recontextImageSourceToVertex(fromSource, toObject);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
recontextImageConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function recontextImageResponseFromVertex(fromObject) {
const toObject = {};
const fromGeneratedImages = getValueByPath(fromObject, [
"predictions"
]);
if (fromGeneratedImages != null) {
let transformedList = fromGeneratedImages;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedImageFromVertex(item);
});
}
setValueByPath(toObject, ["generatedImages"], transformedList);
}
return toObject;
}
function recontextImageSourceToVertex(fromObject, parentObject) {
const toObject = {};
const fromPrompt = getValueByPath(fromObject, ["prompt"]);
if (parentObject !== void 0 && fromPrompt != null) {
setValueByPath(parentObject, ["instances[0]", "prompt"], fromPrompt);
}
const fromPersonImage = getValueByPath(fromObject, ["personImage"]);
if (parentObject !== void 0 && fromPersonImage != null) {
setValueByPath(parentObject, ["instances[0]", "personImage", "image"], imageToVertex(fromPersonImage));
}
const fromProductImages = getValueByPath(fromObject, [
"productImages"
]);
if (parentObject !== void 0 && fromProductImages != null) {
let transformedList = fromProductImages;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return productImageToVertex(item);
});
}
setValueByPath(parentObject, ["instances[0]", "productImages"], transformedList);
}
return toObject;
}
function referenceImageAPIInternalToVertex(fromObject) {
const toObject = {};
const fromReferenceImage = getValueByPath(fromObject, [
"referenceImage"
]);
if (fromReferenceImage != null) {
setValueByPath(toObject, ["referenceImage"], imageToVertex(fromReferenceImage));
}
const fromReferenceId = getValueByPath(fromObject, ["referenceId"]);
if (fromReferenceId != null) {
setValueByPath(toObject, ["referenceId"], fromReferenceId);
}
const fromReferenceType = getValueByPath(fromObject, [
"referenceType"
]);
if (fromReferenceType != null) {
setValueByPath(toObject, ["referenceType"], fromReferenceType);
}
const fromMaskImageConfig = getValueByPath(fromObject, [
"maskImageConfig"
]);
if (fromMaskImageConfig != null) {
setValueByPath(toObject, ["maskImageConfig"], maskReferenceConfigToVertex(fromMaskImageConfig));
}
const fromControlImageConfig = getValueByPath(fromObject, [
"controlImageConfig"
]);
if (fromControlImageConfig != null) {
setValueByPath(toObject, ["controlImageConfig"], controlReferenceConfigToVertex(fromControlImageConfig));
}
const fromStyleImageConfig = getValueByPath(fromObject, [
"styleImageConfig"
]);
if (fromStyleImageConfig != null) {
setValueByPath(toObject, ["styleImageConfig"], fromStyleImageConfig);
}
const fromSubjectImageConfig = getValueByPath(fromObject, [
"subjectImageConfig"
]);
if (fromSubjectImageConfig != null) {
setValueByPath(toObject, ["subjectImageConfig"], fromSubjectImageConfig);
}
return toObject;
}
function safetyAttributesFromMldev(fromObject) {
const toObject = {};
const fromCategories = getValueByPath(fromObject, [
"safetyAttributes",
"categories"
]);
if (fromCategories != null) {
setValueByPath(toObject, ["categories"], fromCategories);
}
const fromScores = getValueByPath(fromObject, [
"safetyAttributes",
"scores"
]);
if (fromScores != null) {
setValueByPath(toObject, ["scores"], fromScores);
}
const fromContentType = getValueByPath(fromObject, ["contentType"]);
if (fromContentType != null) {
setValueByPath(toObject, ["contentType"], fromContentType);
}
return toObject;
}
function safetyAttributesFromVertex(fromObject) {
const toObject = {};
const fromCategories = getValueByPath(fromObject, [
"safetyAttributes",
"categories"
]);
if (fromCategories != null) {
setValueByPath(toObject, ["categories"], fromCategories);
}
const fromScores = getValueByPath(fromObject, [
"safetyAttributes",
"scores"
]);
if (fromScores != null) {
setValueByPath(toObject, ["scores"], fromScores);
}
const fromContentType = getValueByPath(fromObject, ["contentType"]);
if (fromContentType != null) {
setValueByPath(toObject, ["contentType"], fromContentType);
}
return toObject;
}
function safetySettingToMldev(fromObject) {
const toObject = {};
const fromCategory = getValueByPath(fromObject, ["category"]);
if (fromCategory != null) {
setValueByPath(toObject, ["category"], fromCategory);
}
if (getValueByPath(fromObject, ["method"]) !== void 0) {
throw new Error("method parameter is not supported in Gemini API.");
}
const fromThreshold = getValueByPath(fromObject, ["threshold"]);
if (fromThreshold != null) {
setValueByPath(toObject, ["threshold"], fromThreshold);
}
return toObject;
}
function scribbleImageToVertex(fromObject) {
const toObject = {};
const fromImage = getValueByPath(fromObject, ["image"]);
if (fromImage != null) {
setValueByPath(toObject, ["image"], imageToVertex(fromImage));
}
return toObject;
}
function segmentImageConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromMode = getValueByPath(fromObject, ["mode"]);
if (parentObject !== void 0 && fromMode != null) {
setValueByPath(parentObject, ["parameters", "mode"], fromMode);
}
const fromMaxPredictions = getValueByPath(fromObject, [
"maxPredictions"
]);
if (parentObject !== void 0 && fromMaxPredictions != null) {
setValueByPath(parentObject, ["parameters", "maxPredictions"], fromMaxPredictions);
}
const fromConfidenceThreshold = getValueByPath(fromObject, [
"confidenceThreshold"
]);
if (parentObject !== void 0 && fromConfidenceThreshold != null) {
setValueByPath(parentObject, ["parameters", "confidenceThreshold"], fromConfidenceThreshold);
}
const fromMaskDilation = getValueByPath(fromObject, ["maskDilation"]);
if (parentObject !== void 0 && fromMaskDilation != null) {
setValueByPath(parentObject, ["parameters", "maskDilation"], fromMaskDilation);
}
const fromBinaryColorThreshold = getValueByPath(fromObject, [
"binaryColorThreshold"
]);
if (parentObject !== void 0 && fromBinaryColorThreshold != null) {
setValueByPath(parentObject, ["parameters", "binaryColorThreshold"], fromBinaryColorThreshold);
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (parentObject !== void 0 && fromLabels != null) {
setValueByPath(parentObject, ["labels"], fromLabels);
}
return toObject;
}
function segmentImageParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromSource = getValueByPath(fromObject, ["source"]);
if (fromSource != null) {
segmentImageSourceToVertex(fromSource, toObject);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
segmentImageConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function segmentImageResponseFromVertex(fromObject) {
const toObject = {};
const fromGeneratedMasks = getValueByPath(fromObject, ["predictions"]);
if (fromGeneratedMasks != null) {
let transformedList = fromGeneratedMasks;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedImageMaskFromVertex(item);
});
}
setValueByPath(toObject, ["generatedMasks"], transformedList);
}
return toObject;
}
function segmentImageSourceToVertex(fromObject, parentObject) {
const toObject = {};
const fromPrompt = getValueByPath(fromObject, ["prompt"]);
if (parentObject !== void 0 && fromPrompt != null) {
setValueByPath(parentObject, ["instances[0]", "prompt"], fromPrompt);
}
const fromImage = getValueByPath(fromObject, ["image"]);
if (parentObject !== void 0 && fromImage != null) {
setValueByPath(parentObject, ["instances[0]", "image"], imageToVertex(fromImage));
}
const fromScribbleImage = getValueByPath(fromObject, [
"scribbleImage"
]);
if (parentObject !== void 0 && fromScribbleImage != null) {
setValueByPath(parentObject, ["instances[0]", "scribble"], scribbleImageToVertex(fromScribbleImage));
}
return toObject;
}
function speechConfigToVertex(fromObject) {
const toObject = {};
const fromLanguageCode = getValueByPath(fromObject, ["languageCode"]);
if (fromLanguageCode != null) {
setValueByPath(toObject, ["languageCode"], fromLanguageCode);
}
const fromVoiceConfig = getValueByPath(fromObject, ["voiceConfig"]);
if (fromVoiceConfig != null) {
setValueByPath(toObject, ["voiceConfig"], fromVoiceConfig);
}
if (getValueByPath(fromObject, ["multiSpeakerVoiceConfig"]) !== void 0) {
throw new Error("multiSpeakerVoiceConfig parameter is not supported in Vertex AI.");
}
return toObject;
}
function toolConfigToMldev(fromObject) {
const toObject = {};
const fromFunctionCallingConfig = getValueByPath(fromObject, [
"functionCallingConfig"
]);
if (fromFunctionCallingConfig != null) {
setValueByPath(toObject, ["functionCallingConfig"], functionCallingConfigToMldev(fromFunctionCallingConfig));
}
const fromRetrievalConfig = getValueByPath(fromObject, [
"retrievalConfig"
]);
if (fromRetrievalConfig != null) {
setValueByPath(toObject, ["retrievalConfig"], fromRetrievalConfig);
}
return toObject;
}
function toolToMldev$1(fromObject) {
const toObject = {};
const fromFunctionDeclarations = getValueByPath(fromObject, [
"functionDeclarations"
]);
if (fromFunctionDeclarations != null) {
let transformedList = fromFunctionDeclarations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["functionDeclarations"], transformedList);
}
if (getValueByPath(fromObject, ["retrieval"]) !== void 0) {
throw new Error("retrieval parameter is not supported in Gemini API.");
}
const fromGoogleSearchRetrieval = getValueByPath(fromObject, [
"googleSearchRetrieval"
]);
if (fromGoogleSearchRetrieval != null) {
setValueByPath(toObject, ["googleSearchRetrieval"], fromGoogleSearchRetrieval);
}
const fromComputerUse = getValueByPath(fromObject, ["computerUse"]);
if (fromComputerUse != null) {
setValueByPath(toObject, ["computerUse"], fromComputerUse);
}
const fromFileSearch = getValueByPath(fromObject, ["fileSearch"]);
if (fromFileSearch != null) {
setValueByPath(toObject, ["fileSearch"], fromFileSearch);
}
const fromCodeExecution = getValueByPath(fromObject, [
"codeExecution"
]);
if (fromCodeExecution != null) {
setValueByPath(toObject, ["codeExecution"], fromCodeExecution);
}
if (getValueByPath(fromObject, ["enterpriseWebSearch"]) !== void 0) {
throw new Error("enterpriseWebSearch parameter is not supported in Gemini API.");
}
const fromGoogleMaps = getValueByPath(fromObject, ["googleMaps"]);
if (fromGoogleMaps != null) {
setValueByPath(toObject, ["googleMaps"], googleMapsToMldev$1(fromGoogleMaps));
}
const fromGoogleSearch = getValueByPath(fromObject, ["googleSearch"]);
if (fromGoogleSearch != null) {
setValueByPath(toObject, ["googleSearch"], googleSearchToMldev$1(fromGoogleSearch));
}
const fromUrlContext = getValueByPath(fromObject, ["urlContext"]);
if (fromUrlContext != null) {
setValueByPath(toObject, ["urlContext"], fromUrlContext);
}
return toObject;
}
function toolToVertex(fromObject) {
const toObject = {};
const fromFunctionDeclarations = getValueByPath(fromObject, [
"functionDeclarations"
]);
if (fromFunctionDeclarations != null) {
let transformedList = fromFunctionDeclarations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return functionDeclarationToVertex(item);
});
}
setValueByPath(toObject, ["functionDeclarations"], transformedList);
}
const fromRetrieval = getValueByPath(fromObject, ["retrieval"]);
if (fromRetrieval != null) {
setValueByPath(toObject, ["retrieval"], fromRetrieval);
}
const fromGoogleSearchRetrieval = getValueByPath(fromObject, [
"googleSearchRetrieval"
]);
if (fromGoogleSearchRetrieval != null) {
setValueByPath(toObject, ["googleSearchRetrieval"], fromGoogleSearchRetrieval);
}
const fromComputerUse = getValueByPath(fromObject, ["computerUse"]);
if (fromComputerUse != null) {
setValueByPath(toObject, ["computerUse"], fromComputerUse);
}
if (getValueByPath(fromObject, ["fileSearch"]) !== void 0) {
throw new Error("fileSearch parameter is not supported in Vertex AI.");
}
const fromCodeExecution = getValueByPath(fromObject, [
"codeExecution"
]);
if (fromCodeExecution != null) {
setValueByPath(toObject, ["codeExecution"], fromCodeExecution);
}
const fromEnterpriseWebSearch = getValueByPath(fromObject, [
"enterpriseWebSearch"
]);
if (fromEnterpriseWebSearch != null) {
setValueByPath(toObject, ["enterpriseWebSearch"], fromEnterpriseWebSearch);
}
const fromGoogleMaps = getValueByPath(fromObject, ["googleMaps"]);
if (fromGoogleMaps != null) {
setValueByPath(toObject, ["googleMaps"], fromGoogleMaps);
}
const fromGoogleSearch = getValueByPath(fromObject, ["googleSearch"]);
if (fromGoogleSearch != null) {
setValueByPath(toObject, ["googleSearch"], fromGoogleSearch);
}
const fromUrlContext = getValueByPath(fromObject, ["urlContext"]);
if (fromUrlContext != null) {
setValueByPath(toObject, ["urlContext"], fromUrlContext);
}
return toObject;
}
function tunedModelInfoFromMldev(fromObject) {
const toObject = {};
const fromBaseModel = getValueByPath(fromObject, ["baseModel"]);
if (fromBaseModel != null) {
setValueByPath(toObject, ["baseModel"], fromBaseModel);
}
const fromCreateTime = getValueByPath(fromObject, ["createTime"]);
if (fromCreateTime != null) {
setValueByPath(toObject, ["createTime"], fromCreateTime);
}
const fromUpdateTime = getValueByPath(fromObject, ["updateTime"]);
if (fromUpdateTime != null) {
setValueByPath(toObject, ["updateTime"], fromUpdateTime);
}
return toObject;
}
function tunedModelInfoFromVertex(fromObject) {
const toObject = {};
const fromBaseModel = getValueByPath(fromObject, [
"labels",
"google-vertex-llm-tuning-base-model-id"
]);
if (fromBaseModel != null) {
setValueByPath(toObject, ["baseModel"], fromBaseModel);
}
const fromCreateTime = getValueByPath(fromObject, ["createTime"]);
if (fromCreateTime != null) {
setValueByPath(toObject, ["createTime"], fromCreateTime);
}
const fromUpdateTime = getValueByPath(fromObject, ["updateTime"]);
if (fromUpdateTime != null) {
setValueByPath(toObject, ["updateTime"], fromUpdateTime);
}
return toObject;
}
function updateModelConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (parentObject !== void 0 && fromDisplayName != null) {
setValueByPath(parentObject, ["displayName"], fromDisplayName);
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (parentObject !== void 0 && fromDescription != null) {
setValueByPath(parentObject, ["description"], fromDescription);
}
const fromDefaultCheckpointId = getValueByPath(fromObject, [
"defaultCheckpointId"
]);
if (parentObject !== void 0 && fromDefaultCheckpointId != null) {
setValueByPath(parentObject, ["defaultCheckpointId"], fromDefaultCheckpointId);
}
return toObject;
}
function updateModelConfigToVertex(fromObject, parentObject) {
const toObject = {};
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (parentObject !== void 0 && fromDisplayName != null) {
setValueByPath(parentObject, ["displayName"], fromDisplayName);
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (parentObject !== void 0 && fromDescription != null) {
setValueByPath(parentObject, ["description"], fromDescription);
}
const fromDefaultCheckpointId = getValueByPath(fromObject, [
"defaultCheckpointId"
]);
if (parentObject !== void 0 && fromDefaultCheckpointId != null) {
setValueByPath(parentObject, ["defaultCheckpointId"], fromDefaultCheckpointId);
}
return toObject;
}
function updateModelParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "name"], tModel(apiClient, fromModel));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
updateModelConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function updateModelParametersToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
updateModelConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function upscaleImageAPIConfigInternalToVertex(fromObject, parentObject) {
const toObject = {};
const fromOutputGcsUri = getValueByPath(fromObject, ["outputGcsUri"]);
if (parentObject !== void 0 && fromOutputGcsUri != null) {
setValueByPath(parentObject, ["parameters", "storageUri"], fromOutputGcsUri);
}
const fromSafetyFilterLevel = getValueByPath(fromObject, [
"safetyFilterLevel"
]);
if (parentObject !== void 0 && fromSafetyFilterLevel != null) {
setValueByPath(parentObject, ["parameters", "safetySetting"], fromSafetyFilterLevel);
}
const fromPersonGeneration = getValueByPath(fromObject, [
"personGeneration"
]);
if (parentObject !== void 0 && fromPersonGeneration != null) {
setValueByPath(parentObject, ["parameters", "personGeneration"], fromPersonGeneration);
}
const fromIncludeRaiReason = getValueByPath(fromObject, [
"includeRaiReason"
]);
if (parentObject !== void 0 && fromIncludeRaiReason != null) {
setValueByPath(parentObject, ["parameters", "includeRaiReason"], fromIncludeRaiReason);
}
const fromOutputMimeType = getValueByPath(fromObject, [
"outputMimeType"
]);
if (parentObject !== void 0 && fromOutputMimeType != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "mimeType"], fromOutputMimeType);
}
const fromOutputCompressionQuality = getValueByPath(fromObject, [
"outputCompressionQuality"
]);
if (parentObject !== void 0 && fromOutputCompressionQuality != null) {
setValueByPath(parentObject, ["parameters", "outputOptions", "compressionQuality"], fromOutputCompressionQuality);
}
const fromEnhanceInputImage = getValueByPath(fromObject, [
"enhanceInputImage"
]);
if (parentObject !== void 0 && fromEnhanceInputImage != null) {
setValueByPath(parentObject, ["parameters", "upscaleConfig", "enhanceInputImage"], fromEnhanceInputImage);
}
const fromImagePreservationFactor = getValueByPath(fromObject, [
"imagePreservationFactor"
]);
if (parentObject !== void 0 && fromImagePreservationFactor != null) {
setValueByPath(parentObject, ["parameters", "upscaleConfig", "imagePreservationFactor"], fromImagePreservationFactor);
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (parentObject !== void 0 && fromLabels != null) {
setValueByPath(parentObject, ["labels"], fromLabels);
}
const fromNumberOfImages = getValueByPath(fromObject, [
"numberOfImages"
]);
if (parentObject !== void 0 && fromNumberOfImages != null) {
setValueByPath(parentObject, ["parameters", "sampleCount"], fromNumberOfImages);
}
const fromMode = getValueByPath(fromObject, ["mode"]);
if (parentObject !== void 0 && fromMode != null) {
setValueByPath(parentObject, ["parameters", "mode"], fromMode);
}
return toObject;
}
function upscaleImageAPIParametersInternalToVertex(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["_url", "model"], tModel(apiClient, fromModel));
}
const fromImage = getValueByPath(fromObject, ["image"]);
if (fromImage != null) {
setValueByPath(toObject, ["instances[0]", "image"], imageToVertex(fromImage));
}
const fromUpscaleFactor = getValueByPath(fromObject, [
"upscaleFactor"
]);
if (fromUpscaleFactor != null) {
setValueByPath(toObject, ["parameters", "upscaleConfig", "upscaleFactor"], fromUpscaleFactor);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
upscaleImageAPIConfigInternalToVertex(fromConfig, toObject);
}
return toObject;
}
function upscaleImageResponseFromVertex(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromGeneratedImages = getValueByPath(fromObject, [
"predictions"
]);
if (fromGeneratedImages != null) {
let transformedList = fromGeneratedImages;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return generatedImageFromVertex(item);
});
}
setValueByPath(toObject, ["generatedImages"], transformedList);
}
return toObject;
}
function videoFromMldev(fromObject) {
const toObject = {};
const fromUri = getValueByPath(fromObject, ["uri"]);
if (fromUri != null) {
setValueByPath(toObject, ["uri"], fromUri);
}
const fromVideoBytes = getValueByPath(fromObject, ["encodedVideo"]);
if (fromVideoBytes != null) {
setValueByPath(toObject, ["videoBytes"], tBytes(fromVideoBytes));
}
const fromMimeType = getValueByPath(fromObject, ["encoding"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function videoFromVertex(fromObject) {
const toObject = {};
const fromUri = getValueByPath(fromObject, ["gcsUri"]);
if (fromUri != null) {
setValueByPath(toObject, ["uri"], fromUri);
}
const fromVideoBytes = getValueByPath(fromObject, [
"bytesBase64Encoded"
]);
if (fromVideoBytes != null) {
setValueByPath(toObject, ["videoBytes"], tBytes(fromVideoBytes));
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function videoGenerationMaskToVertex(fromObject) {
const toObject = {};
const fromImage = getValueByPath(fromObject, ["image"]);
if (fromImage != null) {
setValueByPath(toObject, ["_self"], imageToVertex(fromImage));
}
const fromMaskMode = getValueByPath(fromObject, ["maskMode"]);
if (fromMaskMode != null) {
setValueByPath(toObject, ["maskMode"], fromMaskMode);
}
return toObject;
}
function videoGenerationReferenceImageToMldev(fromObject) {
const toObject = {};
const fromImage = getValueByPath(fromObject, ["image"]);
if (fromImage != null) {
setValueByPath(toObject, ["image"], imageToMldev(fromImage));
}
const fromReferenceType = getValueByPath(fromObject, [
"referenceType"
]);
if (fromReferenceType != null) {
setValueByPath(toObject, ["referenceType"], fromReferenceType);
}
return toObject;
}
function videoGenerationReferenceImageToVertex(fromObject) {
const toObject = {};
const fromImage = getValueByPath(fromObject, ["image"]);
if (fromImage != null) {
setValueByPath(toObject, ["image"], imageToVertex(fromImage));
}
const fromReferenceType = getValueByPath(fromObject, [
"referenceType"
]);
if (fromReferenceType != null) {
setValueByPath(toObject, ["referenceType"], fromReferenceType);
}
return toObject;
}
function videoToMldev(fromObject) {
const toObject = {};
const fromUri = getValueByPath(fromObject, ["uri"]);
if (fromUri != null) {
setValueByPath(toObject, ["uri"], fromUri);
}
const fromVideoBytes = getValueByPath(fromObject, ["videoBytes"]);
if (fromVideoBytes != null) {
setValueByPath(toObject, ["encodedVideo"], tBytes(fromVideoBytes));
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["encoding"], fromMimeType);
}
return toObject;
}
function videoToVertex(fromObject) {
const toObject = {};
const fromUri = getValueByPath(fromObject, ["uri"]);
if (fromUri != null) {
setValueByPath(toObject, ["gcsUri"], fromUri);
}
const fromVideoBytes = getValueByPath(fromObject, ["videoBytes"]);
if (fromVideoBytes != null) {
setValueByPath(toObject, ["bytesBase64Encoded"], tBytes(fromVideoBytes));
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
var CONTENT_TYPE_HEADER = "Content-Type";
var SERVER_TIMEOUT_HEADER = "X-Server-Timeout";
var USER_AGENT_HEADER = "User-Agent";
var GOOGLE_API_CLIENT_HEADER = "x-goog-api-client";
var SDK_VERSION = "1.30.0";
var LIBRARY_LABEL = `google-genai-sdk/${SDK_VERSION}`;
var VERTEX_AI_API_DEFAULT_VERSION = "v1beta1";
var GOOGLE_AI_API_DEFAULT_VERSION = "v1beta";
var responseLineRE = /^\s*data: (.*)(?:\n\n|\r\r|\r\n\r\n)/;
var ApiClient = class {
constructor(opts) {
var _a, _b;
this.clientOptions = Object.assign(Object.assign({}, opts), { project: opts.project, location: opts.location, apiKey: opts.apiKey, vertexai: opts.vertexai });
const initHttpOptions = {};
if (this.clientOptions.vertexai) {
initHttpOptions.apiVersion = (_a = this.clientOptions.apiVersion) !== null && _a !== void 0 ? _a : VERTEX_AI_API_DEFAULT_VERSION;
initHttpOptions.baseUrl = this.baseUrlFromProjectLocation();
this.normalizeAuthParameters();
} else {
initHttpOptions.apiVersion = (_b = this.clientOptions.apiVersion) !== null && _b !== void 0 ? _b : GOOGLE_AI_API_DEFAULT_VERSION;
initHttpOptions.baseUrl = `https://generativelanguage.googleapis.com/`;
}
initHttpOptions.headers = this.getDefaultHeaders();
this.clientOptions.httpOptions = initHttpOptions;
if (opts.httpOptions) {
this.clientOptions.httpOptions = this.patchHttpOptions(initHttpOptions, opts.httpOptions);
}
}
/**
* Determines the base URL for Vertex AI based on project and location.
* Uses the global endpoint if location is 'global' or if project/location
* are not specified (implying API key usage).
* @private
*/
baseUrlFromProjectLocation() {
if (this.clientOptions.project && this.clientOptions.location && this.clientOptions.location !== "global") {
return `https://${this.clientOptions.location}-aiplatform.googleapis.com/`;
}
return `https://aiplatform.googleapis.com/`;
}
/**
* Normalizes authentication parameters for Vertex AI.
* If project and location are provided, API key is cleared.
* If project and location are not provided (implying API key usage),
* project and location are cleared.
* @private
*/
normalizeAuthParameters() {
if (this.clientOptions.project && this.clientOptions.location) {
this.clientOptions.apiKey = void 0;
return;
}
this.clientOptions.project = void 0;
this.clientOptions.location = void 0;
}
isVertexAI() {
var _a;
return (_a = this.clientOptions.vertexai) !== null && _a !== void 0 ? _a : false;
}
getProject() {
return this.clientOptions.project;
}
getLocation() {
return this.clientOptions.location;
}
getApiVersion() {
if (this.clientOptions.httpOptions && this.clientOptions.httpOptions.apiVersion !== void 0) {
return this.clientOptions.httpOptions.apiVersion;
}
throw new Error("API version is not set.");
}
getBaseUrl() {
if (this.clientOptions.httpOptions && this.clientOptions.httpOptions.baseUrl !== void 0) {
return this.clientOptions.httpOptions.baseUrl;
}
throw new Error("Base URL is not set.");
}
getRequestUrl() {
return this.getRequestUrlInternal(this.clientOptions.httpOptions);
}
getHeaders() {
if (this.clientOptions.httpOptions && this.clientOptions.httpOptions.headers !== void 0) {
return this.clientOptions.httpOptions.headers;
} else {
throw new Error("Headers are not set.");
}
}
getRequestUrlInternal(httpOptions) {
if (!httpOptions || httpOptions.baseUrl === void 0 || httpOptions.apiVersion === void 0) {
throw new Error("HTTP options are not correctly set.");
}
const baseUrl = httpOptions.baseUrl.endsWith("/") ? httpOptions.baseUrl.slice(0, -1) : httpOptions.baseUrl;
const urlElement = [baseUrl];
if (httpOptions.apiVersion && httpOptions.apiVersion !== "") {
urlElement.push(httpOptions.apiVersion);
}
return urlElement.join("/");
}
getBaseResourcePath() {
return `projects/${this.clientOptions.project}/locations/${this.clientOptions.location}`;
}
getApiKey() {
return this.clientOptions.apiKey;
}
getWebsocketBaseUrl() {
const baseUrl = this.getBaseUrl();
const urlParts = new URL(baseUrl);
urlParts.protocol = urlParts.protocol == "http:" ? "ws" : "wss";
return urlParts.toString();
}
setBaseUrl(url) {
if (this.clientOptions.httpOptions) {
this.clientOptions.httpOptions.baseUrl = url;
} else {
throw new Error("HTTP options are not correctly set.");
}
}
constructUrl(path10, httpOptions, prependProjectLocation) {
const urlElement = [this.getRequestUrlInternal(httpOptions)];
if (prependProjectLocation) {
urlElement.push(this.getBaseResourcePath());
}
if (path10 !== "") {
urlElement.push(path10);
}
const url = new URL(`${urlElement.join("/")}`);
return url;
}
shouldPrependVertexProjectPath(request) {
if (this.clientOptions.apiKey) {
return false;
}
if (!this.clientOptions.vertexai) {
return false;
}
if (request.path.startsWith("projects/")) {
return false;
}
if (request.httpMethod === "GET" && request.path.startsWith("publishers/google/models")) {
return false;
}
return true;
}
async request(request) {
let patchedHttpOptions = this.clientOptions.httpOptions;
if (request.httpOptions) {
patchedHttpOptions = this.patchHttpOptions(this.clientOptions.httpOptions, request.httpOptions);
}
const prependProjectLocation = this.shouldPrependVertexProjectPath(request);
const url = this.constructUrl(request.path, patchedHttpOptions, prependProjectLocation);
if (request.queryParams) {
for (const [key, value] of Object.entries(request.queryParams)) {
url.searchParams.append(key, String(value));
}
}
let requestInit = {};
if (request.httpMethod === "GET") {
if (request.body && request.body !== "{}") {
throw new Error("Request body should be empty for GET request, but got non empty request body");
}
} else {
requestInit.body = request.body;
}
requestInit = await this.includeExtraHttpOptionsToRequestInit(requestInit, patchedHttpOptions, url.toString(), request.abortSignal);
return this.unaryApiCall(url, requestInit, request.httpMethod);
}
patchHttpOptions(baseHttpOptions, requestHttpOptions) {
const patchedHttpOptions = JSON.parse(JSON.stringify(baseHttpOptions));
for (const [key, value] of Object.entries(requestHttpOptions)) {
if (typeof value === "object") {
patchedHttpOptions[key] = Object.assign(Object.assign({}, patchedHttpOptions[key]), value);
} else if (value !== void 0) {
patchedHttpOptions[key] = value;
}
}
return patchedHttpOptions;
}
async requestStream(request) {
let patchedHttpOptions = this.clientOptions.httpOptions;
if (request.httpOptions) {
patchedHttpOptions = this.patchHttpOptions(this.clientOptions.httpOptions, request.httpOptions);
}
const prependProjectLocation = this.shouldPrependVertexProjectPath(request);
const url = this.constructUrl(request.path, patchedHttpOptions, prependProjectLocation);
if (!url.searchParams.has("alt") || url.searchParams.get("alt") !== "sse") {
url.searchParams.set("alt", "sse");
}
let requestInit = {};
requestInit.body = request.body;
requestInit = await this.includeExtraHttpOptionsToRequestInit(requestInit, patchedHttpOptions, url.toString(), request.abortSignal);
return this.streamApiCall(url, requestInit, request.httpMethod);
}
async includeExtraHttpOptionsToRequestInit(requestInit, httpOptions, url, abortSignal) {
if (httpOptions && httpOptions.timeout || abortSignal) {
const abortController = new AbortController();
const signal = abortController.signal;
if (httpOptions.timeout && (httpOptions === null || httpOptions === void 0 ? void 0 : httpOptions.timeout) > 0) {
const timeoutHandle = setTimeout(() => abortController.abort(), httpOptions.timeout);
if (timeoutHandle && typeof timeoutHandle.unref === "function") {
timeoutHandle.unref();
}
}
if (abortSignal) {
abortSignal.addEventListener("abort", () => {
abortController.abort();
});
}
requestInit.signal = signal;
}
if (httpOptions && httpOptions.extraBody !== null) {
includeExtraBodyToRequestInit(requestInit, httpOptions.extraBody);
}
requestInit.headers = await this.getHeadersInternal(httpOptions, url);
return requestInit;
}
async unaryApiCall(url, requestInit, httpMethod) {
return this.apiCall(url.toString(), Object.assign(Object.assign({}, requestInit), { method: httpMethod })).then(async (response) => {
await throwErrorIfNotOK(response);
return new HttpResponse(response);
}).catch((e) => {
if (e instanceof Error) {
throw e;
} else {
throw new Error(JSON.stringify(e));
}
});
}
async streamApiCall(url, requestInit, httpMethod) {
return this.apiCall(url.toString(), Object.assign(Object.assign({}, requestInit), { method: httpMethod })).then(async (response) => {
await throwErrorIfNotOK(response);
return this.processStreamResponse(response);
}).catch((e) => {
if (e instanceof Error) {
throw e;
} else {
throw new Error(JSON.stringify(e));
}
});
}
processStreamResponse(response) {
var _a;
return __asyncGenerator(this, arguments, function* processStreamResponse_1() {
const reader = (_a = response === null || response === void 0 ? void 0 : response.body) === null || _a === void 0 ? void 0 : _a.getReader();
const decoder = new TextDecoder("utf-8");
if (!reader) {
throw new Error("Response body is empty");
}
try {
let buffer = "";
while (true) {
const { done, value } = yield __await(reader.read());
if (done) {
if (buffer.trim().length > 0) {
throw new Error("Incomplete JSON segment at the end");
}
break;
}
const chunkString = decoder.decode(value, { stream: true });
try {
const chunkJson = JSON.parse(chunkString);
if ("error" in chunkJson) {
const errorJson = JSON.parse(JSON.stringify(chunkJson["error"]));
const status = errorJson["status"];
const code = errorJson["code"];
const errorMessage = `got status: ${status}. ${JSON.stringify(chunkJson)}`;
if (code >= 400 && code < 600) {
const apiError = new ApiError({
message: errorMessage,
status: code
});
throw apiError;
}
}
} catch (e) {
const error = e;
if (error.name === "ApiError") {
throw e;
}
}
buffer += chunkString;
let match = buffer.match(responseLineRE);
while (match) {
const processedChunkString = match[1];
try {
const partialResponse = new Response(processedChunkString, {
headers: response === null || response === void 0 ? void 0 : response.headers,
status: response === null || response === void 0 ? void 0 : response.status,
statusText: response === null || response === void 0 ? void 0 : response.statusText
});
yield yield __await(new HttpResponse(partialResponse));
buffer = buffer.slice(match[0].length);
match = buffer.match(responseLineRE);
} catch (e) {
throw new Error(`exception parsing stream chunk ${processedChunkString}. ${e}`);
}
}
}
} finally {
reader.releaseLock();
}
});
}
async apiCall(url, requestInit) {
return fetch(url, requestInit).catch((e) => {
throw new Error(`exception ${e} sending request`);
});
}
getDefaultHeaders() {
const headers = {};
const versionHeaderValue = LIBRARY_LABEL + " " + this.clientOptions.userAgentExtra;
headers[USER_AGENT_HEADER] = versionHeaderValue;
headers[GOOGLE_API_CLIENT_HEADER] = versionHeaderValue;
headers[CONTENT_TYPE_HEADER] = "application/json";
return headers;
}
async getHeadersInternal(httpOptions, url) {
const headers = new Headers();
if (httpOptions && httpOptions.headers) {
for (const [key, value] of Object.entries(httpOptions.headers)) {
headers.append(key, value);
}
if (httpOptions.timeout && httpOptions.timeout > 0) {
headers.append(SERVER_TIMEOUT_HEADER, String(Math.ceil(httpOptions.timeout / 1e3)));
}
}
await this.clientOptions.auth.addAuthHeaders(headers, url);
return headers;
}
getFileName(file) {
var _a;
let fileName = "";
if (typeof file === "string") {
fileName = file.replace(/[/\\]+$/, "");
fileName = (_a = fileName.split(/[/\\]/).pop()) !== null && _a !== void 0 ? _a : "";
}
return fileName;
}
/**
* Uploads a file asynchronously using Gemini API only, this is not supported
* in Vertex AI.
*
* @param file The string path to the file to be uploaded or a Blob object.
* @param config Optional parameters specified in the `UploadFileConfig`
* interface. @see {@link types.UploadFileConfig}
* @return A promise that resolves to a `File` object.
* @throws An error if called on a Vertex AI client.
* @throws An error if the `mimeType` is not provided and can not be inferred,
*/
async uploadFile(file, config) {
var _a;
const fileToUpload = {};
if (config != null) {
fileToUpload.mimeType = config.mimeType;
fileToUpload.name = config.name;
fileToUpload.displayName = config.displayName;
}
if (fileToUpload.name && !fileToUpload.name.startsWith("files/")) {
fileToUpload.name = `files/${fileToUpload.name}`;
}
const uploader = this.clientOptions.uploader;
const fileStat = await uploader.stat(file);
fileToUpload.sizeBytes = String(fileStat.size);
const mimeType = (_a = config === null || config === void 0 ? void 0 : config.mimeType) !== null && _a !== void 0 ? _a : fileStat.type;
if (mimeType === void 0 || mimeType === "") {
throw new Error("Can not determine mimeType. Please provide mimeType in the config.");
}
fileToUpload.mimeType = mimeType;
const body = {
file: fileToUpload
};
const fileName = this.getFileName(file);
const path10 = formatMap("upload/v1beta/files", body["_url"]);
const uploadUrl = await this.fetchUploadUrl(path10, fileToUpload.sizeBytes, fileToUpload.mimeType, fileName, body, config === null || config === void 0 ? void 0 : config.httpOptions);
return uploader.upload(file, uploadUrl, this);
}
/**
* Uploads a file to a given file search store asynchronously using Gemini API only, this is not supported
* in Vertex AI.
*
* @param fileSearchStoreName The name of the file search store to upload the file to.
* @param file The string path to the file to be uploaded or a Blob object.
* @param config Optional parameters specified in the `UploadFileConfig`
* interface. @see {@link UploadFileConfig}
* @return A promise that resolves to a `File` object.
* @throws An error if called on a Vertex AI client.
* @throws An error if the `mimeType` is not provided and can not be inferred,
*/
async uploadFileToFileSearchStore(fileSearchStoreName, file, config) {
var _a;
const uploader = this.clientOptions.uploader;
const fileStat = await uploader.stat(file);
const sizeBytes = String(fileStat.size);
const mimeType = (_a = config === null || config === void 0 ? void 0 : config.mimeType) !== null && _a !== void 0 ? _a : fileStat.type;
if (mimeType === void 0 || mimeType === "") {
throw new Error("Can not determine mimeType. Please provide mimeType in the config.");
}
const path10 = `upload/v1beta/${fileSearchStoreName}:uploadToFileSearchStore`;
const fileName = this.getFileName(file);
const body = {};
if (config === null || config === void 0 ? void 0 : config.customMetadata) {
body["customMetadata"] = config.customMetadata;
}
if (config === null || config === void 0 ? void 0 : config.chunkingConfig) {
body["chunkingConfig"] = config.chunkingConfig;
}
const uploadUrl = await this.fetchUploadUrl(path10, sizeBytes, mimeType, fileName, body, config === null || config === void 0 ? void 0 : config.httpOptions);
return uploader.uploadToFileSearchStore(file, uploadUrl, this);
}
/**
* Downloads a file asynchronously to the specified path.
*
* @params params - The parameters for the download request, see {@link
* types.DownloadFileParameters}
*/
async downloadFile(params) {
const downloader = this.clientOptions.downloader;
await downloader.download(params, this);
}
async fetchUploadUrl(path10, sizeBytes, mimeType, fileName, body, configHttpOptions) {
var _a;
let httpOptions = {};
if (configHttpOptions) {
httpOptions = configHttpOptions;
} else {
httpOptions = {
apiVersion: "",
headers: Object.assign({ "Content-Type": "application/json", "X-Goog-Upload-Protocol": "resumable", "X-Goog-Upload-Command": "start", "X-Goog-Upload-Header-Content-Length": `${sizeBytes}`, "X-Goog-Upload-Header-Content-Type": `${mimeType}` }, fileName ? { "X-Goog-Upload-File-Name": fileName } : {})
};
}
const httpResponse = await this.request({
path: path10,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions
});
if (!httpResponse || !(httpResponse === null || httpResponse === void 0 ? void 0 : httpResponse.headers)) {
throw new Error("Server did not return an HttpResponse or the returned HttpResponse did not have headers.");
}
const uploadUrl = (_a = httpResponse === null || httpResponse === void 0 ? void 0 : httpResponse.headers) === null || _a === void 0 ? void 0 : _a["x-goog-upload-url"];
if (uploadUrl === void 0) {
throw new Error("Failed to get upload url. Server did not return the x-google-upload-url in the headers");
}
return uploadUrl;
}
};
async function throwErrorIfNotOK(response) {
var _a;
if (response === void 0) {
throw new Error("response is undefined");
}
if (!response.ok) {
const status = response.status;
let errorBody;
if ((_a = response.headers.get("content-type")) === null || _a === void 0 ? void 0 : _a.includes("application/json")) {
errorBody = await response.json();
} else {
errorBody = {
error: {
message: await response.text(),
code: response.status,
status: response.statusText
}
};
}
const errorMessage = JSON.stringify(errorBody);
if (status >= 400 && status < 600) {
const apiError = new ApiError({
message: errorMessage,
status
});
throw apiError;
}
throw new Error(errorMessage);
}
}
function includeExtraBodyToRequestInit(requestInit, extraBody) {
if (!extraBody || Object.keys(extraBody).length === 0) {
return;
}
if (requestInit.body instanceof Blob) {
console.warn("includeExtraBodyToRequestInit: extraBody provided but current request body is a Blob. extraBody will be ignored as merging is not supported for Blob bodies.");
return;
}
let currentBodyObject = {};
if (typeof requestInit.body === "string" && requestInit.body.length > 0) {
try {
const parsedBody = JSON.parse(requestInit.body);
if (typeof parsedBody === "object" && parsedBody !== null && !Array.isArray(parsedBody)) {
currentBodyObject = parsedBody;
} else {
console.warn("includeExtraBodyToRequestInit: Original request body is valid JSON but not a non-array object. Skip applying extraBody to the request body.");
return;
}
} catch (e) {
console.warn("includeExtraBodyToRequestInit: Original request body is not valid JSON. Skip applying extraBody to the request body.");
return;
}
}
function deepMerge(target, source) {
const output = Object.assign({}, target);
for (const key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
const sourceValue = source[key];
const targetValue = output[key];
if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
output[key] = deepMerge(targetValue, sourceValue);
} else {
if (targetValue && sourceValue && typeof targetValue !== typeof sourceValue) {
console.warn(`includeExtraBodyToRequestInit:deepMerge: Type mismatch for key "${key}". Original type: ${typeof targetValue}, New type: ${typeof sourceValue}. Overwriting.`);
}
output[key] = sourceValue;
}
}
}
return output;
}
const mergedBody = deepMerge(currentBodyObject, extraBody);
requestInit.body = JSON.stringify(mergedBody);
}
var MCP_LABEL = "mcp_used/unknown";
var hasMcpToolUsageFromMcpToTool = false;
function hasMcpToolUsage(tools) {
for (const tool of tools) {
if (isMcpCallableTool(tool)) {
return true;
}
if (typeof tool === "object" && "inputSchema" in tool) {
return true;
}
}
return hasMcpToolUsageFromMcpToTool;
}
function setMcpUsageHeader(headers) {
var _a;
const existingHeader = (_a = headers[GOOGLE_API_CLIENT_HEADER]) !== null && _a !== void 0 ? _a : "";
headers[GOOGLE_API_CLIENT_HEADER] = (existingHeader + ` ${MCP_LABEL}`).trimStart();
}
function isMcpCallableTool(object) {
return object !== null && typeof object === "object" && object instanceof McpCallableTool;
}
function listAllTools(mcpClient, maxTools = 100) {
return __asyncGenerator(this, arguments, function* listAllTools_1() {
let cursor = void 0;
let numTools = 0;
while (numTools < maxTools) {
const t = yield __await(mcpClient.listTools({ cursor }));
for (const tool of t.tools) {
yield yield __await(tool);
numTools++;
}
if (!t.nextCursor) {
break;
}
cursor = t.nextCursor;
}
});
}
var McpCallableTool = class _McpCallableTool {
constructor(mcpClients = [], config) {
this.mcpTools = [];
this.functionNameToMcpClient = {};
this.mcpClients = mcpClients;
this.config = config;
}
/**
* Creates a McpCallableTool.
*/
static create(mcpClients, config) {
return new _McpCallableTool(mcpClients, config);
}
/**
* Validates the function names are not duplicate and initialize the function
* name to MCP client mapping.
*
* @throws {Error} if the MCP tools from the MCP clients have duplicate tool
* names.
*/
async initialize() {
var _a, e_1, _b, _c;
if (this.mcpTools.length > 0) {
return;
}
const functionMap = {};
const mcpTools = [];
for (const mcpClient of this.mcpClients) {
try {
for (var _d = true, _e = (e_1 = void 0, __asyncValues(listAllTools(mcpClient))), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
_c = _f.value;
_d = false;
const mcpTool = _c;
mcpTools.push(mcpTool);
const mcpToolName = mcpTool.name;
if (functionMap[mcpToolName]) {
throw new Error(`Duplicate function name ${mcpToolName} found in MCP tools. Please ensure function names are unique.`);
}
functionMap[mcpToolName] = mcpClient;
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
} finally {
if (e_1) throw e_1.error;
}
}
}
this.mcpTools = mcpTools;
this.functionNameToMcpClient = functionMap;
}
async tool() {
await this.initialize();
return mcpToolsToGeminiTool(this.mcpTools, this.config);
}
async callTool(functionCalls) {
await this.initialize();
const functionCallResponseParts = [];
for (const functionCall of functionCalls) {
if (functionCall.name in this.functionNameToMcpClient) {
const mcpClient = this.functionNameToMcpClient[functionCall.name];
let requestOptions = void 0;
if (this.config.timeout) {
requestOptions = {
timeout: this.config.timeout
};
}
const callToolResponse = await mcpClient.callTool(
{
name: functionCall.name,
arguments: functionCall.args
},
// Set the result schema to undefined to allow MCP to rely on the
// default schema.
void 0,
requestOptions
);
functionCallResponseParts.push({
functionResponse: {
name: functionCall.name,
response: callToolResponse.isError ? { error: callToolResponse } : callToolResponse
}
});
}
}
return functionCallResponseParts;
}
};
async function handleWebSocketMessage$1(apiClient, onmessage, event) {
const serverMessage = new LiveMusicServerMessage();
let data;
if (event.data instanceof Blob) {
data = JSON.parse(await event.data.text());
} else {
data = JSON.parse(event.data);
}
Object.assign(serverMessage, data);
onmessage(serverMessage);
}
var LiveMusic = class {
constructor(apiClient, auth, webSocketFactory) {
this.apiClient = apiClient;
this.auth = auth;
this.webSocketFactory = webSocketFactory;
}
/**
Establishes a connection to the specified model and returns a
LiveMusicSession object representing that connection.
@experimental
@remarks
@param params - The parameters for establishing a connection to the model.
@return A live session.
@example
```ts
let model = 'models/lyria-realtime-exp';
const session = await ai.live.music.connect({
model: model,
callbacks: {
onmessage: (e: MessageEvent) => {
console.log('Received message from the server: %s\n', debug(e.data));
},
onerror: (e: ErrorEvent) => {
console.log('Error occurred: %s\n', debug(e.error));
},
onclose: (e: CloseEvent) => {
console.log('Connection closed.');
},
},
});
```
*/
async connect(params) {
var _a, _b;
if (this.apiClient.isVertexAI()) {
throw new Error("Live music is not supported for Vertex AI.");
}
console.warn("Live music generation is experimental and may change in future versions.");
const websocketBaseUrl = this.apiClient.getWebsocketBaseUrl();
const apiVersion = this.apiClient.getApiVersion();
const headers = mapToHeaders$1(this.apiClient.getDefaultHeaders());
const apiKey = this.apiClient.getApiKey();
const url = `${websocketBaseUrl}/ws/google.ai.generativelanguage.${apiVersion}.GenerativeService.BidiGenerateMusic?key=${apiKey}`;
let onopenResolve = () => {
};
const onopenPromise = new Promise((resolve5) => {
onopenResolve = resolve5;
});
const callbacks = params.callbacks;
const onopenAwaitedCallback = function() {
onopenResolve({});
};
const apiClient = this.apiClient;
const websocketCallbacks = {
onopen: onopenAwaitedCallback,
onmessage: (event) => {
void handleWebSocketMessage$1(apiClient, callbacks.onmessage, event);
},
onerror: (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onerror) !== null && _a !== void 0 ? _a : function(e) {
},
onclose: (_b = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onclose) !== null && _b !== void 0 ? _b : function(e) {
}
};
const conn = this.webSocketFactory.create(url, headersToMap$1(headers), websocketCallbacks);
conn.connect();
await onopenPromise;
const model = tModel(this.apiClient, params.model);
const setup = { model };
const clientMessage = { setup };
conn.send(JSON.stringify(clientMessage));
return new LiveMusicSession(conn, this.apiClient);
}
};
var LiveMusicSession = class {
constructor(conn, apiClient) {
this.conn = conn;
this.apiClient = apiClient;
}
/**
Sets inputs to steer music generation. Updates the session's current
weighted prompts.
@param params - Contains one property, `weightedPrompts`.
- `weightedPrompts` to send to the model; weights are normalized to
sum to 1.0.
@experimental
*/
async setWeightedPrompts(params) {
if (!params.weightedPrompts || Object.keys(params.weightedPrompts).length === 0) {
throw new Error("Weighted prompts must be set and contain at least one entry.");
}
const clientContent = liveMusicSetWeightedPromptsParametersToMldev(params);
this.conn.send(JSON.stringify({ clientContent }));
}
/**
Sets a configuration to the model. Updates the session's current
music generation config.
@param params - Contains one property, `musicGenerationConfig`.
- `musicGenerationConfig` to set in the model. Passing an empty or
undefined config to the model will reset the config to defaults.
@experimental
*/
async setMusicGenerationConfig(params) {
if (!params.musicGenerationConfig) {
params.musicGenerationConfig = {};
}
const setConfigParameters = liveMusicSetConfigParametersToMldev(params);
this.conn.send(JSON.stringify(setConfigParameters));
}
sendPlaybackControl(playbackControl) {
const clientMessage = { playbackControl };
this.conn.send(JSON.stringify(clientMessage));
}
/**
* Start the music stream.
*
* @experimental
*/
play() {
this.sendPlaybackControl(LiveMusicPlaybackControl.PLAY);
}
/**
* Temporarily halt the music stream. Use `play` to resume from the current
* position.
*
* @experimental
*/
pause() {
this.sendPlaybackControl(LiveMusicPlaybackControl.PAUSE);
}
/**
* Stop the music stream and reset the state. Retains the current prompts
* and config.
*
* @experimental
*/
stop() {
this.sendPlaybackControl(LiveMusicPlaybackControl.STOP);
}
/**
* Resets the context of the music generation without stopping it.
* Retains the current prompts and config.
*
* @experimental
*/
resetContext() {
this.sendPlaybackControl(LiveMusicPlaybackControl.RESET_CONTEXT);
}
/**
Terminates the WebSocket connection.
@experimental
*/
close() {
this.conn.close();
}
};
function headersToMap$1(headers) {
const headerMap = {};
headers.forEach((value, key) => {
headerMap[key] = value;
});
return headerMap;
}
function mapToHeaders$1(map) {
const headers = new Headers();
for (const [key, value] of Object.entries(map)) {
headers.append(key, value);
}
return headers;
}
var FUNCTION_RESPONSE_REQUIRES_ID = "FunctionResponse request must have an `id` field from the response of a ToolCall.FunctionalCalls in Google AI.";
async function handleWebSocketMessage(apiClient, onmessage, event) {
const serverMessage = new LiveServerMessage();
let jsonData;
if (event.data instanceof Blob) {
jsonData = await event.data.text();
} else if (event.data instanceof ArrayBuffer) {
jsonData = new TextDecoder().decode(event.data);
} else {
jsonData = event.data;
}
const data = JSON.parse(jsonData);
if (apiClient.isVertexAI()) {
const resp = liveServerMessageFromVertex(data);
Object.assign(serverMessage, resp);
} else {
const resp = data;
Object.assign(serverMessage, resp);
}
onmessage(serverMessage);
}
var Live = class {
constructor(apiClient, auth, webSocketFactory) {
this.apiClient = apiClient;
this.auth = auth;
this.webSocketFactory = webSocketFactory;
this.music = new LiveMusic(this.apiClient, this.auth, this.webSocketFactory);
}
/**
Establishes a connection to the specified model with the given
configuration and returns a Session object representing that connection.
@experimental Built-in MCP support is an experimental feature, may change in
future versions.
@remarks
@param params - The parameters for establishing a connection to the model.
@return A live session.
@example
```ts
let model: string;
if (GOOGLE_GENAI_USE_VERTEXAI) {
model = 'gemini-2.0-flash-live-preview-04-09';
} else {
model = 'gemini-live-2.5-flash-preview';
}
const session = await ai.live.connect({
model: model,
config: {
responseModalities: [Modality.AUDIO],
},
callbacks: {
onopen: () => {
console.log('Connected to the socket.');
},
onmessage: (e: MessageEvent) => {
console.log('Received message from the server: %s\n', debug(e.data));
},
onerror: (e: ErrorEvent) => {
console.log('Error occurred: %s\n', debug(e.error));
},
onclose: (e: CloseEvent) => {
console.log('Connection closed.');
},
},
});
```
*/
async connect(params) {
var _a, _b, _c, _d, _e, _f;
if (params.config && params.config.httpOptions) {
throw new Error("The Live module does not support httpOptions at request-level in LiveConnectConfig yet. Please use the client-level httpOptions configuration instead.");
}
const websocketBaseUrl = this.apiClient.getWebsocketBaseUrl();
const apiVersion = this.apiClient.getApiVersion();
let url;
const clientHeaders = this.apiClient.getHeaders();
if (params.config && params.config.tools && hasMcpToolUsage(params.config.tools)) {
setMcpUsageHeader(clientHeaders);
}
const headers = mapToHeaders(clientHeaders);
if (this.apiClient.isVertexAI()) {
url = `${websocketBaseUrl}/ws/google.cloud.aiplatform.${apiVersion}.LlmBidiService/BidiGenerateContent`;
await this.auth.addAuthHeaders(headers, url);
} else {
const apiKey = this.apiClient.getApiKey();
let method = "BidiGenerateContent";
let keyName = "key";
if (apiKey === null || apiKey === void 0 ? void 0 : apiKey.startsWith("auth_tokens/")) {
console.warn("Warning: Ephemeral token support is experimental and may change in future versions.");
if (apiVersion !== "v1alpha") {
console.warn("Warning: The SDK's ephemeral token support is in v1alpha only. Please use const ai = new GoogleGenAI({apiKey: token.name, httpOptions: { apiVersion: 'v1alpha' }}); before session connection.");
}
method = "BidiGenerateContentConstrained";
keyName = "access_token";
}
url = `${websocketBaseUrl}/ws/google.ai.generativelanguage.${apiVersion}.GenerativeService.${method}?${keyName}=${apiKey}`;
}
let onopenResolve = () => {
};
const onopenPromise = new Promise((resolve5) => {
onopenResolve = resolve5;
});
const callbacks = params.callbacks;
const onopenAwaitedCallback = function() {
var _a2;
(_a2 = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onopen) === null || _a2 === void 0 ? void 0 : _a2.call(callbacks);
onopenResolve({});
};
const apiClient = this.apiClient;
const websocketCallbacks = {
onopen: onopenAwaitedCallback,
onmessage: (event) => {
void handleWebSocketMessage(apiClient, callbacks.onmessage, event);
},
onerror: (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onerror) !== null && _a !== void 0 ? _a : function(e) {
},
onclose: (_b = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onclose) !== null && _b !== void 0 ? _b : function(e) {
}
};
const conn = this.webSocketFactory.create(url, headersToMap(headers), websocketCallbacks);
conn.connect();
await onopenPromise;
let transformedModel = tModel(this.apiClient, params.model);
if (this.apiClient.isVertexAI() && transformedModel.startsWith("publishers/")) {
const project = this.apiClient.getProject();
const location = this.apiClient.getLocation();
transformedModel = `projects/${project}/locations/${location}/` + transformedModel;
}
let clientMessage = {};
if (this.apiClient.isVertexAI() && ((_c = params.config) === null || _c === void 0 ? void 0 : _c.responseModalities) === void 0) {
if (params.config === void 0) {
params.config = { responseModalities: [Modality.AUDIO] };
} else {
params.config.responseModalities = [Modality.AUDIO];
}
}
if ((_d = params.config) === null || _d === void 0 ? void 0 : _d.generationConfig) {
console.warn("Setting `LiveConnectConfig.generation_config` is deprecated, please set the fields on `LiveConnectConfig` directly. This will become an error in a future version (not before Q3 2025).");
}
const inputTools = (_f = (_e = params.config) === null || _e === void 0 ? void 0 : _e.tools) !== null && _f !== void 0 ? _f : [];
const convertedTools = [];
for (const tool of inputTools) {
if (this.isCallableTool(tool)) {
const callableTool = tool;
convertedTools.push(await callableTool.tool());
} else {
convertedTools.push(tool);
}
}
if (convertedTools.length > 0) {
params.config.tools = convertedTools;
}
const liveConnectParameters = {
model: transformedModel,
config: params.config,
callbacks: params.callbacks
};
if (this.apiClient.isVertexAI()) {
clientMessage = liveConnectParametersToVertex(this.apiClient, liveConnectParameters);
} else {
clientMessage = liveConnectParametersToMldev(this.apiClient, liveConnectParameters);
}
delete clientMessage["config"];
conn.send(JSON.stringify(clientMessage));
return new Session(conn, this.apiClient);
}
// TODO: b/416041229 - Abstract this method to a common place.
isCallableTool(tool) {
return "callTool" in tool && typeof tool.callTool === "function";
}
};
var defaultLiveSendClientContentParamerters = {
turnComplete: true
};
var Session = class {
constructor(conn, apiClient) {
this.conn = conn;
this.apiClient = apiClient;
}
tLiveClientContent(apiClient, params) {
if (params.turns !== null && params.turns !== void 0) {
let contents = [];
try {
contents = tContents(params.turns);
if (!apiClient.isVertexAI()) {
contents = contents.map((item) => contentToMldev$1(item));
}
} catch (_a) {
throw new Error(`Failed to parse client content "turns", type: '${typeof params.turns}'`);
}
return {
clientContent: { turns: contents, turnComplete: params.turnComplete }
};
}
return {
clientContent: { turnComplete: params.turnComplete }
};
}
tLiveClienttToolResponse(apiClient, params) {
let functionResponses = [];
if (params.functionResponses == null) {
throw new Error("functionResponses is required.");
}
if (!Array.isArray(params.functionResponses)) {
functionResponses = [params.functionResponses];
} else {
functionResponses = params.functionResponses;
}
if (functionResponses.length === 0) {
throw new Error("functionResponses is required.");
}
for (const functionResponse of functionResponses) {
if (typeof functionResponse !== "object" || functionResponse === null || !("name" in functionResponse) || !("response" in functionResponse)) {
throw new Error(`Could not parse function response, type '${typeof functionResponse}'.`);
}
if (!apiClient.isVertexAI() && !("id" in functionResponse)) {
throw new Error(FUNCTION_RESPONSE_REQUIRES_ID);
}
}
const clientMessage = {
toolResponse: { functionResponses }
};
return clientMessage;
}
/**
Send a message over the established connection.
@param params - Contains two **optional** properties, `turns` and
`turnComplete`.
- `turns` will be converted to a `Content[]`
- `turnComplete: true` [default] indicates that you are done sending
content and expect a response. If `turnComplete: false`, the server
will wait for additional messages before starting generation.
@experimental
@remarks
There are two ways to send messages to the live API:
`sendClientContent` and `sendRealtimeInput`.
`sendClientContent` messages are added to the model context **in order**.
Having a conversation using `sendClientContent` messages is roughly
equivalent to using the `Chat.sendMessageStream`, except that the state of
the `chat` history is stored on the API server instead of locally.
Because of `sendClientContent`'s order guarantee, the model cannot respons
as quickly to `sendClientContent` messages as to `sendRealtimeInput`
messages. This makes the biggest difference when sending objects that have
significant preprocessing time (typically images).
The `sendClientContent` message sends a `Content[]`
which has more options than the `Blob` sent by `sendRealtimeInput`.
So the main use-cases for `sendClientContent` over `sendRealtimeInput` are:
- Sending anything that can't be represented as a `Blob` (text,
`sendClientContent({turns="Hello?"}`)).
- Managing turns when not using audio input and voice activity detection.
(`sendClientContent({turnComplete:true})` or the short form
`sendClientContent()`)
- Prefilling a conversation context
```
sendClientContent({
turns: [
Content({role:user, parts:...}),
Content({role:user, parts:...}),
...
]
})
```
@experimental
*/
sendClientContent(params) {
params = Object.assign(Object.assign({}, defaultLiveSendClientContentParamerters), params);
const clientMessage = this.tLiveClientContent(this.apiClient, params);
this.conn.send(JSON.stringify(clientMessage));
}
/**
Send a realtime message over the established connection.
@param params - Contains one property, `media`.
- `media` will be converted to a `Blob`
@experimental
@remarks
Use `sendRealtimeInput` for realtime audio chunks and video frames (images).
With `sendRealtimeInput` the api will respond to audio automatically
based on voice activity detection (VAD).
`sendRealtimeInput` is optimized for responsivness at the expense of
deterministic ordering guarantees. Audio and video tokens are to the
context when they become available.
Note: The Call signature expects a `Blob` object, but only a subset
of audio and image mimetypes are allowed.
*/
sendRealtimeInput(params) {
let clientMessage = {};
if (this.apiClient.isVertexAI()) {
clientMessage = {
"realtimeInput": liveSendRealtimeInputParametersToVertex(params)
};
} else {
clientMessage = {
"realtimeInput": liveSendRealtimeInputParametersToMldev(params)
};
}
this.conn.send(JSON.stringify(clientMessage));
}
/**
Send a function response message over the established connection.
@param params - Contains property `functionResponses`.
- `functionResponses` will be converted to a `functionResponses[]`
@remarks
Use `sendFunctionResponse` to reply to `LiveServerToolCall` from the server.
Use {@link types.LiveConnectConfig#tools} to configure the callable functions.
@experimental
*/
sendToolResponse(params) {
if (params.functionResponses == null) {
throw new Error("Tool response parameters are required.");
}
const clientMessage = this.tLiveClienttToolResponse(this.apiClient, params);
this.conn.send(JSON.stringify(clientMessage));
}
/**
Terminates the WebSocket connection.
@experimental
@example
```ts
let model: string;
if (GOOGLE_GENAI_USE_VERTEXAI) {
model = 'gemini-2.0-flash-live-preview-04-09';
} else {
model = 'gemini-live-2.5-flash-preview';
}
const session = await ai.live.connect({
model: model,
config: {
responseModalities: [Modality.AUDIO],
}
});
session.close();
```
*/
close() {
this.conn.close();
}
};
function headersToMap(headers) {
const headerMap = {};
headers.forEach((value, key) => {
headerMap[key] = value;
});
return headerMap;
}
function mapToHeaders(map) {
const headers = new Headers();
for (const [key, value] of Object.entries(map)) {
headers.append(key, value);
}
return headers;
}
var DEFAULT_MAX_REMOTE_CALLS = 10;
function shouldDisableAfc(config) {
var _a, _b, _c;
if ((_a = config === null || config === void 0 ? void 0 : config.automaticFunctionCalling) === null || _a === void 0 ? void 0 : _a.disable) {
return true;
}
let callableToolsPresent = false;
for (const tool of (_b = config === null || config === void 0 ? void 0 : config.tools) !== null && _b !== void 0 ? _b : []) {
if (isCallableTool(tool)) {
callableToolsPresent = true;
break;
}
}
if (!callableToolsPresent) {
return true;
}
const maxCalls = (_c = config === null || config === void 0 ? void 0 : config.automaticFunctionCalling) === null || _c === void 0 ? void 0 : _c.maximumRemoteCalls;
if (maxCalls && (maxCalls < 0 || !Number.isInteger(maxCalls)) || maxCalls == 0) {
console.warn("Invalid maximumRemoteCalls value provided for automatic function calling. Disabled automatic function calling. Please provide a valid integer value greater than 0. maximumRemoteCalls provided:", maxCalls);
return true;
}
return false;
}
function isCallableTool(tool) {
return "callTool" in tool && typeof tool.callTool === "function";
}
function hasCallableTools(params) {
var _a, _b, _c;
return (_c = (_b = (_a = params.config) === null || _a === void 0 ? void 0 : _a.tools) === null || _b === void 0 ? void 0 : _b.some((tool) => isCallableTool(tool))) !== null && _c !== void 0 ? _c : false;
}
function findAfcIncompatibleToolIndexes(params) {
var _a;
const afcIncompatibleToolIndexes = [];
if (!((_a = params === null || params === void 0 ? void 0 : params.config) === null || _a === void 0 ? void 0 : _a.tools)) {
return afcIncompatibleToolIndexes;
}
params.config.tools.forEach((tool, index) => {
if (isCallableTool(tool)) {
return;
}
const geminiTool = tool;
if (geminiTool.functionDeclarations && geminiTool.functionDeclarations.length > 0) {
afcIncompatibleToolIndexes.push(index);
}
});
return afcIncompatibleToolIndexes;
}
function shouldAppendAfcHistory(config) {
var _a;
return !((_a = config === null || config === void 0 ? void 0 : config.automaticFunctionCalling) === null || _a === void 0 ? void 0 : _a.ignoreCallHistory);
}
var Models = class extends BaseModule {
constructor(apiClient) {
super();
this.apiClient = apiClient;
this.generateContent = async (params) => {
var _a, _b, _c, _d, _e;
const transformedParams = await this.processParamsMaybeAddMcpUsage(params);
this.maybeMoveToResponseJsonSchem(params);
if (!hasCallableTools(params) || shouldDisableAfc(params.config)) {
return await this.generateContentInternal(transformedParams);
}
const incompatibleToolIndexes = findAfcIncompatibleToolIndexes(params);
if (incompatibleToolIndexes.length > 0) {
const formattedIndexes = incompatibleToolIndexes.map((index) => `tools[${index}]`).join(", ");
throw new Error(`Automatic function calling with CallableTools (or MCP objects) and basic FunctionDeclarations is not yet supported. Incompatible tools found at ${formattedIndexes}.`);
}
let response;
let functionResponseContent;
const automaticFunctionCallingHistory = tContents(transformedParams.contents);
const maxRemoteCalls = (_c = (_b = (_a = transformedParams.config) === null || _a === void 0 ? void 0 : _a.automaticFunctionCalling) === null || _b === void 0 ? void 0 : _b.maximumRemoteCalls) !== null && _c !== void 0 ? _c : DEFAULT_MAX_REMOTE_CALLS;
let remoteCalls = 0;
while (remoteCalls < maxRemoteCalls) {
response = await this.generateContentInternal(transformedParams);
if (!response.functionCalls || response.functionCalls.length === 0) {
break;
}
const responseContent = response.candidates[0].content;
const functionResponseParts = [];
for (const tool of (_e = (_d = params.config) === null || _d === void 0 ? void 0 : _d.tools) !== null && _e !== void 0 ? _e : []) {
if (isCallableTool(tool)) {
const callableTool = tool;
const parts = await callableTool.callTool(response.functionCalls);
functionResponseParts.push(...parts);
}
}
remoteCalls++;
functionResponseContent = {
role: "user",
parts: functionResponseParts
};
transformedParams.contents = tContents(transformedParams.contents);
transformedParams.contents.push(responseContent);
transformedParams.contents.push(functionResponseContent);
if (shouldAppendAfcHistory(transformedParams.config)) {
automaticFunctionCallingHistory.push(responseContent);
automaticFunctionCallingHistory.push(functionResponseContent);
}
}
if (shouldAppendAfcHistory(transformedParams.config)) {
response.automaticFunctionCallingHistory = automaticFunctionCallingHistory;
}
return response;
};
this.generateContentStream = async (params) => {
var _a, _b, _c, _d, _e;
this.maybeMoveToResponseJsonSchem(params);
if (shouldDisableAfc(params.config)) {
const transformedParams = await this.processParamsMaybeAddMcpUsage(params);
return await this.generateContentStreamInternal(transformedParams);
}
const incompatibleToolIndexes = findAfcIncompatibleToolIndexes(params);
if (incompatibleToolIndexes.length > 0) {
const formattedIndexes = incompatibleToolIndexes.map((index) => `tools[${index}]`).join(", ");
throw new Error(`Incompatible tools found at ${formattedIndexes}. Automatic function calling with CallableTools (or MCP objects) and basic FunctionDeclarations" is not yet supported.`);
}
const streamFunctionCall = (_c = (_b = (_a = params === null || params === void 0 ? void 0 : params.config) === null || _a === void 0 ? void 0 : _a.toolConfig) === null || _b === void 0 ? void 0 : _b.functionCallingConfig) === null || _c === void 0 ? void 0 : _c.streamFunctionCallArguments;
const disableAfc = (_e = (_d = params === null || params === void 0 ? void 0 : params.config) === null || _d === void 0 ? void 0 : _d.automaticFunctionCalling) === null || _e === void 0 ? void 0 : _e.disable;
if (streamFunctionCall && !disableAfc) {
throw new Error("Running in streaming mode with 'streamFunctionCallArguments' enabled, this feature is not compatible with automatic function calling (AFC). Please set 'config.automaticFunctionCalling.disable' to true to disable AFC or leave 'config.toolConfig.functionCallingConfig.streamFunctionCallArguments' to be undefined or set to false to disable streaming function call arguments feature.");
}
return await this.processAfcStream(params);
};
this.generateImages = async (params) => {
return await this.generateImagesInternal(params).then((apiResponse) => {
var _a;
let positivePromptSafetyAttributes;
const generatedImages = [];
if (apiResponse === null || apiResponse === void 0 ? void 0 : apiResponse.generatedImages) {
for (const generatedImage of apiResponse.generatedImages) {
if (generatedImage && (generatedImage === null || generatedImage === void 0 ? void 0 : generatedImage.safetyAttributes) && ((_a = generatedImage === null || generatedImage === void 0 ? void 0 : generatedImage.safetyAttributes) === null || _a === void 0 ? void 0 : _a.contentType) === "Positive Prompt") {
positivePromptSafetyAttributes = generatedImage === null || generatedImage === void 0 ? void 0 : generatedImage.safetyAttributes;
} else {
generatedImages.push(generatedImage);
}
}
}
let response;
if (positivePromptSafetyAttributes) {
response = {
generatedImages,
positivePromptSafetyAttributes,
sdkHttpResponse: apiResponse.sdkHttpResponse
};
} else {
response = {
generatedImages,
sdkHttpResponse: apiResponse.sdkHttpResponse
};
}
return response;
});
};
this.list = async (params) => {
var _a;
const defaultConfig = {
queryBase: true
};
const actualConfig = Object.assign(Object.assign({}, defaultConfig), params === null || params === void 0 ? void 0 : params.config);
const actualParams = {
config: actualConfig
};
if (this.apiClient.isVertexAI()) {
if (!actualParams.config.queryBase) {
if ((_a = actualParams.config) === null || _a === void 0 ? void 0 : _a.filter) {
throw new Error("Filtering tuned models list for Vertex AI is not currently supported");
} else {
actualParams.config.filter = "labels.tune-type:*";
}
}
}
return new Pager(PagedItem.PAGED_ITEM_MODELS, (x) => this.listInternal(x), await this.listInternal(actualParams), actualParams);
};
this.editImage = async (params) => {
const paramsInternal = {
model: params.model,
prompt: params.prompt,
referenceImages: [],
config: params.config
};
if (params.referenceImages) {
if (params.referenceImages) {
paramsInternal.referenceImages = params.referenceImages.map((img) => img.toReferenceImageAPI());
}
}
return await this.editImageInternal(paramsInternal);
};
this.upscaleImage = async (params) => {
let apiConfig = {
numberOfImages: 1,
mode: "upscale"
};
if (params.config) {
apiConfig = Object.assign(Object.assign({}, apiConfig), params.config);
}
const apiParams = {
model: params.model,
image: params.image,
upscaleFactor: params.upscaleFactor,
config: apiConfig
};
return await this.upscaleImageInternal(apiParams);
};
this.generateVideos = async (params) => {
var _a, _b, _c, _d, _e, _f;
if ((params.prompt || params.image || params.video) && params.source) {
throw new Error("Source and prompt/image/video are mutually exclusive. Please only use source.");
}
if (!this.apiClient.isVertexAI()) {
if (((_a = params.video) === null || _a === void 0 ? void 0 : _a.uri) && ((_b = params.video) === null || _b === void 0 ? void 0 : _b.videoBytes)) {
params.video = {
uri: params.video.uri,
mimeType: params.video.mimeType
};
} else if (((_d = (_c = params.source) === null || _c === void 0 ? void 0 : _c.video) === null || _d === void 0 ? void 0 : _d.uri) && ((_f = (_e = params.source) === null || _e === void 0 ? void 0 : _e.video) === null || _f === void 0 ? void 0 : _f.videoBytes)) {
params.source.video = {
uri: params.source.video.uri,
mimeType: params.source.video.mimeType
};
}
}
return await this.generateVideosInternal(params);
};
}
/**
* This logic is needed for GenerateContentConfig only.
* Previously we made GenerateContentConfig.responseSchema field to accept
* unknown. Since v1.9.0, we switch to use backend JSON schema support.
* To maintain backward compatibility, we move the data that was treated as
* JSON schema from the responseSchema field to the responseJsonSchema field.
*/
maybeMoveToResponseJsonSchem(params) {
if (params.config && params.config.responseSchema) {
if (!params.config.responseJsonSchema) {
if (Object.keys(params.config.responseSchema).includes("$schema")) {
params.config.responseJsonSchema = params.config.responseSchema;
delete params.config.responseSchema;
}
}
}
return;
}
/**
* Transforms the CallableTools in the parameters to be simply Tools, it
* copies the params into a new object and replaces the tools, it does not
* modify the original params. Also sets the MCP usage header if there are
* MCP tools in the parameters.
*/
async processParamsMaybeAddMcpUsage(params) {
var _a, _b, _c;
const tools = (_a = params.config) === null || _a === void 0 ? void 0 : _a.tools;
if (!tools) {
return params;
}
const transformedTools = await Promise.all(tools.map(async (tool) => {
if (isCallableTool(tool)) {
const callableTool = tool;
return await callableTool.tool();
}
return tool;
}));
const newParams = {
model: params.model,
contents: params.contents,
config: Object.assign(Object.assign({}, params.config), { tools: transformedTools })
};
newParams.config.tools = transformedTools;
if (params.config && params.config.tools && hasMcpToolUsage(params.config.tools)) {
const headers = (_c = (_b = params.config.httpOptions) === null || _b === void 0 ? void 0 : _b.headers) !== null && _c !== void 0 ? _c : {};
let newHeaders = Object.assign({}, headers);
if (Object.keys(newHeaders).length === 0) {
newHeaders = this.apiClient.getDefaultHeaders();
}
setMcpUsageHeader(newHeaders);
newParams.config.httpOptions = Object.assign(Object.assign({}, params.config.httpOptions), { headers: newHeaders });
}
return newParams;
}
async initAfcToolsMap(params) {
var _a, _b, _c;
const afcTools = /* @__PURE__ */ new Map();
for (const tool of (_b = (_a = params.config) === null || _a === void 0 ? void 0 : _a.tools) !== null && _b !== void 0 ? _b : []) {
if (isCallableTool(tool)) {
const callableTool = tool;
const toolDeclaration = await callableTool.tool();
for (const declaration of (_c = toolDeclaration.functionDeclarations) !== null && _c !== void 0 ? _c : []) {
if (!declaration.name) {
throw new Error("Function declaration name is required.");
}
if (afcTools.has(declaration.name)) {
throw new Error(`Duplicate tool declaration name: ${declaration.name}`);
}
afcTools.set(declaration.name, callableTool);
}
}
}
return afcTools;
}
async processAfcStream(params) {
var _a, _b, _c;
const maxRemoteCalls = (_c = (_b = (_a = params.config) === null || _a === void 0 ? void 0 : _a.automaticFunctionCalling) === null || _b === void 0 ? void 0 : _b.maximumRemoteCalls) !== null && _c !== void 0 ? _c : DEFAULT_MAX_REMOTE_CALLS;
let wereFunctionsCalled = false;
let remoteCallCount = 0;
const afcToolsMap = await this.initAfcToolsMap(params);
return function(models, afcTools, params2) {
var _a2, _b2;
return __asyncGenerator(this, arguments, function* () {
var _c2, e_1, _d, _e;
while (remoteCallCount < maxRemoteCalls) {
if (wereFunctionsCalled) {
remoteCallCount++;
wereFunctionsCalled = false;
}
const transformedParams = yield __await(models.processParamsMaybeAddMcpUsage(params2));
const response = yield __await(models.generateContentStreamInternal(transformedParams));
const functionResponses = [];
const responseContents = [];
try {
for (var _f = true, response_1 = (e_1 = void 0, __asyncValues(response)), response_1_1; response_1_1 = yield __await(response_1.next()), _c2 = response_1_1.done, !_c2; _f = true) {
_e = response_1_1.value;
_f = false;
const chunk = _e;
yield yield __await(chunk);
if (chunk.candidates && ((_a2 = chunk.candidates[0]) === null || _a2 === void 0 ? void 0 : _a2.content)) {
responseContents.push(chunk.candidates[0].content);
for (const part of (_b2 = chunk.candidates[0].content.parts) !== null && _b2 !== void 0 ? _b2 : []) {
if (remoteCallCount < maxRemoteCalls && part.functionCall) {
if (!part.functionCall.name) {
throw new Error("Function call name was not returned by the model.");
}
if (!afcTools.has(part.functionCall.name)) {
throw new Error(`Automatic function calling was requested, but not all the tools the model used implement the CallableTool interface. Available tools: ${afcTools.keys()}, mising tool: ${part.functionCall.name}`);
} else {
const responseParts = yield __await(afcTools.get(part.functionCall.name).callTool([part.functionCall]));
functionResponses.push(...responseParts);
}
}
}
}
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (!_f && !_c2 && (_d = response_1.return)) yield __await(_d.call(response_1));
} finally {
if (e_1) throw e_1.error;
}
}
if (functionResponses.length > 0) {
wereFunctionsCalled = true;
const typedResponseChunk = new GenerateContentResponse();
typedResponseChunk.candidates = [
{
content: {
role: "user",
parts: functionResponses
}
}
];
yield yield __await(typedResponseChunk);
const newContents = [];
newContents.push(...responseContents);
newContents.push({
role: "user",
parts: functionResponses
});
const updatedContents = tContents(params2.contents).concat(newContents);
params2.contents = updatedContents;
} else {
break;
}
}
});
}(this, afcToolsMap, params);
}
async generateContentInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = generateContentParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}:generateContent", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = generateContentResponseFromVertex(apiResponse);
const typedResp = new GenerateContentResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = generateContentParametersToMldev(this.apiClient, params);
path10 = formatMap("{model}:generateContent", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = generateContentResponseFromMldev(apiResponse);
const typedResp = new GenerateContentResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
async generateContentStreamInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = generateContentParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}:streamGenerateContent?alt=sse", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
const apiClient = this.apiClient;
response = apiClient.requestStream({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
});
return response.then(function(apiResponse) {
return __asyncGenerator(this, arguments, function* () {
var _a2, e_2, _b2, _c2;
try {
for (var _d2 = true, apiResponse_1 = __asyncValues(apiResponse), apiResponse_1_1; apiResponse_1_1 = yield __await(apiResponse_1.next()), _a2 = apiResponse_1_1.done, !_a2; _d2 = true) {
_c2 = apiResponse_1_1.value;
_d2 = false;
const chunk = _c2;
const resp = generateContentResponseFromVertex(yield __await(chunk.json()));
resp["sdkHttpResponse"] = {
headers: chunk.headers
};
const typedResp = new GenerateContentResponse();
Object.assign(typedResp, resp);
yield yield __await(typedResp);
}
} catch (e_2_1) {
e_2 = { error: e_2_1 };
} finally {
try {
if (!_d2 && !_a2 && (_b2 = apiResponse_1.return)) yield __await(_b2.call(apiResponse_1));
} finally {
if (e_2) throw e_2.error;
}
}
});
});
} else {
const body = generateContentParametersToMldev(this.apiClient, params);
path10 = formatMap("{model}:streamGenerateContent?alt=sse", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
const apiClient = this.apiClient;
response = apiClient.requestStream({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
});
return response.then(function(apiResponse) {
return __asyncGenerator(this, arguments, function* () {
var _a2, e_3, _b2, _c2;
try {
for (var _d2 = true, apiResponse_2 = __asyncValues(apiResponse), apiResponse_2_1; apiResponse_2_1 = yield __await(apiResponse_2.next()), _a2 = apiResponse_2_1.done, !_a2; _d2 = true) {
_c2 = apiResponse_2_1.value;
_d2 = false;
const chunk = _c2;
const resp = generateContentResponseFromMldev(yield __await(chunk.json()));
resp["sdkHttpResponse"] = {
headers: chunk.headers
};
const typedResp = new GenerateContentResponse();
Object.assign(typedResp, resp);
yield yield __await(typedResp);
}
} catch (e_3_1) {
e_3 = { error: e_3_1 };
} finally {
try {
if (!_d2 && !_a2 && (_b2 = apiResponse_2.return)) yield __await(_b2.call(apiResponse_2));
} finally {
if (e_3) throw e_3.error;
}
}
});
});
}
}
/**
* Calculates embeddings for the given contents. Only text is supported.
*
* @param params - The parameters for embedding contents.
* @return The response from the API.
*
* @example
* ```ts
* const response = await ai.models.embedContent({
* model: 'text-embedding-004',
* contents: [
* 'What is your name?',
* 'What is your favorite color?',
* ],
* config: {
* outputDimensionality: 64,
* },
* });
* console.log(response);
* ```
*/
async embedContent(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = embedContentParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}:predict", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = embedContentResponseFromVertex(apiResponse);
const typedResp = new EmbedContentResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = embedContentParametersToMldev(this.apiClient, params);
path10 = formatMap("{model}:batchEmbedContents", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = embedContentResponseFromMldev(apiResponse);
const typedResp = new EmbedContentResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Private method for generating images.
*/
async generateImagesInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = generateImagesParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}:predict", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = generateImagesResponseFromVertex(apiResponse);
const typedResp = new GenerateImagesResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = generateImagesParametersToMldev(this.apiClient, params);
path10 = formatMap("{model}:predict", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = generateImagesResponseFromMldev(apiResponse);
const typedResp = new GenerateImagesResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Private method for editing an image.
*/
async editImageInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = editImageParametersInternalToVertex(this.apiClient, params);
path10 = formatMap("{model}:predict", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = editImageResponseFromVertex(apiResponse);
const typedResp = new EditImageResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
throw new Error("This method is only supported by the Vertex AI.");
}
}
/**
* Private method for upscaling an image.
*/
async upscaleImageInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = upscaleImageAPIParametersInternalToVertex(this.apiClient, params);
path10 = formatMap("{model}:predict", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = upscaleImageResponseFromVertex(apiResponse);
const typedResp = new UpscaleImageResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
throw new Error("This method is only supported by the Vertex AI.");
}
}
/**
* Recontextualizes an image.
*
* There are two types of recontextualization currently supported:
* 1) Imagen Product Recontext - Generate images of products in new scenes
* and contexts.
* 2) Virtual Try-On: Generate images of persons modeling fashion products.
*
* @param params - The parameters for recontextualizing an image.
* @return The response from the API.
*
* @example
* ```ts
* const response1 = await ai.models.recontextImage({
* model: 'imagen-product-recontext-preview-06-30',
* source: {
* prompt: 'In a modern kitchen setting.',
* productImages: [productImage],
* },
* config: {
* numberOfImages: 1,
* },
* });
* console.log(response1?.generatedImages?.[0]?.image?.imageBytes);
*
* const response2 = await ai.models.recontextImage({
* model: 'virtual-try-on-preview-08-04',
* source: {
* personImage: personImage,
* productImages: [productImage],
* },
* config: {
* numberOfImages: 1,
* },
* });
* console.log(response2?.generatedImages?.[0]?.image?.imageBytes);
* ```
*/
async recontextImage(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = recontextImageParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}:predict", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = recontextImageResponseFromVertex(apiResponse);
const typedResp = new RecontextImageResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
throw new Error("This method is only supported by the Vertex AI.");
}
}
/**
* Segments an image, creating a mask of a specified area.
*
* @param params - The parameters for segmenting an image.
* @return The response from the API.
*
* @example
* ```ts
* const response = await ai.models.segmentImage({
* model: 'image-segmentation-001',
* source: {
* image: image,
* },
* config: {
* mode: 'foreground',
* },
* });
* console.log(response?.generatedMasks?.[0]?.mask?.imageBytes);
* ```
*/
async segmentImage(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = segmentImageParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}:predict", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = segmentImageResponseFromVertex(apiResponse);
const typedResp = new SegmentImageResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
throw new Error("This method is only supported by the Vertex AI.");
}
}
/**
* Fetches information about a model by name.
*
* @example
* ```ts
* const modelInfo = await ai.models.get({model: 'gemini-2.0-flash'});
* ```
*/
async get(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = getModelParametersToVertex(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = modelFromVertex(apiResponse);
return resp;
});
} else {
const body = getModelParametersToMldev(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = modelFromMldev(apiResponse);
return resp;
});
}
}
async listInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = listModelsParametersToVertex(this.apiClient, params);
path10 = formatMap("{models_url}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = listModelsResponseFromVertex(apiResponse);
const typedResp = new ListModelsResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = listModelsParametersToMldev(this.apiClient, params);
path10 = formatMap("{models_url}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = listModelsResponseFromMldev(apiResponse);
const typedResp = new ListModelsResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Updates a tuned model by its name.
*
* @param params - The parameters for updating the model.
* @return The response from the API.
*
* @example
* ```ts
* const response = await ai.models.update({
* model: 'tuned-model-name',
* config: {
* displayName: 'New display name',
* description: 'New description',
* },
* });
* ```
*/
async update(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = updateModelParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "PATCH",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = modelFromVertex(apiResponse);
return resp;
});
} else {
const body = updateModelParametersToMldev(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "PATCH",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = modelFromMldev(apiResponse);
return resp;
});
}
}
/**
* Deletes a tuned model by its name.
*
* @param params - The parameters for deleting the model.
* @return The response from the API.
*
* @example
* ```ts
* const response = await ai.models.delete({model: 'tuned-model-name'});
* ```
*/
async delete(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = deleteModelParametersToVertex(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "DELETE",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = deleteModelResponseFromVertex(apiResponse);
const typedResp = new DeleteModelResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = deleteModelParametersToMldev(this.apiClient, params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "DELETE",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = deleteModelResponseFromMldev(apiResponse);
const typedResp = new DeleteModelResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Counts the number of tokens in the given contents. Multimodal input is
* supported for Gemini models.
*
* @param params - The parameters for counting tokens.
* @return The response from the API.
*
* @example
* ```ts
* const response = await ai.models.countTokens({
* model: 'gemini-2.0-flash',
* contents: 'The quick brown fox jumps over the lazy dog.'
* });
* console.log(response);
* ```
*/
async countTokens(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = countTokensParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}:countTokens", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = countTokensResponseFromVertex(apiResponse);
const typedResp = new CountTokensResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = countTokensParametersToMldev(this.apiClient, params);
path10 = formatMap("{model}:countTokens", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = countTokensResponseFromMldev(apiResponse);
const typedResp = new CountTokensResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Given a list of contents, returns a corresponding TokensInfo containing
* the list of tokens and list of token ids.
*
* This method is not supported by the Gemini Developer API.
*
* @param params - The parameters for computing tokens.
* @return The response from the API.
*
* @example
* ```ts
* const response = await ai.models.computeTokens({
* model: 'gemini-2.0-flash',
* contents: 'What is your name?'
* });
* console.log(response);
* ```
*/
async computeTokens(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = computeTokensParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}:computeTokens", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = computeTokensResponseFromVertex(apiResponse);
const typedResp = new ComputeTokensResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
throw new Error("This method is only supported by the Vertex AI.");
}
}
/**
* Private method for generating videos.
*/
async generateVideosInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = generateVideosParametersToVertex(this.apiClient, params);
path10 = formatMap("{model}:predictLongRunning", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = generateVideosOperationFromVertex(apiResponse);
const typedResp = new GenerateVideosOperation();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = generateVideosParametersToMldev(this.apiClient, params);
path10 = formatMap("{model}:predictLongRunning", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = generateVideosOperationFromMldev(apiResponse);
const typedResp = new GenerateVideosOperation();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
};
var Operations = class extends BaseModule {
constructor(apiClient) {
super();
this.apiClient = apiClient;
}
/**
* Gets the status of a long-running operation.
*
* @param parameters The parameters for the get operation request.
* @return The updated Operation object, with the latest status or result.
*/
async getVideosOperation(parameters) {
const operation = parameters.operation;
const config = parameters.config;
if (operation.name === void 0 || operation.name === "") {
throw new Error("Operation name is required.");
}
if (this.apiClient.isVertexAI()) {
const resourceName2 = operation.name.split("/operations/")[0];
let httpOptions = void 0;
if (config && "httpOptions" in config) {
httpOptions = config.httpOptions;
}
const rawOperation = await this.fetchPredictVideosOperationInternal({
operationName: operation.name,
resourceName: resourceName2,
config: { httpOptions }
});
return operation._fromAPIResponse({
apiResponse: rawOperation,
_isVertexAI: true
});
} else {
const rawOperation = await this.getVideosOperationInternal({
operationName: operation.name,
config
});
return operation._fromAPIResponse({
apiResponse: rawOperation,
_isVertexAI: false
});
}
}
/**
* Gets the status of a long-running operation.
*
* @param parameters The parameters for the get operation request.
* @return The updated Operation object, with the latest status or result.
*/
async get(parameters) {
const operation = parameters.operation;
const config = parameters.config;
if (operation.name === void 0 || operation.name === "") {
throw new Error("Operation name is required.");
}
if (this.apiClient.isVertexAI()) {
const resourceName2 = operation.name.split("/operations/")[0];
let httpOptions = void 0;
if (config && "httpOptions" in config) {
httpOptions = config.httpOptions;
}
const rawOperation = await this.fetchPredictVideosOperationInternal({
operationName: operation.name,
resourceName: resourceName2,
config: { httpOptions }
});
return operation._fromAPIResponse({
apiResponse: rawOperation,
_isVertexAI: true
});
} else {
const rawOperation = await this.getVideosOperationInternal({
operationName: operation.name,
config
});
return operation._fromAPIResponse({
apiResponse: rawOperation,
_isVertexAI: false
});
}
}
async getVideosOperationInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = getOperationParametersToVertex(params);
path10 = formatMap("{operationName}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response;
} else {
const body = getOperationParametersToMldev(params);
path10 = formatMap("{operationName}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response;
}
}
async fetchPredictVideosOperationInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = fetchPredictOperationParametersToVertex(params);
path10 = formatMap("{resourceName}:fetchPredictOperation", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response;
} else {
throw new Error("This method is only supported by the Vertex AI.");
}
}
};
function blobToMldev(fromObject) {
const toObject = {};
const fromData = getValueByPath(fromObject, ["data"]);
if (fromData != null) {
setValueByPath(toObject, ["data"], fromData);
}
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function contentToMldev(fromObject) {
const toObject = {};
const fromParts = getValueByPath(fromObject, ["parts"]);
if (fromParts != null) {
let transformedList = fromParts;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return partToMldev(item);
});
}
setValueByPath(toObject, ["parts"], transformedList);
}
const fromRole = getValueByPath(fromObject, ["role"]);
if (fromRole != null) {
setValueByPath(toObject, ["role"], fromRole);
}
return toObject;
}
function createAuthTokenConfigToMldev(apiClient, fromObject, parentObject) {
const toObject = {};
const fromExpireTime = getValueByPath(fromObject, ["expireTime"]);
if (parentObject !== void 0 && fromExpireTime != null) {
setValueByPath(parentObject, ["expireTime"], fromExpireTime);
}
const fromNewSessionExpireTime = getValueByPath(fromObject, [
"newSessionExpireTime"
]);
if (parentObject !== void 0 && fromNewSessionExpireTime != null) {
setValueByPath(parentObject, ["newSessionExpireTime"], fromNewSessionExpireTime);
}
const fromUses = getValueByPath(fromObject, ["uses"]);
if (parentObject !== void 0 && fromUses != null) {
setValueByPath(parentObject, ["uses"], fromUses);
}
const fromLiveConnectConstraints = getValueByPath(fromObject, [
"liveConnectConstraints"
]);
if (parentObject !== void 0 && fromLiveConnectConstraints != null) {
setValueByPath(parentObject, ["bidiGenerateContentSetup"], liveConnectConstraintsToMldev(apiClient, fromLiveConnectConstraints));
}
const fromLockAdditionalFields = getValueByPath(fromObject, [
"lockAdditionalFields"
]);
if (parentObject !== void 0 && fromLockAdditionalFields != null) {
setValueByPath(parentObject, ["fieldMask"], fromLockAdditionalFields);
}
return toObject;
}
function createAuthTokenParametersToMldev(apiClient, fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
setValueByPath(toObject, ["config"], createAuthTokenConfigToMldev(apiClient, fromConfig, toObject));
}
return toObject;
}
function fileDataToMldev(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["displayName"]) !== void 0) {
throw new Error("displayName parameter is not supported in Gemini API.");
}
const fromFileUri = getValueByPath(fromObject, ["fileUri"]);
if (fromFileUri != null) {
setValueByPath(toObject, ["fileUri"], fromFileUri);
}
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (fromMimeType != null) {
setValueByPath(toObject, ["mimeType"], fromMimeType);
}
return toObject;
}
function functionCallToMldev(fromObject) {
const toObject = {};
const fromId = getValueByPath(fromObject, ["id"]);
if (fromId != null) {
setValueByPath(toObject, ["id"], fromId);
}
const fromArgs = getValueByPath(fromObject, ["args"]);
if (fromArgs != null) {
setValueByPath(toObject, ["args"], fromArgs);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
if (getValueByPath(fromObject, ["partialArgs"]) !== void 0) {
throw new Error("partialArgs parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["willContinue"]) !== void 0) {
throw new Error("willContinue parameter is not supported in Gemini API.");
}
return toObject;
}
function googleMapsToMldev(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["authConfig"]) !== void 0) {
throw new Error("authConfig parameter is not supported in Gemini API.");
}
const fromEnableWidget = getValueByPath(fromObject, ["enableWidget"]);
if (fromEnableWidget != null) {
setValueByPath(toObject, ["enableWidget"], fromEnableWidget);
}
return toObject;
}
function googleSearchToMldev(fromObject) {
const toObject = {};
if (getValueByPath(fromObject, ["excludeDomains"]) !== void 0) {
throw new Error("excludeDomains parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["blockingConfidence"]) !== void 0) {
throw new Error("blockingConfidence parameter is not supported in Gemini API.");
}
const fromTimeRangeFilter = getValueByPath(fromObject, [
"timeRangeFilter"
]);
if (fromTimeRangeFilter != null) {
setValueByPath(toObject, ["timeRangeFilter"], fromTimeRangeFilter);
}
return toObject;
}
function liveConnectConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromGenerationConfig = getValueByPath(fromObject, [
"generationConfig"
]);
if (parentObject !== void 0 && fromGenerationConfig != null) {
setValueByPath(parentObject, ["setup", "generationConfig"], fromGenerationConfig);
}
const fromResponseModalities = getValueByPath(fromObject, [
"responseModalities"
]);
if (parentObject !== void 0 && fromResponseModalities != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "responseModalities"], fromResponseModalities);
}
const fromTemperature = getValueByPath(fromObject, ["temperature"]);
if (parentObject !== void 0 && fromTemperature != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "temperature"], fromTemperature);
}
const fromTopP = getValueByPath(fromObject, ["topP"]);
if (parentObject !== void 0 && fromTopP != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "topP"], fromTopP);
}
const fromTopK = getValueByPath(fromObject, ["topK"]);
if (parentObject !== void 0 && fromTopK != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "topK"], fromTopK);
}
const fromMaxOutputTokens = getValueByPath(fromObject, [
"maxOutputTokens"
]);
if (parentObject !== void 0 && fromMaxOutputTokens != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "maxOutputTokens"], fromMaxOutputTokens);
}
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (parentObject !== void 0 && fromMediaResolution != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "mediaResolution"], fromMediaResolution);
}
const fromSeed = getValueByPath(fromObject, ["seed"]);
if (parentObject !== void 0 && fromSeed != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "seed"], fromSeed);
}
const fromSpeechConfig = getValueByPath(fromObject, ["speechConfig"]);
if (parentObject !== void 0 && fromSpeechConfig != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "speechConfig"], tLiveSpeechConfig(fromSpeechConfig));
}
const fromThinkingConfig = getValueByPath(fromObject, [
"thinkingConfig"
]);
if (parentObject !== void 0 && fromThinkingConfig != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "thinkingConfig"], fromThinkingConfig);
}
const fromEnableAffectiveDialog = getValueByPath(fromObject, [
"enableAffectiveDialog"
]);
if (parentObject !== void 0 && fromEnableAffectiveDialog != null) {
setValueByPath(parentObject, ["setup", "generationConfig", "enableAffectiveDialog"], fromEnableAffectiveDialog);
}
const fromSystemInstruction = getValueByPath(fromObject, [
"systemInstruction"
]);
if (parentObject !== void 0 && fromSystemInstruction != null) {
setValueByPath(parentObject, ["setup", "systemInstruction"], contentToMldev(tContent(fromSystemInstruction)));
}
const fromTools = getValueByPath(fromObject, ["tools"]);
if (parentObject !== void 0 && fromTools != null) {
let transformedList = tTools(fromTools);
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return toolToMldev(tTool(item));
});
}
setValueByPath(parentObject, ["setup", "tools"], transformedList);
}
const fromSessionResumption = getValueByPath(fromObject, [
"sessionResumption"
]);
if (parentObject !== void 0 && fromSessionResumption != null) {
setValueByPath(parentObject, ["setup", "sessionResumption"], sessionResumptionConfigToMldev(fromSessionResumption));
}
const fromInputAudioTranscription = getValueByPath(fromObject, [
"inputAudioTranscription"
]);
if (parentObject !== void 0 && fromInputAudioTranscription != null) {
setValueByPath(parentObject, ["setup", "inputAudioTranscription"], fromInputAudioTranscription);
}
const fromOutputAudioTranscription = getValueByPath(fromObject, [
"outputAudioTranscription"
]);
if (parentObject !== void 0 && fromOutputAudioTranscription != null) {
setValueByPath(parentObject, ["setup", "outputAudioTranscription"], fromOutputAudioTranscription);
}
const fromRealtimeInputConfig = getValueByPath(fromObject, [
"realtimeInputConfig"
]);
if (parentObject !== void 0 && fromRealtimeInputConfig != null) {
setValueByPath(parentObject, ["setup", "realtimeInputConfig"], fromRealtimeInputConfig);
}
const fromContextWindowCompression = getValueByPath(fromObject, [
"contextWindowCompression"
]);
if (parentObject !== void 0 && fromContextWindowCompression != null) {
setValueByPath(parentObject, ["setup", "contextWindowCompression"], fromContextWindowCompression);
}
const fromProactivity = getValueByPath(fromObject, ["proactivity"]);
if (parentObject !== void 0 && fromProactivity != null) {
setValueByPath(parentObject, ["setup", "proactivity"], fromProactivity);
}
return toObject;
}
function liveConnectConstraintsToMldev(apiClient, fromObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["model"]);
if (fromModel != null) {
setValueByPath(toObject, ["setup", "model"], tModel(apiClient, fromModel));
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
setValueByPath(toObject, ["config"], liveConnectConfigToMldev(fromConfig, toObject));
}
return toObject;
}
function partToMldev(fromObject) {
const toObject = {};
const fromMediaResolution = getValueByPath(fromObject, [
"mediaResolution"
]);
if (fromMediaResolution != null) {
setValueByPath(toObject, ["mediaResolution"], fromMediaResolution);
}
const fromCodeExecutionResult = getValueByPath(fromObject, [
"codeExecutionResult"
]);
if (fromCodeExecutionResult != null) {
setValueByPath(toObject, ["codeExecutionResult"], fromCodeExecutionResult);
}
const fromExecutableCode = getValueByPath(fromObject, [
"executableCode"
]);
if (fromExecutableCode != null) {
setValueByPath(toObject, ["executableCode"], fromExecutableCode);
}
const fromFileData = getValueByPath(fromObject, ["fileData"]);
if (fromFileData != null) {
setValueByPath(toObject, ["fileData"], fileDataToMldev(fromFileData));
}
const fromFunctionCall = getValueByPath(fromObject, ["functionCall"]);
if (fromFunctionCall != null) {
setValueByPath(toObject, ["functionCall"], functionCallToMldev(fromFunctionCall));
}
const fromFunctionResponse = getValueByPath(fromObject, [
"functionResponse"
]);
if (fromFunctionResponse != null) {
setValueByPath(toObject, ["functionResponse"], fromFunctionResponse);
}
const fromInlineData = getValueByPath(fromObject, ["inlineData"]);
if (fromInlineData != null) {
setValueByPath(toObject, ["inlineData"], blobToMldev(fromInlineData));
}
const fromText = getValueByPath(fromObject, ["text"]);
if (fromText != null) {
setValueByPath(toObject, ["text"], fromText);
}
const fromThought = getValueByPath(fromObject, ["thought"]);
if (fromThought != null) {
setValueByPath(toObject, ["thought"], fromThought);
}
const fromThoughtSignature = getValueByPath(fromObject, [
"thoughtSignature"
]);
if (fromThoughtSignature != null) {
setValueByPath(toObject, ["thoughtSignature"], fromThoughtSignature);
}
const fromVideoMetadata = getValueByPath(fromObject, [
"videoMetadata"
]);
if (fromVideoMetadata != null) {
setValueByPath(toObject, ["videoMetadata"], fromVideoMetadata);
}
return toObject;
}
function sessionResumptionConfigToMldev(fromObject) {
const toObject = {};
const fromHandle = getValueByPath(fromObject, ["handle"]);
if (fromHandle != null) {
setValueByPath(toObject, ["handle"], fromHandle);
}
if (getValueByPath(fromObject, ["transparent"]) !== void 0) {
throw new Error("transparent parameter is not supported in Gemini API.");
}
return toObject;
}
function toolToMldev(fromObject) {
const toObject = {};
const fromFunctionDeclarations = getValueByPath(fromObject, [
"functionDeclarations"
]);
if (fromFunctionDeclarations != null) {
let transformedList = fromFunctionDeclarations;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["functionDeclarations"], transformedList);
}
if (getValueByPath(fromObject, ["retrieval"]) !== void 0) {
throw new Error("retrieval parameter is not supported in Gemini API.");
}
const fromGoogleSearchRetrieval = getValueByPath(fromObject, [
"googleSearchRetrieval"
]);
if (fromGoogleSearchRetrieval != null) {
setValueByPath(toObject, ["googleSearchRetrieval"], fromGoogleSearchRetrieval);
}
const fromComputerUse = getValueByPath(fromObject, ["computerUse"]);
if (fromComputerUse != null) {
setValueByPath(toObject, ["computerUse"], fromComputerUse);
}
const fromFileSearch = getValueByPath(fromObject, ["fileSearch"]);
if (fromFileSearch != null) {
setValueByPath(toObject, ["fileSearch"], fromFileSearch);
}
const fromCodeExecution = getValueByPath(fromObject, [
"codeExecution"
]);
if (fromCodeExecution != null) {
setValueByPath(toObject, ["codeExecution"], fromCodeExecution);
}
if (getValueByPath(fromObject, ["enterpriseWebSearch"]) !== void 0) {
throw new Error("enterpriseWebSearch parameter is not supported in Gemini API.");
}
const fromGoogleMaps = getValueByPath(fromObject, ["googleMaps"]);
if (fromGoogleMaps != null) {
setValueByPath(toObject, ["googleMaps"], googleMapsToMldev(fromGoogleMaps));
}
const fromGoogleSearch = getValueByPath(fromObject, ["googleSearch"]);
if (fromGoogleSearch != null) {
setValueByPath(toObject, ["googleSearch"], googleSearchToMldev(fromGoogleSearch));
}
const fromUrlContext = getValueByPath(fromObject, ["urlContext"]);
if (fromUrlContext != null) {
setValueByPath(toObject, ["urlContext"], fromUrlContext);
}
return toObject;
}
function getFieldMasks(setup) {
const fields = [];
for (const key in setup) {
if (Object.prototype.hasOwnProperty.call(setup, key)) {
const value = setup[key];
if (typeof value === "object" && value != null && Object.keys(value).length > 0) {
const field = Object.keys(value).map((kk) => `${key}.${kk}`);
fields.push(...field);
} else {
fields.push(key);
}
}
}
return fields.join(",");
}
function convertBidiSetupToTokenSetup(requestDict, config) {
let setupForMaskGeneration = null;
const bidiGenerateContentSetupValue = requestDict["bidiGenerateContentSetup"];
if (typeof bidiGenerateContentSetupValue === "object" && bidiGenerateContentSetupValue !== null && "setup" in bidiGenerateContentSetupValue) {
const innerSetup = bidiGenerateContentSetupValue.setup;
if (typeof innerSetup === "object" && innerSetup !== null) {
requestDict["bidiGenerateContentSetup"] = innerSetup;
setupForMaskGeneration = innerSetup;
} else {
delete requestDict["bidiGenerateContentSetup"];
}
} else if (bidiGenerateContentSetupValue !== void 0) {
delete requestDict["bidiGenerateContentSetup"];
}
const preExistingFieldMask = requestDict["fieldMask"];
if (setupForMaskGeneration) {
const generatedMaskFromBidi = getFieldMasks(setupForMaskGeneration);
if (Array.isArray(config === null || config === void 0 ? void 0 : config.lockAdditionalFields) && (config === null || config === void 0 ? void 0 : config.lockAdditionalFields.length) === 0) {
if (generatedMaskFromBidi) {
requestDict["fieldMask"] = generatedMaskFromBidi;
} else {
delete requestDict["fieldMask"];
}
} else if ((config === null || config === void 0 ? void 0 : config.lockAdditionalFields) && config.lockAdditionalFields.length > 0 && preExistingFieldMask !== null && Array.isArray(preExistingFieldMask) && preExistingFieldMask.length > 0) {
const generationConfigFields = [
"temperature",
"topK",
"topP",
"maxOutputTokens",
"responseModalities",
"seed",
"speechConfig"
];
let mappedFieldsFromPreExisting = [];
if (preExistingFieldMask.length > 0) {
mappedFieldsFromPreExisting = preExistingFieldMask.map((field) => {
if (generationConfigFields.includes(field)) {
return `generationConfig.${field}`;
}
return field;
});
}
const finalMaskParts = [];
if (generatedMaskFromBidi) {
finalMaskParts.push(generatedMaskFromBidi);
}
if (mappedFieldsFromPreExisting.length > 0) {
finalMaskParts.push(...mappedFieldsFromPreExisting);
}
if (finalMaskParts.length > 0) {
requestDict["fieldMask"] = finalMaskParts.join(",");
} else {
delete requestDict["fieldMask"];
}
} else {
delete requestDict["fieldMask"];
}
} else {
if (preExistingFieldMask !== null && Array.isArray(preExistingFieldMask) && preExistingFieldMask.length > 0) {
requestDict["fieldMask"] = preExistingFieldMask.join(",");
} else {
delete requestDict["fieldMask"];
}
}
return requestDict;
}
var Tokens = class extends BaseModule {
constructor(apiClient) {
super();
this.apiClient = apiClient;
}
/**
* Creates an ephemeral auth token resource.
*
* @experimental
*
* @remarks
* Ephemeral auth tokens is only supported in the Gemini Developer API.
* It can be used for the session connection to the Live constrained API.
* Support in v1alpha only.
*
* @param params - The parameters for the create request.
* @return The created auth token.
*
* @example
* ```ts
* const ai = new GoogleGenAI({
* apiKey: token.name,
* httpOptions: { apiVersion: 'v1alpha' } // Support in v1alpha only.
* });
*
* // Case 1: If LiveEphemeralParameters is unset, unlock LiveConnectConfig
* // when using the token in Live API sessions. Each session connection can
* // use a different configuration.
* const config: CreateAuthTokenConfig = {
* uses: 3,
* expireTime: '2025-05-01T00:00:00Z',
* }
* const token = await ai.tokens.create(config);
*
* // Case 2: If LiveEphemeralParameters is set, lock all fields in
* // LiveConnectConfig when using the token in Live API sessions. For
* // example, changing `outputAudioTranscription` in the Live API
* // connection will be ignored by the API.
* const config: CreateAuthTokenConfig =
* uses: 3,
* expireTime: '2025-05-01T00:00:00Z',
* LiveEphemeralParameters: {
* model: 'gemini-2.0-flash-001',
* config: {
* 'responseModalities': ['AUDIO'],
* 'systemInstruction': 'Always answer in English.',
* }
* }
* }
* const token = await ai.tokens.create(config);
*
* // Case 3: If LiveEphemeralParameters is set and lockAdditionalFields is
* // set, lock LiveConnectConfig with set and additional fields (e.g.
* // responseModalities, systemInstruction, temperature in this example) when
* // using the token in Live API sessions.
* const config: CreateAuthTokenConfig =
* uses: 3,
* expireTime: '2025-05-01T00:00:00Z',
* LiveEphemeralParameters: {
* model: 'gemini-2.0-flash-001',
* config: {
* 'responseModalities': ['AUDIO'],
* 'systemInstruction': 'Always answer in English.',
* }
* },
* lockAdditionalFields: ['temperature'],
* }
* const token = await ai.tokens.create(config);
*
* // Case 4: If LiveEphemeralParameters is set and lockAdditionalFields is
* // empty array, lock LiveConnectConfig with set fields (e.g.
* // responseModalities, systemInstruction in this example) when using the
* // token in Live API sessions.
* const config: CreateAuthTokenConfig =
* uses: 3,
* expireTime: '2025-05-01T00:00:00Z',
* LiveEphemeralParameters: {
* model: 'gemini-2.0-flash-001',
* config: {
* 'responseModalities': ['AUDIO'],
* 'systemInstruction': 'Always answer in English.',
* }
* },
* lockAdditionalFields: [],
* }
* const token = await ai.tokens.create(config);
* ```
*/
async create(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("The client.tokens.create method is only supported by the Gemini Developer API.");
} else {
const body = createAuthTokenParametersToMldev(this.apiClient, params);
path10 = formatMap("auth_tokens", body["_url"]);
queryParams = body["_query"];
delete body["config"];
delete body["_url"];
delete body["_query"];
const transformedBody = convertBidiSetupToTokenSetup(body, params.config);
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(transformedBody),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
}
}
};
function createFileSearchStoreConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (parentObject !== void 0 && fromDisplayName != null) {
setValueByPath(parentObject, ["displayName"], fromDisplayName);
}
return toObject;
}
function createFileSearchStoreParametersToMldev(fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
createFileSearchStoreConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function deleteFileSearchStoreConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromForce = getValueByPath(fromObject, ["force"]);
if (parentObject !== void 0 && fromForce != null) {
setValueByPath(parentObject, ["_query", "force"], fromForce);
}
return toObject;
}
function deleteFileSearchStoreParametersToMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], fromName);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
deleteFileSearchStoreConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function getFileSearchStoreParametersToMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], fromName);
}
return toObject;
}
function importFileConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromCustomMetadata = getValueByPath(fromObject, [
"customMetadata"
]);
if (parentObject !== void 0 && fromCustomMetadata != null) {
let transformedList = fromCustomMetadata;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(parentObject, ["customMetadata"], transformedList);
}
const fromChunkingConfig = getValueByPath(fromObject, [
"chunkingConfig"
]);
if (parentObject !== void 0 && fromChunkingConfig != null) {
setValueByPath(parentObject, ["chunkingConfig"], fromChunkingConfig);
}
return toObject;
}
function importFileOperationFromMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
const fromResponse = getValueByPath(fromObject, ["response"]);
if (fromResponse != null) {
setValueByPath(toObject, ["response"], importFileResponseFromMldev(fromResponse));
}
return toObject;
}
function importFileParametersToMldev(fromObject) {
const toObject = {};
const fromFileSearchStoreName = getValueByPath(fromObject, [
"fileSearchStoreName"
]);
if (fromFileSearchStoreName != null) {
setValueByPath(toObject, ["_url", "file_search_store_name"], fromFileSearchStoreName);
}
const fromFileName = getValueByPath(fromObject, ["fileName"]);
if (fromFileName != null) {
setValueByPath(toObject, ["fileName"], fromFileName);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
importFileConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function importFileResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromParent = getValueByPath(fromObject, ["parent"]);
if (fromParent != null) {
setValueByPath(toObject, ["parent"], fromParent);
}
const fromDocumentName = getValueByPath(fromObject, ["documentName"]);
if (fromDocumentName != null) {
setValueByPath(toObject, ["documentName"], fromDocumentName);
}
return toObject;
}
function listFileSearchStoresConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
return toObject;
}
function listFileSearchStoresParametersToMldev(fromObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listFileSearchStoresConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function listFileSearchStoresResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromFileSearchStores = getValueByPath(fromObject, [
"fileSearchStores"
]);
if (fromFileSearchStores != null) {
let transformedList = fromFileSearchStores;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["fileSearchStores"], transformedList);
}
return toObject;
}
function uploadToFileSearchStoreConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromMimeType = getValueByPath(fromObject, ["mimeType"]);
if (parentObject !== void 0 && fromMimeType != null) {
setValueByPath(parentObject, ["mimeType"], fromMimeType);
}
const fromDisplayName = getValueByPath(fromObject, ["displayName"]);
if (parentObject !== void 0 && fromDisplayName != null) {
setValueByPath(parentObject, ["displayName"], fromDisplayName);
}
const fromCustomMetadata = getValueByPath(fromObject, [
"customMetadata"
]);
if (parentObject !== void 0 && fromCustomMetadata != null) {
let transformedList = fromCustomMetadata;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(parentObject, ["customMetadata"], transformedList);
}
const fromChunkingConfig = getValueByPath(fromObject, [
"chunkingConfig"
]);
if (parentObject !== void 0 && fromChunkingConfig != null) {
setValueByPath(parentObject, ["chunkingConfig"], fromChunkingConfig);
}
return toObject;
}
function uploadToFileSearchStoreParametersToMldev(fromObject) {
const toObject = {};
const fromFileSearchStoreName = getValueByPath(fromObject, [
"fileSearchStoreName"
]);
if (fromFileSearchStoreName != null) {
setValueByPath(toObject, ["_url", "file_search_store_name"], fromFileSearchStoreName);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
uploadToFileSearchStoreConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function uploadToFileSearchStoreResumableResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
return toObject;
}
function deleteDocumentConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromForce = getValueByPath(fromObject, ["force"]);
if (parentObject !== void 0 && fromForce != null) {
setValueByPath(parentObject, ["_query", "force"], fromForce);
}
return toObject;
}
function deleteDocumentParametersToMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], fromName);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
deleteDocumentConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function getDocumentParametersToMldev(fromObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], fromName);
}
return toObject;
}
function listDocumentsConfigToMldev(fromObject, parentObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
return toObject;
}
function listDocumentsParametersToMldev(fromObject) {
const toObject = {};
const fromParent = getValueByPath(fromObject, ["parent"]);
if (fromParent != null) {
setValueByPath(toObject, ["_url", "parent"], fromParent);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listDocumentsConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function listDocumentsResponseFromMldev(fromObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromDocuments = getValueByPath(fromObject, ["documents"]);
if (fromDocuments != null) {
let transformedList = fromDocuments;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["documents"], transformedList);
}
return toObject;
}
var Documents = class extends BaseModule {
constructor(apiClient) {
super();
this.apiClient = apiClient;
this.list = async (params) => {
return new Pager(PagedItem.PAGED_ITEM_DOCUMENTS, (x) => this.listInternal({
parent: params.parent,
config: x.config
}), await this.listInternal(params), params);
};
}
/**
* Gets a Document.
*
* @param params - The parameters for getting a document.
* @return Document.
*/
async get(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = getDocumentParametersToMldev(params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
}
}
/**
* Deletes a Document.
*
* @param params - The parameters for deleting a document.
*/
async delete(params) {
var _a, _b;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = deleteDocumentParametersToMldev(params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
await this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "DELETE",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
});
}
}
/**
* Lists all Documents in a FileSearchStore.
*
* @param params - The parameters for listing documents.
* @return ListDocumentsResponse.
*/
async listInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = listDocumentsParametersToMldev(params);
path10 = formatMap("{parent}/documents", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = listDocumentsResponseFromMldev(apiResponse);
const typedResp = new ListDocumentsResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
};
var FileSearchStores = class extends BaseModule {
constructor(apiClient, documents = new Documents(apiClient)) {
super();
this.apiClient = apiClient;
this.documents = documents;
this.list = async (params = {}) => {
return new Pager(PagedItem.PAGED_ITEM_FILE_SEARCH_STORES, (x) => this.listInternal(x), await this.listInternal(params), params);
};
}
/**
* Uploads a file asynchronously to a given File Search Store.
* This method is not available in Vertex AI.
* Supported upload sources:
* - Node.js: File path (string) or Blob object.
* - Browser: Blob object (e.g., File).
*
* @remarks
* The `mimeType` can be specified in the `config` parameter. If omitted:
* - For file path (string) inputs, the `mimeType` will be inferred from the
* file extension.
* - For Blob object inputs, the `mimeType` will be set to the Blob's `type`
* property.
*
* This section can contain multiple paragraphs and code examples.
*
* @param params - Optional parameters specified in the
* `types.UploadToFileSearchStoreParameters` interface.
* @see {@link types.UploadToFileSearchStoreParameters#config} for the optional
* config in the parameters.
* @return A promise that resolves to a long running operation.
* @throws An error if called on a Vertex AI client.
* @throws An error if the `mimeType` is not provided and can not be inferred,
* the `mimeType` can be provided in the `params.config` parameter.
* @throws An error occurs if a suitable upload location cannot be established.
*
* @example
* The following code uploads a file to a given file search store.
*
* ```ts
* const operation = await ai.fileSearchStores.upload({fileSearchStoreName: 'fileSearchStores/foo-bar', file: 'file.txt', config: {
* mimeType: 'text/plain',
* }});
* console.log(operation.name);
* ```
*/
async uploadToFileSearchStore(params) {
if (this.apiClient.isVertexAI()) {
throw new Error("Vertex AI does not support uploading files to a file search store.");
}
return this.apiClient.uploadFileToFileSearchStore(params.fileSearchStoreName, params.file, params.config);
}
/**
* Creates a File Search Store.
*
* @param params - The parameters for creating a File Search Store.
* @return FileSearchStore.
*/
async create(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = createFileSearchStoreParametersToMldev(params);
path10 = formatMap("fileSearchStores", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
}
}
/**
* Gets a File Search Store.
*
* @param params - The parameters for getting a File Search Store.
* @return FileSearchStore.
*/
async get(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = getFileSearchStoreParametersToMldev(params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((resp) => {
return resp;
});
}
}
/**
* Deletes a File Search Store.
*
* @param params - The parameters for deleting a File Search Store.
*/
async delete(params) {
var _a, _b;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = deleteFileSearchStoreParametersToMldev(params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
await this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "DELETE",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
});
}
}
/**
* Lists all FileSearchStore owned by the user.
*
* @param params - The parameters for listing file search stores.
* @return ListFileSearchStoresResponse.
*/
async listInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = listFileSearchStoresParametersToMldev(params);
path10 = formatMap("fileSearchStores", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = listFileSearchStoresResponseFromMldev(apiResponse);
const typedResp = new ListFileSearchStoresResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
async uploadToFileSearchStoreInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = uploadToFileSearchStoreParametersToMldev(params);
path10 = formatMap("upload/v1beta/{file_search_store_name}:uploadToFileSearchStore", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = uploadToFileSearchStoreResumableResponseFromMldev(apiResponse);
const typedResp = new UploadToFileSearchStoreResumableResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Imports a File from File Service to a FileSearchStore.
*
* This is a long-running operation, see aip.dev/151
*
* @param params - The parameters for importing a file to a file search store.
* @return ImportFileOperation.
*/
async importFile(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = importFileParametersToMldev(params);
path10 = formatMap("{file_search_store_name}:importFile", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json();
});
return response.then((apiResponse) => {
const resp = importFileOperationFromMldev(apiResponse);
const typedResp = new ImportFileOperation();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
};
var GOOGLE_API_KEY_HEADER = "x-goog-api-key";
var REQUIRED_VERTEX_AI_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
var NodeAuth = class {
constructor(opts) {
if (opts.apiKey !== void 0) {
this.apiKey = opts.apiKey;
return;
}
const vertexAuthOptions = buildGoogleAuthOptions(opts.googleAuthOptions);
this.googleAuth = new import_google_auth_library.GoogleAuth(vertexAuthOptions);
}
async addAuthHeaders(headers, url) {
if (this.apiKey !== void 0) {
if (this.apiKey.startsWith("auth_tokens/")) {
throw new Error("Ephemeral tokens are only supported by the live API.");
}
this.addKeyHeader(headers);
return;
}
return this.addGoogleAuthHeaders(headers, url);
}
addKeyHeader(headers) {
if (headers.get(GOOGLE_API_KEY_HEADER) !== null) {
return;
}
if (this.apiKey === void 0) {
throw new Error("Trying to set API key header but apiKey is not set");
}
headers.append(GOOGLE_API_KEY_HEADER, this.apiKey);
}
async addGoogleAuthHeaders(headers, url) {
if (this.googleAuth === void 0) {
throw new Error("Trying to set google-auth headers but googleAuth is unset");
}
const authHeaders = await this.googleAuth.getRequestHeaders(url);
for (const [key, value] of authHeaders) {
if (headers.get(key) !== null) {
continue;
}
headers.append(key, value);
}
}
};
function buildGoogleAuthOptions(googleAuthOptions) {
let authOptions;
if (!googleAuthOptions) {
authOptions = {
scopes: [REQUIRED_VERTEX_AI_SCOPE]
};
return authOptions;
} else {
authOptions = googleAuthOptions;
if (!authOptions.scopes) {
authOptions.scopes = [REQUIRED_VERTEX_AI_SCOPE];
return authOptions;
} else if (typeof authOptions.scopes === "string" && authOptions.scopes !== REQUIRED_VERTEX_AI_SCOPE || Array.isArray(authOptions.scopes) && authOptions.scopes.indexOf(REQUIRED_VERTEX_AI_SCOPE) < 0) {
throw new Error(`Invalid auth scopes. Scopes must include: ${REQUIRED_VERTEX_AI_SCOPE}`);
}
return authOptions;
}
}
var NodeDownloader = class {
async download(params, apiClient) {
if (params.downloadPath) {
const response = await downloadFile(params, apiClient);
if (response instanceof HttpResponse) {
const writer = createWriteStream2(params.downloadPath);
const body = Readable.fromWeb(response.responseInternal.body);
body.pipe(writer);
await finished(writer);
} else {
try {
await writeFile(params.downloadPath, response, {
encoding: "base64"
});
} catch (error) {
throw new Error(`Failed to write file to ${params.downloadPath}: ${error}`);
}
}
}
}
};
async function downloadFile(params, apiClient) {
var _a, _b, _c;
const name = tFileName(params.file);
if (name !== void 0) {
return await apiClient.request({
path: `files/${name}:download`,
httpMethod: "GET",
queryParams: {
"alt": "media"
},
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
});
} else if (isGeneratedVideo(params.file)) {
const videoBytes = (_c = params.file.video) === null || _c === void 0 ? void 0 : _c.videoBytes;
if (typeof videoBytes === "string") {
return videoBytes;
} else {
throw new Error("Failed to download generated video, Uri or videoBytes not found.");
}
} else if (isVideo(params.file)) {
const videoBytes = params.file.videoBytes;
if (typeof videoBytes === "string") {
return videoBytes;
} else {
throw new Error("Failed to download video, Uri or videoBytes not found.");
}
} else {
throw new Error("Unsupported file type");
}
}
var NodeWebSocketFactory = class {
create(url, headers, callbacks) {
return new NodeWebSocket(url, headers, callbacks);
}
};
var NodeWebSocket = class {
constructor(url, headers, callbacks) {
this.url = url;
this.headers = headers;
this.callbacks = callbacks;
}
connect() {
this.ws = new import_websocket.default(this.url, { headers: this.headers });
this.ws.onopen = this.callbacks.onopen;
this.ws.onerror = this.callbacks.onerror;
this.ws.onclose = this.callbacks.onclose;
this.ws.onmessage = this.callbacks.onmessage;
}
send(message) {
if (this.ws === void 0) {
throw new Error("WebSocket is not connected");
}
this.ws.send(message);
}
close() {
if (this.ws === void 0) {
throw new Error("WebSocket is not connected");
}
this.ws.close();
}
};
function cancelTuningJobParametersToMldev(fromObject, _rootObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], fromName);
}
return toObject;
}
function cancelTuningJobParametersToVertex(fromObject, _rootObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], fromName);
}
return toObject;
}
function createTuningJobConfigToMldev(fromObject, parentObject, _rootObject) {
const toObject = {};
if (getValueByPath(fromObject, ["validationDataset"]) !== void 0) {
throw new Error("validationDataset parameter is not supported in Gemini API.");
}
const fromTunedModelDisplayName = getValueByPath(fromObject, [
"tunedModelDisplayName"
]);
if (parentObject !== void 0 && fromTunedModelDisplayName != null) {
setValueByPath(parentObject, ["displayName"], fromTunedModelDisplayName);
}
if (getValueByPath(fromObject, ["description"]) !== void 0) {
throw new Error("description parameter is not supported in Gemini API.");
}
const fromEpochCount = getValueByPath(fromObject, ["epochCount"]);
if (parentObject !== void 0 && fromEpochCount != null) {
setValueByPath(parentObject, ["tuningTask", "hyperparameters", "epochCount"], fromEpochCount);
}
const fromLearningRateMultiplier = getValueByPath(fromObject, [
"learningRateMultiplier"
]);
if (fromLearningRateMultiplier != null) {
setValueByPath(toObject, ["tuningTask", "hyperparameters", "learningRateMultiplier"], fromLearningRateMultiplier);
}
if (getValueByPath(fromObject, ["exportLastCheckpointOnly"]) !== void 0) {
throw new Error("exportLastCheckpointOnly parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["preTunedModelCheckpointId"]) !== void 0) {
throw new Error("preTunedModelCheckpointId parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["adapterSize"]) !== void 0) {
throw new Error("adapterSize parameter is not supported in Gemini API.");
}
const fromBatchSize = getValueByPath(fromObject, ["batchSize"]);
if (parentObject !== void 0 && fromBatchSize != null) {
setValueByPath(parentObject, ["tuningTask", "hyperparameters", "batchSize"], fromBatchSize);
}
const fromLearningRate = getValueByPath(fromObject, ["learningRate"]);
if (parentObject !== void 0 && fromLearningRate != null) {
setValueByPath(parentObject, ["tuningTask", "hyperparameters", "learningRate"], fromLearningRate);
}
if (getValueByPath(fromObject, ["labels"]) !== void 0) {
throw new Error("labels parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["beta"]) !== void 0) {
throw new Error("beta parameter is not supported in Gemini API.");
}
return toObject;
}
function createTuningJobConfigToVertex(fromObject, parentObject, rootObject) {
const toObject = {};
let discriminatorValidationDataset = getValueByPath(rootObject, [
"config",
"method"
]);
if (discriminatorValidationDataset === void 0) {
discriminatorValidationDataset = "SUPERVISED_FINE_TUNING";
}
if (discriminatorValidationDataset === "SUPERVISED_FINE_TUNING") {
const fromValidationDataset = getValueByPath(fromObject, [
"validationDataset"
]);
if (parentObject !== void 0 && fromValidationDataset != null) {
setValueByPath(parentObject, ["supervisedTuningSpec"], tuningValidationDatasetToVertex(fromValidationDataset));
}
} else if (discriminatorValidationDataset === "PREFERENCE_TUNING") {
const fromValidationDataset = getValueByPath(fromObject, [
"validationDataset"
]);
if (parentObject !== void 0 && fromValidationDataset != null) {
setValueByPath(parentObject, ["preferenceOptimizationSpec"], tuningValidationDatasetToVertex(fromValidationDataset));
}
}
const fromTunedModelDisplayName = getValueByPath(fromObject, [
"tunedModelDisplayName"
]);
if (parentObject !== void 0 && fromTunedModelDisplayName != null) {
setValueByPath(parentObject, ["tunedModelDisplayName"], fromTunedModelDisplayName);
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (parentObject !== void 0 && fromDescription != null) {
setValueByPath(parentObject, ["description"], fromDescription);
}
let discriminatorEpochCount = getValueByPath(rootObject, [
"config",
"method"
]);
if (discriminatorEpochCount === void 0) {
discriminatorEpochCount = "SUPERVISED_FINE_TUNING";
}
if (discriminatorEpochCount === "SUPERVISED_FINE_TUNING") {
const fromEpochCount = getValueByPath(fromObject, ["epochCount"]);
if (parentObject !== void 0 && fromEpochCount != null) {
setValueByPath(parentObject, ["supervisedTuningSpec", "hyperParameters", "epochCount"], fromEpochCount);
}
} else if (discriminatorEpochCount === "PREFERENCE_TUNING") {
const fromEpochCount = getValueByPath(fromObject, ["epochCount"]);
if (parentObject !== void 0 && fromEpochCount != null) {
setValueByPath(parentObject, ["preferenceOptimizationSpec", "hyperParameters", "epochCount"], fromEpochCount);
}
}
let discriminatorLearningRateMultiplier = getValueByPath(rootObject, [
"config",
"method"
]);
if (discriminatorLearningRateMultiplier === void 0) {
discriminatorLearningRateMultiplier = "SUPERVISED_FINE_TUNING";
}
if (discriminatorLearningRateMultiplier === "SUPERVISED_FINE_TUNING") {
const fromLearningRateMultiplier = getValueByPath(fromObject, [
"learningRateMultiplier"
]);
if (parentObject !== void 0 && fromLearningRateMultiplier != null) {
setValueByPath(parentObject, ["supervisedTuningSpec", "hyperParameters", "learningRateMultiplier"], fromLearningRateMultiplier);
}
} else if (discriminatorLearningRateMultiplier === "PREFERENCE_TUNING") {
const fromLearningRateMultiplier = getValueByPath(fromObject, [
"learningRateMultiplier"
]);
if (parentObject !== void 0 && fromLearningRateMultiplier != null) {
setValueByPath(parentObject, [
"preferenceOptimizationSpec",
"hyperParameters",
"learningRateMultiplier"
], fromLearningRateMultiplier);
}
}
let discriminatorExportLastCheckpointOnly = getValueByPath(rootObject, ["config", "method"]);
if (discriminatorExportLastCheckpointOnly === void 0) {
discriminatorExportLastCheckpointOnly = "SUPERVISED_FINE_TUNING";
}
if (discriminatorExportLastCheckpointOnly === "SUPERVISED_FINE_TUNING") {
const fromExportLastCheckpointOnly = getValueByPath(fromObject, [
"exportLastCheckpointOnly"
]);
if (parentObject !== void 0 && fromExportLastCheckpointOnly != null) {
setValueByPath(parentObject, ["supervisedTuningSpec", "exportLastCheckpointOnly"], fromExportLastCheckpointOnly);
}
} else if (discriminatorExportLastCheckpointOnly === "PREFERENCE_TUNING") {
const fromExportLastCheckpointOnly = getValueByPath(fromObject, [
"exportLastCheckpointOnly"
]);
if (parentObject !== void 0 && fromExportLastCheckpointOnly != null) {
setValueByPath(parentObject, ["preferenceOptimizationSpec", "exportLastCheckpointOnly"], fromExportLastCheckpointOnly);
}
}
let discriminatorAdapterSize = getValueByPath(rootObject, [
"config",
"method"
]);
if (discriminatorAdapterSize === void 0) {
discriminatorAdapterSize = "SUPERVISED_FINE_TUNING";
}
if (discriminatorAdapterSize === "SUPERVISED_FINE_TUNING") {
const fromAdapterSize = getValueByPath(fromObject, ["adapterSize"]);
if (parentObject !== void 0 && fromAdapterSize != null) {
setValueByPath(parentObject, ["supervisedTuningSpec", "hyperParameters", "adapterSize"], fromAdapterSize);
}
} else if (discriminatorAdapterSize === "PREFERENCE_TUNING") {
const fromAdapterSize = getValueByPath(fromObject, ["adapterSize"]);
if (parentObject !== void 0 && fromAdapterSize != null) {
setValueByPath(parentObject, ["preferenceOptimizationSpec", "hyperParameters", "adapterSize"], fromAdapterSize);
}
}
if (getValueByPath(fromObject, ["batchSize"]) !== void 0) {
throw new Error("batchSize parameter is not supported in Vertex AI.");
}
if (getValueByPath(fromObject, ["learningRate"]) !== void 0) {
throw new Error("learningRate parameter is not supported in Vertex AI.");
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (parentObject !== void 0 && fromLabels != null) {
setValueByPath(parentObject, ["labels"], fromLabels);
}
const fromBeta = getValueByPath(fromObject, ["beta"]);
if (parentObject !== void 0 && fromBeta != null) {
setValueByPath(parentObject, ["preferenceOptimizationSpec", "hyperParameters", "beta"], fromBeta);
}
return toObject;
}
function createTuningJobParametersPrivateToMldev(fromObject, rootObject) {
const toObject = {};
const fromBaseModel = getValueByPath(fromObject, ["baseModel"]);
if (fromBaseModel != null) {
setValueByPath(toObject, ["baseModel"], fromBaseModel);
}
const fromPreTunedModel = getValueByPath(fromObject, [
"preTunedModel"
]);
if (fromPreTunedModel != null) {
setValueByPath(toObject, ["preTunedModel"], fromPreTunedModel);
}
const fromTrainingDataset = getValueByPath(fromObject, [
"trainingDataset"
]);
if (fromTrainingDataset != null) {
tuningDatasetToMldev(fromTrainingDataset);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
createTuningJobConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function createTuningJobParametersPrivateToVertex(fromObject, rootObject) {
const toObject = {};
const fromBaseModel = getValueByPath(fromObject, ["baseModel"]);
if (fromBaseModel != null) {
setValueByPath(toObject, ["baseModel"], fromBaseModel);
}
const fromPreTunedModel = getValueByPath(fromObject, [
"preTunedModel"
]);
if (fromPreTunedModel != null) {
setValueByPath(toObject, ["preTunedModel"], fromPreTunedModel);
}
const fromTrainingDataset = getValueByPath(fromObject, [
"trainingDataset"
]);
if (fromTrainingDataset != null) {
tuningDatasetToVertex(fromTrainingDataset, toObject, rootObject);
}
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
createTuningJobConfigToVertex(fromConfig, toObject, rootObject);
}
return toObject;
}
function getTuningJobParametersToMldev(fromObject, _rootObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], fromName);
}
return toObject;
}
function getTuningJobParametersToVertex(fromObject, _rootObject) {
const toObject = {};
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["_url", "name"], fromName);
}
return toObject;
}
function listTuningJobsConfigToMldev(fromObject, parentObject, _rootObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
const fromFilter = getValueByPath(fromObject, ["filter"]);
if (parentObject !== void 0 && fromFilter != null) {
setValueByPath(parentObject, ["_query", "filter"], fromFilter);
}
return toObject;
}
function listTuningJobsConfigToVertex(fromObject, parentObject, _rootObject) {
const toObject = {};
const fromPageSize = getValueByPath(fromObject, ["pageSize"]);
if (parentObject !== void 0 && fromPageSize != null) {
setValueByPath(parentObject, ["_query", "pageSize"], fromPageSize);
}
const fromPageToken = getValueByPath(fromObject, ["pageToken"]);
if (parentObject !== void 0 && fromPageToken != null) {
setValueByPath(parentObject, ["_query", "pageToken"], fromPageToken);
}
const fromFilter = getValueByPath(fromObject, ["filter"]);
if (parentObject !== void 0 && fromFilter != null) {
setValueByPath(parentObject, ["_query", "filter"], fromFilter);
}
return toObject;
}
function listTuningJobsParametersToMldev(fromObject, rootObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listTuningJobsConfigToMldev(fromConfig, toObject);
}
return toObject;
}
function listTuningJobsParametersToVertex(fromObject, rootObject) {
const toObject = {};
const fromConfig = getValueByPath(fromObject, ["config"]);
if (fromConfig != null) {
listTuningJobsConfigToVertex(fromConfig, toObject);
}
return toObject;
}
function listTuningJobsResponseFromMldev(fromObject, rootObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromTuningJobs = getValueByPath(fromObject, ["tunedModels"]);
if (fromTuningJobs != null) {
let transformedList = fromTuningJobs;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return tuningJobFromMldev(item);
});
}
setValueByPath(toObject, ["tuningJobs"], transformedList);
}
return toObject;
}
function listTuningJobsResponseFromVertex(fromObject, rootObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromNextPageToken = getValueByPath(fromObject, [
"nextPageToken"
]);
if (fromNextPageToken != null) {
setValueByPath(toObject, ["nextPageToken"], fromNextPageToken);
}
const fromTuningJobs = getValueByPath(fromObject, ["tuningJobs"]);
if (fromTuningJobs != null) {
let transformedList = fromTuningJobs;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return tuningJobFromVertex(item);
});
}
setValueByPath(toObject, ["tuningJobs"], transformedList);
}
return toObject;
}
function tunedModelFromMldev(fromObject, _rootObject) {
const toObject = {};
const fromModel = getValueByPath(fromObject, ["name"]);
if (fromModel != null) {
setValueByPath(toObject, ["model"], fromModel);
}
const fromEndpoint = getValueByPath(fromObject, ["name"]);
if (fromEndpoint != null) {
setValueByPath(toObject, ["endpoint"], fromEndpoint);
}
return toObject;
}
function tuningDatasetToMldev(fromObject, _rootObject) {
const toObject = {};
if (getValueByPath(fromObject, ["gcsUri"]) !== void 0) {
throw new Error("gcsUri parameter is not supported in Gemini API.");
}
if (getValueByPath(fromObject, ["vertexDatasetResource"]) !== void 0) {
throw new Error("vertexDatasetResource parameter is not supported in Gemini API.");
}
const fromExamples = getValueByPath(fromObject, ["examples"]);
if (fromExamples != null) {
let transformedList = fromExamples;
if (Array.isArray(transformedList)) {
transformedList = transformedList.map((item) => {
return item;
});
}
setValueByPath(toObject, ["examples", "examples"], transformedList);
}
return toObject;
}
function tuningDatasetToVertex(fromObject, parentObject, rootObject) {
const toObject = {};
let discriminatorGcsUri = getValueByPath(rootObject, [
"config",
"method"
]);
if (discriminatorGcsUri === void 0) {
discriminatorGcsUri = "SUPERVISED_FINE_TUNING";
}
if (discriminatorGcsUri === "SUPERVISED_FINE_TUNING") {
const fromGcsUri = getValueByPath(fromObject, ["gcsUri"]);
if (parentObject !== void 0 && fromGcsUri != null) {
setValueByPath(parentObject, ["supervisedTuningSpec", "trainingDatasetUri"], fromGcsUri);
}
} else if (discriminatorGcsUri === "PREFERENCE_TUNING") {
const fromGcsUri = getValueByPath(fromObject, ["gcsUri"]);
if (parentObject !== void 0 && fromGcsUri != null) {
setValueByPath(parentObject, ["preferenceOptimizationSpec", "trainingDatasetUri"], fromGcsUri);
}
}
let discriminatorVertexDatasetResource = getValueByPath(rootObject, [
"config",
"method"
]);
if (discriminatorVertexDatasetResource === void 0) {
discriminatorVertexDatasetResource = "SUPERVISED_FINE_TUNING";
}
if (discriminatorVertexDatasetResource === "SUPERVISED_FINE_TUNING") {
const fromVertexDatasetResource = getValueByPath(fromObject, [
"vertexDatasetResource"
]);
if (parentObject !== void 0 && fromVertexDatasetResource != null) {
setValueByPath(parentObject, ["supervisedTuningSpec", "trainingDatasetUri"], fromVertexDatasetResource);
}
} else if (discriminatorVertexDatasetResource === "PREFERENCE_TUNING") {
const fromVertexDatasetResource = getValueByPath(fromObject, [
"vertexDatasetResource"
]);
if (parentObject !== void 0 && fromVertexDatasetResource != null) {
setValueByPath(parentObject, ["preferenceOptimizationSpec", "trainingDatasetUri"], fromVertexDatasetResource);
}
}
if (getValueByPath(fromObject, ["examples"]) !== void 0) {
throw new Error("examples parameter is not supported in Vertex AI.");
}
return toObject;
}
function tuningJobFromMldev(fromObject, rootObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromState = getValueByPath(fromObject, ["state"]);
if (fromState != null) {
setValueByPath(toObject, ["state"], tTuningJobStatus(fromState));
}
const fromCreateTime = getValueByPath(fromObject, ["createTime"]);
if (fromCreateTime != null) {
setValueByPath(toObject, ["createTime"], fromCreateTime);
}
const fromStartTime = getValueByPath(fromObject, [
"tuningTask",
"startTime"
]);
if (fromStartTime != null) {
setValueByPath(toObject, ["startTime"], fromStartTime);
}
const fromEndTime = getValueByPath(fromObject, [
"tuningTask",
"completeTime"
]);
if (fromEndTime != null) {
setValueByPath(toObject, ["endTime"], fromEndTime);
}
const fromUpdateTime = getValueByPath(fromObject, ["updateTime"]);
if (fromUpdateTime != null) {
setValueByPath(toObject, ["updateTime"], fromUpdateTime);
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (fromDescription != null) {
setValueByPath(toObject, ["description"], fromDescription);
}
const fromBaseModel = getValueByPath(fromObject, ["baseModel"]);
if (fromBaseModel != null) {
setValueByPath(toObject, ["baseModel"], fromBaseModel);
}
const fromTunedModel = getValueByPath(fromObject, ["_self"]);
if (fromTunedModel != null) {
setValueByPath(toObject, ["tunedModel"], tunedModelFromMldev(fromTunedModel));
}
return toObject;
}
function tuningJobFromVertex(fromObject, _rootObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromState = getValueByPath(fromObject, ["state"]);
if (fromState != null) {
setValueByPath(toObject, ["state"], tTuningJobStatus(fromState));
}
const fromCreateTime = getValueByPath(fromObject, ["createTime"]);
if (fromCreateTime != null) {
setValueByPath(toObject, ["createTime"], fromCreateTime);
}
const fromStartTime = getValueByPath(fromObject, ["startTime"]);
if (fromStartTime != null) {
setValueByPath(toObject, ["startTime"], fromStartTime);
}
const fromEndTime = getValueByPath(fromObject, ["endTime"]);
if (fromEndTime != null) {
setValueByPath(toObject, ["endTime"], fromEndTime);
}
const fromUpdateTime = getValueByPath(fromObject, ["updateTime"]);
if (fromUpdateTime != null) {
setValueByPath(toObject, ["updateTime"], fromUpdateTime);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
const fromDescription = getValueByPath(fromObject, ["description"]);
if (fromDescription != null) {
setValueByPath(toObject, ["description"], fromDescription);
}
const fromBaseModel = getValueByPath(fromObject, ["baseModel"]);
if (fromBaseModel != null) {
setValueByPath(toObject, ["baseModel"], fromBaseModel);
}
const fromTunedModel = getValueByPath(fromObject, ["tunedModel"]);
if (fromTunedModel != null) {
setValueByPath(toObject, ["tunedModel"], fromTunedModel);
}
const fromPreTunedModel = getValueByPath(fromObject, [
"preTunedModel"
]);
if (fromPreTunedModel != null) {
setValueByPath(toObject, ["preTunedModel"], fromPreTunedModel);
}
const fromSupervisedTuningSpec = getValueByPath(fromObject, [
"supervisedTuningSpec"
]);
if (fromSupervisedTuningSpec != null) {
setValueByPath(toObject, ["supervisedTuningSpec"], fromSupervisedTuningSpec);
}
const fromPreferenceOptimizationSpec = getValueByPath(fromObject, [
"preferenceOptimizationSpec"
]);
if (fromPreferenceOptimizationSpec != null) {
setValueByPath(toObject, ["preferenceOptimizationSpec"], fromPreferenceOptimizationSpec);
}
const fromTuningDataStats = getValueByPath(fromObject, [
"tuningDataStats"
]);
if (fromTuningDataStats != null) {
setValueByPath(toObject, ["tuningDataStats"], fromTuningDataStats);
}
const fromEncryptionSpec = getValueByPath(fromObject, [
"encryptionSpec"
]);
if (fromEncryptionSpec != null) {
setValueByPath(toObject, ["encryptionSpec"], fromEncryptionSpec);
}
const fromPartnerModelTuningSpec = getValueByPath(fromObject, [
"partnerModelTuningSpec"
]);
if (fromPartnerModelTuningSpec != null) {
setValueByPath(toObject, ["partnerModelTuningSpec"], fromPartnerModelTuningSpec);
}
const fromCustomBaseModel = getValueByPath(fromObject, [
"customBaseModel"
]);
if (fromCustomBaseModel != null) {
setValueByPath(toObject, ["customBaseModel"], fromCustomBaseModel);
}
const fromExperiment = getValueByPath(fromObject, ["experiment"]);
if (fromExperiment != null) {
setValueByPath(toObject, ["experiment"], fromExperiment);
}
const fromLabels = getValueByPath(fromObject, ["labels"]);
if (fromLabels != null) {
setValueByPath(toObject, ["labels"], fromLabels);
}
const fromOutputUri = getValueByPath(fromObject, ["outputUri"]);
if (fromOutputUri != null) {
setValueByPath(toObject, ["outputUri"], fromOutputUri);
}
const fromPipelineJob = getValueByPath(fromObject, ["pipelineJob"]);
if (fromPipelineJob != null) {
setValueByPath(toObject, ["pipelineJob"], fromPipelineJob);
}
const fromServiceAccount = getValueByPath(fromObject, [
"serviceAccount"
]);
if (fromServiceAccount != null) {
setValueByPath(toObject, ["serviceAccount"], fromServiceAccount);
}
const fromTunedModelDisplayName = getValueByPath(fromObject, [
"tunedModelDisplayName"
]);
if (fromTunedModelDisplayName != null) {
setValueByPath(toObject, ["tunedModelDisplayName"], fromTunedModelDisplayName);
}
const fromVeoTuningSpec = getValueByPath(fromObject, [
"veoTuningSpec"
]);
if (fromVeoTuningSpec != null) {
setValueByPath(toObject, ["veoTuningSpec"], fromVeoTuningSpec);
}
return toObject;
}
function tuningOperationFromMldev(fromObject, _rootObject) {
const toObject = {};
const fromSdkHttpResponse = getValueByPath(fromObject, [
"sdkHttpResponse"
]);
if (fromSdkHttpResponse != null) {
setValueByPath(toObject, ["sdkHttpResponse"], fromSdkHttpResponse);
}
const fromName = getValueByPath(fromObject, ["name"]);
if (fromName != null) {
setValueByPath(toObject, ["name"], fromName);
}
const fromMetadata = getValueByPath(fromObject, ["metadata"]);
if (fromMetadata != null) {
setValueByPath(toObject, ["metadata"], fromMetadata);
}
const fromDone = getValueByPath(fromObject, ["done"]);
if (fromDone != null) {
setValueByPath(toObject, ["done"], fromDone);
}
const fromError = getValueByPath(fromObject, ["error"]);
if (fromError != null) {
setValueByPath(toObject, ["error"], fromError);
}
return toObject;
}
function tuningValidationDatasetToVertex(fromObject, _rootObject) {
const toObject = {};
const fromGcsUri = getValueByPath(fromObject, ["gcsUri"]);
if (fromGcsUri != null) {
setValueByPath(toObject, ["validationDatasetUri"], fromGcsUri);
}
const fromVertexDatasetResource = getValueByPath(fromObject, [
"vertexDatasetResource"
]);
if (fromVertexDatasetResource != null) {
setValueByPath(toObject, ["validationDatasetUri"], fromVertexDatasetResource);
}
return toObject;
}
var Tunings = class extends BaseModule {
constructor(apiClient) {
super();
this.apiClient = apiClient;
this.get = async (params) => {
return await this.getInternal(params);
};
this.list = async (params = {}) => {
return new Pager(PagedItem.PAGED_ITEM_TUNING_JOBS, (x) => this.listInternal(x), await this.listInternal(params), params);
};
this.tune = async (params) => {
var _a;
if (this.apiClient.isVertexAI()) {
if (params.baseModel.startsWith("projects/")) {
const preTunedModel = {
tunedModelName: params.baseModel
};
if ((_a = params.config) === null || _a === void 0 ? void 0 : _a.preTunedModelCheckpointId) {
preTunedModel.checkpointId = params.config.preTunedModelCheckpointId;
}
const paramsPrivate = Object.assign(Object.assign({}, params), { preTunedModel });
paramsPrivate.baseModel = void 0;
return await this.tuneInternal(paramsPrivate);
} else {
const paramsPrivate = Object.assign({}, params);
return await this.tuneInternal(paramsPrivate);
}
} else {
const paramsPrivate = Object.assign({}, params);
const operation = await this.tuneMldevInternal(paramsPrivate);
let tunedModelName = "";
if (operation["metadata"] !== void 0 && operation["metadata"]["tunedModel"] !== void 0) {
tunedModelName = operation["metadata"]["tunedModel"];
} else if (operation["name"] !== void 0 && operation["name"].includes("/operations/")) {
tunedModelName = operation["name"].split("/operations/")[0];
}
const tuningJob = {
name: tunedModelName,
state: JobState.JOB_STATE_QUEUED
};
return tuningJob;
}
};
}
async getInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = getTuningJobParametersToVertex(params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = tuningJobFromVertex(apiResponse);
return resp;
});
} else {
const body = getTuningJobParametersToMldev(params);
path10 = formatMap("{name}", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = tuningJobFromMldev(apiResponse);
return resp;
});
}
}
async listInternal(params) {
var _a, _b, _c, _d;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = listTuningJobsParametersToVertex(params);
path10 = formatMap("tuningJobs", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = listTuningJobsResponseFromVertex(apiResponse);
const typedResp = new ListTuningJobsResponse();
Object.assign(typedResp, resp);
return typedResp;
});
} else {
const body = listTuningJobsParametersToMldev(params);
path10 = formatMap("tunedModels", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "GET",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = listTuningJobsResponseFromMldev(apiResponse);
const typedResp = new ListTuningJobsResponse();
Object.assign(typedResp, resp);
return typedResp;
});
}
}
/**
* Cancels a tuning job.
*
* @param params - The parameters for the cancel request.
* @return The empty response returned by the API.
*
* @example
* ```ts
* await ai.tunings.cancel({name: '...'}); // The server-generated resource name.
* ```
*/
async cancel(params) {
var _a, _b, _c, _d;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = cancelTuningJobParametersToVertex(params);
path10 = formatMap("{name}:cancel", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
await this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
});
} else {
const body = cancelTuningJobParametersToMldev(params);
path10 = formatMap("{name}:cancel", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
await this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal
});
}
}
async tuneInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
const body = createTuningJobParametersPrivateToVertex(params, params);
path10 = formatMap("tuningJobs", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = tuningJobFromVertex(apiResponse);
return resp;
});
} else {
throw new Error("This method is only supported by the Vertex AI.");
}
}
async tuneMldevInternal(params) {
var _a, _b;
let response;
let path10 = "";
let queryParams = {};
if (this.apiClient.isVertexAI()) {
throw new Error("This method is only supported by the Gemini Developer API.");
} else {
const body = createTuningJobParametersPrivateToMldev(params);
path10 = formatMap("tunedModels", body["_url"]);
queryParams = body["_query"];
delete body["_url"];
delete body["_query"];
response = this.apiClient.request({
path: path10,
queryParams,
body: JSON.stringify(body),
httpMethod: "POST",
httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal
}).then((httpResponse) => {
return httpResponse.json().then((jsonResponse) => {
const response2 = jsonResponse;
response2.sdkHttpResponse = {
headers: httpResponse.headers
};
return response2;
});
});
return response.then((apiResponse) => {
const resp = tuningOperationFromMldev(apiResponse);
return resp;
});
}
}
};
var MAX_CHUNK_SIZE = 1024 * 1024 * 8;
var MAX_RETRY_COUNT = 3;
var INITIAL_RETRY_DELAY_MS = 1e3;
var DELAY_MULTIPLIER = 2;
var X_GOOG_UPLOAD_STATUS_HEADER_FIELD = "x-goog-upload-status";
async function uploadBlob(file, uploadUrl, apiClient) {
var _a;
const response = await uploadBlobInternal(file, uploadUrl, apiClient);
const responseJson = await (response === null || response === void 0 ? void 0 : response.json());
if (((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a[X_GOOG_UPLOAD_STATUS_HEADER_FIELD]) !== "final") {
throw new Error("Failed to upload file: Upload status is not finalized.");
}
return responseJson["file"];
}
async function uploadBlobToFileSearchStore(file, uploadUrl, apiClient) {
var _a;
const response = await uploadBlobInternal(file, uploadUrl, apiClient);
const responseJson = await (response === null || response === void 0 ? void 0 : response.json());
if (((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a[X_GOOG_UPLOAD_STATUS_HEADER_FIELD]) !== "final") {
throw new Error("Failed to upload file: Upload status is not finalized.");
}
const resp = uploadToFileSearchStoreOperationFromMldev(responseJson);
const typedResp = new UploadToFileSearchStoreOperation();
Object.assign(typedResp, resp);
return typedResp;
}
async function uploadBlobInternal(file, uploadUrl, apiClient) {
var _a, _b;
let fileSize = 0;
let offset = 0;
let response = new HttpResponse(new Response());
let uploadCommand = "upload";
fileSize = file.size;
while (offset < fileSize) {
const chunkSize = Math.min(MAX_CHUNK_SIZE, fileSize - offset);
const chunk = file.slice(offset, offset + chunkSize);
if (offset + chunkSize >= fileSize) {
uploadCommand += ", finalize";
}
let retryCount = 0;
let currentDelayMs = INITIAL_RETRY_DELAY_MS;
while (retryCount < MAX_RETRY_COUNT) {
response = await apiClient.request({
path: "",
body: chunk,
httpMethod: "POST",
httpOptions: {
apiVersion: "",
baseUrl: uploadUrl,
headers: {
"X-Goog-Upload-Command": uploadCommand,
"X-Goog-Upload-Offset": String(offset),
"Content-Length": String(chunkSize)
}
}
});
if ((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a[X_GOOG_UPLOAD_STATUS_HEADER_FIELD]) {
break;
}
retryCount++;
await sleep(currentDelayMs);
currentDelayMs = currentDelayMs * DELAY_MULTIPLIER;
}
offset += chunkSize;
if (((_b = response === null || response === void 0 ? void 0 : response.headers) === null || _b === void 0 ? void 0 : _b[X_GOOG_UPLOAD_STATUS_HEADER_FIELD]) !== "active") {
break;
}
if (fileSize <= offset) {
throw new Error("All content has been uploaded, but the upload status is not finalized.");
}
}
return response;
}
async function getBlobStat(file) {
const fileStat = { size: file.size, type: file.type };
return fileStat;
}
function sleep(ms) {
return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
}
var NodeUploader = class {
async stat(file) {
const fileStat = { size: 0, type: void 0 };
if (typeof file === "string") {
const originalStat = await fs3.stat(file);
fileStat.size = originalStat.size;
fileStat.type = this.inferMimeType(file);
return fileStat;
} else {
return await getBlobStat(file);
}
}
async upload(file, uploadUrl, apiClient) {
if (typeof file === "string") {
return await this.uploadFileFromPath(file, uploadUrl, apiClient);
} else {
return uploadBlob(file, uploadUrl, apiClient);
}
}
async uploadToFileSearchStore(file, uploadUrl, apiClient) {
if (typeof file === "string") {
return await this.uploadFileToFileSearchStoreFromPath(file, uploadUrl, apiClient);
} else {
return uploadBlobToFileSearchStore(file, uploadUrl, apiClient);
}
}
/**
* Infers the MIME type of a file based on its extension.
*
* @param filePath The path to the file.
* @returns The MIME type of the file, or undefined if it cannot be inferred.
*/
inferMimeType(filePath) {
const fileExtension = filePath.slice(filePath.lastIndexOf(".") + 1);
const mimeTypes = {
"aac": "audio/aac",
"abw": "application/x-abiword",
"arc": "application/x-freearc",
"avi": "video/x-msvideo",
"azw": "application/vnd.amazon.ebook",
"bin": "application/octet-stream",
"bmp": "image/bmp",
"bz": "application/x-bzip",
"bz2": "application/x-bzip2",
"csh": "application/x-csh",
"css": "text/css",
"csv": "text/csv",
"doc": "application/msword",
"docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"eot": "application/vnd.ms-fontobject",
"epub": "application/epub+zip",
"gz": "application/gzip",
"gif": "image/gif",
"htm": "text/html",
"html": "text/html",
"ico": "image/vnd.microsoft.icon",
"ics": "text/calendar",
"jar": "application/java-archive",
"jpeg": "image/jpeg",
"jpg": "image/jpeg",
"js": "text/javascript",
"json": "application/json",
"jsonld": "application/ld+json",
"kml": "application/vnd.google-earth.kml+xml",
"kmz": "application/vnd.google-earth.kmz+xml",
"mjs": "text/javascript",
"mp3": "audio/mpeg",
"mp4": "video/mp4",
"mpeg": "video/mpeg",
"mpkg": "application/vnd.apple.installer+xml",
"odt": "application/vnd.oasis.opendocument.text",
"oga": "audio/ogg",
"ogv": "video/ogg",
"ogx": "application/ogg",
"opus": "audio/opus",
"otf": "font/otf",
"png": "image/png",
"pdf": "application/pdf",
"php": "application/x-httpd-php",
"ppt": "application/vnd.ms-powerpoint",
"pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
"rar": "application/vnd.rar",
"rtf": "application/rtf",
"sh": "application/x-sh",
"svg": "image/svg+xml",
"swf": "application/x-shockwave-flash",
"tar": "application/x-tar",
"tif": "image/tiff",
"tiff": "image/tiff",
"ts": "video/mp2t",
"ttf": "font/ttf",
"txt": "text/plain",
"vsd": "application/vnd.visio",
"wav": "audio/wav",
"weba": "audio/webm",
"webm": "video/webm",
"webp": "image/webp",
"woff": "font/woff",
"woff2": "font/woff2",
"xhtml": "application/xhtml+xml",
"xls": "application/vnd.ms-excel",
"xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
"xml": "application/xml",
"xul": "application/vnd.mozilla.xul+xml",
"zip": "application/zip",
"3gp": "video/3gpp",
"3g2": "video/3gpp2",
"7z": "application/x-7z-compressed"
};
const mimeType = mimeTypes[fileExtension.toLowerCase()];
return mimeType;
}
async uploadFileFromPath(file, uploadUrl, apiClient) {
var _a;
const response = await this.uploadFileFromPathInternal(file, uploadUrl, apiClient);
const responseJson = await (response === null || response === void 0 ? void 0 : response.json());
if (((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a[X_GOOG_UPLOAD_STATUS_HEADER_FIELD]) !== "final") {
throw new Error("Failed to upload file: Upload status is not finalized.");
}
return responseJson["file"];
}
async uploadFileToFileSearchStoreFromPath(file, uploadUrl, apiClient) {
var _a;
const response = await this.uploadFileFromPathInternal(file, uploadUrl, apiClient);
const responseJson = await (response === null || response === void 0 ? void 0 : response.json());
if (((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a[X_GOOG_UPLOAD_STATUS_HEADER_FIELD]) !== "final") {
throw new Error("Failed to upload file: Upload status is not finalized.");
}
const resp = uploadToFileSearchStoreOperationFromMldev(responseJson);
const typedResp = new UploadToFileSearchStoreOperation();
Object.assign(typedResp, resp);
return typedResp;
}
async uploadFileFromPathInternal(file, uploadUrl, apiClient) {
var _a, _b;
let fileSize = 0;
let offset = 0;
let response = new HttpResponse(new Response());
let uploadCommand = "upload";
let fileHandle;
const fileName = path2.basename(file);
try {
fileHandle = await fs3.open(file, "r");
if (!fileHandle) {
throw new Error(`Failed to open file`);
}
fileSize = (await fileHandle.stat()).size;
while (offset < fileSize) {
const chunkSize = Math.min(MAX_CHUNK_SIZE, fileSize - offset);
if (offset + chunkSize >= fileSize) {
uploadCommand += ", finalize";
}
const buffer = new Uint8Array(chunkSize);
const { bytesRead } = await fileHandle.read(buffer, 0, chunkSize, offset);
if (bytesRead !== chunkSize) {
throw new Error(`Failed to read ${chunkSize} bytes from file at offset ${offset}. bytes actually read: ${bytesRead}`);
}
const chunk = new Blob([buffer]);
let retryCount = 0;
let currentDelayMs = INITIAL_RETRY_DELAY_MS;
while (retryCount < MAX_RETRY_COUNT) {
response = await apiClient.request({
path: "",
body: chunk,
httpMethod: "POST",
httpOptions: {
apiVersion: "",
baseUrl: uploadUrl,
headers: {
"X-Goog-Upload-Command": uploadCommand,
"X-Goog-Upload-Offset": String(offset),
"Content-Length": String(bytesRead),
"X-Goog-Upload-File-Name": fileName
}
}
});
if ((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a[X_GOOG_UPLOAD_STATUS_HEADER_FIELD]) {
break;
}
retryCount++;
await sleep(currentDelayMs);
currentDelayMs = currentDelayMs * DELAY_MULTIPLIER;
}
offset += bytesRead;
if (((_b = response === null || response === void 0 ? void 0 : response.headers) === null || _b === void 0 ? void 0 : _b[X_GOOG_UPLOAD_STATUS_HEADER_FIELD]) !== "active") {
break;
}
if (fileSize <= offset) {
throw new Error("All content has been uploaded, but the upload status is not finalized.");
}
}
return response;
} finally {
if (fileHandle) {
await fileHandle.close();
}
}
}
};
var LANGUAGE_LABEL_PREFIX = "gl-node/";
var GoogleGenAI = class {
constructor(options) {
var _a, _b, _c, _d, _e, _f;
if ((options.project || options.location) && options.apiKey) {
throw new Error("Project/location and API key are mutually exclusive in the client initializer.");
}
this.vertexai = (_b = (_a = options.vertexai) !== null && _a !== void 0 ? _a : getBooleanEnv("GOOGLE_GENAI_USE_VERTEXAI")) !== null && _b !== void 0 ? _b : false;
const envApiKey = getApiKeyFromEnv();
const envProject = getEnv("GOOGLE_CLOUD_PROJECT");
const envLocation = getEnv("GOOGLE_CLOUD_LOCATION");
this.apiKey = (_c = options.apiKey) !== null && _c !== void 0 ? _c : envApiKey;
this.project = (_d = options.project) !== null && _d !== void 0 ? _d : envProject;
this.location = (_e = options.location) !== null && _e !== void 0 ? _e : envLocation;
if (options.vertexai) {
if ((_f = options.googleAuthOptions) === null || _f === void 0 ? void 0 : _f.credentials) {
console.debug("The user provided Google Cloud credentials will take precedence over the API key from the environment variable.");
this.apiKey = void 0;
}
if ((envProject || envLocation) && options.apiKey) {
console.debug("The user provided Vertex AI API key will take precedence over the project/location from the environment variables.");
this.project = void 0;
this.location = void 0;
} else if ((options.project || options.location) && envApiKey) {
console.debug("The user provided project/location will take precedence over the API key from the environment variables.");
this.apiKey = void 0;
} else if ((envProject || envLocation) && envApiKey) {
console.debug("The project/location from the environment variables will take precedence over the API key from the environment variables.");
this.apiKey = void 0;
}
if (!this.location && !this.apiKey) {
this.location = "global";
}
}
const baseUrl = getBaseUrl(options.httpOptions, options.vertexai, getEnv("GOOGLE_VERTEX_BASE_URL"), getEnv("GOOGLE_GEMINI_BASE_URL"));
if (baseUrl) {
if (options.httpOptions) {
options.httpOptions.baseUrl = baseUrl;
} else {
options.httpOptions = { baseUrl };
}
}
this.apiVersion = options.apiVersion;
const auth = new NodeAuth({
apiKey: this.apiKey,
googleAuthOptions: options.googleAuthOptions
});
this.apiClient = new ApiClient({
auth,
project: this.project,
location: this.location,
apiVersion: this.apiVersion,
apiKey: this.apiKey,
vertexai: this.vertexai,
httpOptions: options.httpOptions,
userAgentExtra: LANGUAGE_LABEL_PREFIX + process.version,
uploader: new NodeUploader(),
downloader: new NodeDownloader()
});
this.models = new Models(this.apiClient);
this.live = new Live(this.apiClient, auth, new NodeWebSocketFactory());
this.batches = new Batches(this.apiClient);
this.chats = new Chats(this.models, this.apiClient);
this.caches = new Caches(this.apiClient);
this.files = new Files(this.apiClient);
this.operations = new Operations(this.apiClient);
this.authTokens = new Tokens(this.apiClient);
this.tunings = new Tunings(this.apiClient);
this.fileSearchStores = new FileSearchStores(this.apiClient);
}
};
function getEnv(env) {
var _a, _b, _c;
return (_c = (_b = (_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a[env]) === null || _b === void 0 ? void 0 : _b.trim()) !== null && _c !== void 0 ? _c : void 0;
}
function getBooleanEnv(env) {
return stringToBoolean(getEnv(env));
}
function stringToBoolean(str) {
if (str === void 0) {
return false;
}
return str.toLowerCase() === "true";
}
function getApiKeyFromEnv() {
const envGoogleApiKey = getEnv("GOOGLE_API_KEY");
const envGeminiApiKey = getEnv("GEMINI_API_KEY");
if (envGoogleApiKey && envGeminiApiKey) {
console.warn("Both GOOGLE_API_KEY and GEMINI_API_KEY are set. Using GOOGLE_API_KEY.");
}
return envGoogleApiKey || envGeminiApiKey || void 0;
}
// packages/core/src/policy/types.ts
var PolicyDecision = /* @__PURE__ */ ((PolicyDecision2) => {
PolicyDecision2["ALLOW"] = "allow";
PolicyDecision2["DENY"] = "deny";
PolicyDecision2["ASK_USER"] = "ask_user";
return PolicyDecision2;
})(PolicyDecision || {});
var VALID_HOOK_SOURCES = [
"project",
"user",
"system",
"extension"
];
function getHookSource(input) {
const source = input["hook_source"];
if (typeof source === "string" && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
VALID_HOOK_SOURCES.includes(source)) {
return source;
}
return "project";
}
var ApprovalMode = /* @__PURE__ */ ((ApprovalMode2) => {
ApprovalMode2["DEFAULT"] = "default";
ApprovalMode2["AUTO_EDIT"] = "autoEdit";
ApprovalMode2["YOLO"] = "yolo";
ApprovalMode2["PLAN"] = "plan";
return ApprovalMode2;
})(ApprovalMode || {});
var MODES_BY_PERMISSIVENESS = [
"plan" /* PLAN */,
"default" /* DEFAULT */,
"autoEdit" /* AUTO_EDIT */,
"yolo" /* YOLO */
];
var InProcessCheckerType = /* @__PURE__ */ ((InProcessCheckerType2) => {
InProcessCheckerType2["ALLOWED_PATH"] = "allowed-path";
InProcessCheckerType2["CONSECA"] = "conseca";
return InProcessCheckerType2;
})(InProcessCheckerType || {});
var PRIORITY_SUBAGENT_TOOL = 1.03;
var ALWAYS_ALLOW_PRIORITY_FRACTION = 950;
var ALWAYS_ALLOW_PRIORITY_OFFSET = ALWAYS_ALLOW_PRIORITY_FRACTION / 1e3;
var PRIORITY_YOLO_ALLOW_ALL = 998;
// packages/core/src/confirmation-bus/types.ts
var MessageBusType = /* @__PURE__ */ ((MessageBusType2) => {
MessageBusType2["TOOL_CONFIRMATION_REQUEST"] = "tool-confirmation-request";
MessageBusType2["TOOL_CONFIRMATION_RESPONSE"] = "tool-confirmation-response";
MessageBusType2["TOOL_POLICY_REJECTION"] = "tool-policy-rejection";
MessageBusType2["TOOL_EXECUTION_SUCCESS"] = "tool-execution-success";
MessageBusType2["TOOL_EXECUTION_FAILURE"] = "tool-execution-failure";
MessageBusType2["UPDATE_POLICY"] = "update-policy";
MessageBusType2["TOOL_CALLS_UPDATE"] = "tool-calls-update";
MessageBusType2["ASK_USER_REQUEST"] = "ask-user-request";
MessageBusType2["ASK_USER_RESPONSE"] = "ask-user-response";
MessageBusType2["SUBAGENT_ACTIVITY"] = "subagent-activity";
return MessageBusType2;
})(MessageBusType || {});
var QuestionType = /* @__PURE__ */ ((QuestionType2) => {
QuestionType2["CHOICE"] = "choice";
QuestionType2["TEXT"] = "text";
QuestionType2["YESNO"] = "yesno";
return QuestionType2;
})(QuestionType || {});
// packages/core/src/tools/tools.ts
function isBackgroundExecutionData(data) {
if (typeof data !== "object" || data === null) {
return false;
}
const pid = "pid" in data ? data.pid : void 0;
const command = "command" in data ? data.command : void 0;
const initialOutput = "initialOutput" in data ? data.initialOutput : void 0;
return (pid === void 0 || typeof pid === "number") && (command === void 0 || typeof command === "string") && (initialOutput === void 0 || typeof initialOutput === "string");
}
var BaseToolInvocation = class {
constructor(params, messageBus, _toolName, _toolDisplayName, _serverName, _toolAnnotations, respectsAutoEdit = false, getApprovalMode = () => "default" /* DEFAULT */) {
this.params = params;
this.messageBus = messageBus;
this._toolName = _toolName;
this._toolDisplayName = _toolDisplayName;
this._serverName = _serverName;
this._toolAnnotations = _toolAnnotations;
this.respectsAutoEdit = respectsAutoEdit;
this.getApprovalMode = getApprovalMode;
}
getDisplayTitle() {
return this.getDescription();
}
getExplanation() {
return "";
}
toolLocations() {
return [];
}
async shouldConfirmExecute(abortSignal, forcedDecision) {
if (this.respectsAutoEdit && this.getApprovalMode() === "autoEdit" /* AUTO_EDIT */ && forcedDecision !== "ask_user") {
return false;
}
const decision = forcedDecision ?? await this.getMessageBusDecision(abortSignal);
if (decision === "allow") {
return false;
}
if (decision === "deny") {
throw new Error(
`Tool execution for "${this._toolDisplayName || this._toolName}" denied by policy.`
);
}
if (decision === "ask_user") {
return this.getConfirmationDetails(abortSignal);
}
return this.getConfirmationDetails(abortSignal);
}
/**
* Returns tool-specific options for policy updates.
* Subclasses can override this to provide additional options like
* commandPrefix (for shell) or mcpName (for MCP tools).
*/
getPolicyUpdateOptions(_outcome) {
return void 0;
}
/**
* Helper method to publish a policy update when user selects
* ProceedAlways or ProceedAlwaysAndSave.
*/
async publishPolicyUpdate(outcome) {
if (outcome === "proceed_always" /* ProceedAlways */ || outcome === "proceed_always_and_save" /* ProceedAlwaysAndSave */) {
if (this._toolName) {
const options = this.getPolicyUpdateOptions(outcome);
void this.messageBus.publish({
type: "update-policy" /* UPDATE_POLICY */,
toolName: this._toolName,
persist: outcome === "proceed_always_and_save" /* ProceedAlwaysAndSave */,
...options
});
}
}
}
/**
* Subclasses should override this method to provide custom confirmation UI
* when the policy engine's decision is 'ask_user'.
* The base implementation provides a generic confirmation prompt.
*/
async getConfirmationDetails(_abortSignal) {
if (!this.messageBus) {
return false;
}
const confirmationDetails = {
type: "info",
title: `Confirm: ${this._toolDisplayName || this._toolName}`,
prompt: this.getDescription(),
onConfirm: async (_outcome) => {
}
};
return confirmationDetails;
}
getMessageBusDecision(abortSignal, forcedDecision) {
if (!this.messageBus || !this._toolName) {
return Promise.resolve("allow");
}
const correlationId = randomUUID();
const request = {
type: "tool-confirmation-request" /* TOOL_CONFIRMATION_REQUEST */,
correlationId,
toolCall: {
name: this._toolName,
// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
args: this.params
},
serverName: this._serverName,
toolAnnotations: this._toolAnnotations,
forcedDecision
};
return new Promise((resolve5) => {
if (!this.messageBus) {
resolve5("allow");
return;
}
let timeoutId = null;
let unsubscribe = null;
const cleanup = () => {
if (timeoutId) {
clearTimeout(timeoutId);
timeoutId = null;
}
if (unsubscribe) {
unsubscribe();
unsubscribe = null;
}
abortSignal.removeEventListener("abort", abortHandler);
};
const abortHandler = () => {
cleanup();
resolve5("deny");
};
if (abortSignal.aborted) {
resolve5("deny");
return;
}
const responseHandler = (response) => {
if (response.correlationId === correlationId) {
cleanup();
if (response.requiresUserConfirmation) {
resolve5("ask_user");
} else if (response.confirmed) {
resolve5("allow");
} else {
resolve5("deny");
}
}
};
abortSignal.addEventListener("abort", abortHandler, { once: true });
timeoutId = setTimeout(() => {
cleanup();
resolve5("ask_user");
}, 3e4);
this.messageBus.subscribe(
"tool-confirmation-response" /* TOOL_CONFIRMATION_RESPONSE */,
responseHandler
);
unsubscribe = () => {
this.messageBus?.unsubscribe(
"tool-confirmation-response" /* TOOL_CONFIRMATION_RESPONSE */,
responseHandler
);
};
try {
void this.messageBus.publish(request);
} catch {
cleanup();
resolve5("allow");
}
});
}
toJSON() {
return {
params: this.params
};
}
};
var DeclarativeTool = class {
constructor(name, displayName, description, kind, parameterSchema, messageBus, isOutputMarkdown = true, canUpdateOutput = false, extensionName, extensionId) {
this.name = name;
this.displayName = displayName;
this.description = description;
this.kind = kind;
this.parameterSchema = parameterSchema;
this.messageBus = messageBus;
this.isOutputMarkdown = isOutputMarkdown;
this.canUpdateOutput = canUpdateOutput;
this.extensionName = extensionName;
this.extensionId = extensionId;
}
clone(messageBus) {
const cloned = Object.assign(
// eslint-disable-next-line no-restricted-syntax
Object.create(Object.getPrototypeOf(this)),
this
);
if (messageBus) {
Object.defineProperty(cloned, "messageBus", {
value: messageBus,
writable: false,
configurable: true
});
}
return cloned;
}
toJSON() {
return {
name: this.name,
displayName: this.displayName,
description: this.description,
kind: this.kind,
parameterSchema: this.parameterSchema
};
}
get isReadOnly() {
return READ_ONLY_KINDS.includes(this.kind);
}
get toolAnnotations() {
return void 0;
}
getSchema(_modelId) {
return {
name: this.name,
description: this.description,
parametersJsonSchema: this.addWaitForPreviousParameter(
this.parameterSchema
)
};
}
/**
* Type guard to check if an unknown value represents a ToolParameterSchema object.
*/
isParameterSchema(obj) {
return isRecord(obj) && "type" in obj;
}
/**
* Adds the `wait_for_previous` parameter to the tool's schema.
* This allows the model to explicitly control parallel vs sequential execution.
*/
addWaitForPreviousParameter(schema) {
if (!this.isParameterSchema(schema) || schema.type !== "object") {
return schema;
}
const props = schema.properties;
let propertiesObj = {};
if (props !== void 0) {
if (!isRecord(props)) {
return schema;
}
propertiesObj = props;
}
return {
...schema,
properties: {
...propertiesObj,
wait_for_previous: {
type: "boolean",
description: "Set to true to wait for all previously requested tools in this turn to complete before starting. Set to false (or omit) to run in parallel. Use true when this tool depends on the output of previous tools."
}
}
};
}
get schema() {
return this.getSchema();
}
/**
* Validates the raw tool parameters.
* Subclasses should override this to add custom validation logic
* beyond the JSON schema check.
* @param params The raw parameters from the model.
* @returns An error message string if invalid, null otherwise.
*/
validateToolParams(_params) {
return null;
}
/**
* A convenience method that builds and executes the tool in one step.
* Throws an error if validation fails.
* @param params The raw, untrusted parameters from the model.
* @param signal AbortSignal for tool cancellation.
* @param updateOutput Optional callback to stream output.
* @returns The result of the tool execution.
*/
async buildAndExecute(params, signal, updateOutput, options) {
const invocation = this.build(params);
return invocation.execute({
...options,
abortSignal: signal,
updateOutput
});
}
/**
* Similar to `build` but never throws.
* @param params The raw, untrusted parameters from the model.
* @returns A `ToolInvocation` instance.
*/
silentBuild(params) {
try {
return this.build(params);
} catch (e) {
if (e instanceof Error) {
return e;
}
return new Error(String(e));
}
}
/**
* A convenience method that builds and executes the tool in one step.
* Never throws.
* @param params The raw, untrusted parameters from the model.
* @param abortSignal a signal to abort.
* @returns The result of the tool execution.
*/
async validateBuildAndExecute(params, abortSignal) {
const invocationOrError = this.silentBuild(params);
if (invocationOrError instanceof Error) {
const errorMessage = invocationOrError.message;
return {
llmContent: `Error: Invalid parameters provided. Reason: ${errorMessage}`,
returnDisplay: errorMessage,
error: {
message: errorMessage,
type: "invalid_tool_params" /* INVALID_TOOL_PARAMS */
}
};
}
try {
return await invocationOrError.execute({ abortSignal });
} catch (error) {
const errorMessage = error instanceof Error ? error.message : String(error);
return {
llmContent: `Error: Tool call execution failed. Reason: ${errorMessage}`,
returnDisplay: errorMessage,
error: {
message: errorMessage,
type: "execution_failed" /* EXECUTION_FAILED */
}
};
}
}
};
var BaseDeclarativeTool = class extends DeclarativeTool {
build(params) {
const validationError = this.validateToolParams(params);
if (validationError) {
throw new Error(validationError);
}
return this.createInvocation(
params,
this.messageBus,
this.name,
this.displayName
);
}
validateToolParams(params) {
const errors = SchemaValidator.validate(
this.schema.parametersJsonSchema,
params
);
if (errors) {
return errors;
}
return this.validateToolParamValues(params);
}
validateToolParamValues(_params) {
return null;
}
};
function isTool(obj) {
return typeof obj === "object" && obj !== null && "name" in obj && "build" in obj && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
typeof obj.build === "function";
}
function hasCycleInSchema(schema) {
function resolveRef(ref) {
if (!ref.startsWith("#/")) {
return null;
}
const path10 = ref.substring(2).split("/");
let current = schema;
for (const segment of path10) {
if (typeof current !== "object" || current === null || !Object.prototype.hasOwnProperty.call(current, segment)) {
return null;
}
current = current[segment];
}
return current;
}
function traverse(node, visitedRefs, pathRefs) {
if (typeof node !== "object" || node === null) {
return false;
}
if (Array.isArray(node)) {
for (const item of node) {
if (traverse(item, visitedRefs, pathRefs)) {
return true;
}
}
return false;
}
if ("$ref" in node && typeof node.$ref === "string") {
const ref = node.$ref;
if (ref === "#" || ref === "#/" || pathRefs.has(ref)) {
return true;
}
if (visitedRefs.has(ref)) {
return false;
}
const resolvedNode = resolveRef(ref);
if (resolvedNode) {
visitedRefs.add(ref);
pathRefs.add(ref);
const hasCycle = traverse(resolvedNode, visitedRefs, pathRefs);
pathRefs.delete(ref);
return hasCycle;
}
}
for (const key in node) {
if (Object.prototype.hasOwnProperty.call(node, key)) {
if (traverse(
// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
node[key],
visitedRefs,
pathRefs
)) {
return true;
}
}
}
return false;
}
return traverse(schema, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
}
function isStructuredToolResult(obj) {
return typeof obj === "object" && obj !== null && "summary" in obj && typeof obj.summary === "string";
}
var hasSummary = (res) => isStructuredToolResult(res);
var isGrepResult = (res) => isStructuredToolResult(res) && "matches" in res && Array.isArray(res.matches);
var isListResult = (res) => isStructuredToolResult(res) && "files" in res && Array.isArray(res.files);
var isReadManyFilesResult = (res) => isListResult(res) && "include" in res;
var isFileDiff = (res) => typeof res === "object" && res !== null && "fileDiff" in res && "fileName" in res && "filePath" in res;
var ToolConfirmationOutcome = /* @__PURE__ */ ((ToolConfirmationOutcome2) => {
ToolConfirmationOutcome2["ProceedOnce"] = "proceed_once";
ToolConfirmationOutcome2["ProceedAlways"] = "proceed_always";
ToolConfirmationOutcome2["ProceedAlwaysAndSave"] = "proceed_always_and_save";
ToolConfirmationOutcome2["ProceedAlwaysServer"] = "proceed_always_server";
ToolConfirmationOutcome2["ProceedAlwaysTool"] = "proceed_always_tool";
ToolConfirmationOutcome2["ModifyWithEditor"] = "modify_with_editor";
ToolConfirmationOutcome2["Cancel"] = "cancel";
return ToolConfirmationOutcome2;
})(ToolConfirmationOutcome || {});
var Kind = /* @__PURE__ */ ((Kind2) => {
Kind2["Read"] = "read";
Kind2["Edit"] = "edit";
Kind2["Delete"] = "delete";
Kind2["Move"] = "move";
Kind2["Search"] = "search";
Kind2["Execute"] = "execute";
Kind2["Think"] = "think";
Kind2["Agent"] = "agent";
Kind2["Fetch"] = "fetch";
Kind2["Communicate"] = "communicate";
Kind2["Plan"] = "plan";
Kind2["SwitchMode"] = "switch_mode";
Kind2["Other"] = "other";
return Kind2;
})(Kind || {});
var MUTATOR_KINDS = [
"edit" /* Edit */,
"delete" /* Delete */,
"move" /* Move */,
"execute" /* Execute */
];
var READ_ONLY_KINDS = [
"read" /* Read */,
"search" /* Search */,
"fetch" /* Fetch */
];
// packages/core/src/tools/memoryTool.ts
import * as fs8 from "node:fs/promises";
import * as path7 from "node:path";
// packages/core/src/config/storage.ts
import * as path6 from "node:path";
import * as os3 from "node:os";
import * as crypto3 from "node:crypto";
import * as fs7 from "node:fs";
// packages/core/src/utils/paths.ts
import path3 from "node:path";
import os from "node:os";
import * as crypto2 from "node:crypto";
import * as fs4 from "node:fs";
import { fileURLToPath } from "node:url";
var GEMINI_DIR = ".gemini";
var GOOGLE_ACCOUNTS_FILENAME = "google_accounts.json";
var TRUSTED_FOLDERS_FILENAME = "trustedFolders.json";
function homedir() {
const envHome = process.env["GEMINI_CLI_HOME"];
if (envHome) {
return envHome;
}
return os.homedir();
}
function tmpdir() {
return os.tmpdir();
}
function tildeifyPath(path10) {
const homeDir = homedir();
if (path10.startsWith(homeDir)) {
return path10.replace(homeDir, "~");
}
return path10;
}
function shortenPath(filePath, maxLen = 35) {
if (filePath.length <= maxLen) {
return filePath;
}
const simpleTruncate = () => {
const keepLen = Math.floor((maxLen - 3) / 2);
if (keepLen <= 0) {
return filePath.substring(0, maxLen - 3) + "...";
}
const start = filePath.substring(0, keepLen);
const end = filePath.substring(filePath.length - keepLen);
return `${start}...${end}`;
};
const truncateComponent = (component, targetLength, mode) => {
if (component.length <= targetLength) {
return component;
}
if (targetLength <= 0) {
return "";
}
if (targetLength <= 3) {
if (mode === "end") {
return component.slice(-targetLength);
}
return component.slice(0, targetLength);
}
if (mode === "start") {
return `${component.slice(0, targetLength - 3)}...`;
}
if (mode === "end") {
return `...${component.slice(component.length - (targetLength - 3))}`;
}
const front = Math.ceil((targetLength - 3) / 2);
const back = targetLength - 3 - front;
return `${component.slice(0, front)}...${component.slice(
component.length - back
)}`;
};
const parsedPath = path3.parse(filePath);
const root = parsedPath.root;
const separator = path3.sep;
const relativePath = filePath.substring(root.length);
const segments = relativePath.split(separator).filter((s) => s !== "");
if (segments.length <= 1) {
return simpleTruncate();
}
const firstDir = segments[0];
const lastSegment = segments[segments.length - 1];
const startComponent = root + firstDir;
const endPartSegments = [lastSegment];
let endPartLength = lastSegment.length;
for (let i = segments.length - 2; i > 0; i--) {
const segment = segments[i];
const newLength = startComponent.length + separator.length + 3 + // for "..."
separator.length + endPartLength + separator.length + segment.length;
if (newLength <= maxLen) {
endPartSegments.unshift(segment);
endPartLength += separator.length + segment.length;
} else {
break;
}
}
const components = [firstDir, ...endPartSegments];
const componentModes = components.map((_, index) => {
if (index === 0) {
return "start";
}
if (index === components.length - 1) {
return "end";
}
return "center";
});
const separatorsCount = endPartSegments.length + 1;
const fixedLen = root.length + separatorsCount * separator.length + 3;
const availableForComponents = maxLen - fixedLen;
const trailingFallback = () => {
const ellipsisTail = `...${separator}${lastSegment}`;
if (ellipsisTail.length <= maxLen) {
return ellipsisTail;
}
if (root) {
const rootEllipsisTail = `${root}...${separator}${lastSegment}`;
if (rootEllipsisTail.length <= maxLen) {
return rootEllipsisTail;
}
}
if (root && `${root}${lastSegment}`.length <= maxLen) {
return `${root}${lastSegment}`;
}
if (lastSegment.length <= maxLen) {
return lastSegment;
}
return simpleTruncate();
};
if (availableForComponents <= 0) {
return trailingFallback();
}
const minLengths = components.map((component, index) => {
if (index === 0) {
return Math.min(component.length, 1);
}
if (index === components.length - 1) {
return component.length;
}
return Math.min(component.length, 1);
});
const minTotal = minLengths.reduce((sum, len) => sum + len, 0);
if (availableForComponents < minTotal) {
return trailingFallback();
}
const budgets = components.map((component) => component.length);
let currentTotal = budgets.reduce((sum, len) => sum + len, 0);
const pickIndexToReduce = () => {
let bestIndex = -1;
let bestScore = -Infinity;
for (let i = 0; i < budgets.length; i++) {
if (budgets[i] <= minLengths[i]) {
continue;
}
const isLast = i === budgets.length - 1;
const score = (isLast ? 0 : 1e6) + budgets[i];
if (score > bestScore) {
bestScore = score;
bestIndex = i;
}
}
return bestIndex;
};
while (currentTotal > availableForComponents) {
const index = pickIndexToReduce();
if (index === -1) {
return trailingFallback();
}
budgets[index]--;
currentTotal--;
}
const truncatedComponents = components.map(
(component, index) => truncateComponent(component, budgets[index], componentModes[index])
);
const truncatedFirst = truncatedComponents[0];
const truncatedEnd = truncatedComponents.slice(1).join(separator);
const result = `${root}${truncatedFirst}${separator}...${separator}${truncatedEnd}`;
if (result.length > maxLen) {
return trailingFallback();
}
return result;
}
function makeRelative(targetPath, rootDirectory) {
if (!path3.isAbsolute(targetPath)) {
return targetPath;
}
const resolvedRootDirectory = path3.resolve(rootDirectory);
const relativePath = path3.relative(resolvedRootDirectory, targetPath);
return relativePath || ".";
}
function escapePath(filePath) {
if (process.platform === "win32") {
if (/[\s&()[\]{}^=;!'+,`~%$@#]/.test(filePath)) {
return `"${filePath}"`;
}
return filePath;
} else {
return filePath.replace(/([ \t()[\]{};|*?$`'"#&<>!~\\])/g, "\\$1");
}
}
function unescapePath(filePath) {
if (process.platform === "win32") {
if (filePath.length >= 2 && filePath.startsWith('"') && filePath.endsWith('"')) {
return filePath.slice(1, -1);
}
return filePath;
} else {
return filePath.replace(/\\(.)/g, "$1");
}
}
function getProjectHash(projectRoot) {
return crypto2.createHash("sha256").update(projectRoot).digest("hex");
}
function toAbsolutePath(p) {
const isWindows = process.platform === "win32";
const pathModule = isWindows ? path3.win32 : path3;
return pathModule.resolve(p).replace(/\\/g, "/");
}
function normalizePath(p) {
const absolute = toAbsolutePath(p);
const platform4 = process.platform;
const isCaseInsensitive = platform4 === "win32" || platform4 === "darwin";
return isCaseInsensitive ? absolute.toLowerCase() : absolute;
}
function isSubpath(parentPath, childPath) {
const platform4 = process.platform;
const isWindows = platform4 === "win32";
const isDarwin = platform4 === "darwin";
const pathModule = isWindows ? path3.win32 : path3;
let p = pathModule.resolve(parentPath);
let c = pathModule.resolve(childPath);
if (isDarwin) {
p = p.toLowerCase();
c = c.toLowerCase();
}
const relative = pathModule.relative(p, c);
return !relative.startsWith(`..${pathModule.sep}`) && relative !== ".." && !pathModule.isAbsolute(relative);
}
function isValidPathString(p) {
return typeof p === "string" && !p.includes("\0");
}
function assertValidPathString(p) {
if (!isValidPathString(p)) {
throw new Error(`Invalid path: ${String(p)}`);
}
}
function resolveToRealPath(pathStr) {
assertValidPathString(pathStr);
let resolvedPath = pathStr;
try {
if (resolvedPath.startsWith("file://")) {
resolvedPath = fileURLToPath(resolvedPath);
}
resolvedPath = decodeURIComponent(resolvedPath);
} catch {
}
return robustRealpath(path3.resolve(resolvedPath));
}
function robustRealpath(p, visited = /* @__PURE__ */ new Set()) {
const key = process.platform === "win32" ? p.toLowerCase() : p;
if (visited.has(key)) {
throw new Error(`Infinite recursion detected in robustRealpath: ${p}`);
}
visited.add(key);
try {
return fs4.realpathSync(p);
} catch (e) {
if (e && typeof e === "object" && "code" in e && (e.code === "ENOENT" || e.code === "EISDIR")) {
try {
const stat3 = fs4.lstatSync(p);
if (stat3.isSymbolicLink()) {
const target = fs4.readlinkSync(p);
const resolvedTarget = path3.resolve(path3.dirname(p), target);
return robustRealpath(resolvedTarget, visited);
}
} catch (lstatError) {
if (!(lstatError && typeof lstatError === "object" && "code" in lstatError && (lstatError.code === "ENOENT" || lstatError.code === "EISDIR"))) {
throw lstatError;
}
}
const parent = path3.dirname(p);
if (parent === p) return p;
return path3.join(robustRealpath(parent, visited), path3.basename(p));
}
throw e;
}
}
function deduplicateAbsolutePaths(paths) {
if (!paths || paths.length === 0) return [];
const uniquePathsMap = /* @__PURE__ */ new Map();
for (const p of paths) {
if (!path3.isAbsolute(p)) {
throw new Error(`Path must be absolute: ${p}`);
}
const key = toPathKey(p);
if (!uniquePathsMap.has(key)) {
uniquePathsMap.set(key, p);
}
}
return Array.from(uniquePathsMap.values());
}
function toPathKey(p) {
let norm = path3.normalize(p);
if (norm.length > 1 && (norm.endsWith("/") || norm.endsWith("\\"))) {
if (!/^[a-zA-Z]:[\\/]$/.test(norm)) {
norm = norm.slice(0, -1);
}
}
const platform4 = process.platform;
const isCaseInsensitive = platform4 === "win32" || platform4 === "darwin";
return isCaseInsensitive ? norm.toLowerCase() : norm;
}
// packages/core/src/config/projectRegistry.ts
var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
import { randomUUID as randomUUID2 } from "node:crypto";
import * as fs5 from "node:fs";
import * as path4 from "node:path";
import * as os2 from "node:os";
// node_modules/zod/v3/external.js
var external_exports = {};
__export(external_exports, {
BRAND: () => BRAND,
DIRTY: () => DIRTY,
EMPTY_PATH: () => EMPTY_PATH,
INVALID: () => INVALID,
NEVER: () => NEVER,
OK: () => OK,
ParseStatus: () => ParseStatus,
Schema: () => ZodType,
ZodAny: () => ZodAny,
ZodArray: () => ZodArray,
ZodBigInt: () => ZodBigInt,
ZodBoolean: () => ZodBoolean,
ZodBranded: () => ZodBranded,
ZodCatch: () => ZodCatch,
ZodDate: () => ZodDate,
ZodDefault: () => ZodDefault,
ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
ZodEffects: () => ZodEffects,
ZodEnum: () => ZodEnum,
ZodError: () => ZodError,
ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
ZodFunction: () => ZodFunction,
ZodIntersection: () => ZodIntersection,
ZodIssueCode: () => ZodIssueCode,
ZodLazy: () => ZodLazy,
ZodLiteral: () => ZodLiteral,
ZodMap: () => ZodMap,
ZodNaN: () => ZodNaN,
ZodNativeEnum: () => ZodNativeEnum,
ZodNever: () => ZodNever,
ZodNull: () => ZodNull,
ZodNullable: () => ZodNullable,
ZodNumber: () => ZodNumber,
ZodObject: () => ZodObject,
ZodOptional: () => ZodOptional,
ZodParsedType: () => ZodParsedType,
ZodPipeline: () => ZodPipeline,
ZodPromise: () => ZodPromise,
ZodReadonly: () => ZodReadonly,
ZodRecord: () => ZodRecord,
ZodSchema: () => ZodType,
ZodSet: () => ZodSet,
ZodString: () => ZodString,
ZodSymbol: () => ZodSymbol,
ZodTransformer: () => ZodEffects,
ZodTuple: () => ZodTuple,
ZodType: () => ZodType,
ZodUndefined: () => ZodUndefined,
ZodUnion: () => ZodUnion,
ZodUnknown: () => ZodUnknown,
ZodVoid: () => ZodVoid,
addIssueToContext: () => addIssueToContext,
any: () => anyType,
array: () => arrayType,
bigint: () => bigIntType,
boolean: () => booleanType,
coerce: () => coerce,
custom: () => custom,
date: () => dateType,
datetimeRegex: () => datetimeRegex,
defaultErrorMap: () => en_default,
discriminatedUnion: () => discriminatedUnionType,
effect: () => effectsType,
enum: () => enumType,
function: () => functionType,
getErrorMap: () => getErrorMap,
getParsedType: () => getParsedType,
instanceof: () => instanceOfType,
intersection: () => intersectionType,
isAborted: () => isAborted,
isAsync: () => isAsync,
isDirty: () => isDirty,
isValid: () => isValid,
late: () => late,
lazy: () => lazyType,
literal: () => literalType,
makeIssue: () => makeIssue,
map: () => mapType,
nan: () => nanType,
nativeEnum: () => nativeEnumType,
never: () => neverType,
null: () => nullType,
nullable: () => nullableType,
number: () => numberType,
object: () => objectType,
objectUtil: () => objectUtil,
oboolean: () => oboolean,
onumber: () => onumber,
optional: () => optionalType,
ostring: () => ostring,
pipeline: () => pipelineType,
preprocess: () => preprocessType,
promise: () => promiseType,
quotelessJson: () => quotelessJson,
record: () => recordType,
set: () => setType,
setErrorMap: () => setErrorMap,
strictObject: () => strictObjectType,
string: () => stringType,
symbol: () => symbolType,
transformer: () => effectsType,
tuple: () => tupleType,
undefined: () => undefinedType,
union: () => unionType,
unknown: () => unknownType,
util: () => util2,
void: () => voidType
});
// node_modules/zod/v3/helpers/util.js
var util2;
(function(util3) {
util3.assertEqual = (_) => {
};
function assertIs(_arg) {
}
util3.assertIs = assertIs;
function assertNever(_x) {
throw new Error();
}
util3.assertNever = assertNever;
util3.arrayToEnum = (items) => {
const obj = {};
for (const item of items) {
obj[item] = item;
}
return obj;
};
util3.getValidEnumValues = (obj) => {
const validKeys = util3.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
const filtered = {};
for (const k of validKeys) {
filtered[k] = obj[k];
}
return util3.objectValues(filtered);
};
util3.objectValues = (obj) => {
return util3.objectKeys(obj).map(function(e) {
return obj[e];
});
};
util3.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
const keys = [];
for (const key in object) {
if (Object.prototype.hasOwnProperty.call(object, key)) {
keys.push(key);
}
}
return keys;
};
util3.find = (arr, checker) => {
for (const item of arr) {
if (checker(item))
return item;
}
return void 0;
};
util3.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
function joinValues(array, separator = " | ") {
return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
}
util3.joinValues = joinValues;
util3.jsonStringifyReplacer = (_, value) => {
if (typeof value === "bigint") {
return value.toString();
}
return value;
};
})(util2 || (util2 = {}));
var objectUtil;
(function(objectUtil2) {
objectUtil2.mergeShapes = (first, second) => {
return {
...first,
...second
// second overwrites first
};
};
})(objectUtil || (objectUtil = {}));
var ZodParsedType = util2.arrayToEnum([
"string",
"nan",
"number",
"integer",
"float",
"boolean",
"date",
"bigint",
"symbol",
"function",
"undefined",
"null",
"array",
"object",
"unknown",
"promise",
"void",
"never",
"map",
"set"
]);
var getParsedType = (data) => {
const t = typeof data;
switch (t) {
case "undefined":
return ZodParsedType.undefined;
case "string":
return ZodParsedType.string;
case "number":
return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
case "boolean":
return ZodParsedType.boolean;
case "function":
return ZodParsedType.function;
case "bigint":
return ZodParsedType.bigint;
case "symbol":
return ZodParsedType.symbol;
case "object":
if (Array.isArray(data)) {
return ZodParsedType.array;
}
if (data === null) {
return ZodParsedType.null;
}
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
return ZodParsedType.promise;
}
if (typeof Map !== "undefined" && data instanceof Map) {
return ZodParsedType.map;
}
if (typeof Set !== "undefined" && data instanceof Set) {
return ZodParsedType.set;
}
if (typeof Date !== "undefined" && data instanceof Date) {
return ZodParsedType.date;
}
return ZodParsedType.object;
default:
return ZodParsedType.unknown;
}
};
// node_modules/zod/v3/ZodError.js
var ZodIssueCode = util2.arrayToEnum([
"invalid_type",
"invalid_literal",
"custom",
"invalid_union",
"invalid_union_discriminator",
"invalid_enum_value",
"unrecognized_keys",
"invalid_arguments",
"invalid_return_type",
"invalid_date",
"invalid_string",
"too_small",
"too_big",
"invalid_intersection_types",
"not_multiple_of",
"not_finite"
]);
var quotelessJson = (obj) => {
const json = JSON.stringify(obj, null, 2);
return json.replace(/"([^"]+)":/g, "$1:");
};
var ZodError = class _ZodError extends Error {
get errors() {
return this.issues;
}
constructor(issues) {
super();
this.issues = [];
this.addIssue = (sub) => {
this.issues = [...this.issues, sub];
};
this.addIssues = (subs = []) => {
this.issues = [...this.issues, ...subs];
};
const actualProto = new.target.prototype;
if (Object.setPrototypeOf) {
Object.setPrototypeOf(this, actualProto);
} else {
this.__proto__ = actualProto;
}
this.name = "ZodError";
this.issues = issues;
}
format(_mapper) {
const mapper = _mapper || function(issue) {
return issue.message;
};
const fieldErrors = { _errors: [] };
const processError = (error) => {
for (const issue of error.issues) {
if (issue.code === "invalid_union") {
issue.unionErrors.map(processError);
} else if (issue.code === "invalid_return_type") {
processError(issue.returnTypeError);
} else if (issue.code === "invalid_arguments") {
processError(issue.argumentsError);
} else if (issue.path.length === 0) {
fieldErrors._errors.push(mapper(issue));
} else {
let curr = fieldErrors;
let i = 0;
while (i < issue.path.length) {
const el = issue.path[i];
const terminal = i === issue.path.length - 1;
if (!terminal) {
curr[el] = curr[el] || { _errors: [] };
} else {
curr[el] = curr[el] || { _errors: [] };
curr[el]._errors.push(mapper(issue));
}
curr = curr[el];
i++;
}
}
}
};
processError(this);
return fieldErrors;
}
static assert(value) {
if (!(value instanceof _ZodError)) {
throw new Error(`Not a ZodError: ${value}`);
}
}
toString() {
return this.message;
}
get message() {
return JSON.stringify(this.issues, util2.jsonStringifyReplacer, 2);
}
get isEmpty() {
return this.issues.length === 0;
}
flatten(mapper = (issue) => issue.message) {
const fieldErrors = {};
const formErrors = [];
for (const sub of this.issues) {
if (sub.path.length > 0) {
const firstEl = sub.path[0];
fieldErrors[firstEl] = fieldErrors[firstEl] || [];
fieldErrors[firstEl].push(mapper(sub));
} else {
formErrors.push(mapper(sub));
}
}
return { formErrors, fieldErrors };
}
get formErrors() {
return this.flatten();
}
};
ZodError.create = (issues) => {
const error = new ZodError(issues);
return error;
};
// node_modules/zod/v3/locales/en.js
var errorMap = (issue, _ctx) => {
let message;
switch (issue.code) {
case ZodIssueCode.invalid_type:
if (issue.received === ZodParsedType.undefined) {
message = "Required";
} else {
message = `Expected ${issue.expected}, received ${issue.received}`;
}
break;
case ZodIssueCode.invalid_literal:
message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util2.jsonStringifyReplacer)}`;
break;
case ZodIssueCode.unrecognized_keys:
message = `Unrecognized key(s) in object: ${util2.joinValues(issue.keys, ", ")}`;
break;
case ZodIssueCode.invalid_union:
message = `Invalid input`;
break;
case ZodIssueCode.invalid_union_discriminator:
message = `Invalid discriminator value. Expected ${util2.joinValues(issue.options)}`;
break;
case ZodIssueCode.invalid_enum_value:
message = `Invalid enum value. Expected ${util2.joinValues(issue.options)}, received '${issue.received}'`;
break;
case ZodIssueCode.invalid_arguments:
message = `Invalid function arguments`;
break;
case ZodIssueCode.invalid_return_type:
message = `Invalid function return type`;
break;
case ZodIssueCode.invalid_date:
message = `Invalid date`;
break;
case ZodIssueCode.invalid_string:
if (typeof issue.validation === "object") {
if ("includes" in issue.validation) {
message = `Invalid input: must include "${issue.validation.includes}"`;
if (typeof issue.validation.position === "number") {
message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
}
} else if ("startsWith" in issue.validation) {
message = `Invalid input: must start with "${issue.validation.startsWith}"`;
} else if ("endsWith" in issue.validation) {
message = `Invalid input: must end with "${issue.validation.endsWith}"`;
} else {
util2.assertNever(issue.validation);
}
} else if (issue.validation !== "regex") {
message = `Invalid ${issue.validation}`;
} else {
message = "Invalid";
}
break;
case ZodIssueCode.too_small:
if (issue.type === "array")
message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
else if (issue.type === "string")
message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
else if (issue.type === "number")
message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
else if (issue.type === "bigint")
message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
else if (issue.type === "date")
message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
else
message = "Invalid input";
break;
case ZodIssueCode.too_big:
if (issue.type === "array")
message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
else if (issue.type === "string")
message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
else if (issue.type === "number")
message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
else if (issue.type === "bigint")
message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
else if (issue.type === "date")
message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
else
message = "Invalid input";
break;
case ZodIssueCode.custom:
message = `Invalid input`;
break;
case ZodIssueCode.invalid_intersection_types:
message = `Intersection results could not be merged`;
break;
case ZodIssueCode.not_multiple_of:
message = `Number must be a multiple of ${issue.multipleOf}`;
break;
case ZodIssueCode.not_finite:
message = "Number must be finite";
break;
default:
message = _ctx.defaultError;
util2.assertNever(issue);
}
return { message };
};
var en_default = errorMap;
// node_modules/zod/v3/errors.js
var overrideErrorMap = en_default;
function setErrorMap(map) {
overrideErrorMap = map;
}
function getErrorMap() {
return overrideErrorMap;
}
// node_modules/zod/v3/helpers/parseUtil.js
var makeIssue = (params) => {
const { data, path: path10, errorMaps, issueData } = params;
const fullPath = [...path10, ...issueData.path || []];
const fullIssue = {
...issueData,
path: fullPath
};
if (issueData.message !== void 0) {
return {
...issueData,
path: fullPath,
message: issueData.message
};
}
let errorMessage = "";
const maps = errorMaps.filter((m) => !!m).slice().reverse();
for (const map of maps) {
errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
}
return {
...issueData,
path: fullPath,
message: errorMessage
};
};
var EMPTY_PATH = [];
function addIssueToContext(ctx, issueData) {
const overrideMap = getErrorMap();
const issue = makeIssue({
issueData,
data: ctx.data,
path: ctx.path,
errorMaps: [
ctx.common.contextualErrorMap,
// contextual error map is first priority
ctx.schemaErrorMap,
// then schema-bound map if available
overrideMap,
// then global override map
overrideMap === en_default ? void 0 : en_default
// then global default map
].filter((x) => !!x)
});
ctx.common.issues.push(issue);
}
var ParseStatus = class _ParseStatus {
constructor() {
this.value = "valid";
}
dirty() {
if (this.value === "valid")
this.value = "dirty";
}
abort() {
if (this.value !== "aborted")
this.value = "aborted";
}
static mergeArray(status, results) {
const arrayValue = [];
for (const s of results) {
if (s.status === "aborted")
return INVALID;
if (s.status === "dirty")
status.dirty();
arrayValue.push(s.value);
}
return { status: status.value, value: arrayValue };
}
static async mergeObjectAsync(status, pairs) {
const syncPairs = [];
for (const pair of pairs) {
const key = await pair.key;
const value = await pair.value;
syncPairs.push({
key,
value
});
}
return _ParseStatus.mergeObjectSync(status, syncPairs);
}
static mergeObjectSync(status, pairs) {
const finalObject = {};
for (const pair of pairs) {
const { key, value } = pair;
if (key.status === "aborted")
return INVALID;
if (value.status === "aborted")
return INVALID;
if (key.status === "dirty")
status.dirty();
if (value.status === "dirty")
status.dirty();
if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
finalObject[key.value] = value.value;
}
}
return { status: status.value, value: finalObject };
}
};
var INVALID = Object.freeze({
status: "aborted"
});
var DIRTY = (value) => ({ status: "dirty", value });
var OK = (value) => ({ status: "valid", value });
var isAborted = (x) => x.status === "aborted";
var isDirty = (x) => x.status === "dirty";
var isValid = (x) => x.status === "valid";
var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
// node_modules/zod/v3/helpers/errorUtil.js
var errorUtil;
(function(errorUtil2) {
errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
})(errorUtil || (errorUtil = {}));
// node_modules/zod/v3/types.js
var ParseInputLazyPath = class {
constructor(parent, value, path10, key) {
this._cachedPath = [];
this.parent = parent;
this.data = value;
this._path = path10;
this._key = key;
}
get path() {
if (!this._cachedPath.length) {
if (Array.isArray(this._key)) {
this._cachedPath.push(...this._path, ...this._key);
} else {
this._cachedPath.push(...this._path, this._key);
}
}
return this._cachedPath;
}
};
var handleResult = (ctx, result) => {
if (isValid(result)) {
return { success: true, data: result.value };
} else {
if (!ctx.common.issues.length) {
throw new Error("Validation failed but no issues detected.");
}
return {
success: false,
get error() {
if (this._error)
return this._error;
const error = new ZodError(ctx.common.issues);
this._error = error;
return this._error;
}
};
}
};
function processCreateParams(params) {
if (!params)
return {};
const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
if (errorMap2 && (invalid_type_error || required_error)) {
throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
}
if (errorMap2)
return { errorMap: errorMap2, description };
const customMap = (iss, ctx) => {
const { message } = params;
if (iss.code === "invalid_enum_value") {
return { message: message ?? ctx.defaultError };
}
if (typeof ctx.data === "undefined") {
return { message: message ?? required_error ?? ctx.defaultError };
}
if (iss.code !== "invalid_type")
return { message: ctx.defaultError };
return { message: message ?? invalid_type_error ?? ctx.defaultError };
};
return { errorMap: customMap, description };
}
var ZodType = class {
get description() {
return this._def.description;
}
_getType(input) {
return getParsedType(input.data);
}
_getOrReturnCtx(input, ctx) {
return ctx || {
common: input.parent.common,
data: input.data,
parsedType: getParsedType(input.data),
schemaErrorMap: this._def.errorMap,
path: input.path,
parent: input.parent
};
}
_processInputParams(input) {
return {
status: new ParseStatus(),
ctx: {
common: input.parent.common,
data: input.data,
parsedType: getParsedType(input.data),
schemaErrorMap: this._def.errorMap,
path: input.path,
parent: input.parent
}
};
}
_parseSync(input) {
const result = this._parse(input);
if (isAsync(result)) {
throw new Error("Synchronous parse encountered promise.");
}
return result;
}
_parseAsync(input) {
const result = this._parse(input);
return Promise.resolve(result);
}
parse(data, params) {
const result = this.safeParse(data, params);
if (result.success)
return result.data;
throw result.error;
}
safeParse(data, params) {
const ctx = {
common: {
issues: [],
async: params?.async ?? false,
contextualErrorMap: params?.errorMap
},
path: params?.path || [],
schemaErrorMap: this._def.errorMap,
parent: null,
data,
parsedType: getParsedType(data)
};
const result = this._parseSync({ data, path: ctx.path, parent: ctx });
return handleResult(ctx, result);
}
"~validate"(data) {
const ctx = {
common: {
issues: [],
async: !!this["~standard"].async
},
path: [],
schemaErrorMap: this._def.errorMap,
parent: null,
data,
parsedType: getParsedType(data)
};
if (!this["~standard"].async) {
try {
const result = this._parseSync({ data, path: [], parent: ctx });
return isValid(result) ? {
value: result.value
} : {
issues: ctx.common.issues
};
} catch (err) {
if (err?.message?.toLowerCase()?.includes("encountered")) {
this["~standard"].async = true;
}
ctx.common = {
issues: [],
async: true
};
}
}
return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
value: result.value
} : {
issues: ctx.common.issues
});
}
async parseAsync(data, params) {
const result = await this.safeParseAsync(data, params);
if (result.success)
return result.data;
throw result.error;
}
async safeParseAsync(data, params) {
const ctx = {
common: {
issues: [],
contextualErrorMap: params?.errorMap,
async: true
},
path: params?.path || [],
schemaErrorMap: this._def.errorMap,
parent: null,
data,
parsedType: getParsedType(data)
};
const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
return handleResult(ctx, result);
}
refine(check, message) {
const getIssueProperties = (val) => {
if (typeof message === "string" || typeof message === "undefined") {
return { message };
} else if (typeof message === "function") {
return message(val);
} else {
return message;
}
};
return this._refinement((val, ctx) => {
const result = check(val);
const setError = () => ctx.addIssue({
code: ZodIssueCode.custom,
...getIssueProperties(val)
});
if (typeof Promise !== "undefined" && result instanceof Promise) {
return result.then((data) => {
if (!data) {
setError();
return false;
} else {
return true;
}
});
}
if (!result) {
setError();
return false;
} else {
return true;
}
});
}
refinement(check, refinementData) {
return this._refinement((val, ctx) => {
if (!check(val)) {
ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
return false;
} else {
return true;
}
});
}
_refinement(refinement) {
return new ZodEffects({
schema: this,
typeName: ZodFirstPartyTypeKind.ZodEffects,
effect: { type: "refinement", refinement }
});
}
superRefine(refinement) {
return this._refinement(refinement);
}
constructor(def) {
this.spa = this.safeParseAsync;
this._def = def;
this.parse = this.parse.bind(this);
this.safeParse = this.safeParse.bind(this);
this.parseAsync = this.parseAsync.bind(this);
this.safeParseAsync = this.safeParseAsync.bind(this);
this.spa = this.spa.bind(this);
this.refine = this.refine.bind(this);
this.refinement = this.refinement.bind(this);
this.superRefine = this.superRefine.bind(this);
this.optional = this.optional.bind(this);
this.nullable = this.nullable.bind(this);
this.nullish = this.nullish.bind(this);
this.array = this.array.bind(this);
this.promise = this.promise.bind(this);
this.or = this.or.bind(this);
this.and = this.and.bind(this);
this.transform = this.transform.bind(this);
this.brand = this.brand.bind(this);
this.default = this.default.bind(this);
this.catch = this.catch.bind(this);
this.describe = this.describe.bind(this);
this.pipe = this.pipe.bind(this);
this.readonly = this.readonly.bind(this);
this.isNullable = this.isNullable.bind(this);
this.isOptional = this.isOptional.bind(this);
this["~standard"] = {
version: 1,
vendor: "zod",
validate: (data) => this["~validate"](data)
};
}
optional() {
return ZodOptional.create(this, this._def);
}
nullable() {
return ZodNullable.create(this, this._def);
}
nullish() {
return this.nullable().optional();
}
array() {
return ZodArray.create(this);
}
promise() {
return ZodPromise.create(this, this._def);
}
or(option) {
return ZodUnion.create([this, option], this._def);
}
and(incoming) {
return ZodIntersection.create(this, incoming, this._def);
}
transform(transform) {
return new ZodEffects({
...processCreateParams(this._def),
schema: this,
typeName: ZodFirstPartyTypeKind.ZodEffects,
effect: { type: "transform", transform }
});
}
default(def) {
const defaultValueFunc = typeof def === "function" ? def : () => def;
return new ZodDefault({
...processCreateParams(this._def),
innerType: this,
defaultValue: defaultValueFunc,
typeName: ZodFirstPartyTypeKind.ZodDefault
});
}
brand() {
return new ZodBranded({
typeName: ZodFirstPartyTypeKind.ZodBranded,
type: this,
...processCreateParams(this._def)
});
}
catch(def) {
const catchValueFunc = typeof def === "function" ? def : () => def;
return new ZodCatch({
...processCreateParams(this._def),
innerType: this,
catchValue: catchValueFunc,
typeName: ZodFirstPartyTypeKind.ZodCatch
});
}
describe(description) {
const This = this.constructor;
return new This({
...this._def,
description
});
}
pipe(target) {
return ZodPipeline.create(this, target);
}
readonly() {
return ZodReadonly.create(this);
}
isOptional() {
return this.safeParse(void 0).success;
}
isNullable() {
return this.safeParse(null).success;
}
};
var cuidRegex = /^c[^\s-]{8,}$/i;
var cuid2Regex = /^[0-9a-z]+$/;
var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
var nanoidRegex = /^[a-z0-9_-]{21}$/i;
var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
var durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
var emojiRegex;
var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/;
var ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
var ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
var dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
var dateRegex = new RegExp(`^${dateRegexSource}$`);
function timeRegexSource(args) {
let secondsRegexSource = `[0-5]\\d`;
if (args.precision) {
secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
} else if (args.precision == null) {
secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
}
const secondsQuantifier = args.precision ? "+" : "?";
return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
}
function timeRegex(args) {
return new RegExp(`^${timeRegexSource(args)}$`);
}
function datetimeRegex(args) {
let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
const opts = [];
opts.push(args.local ? `Z?` : `Z`);
if (args.offset)
opts.push(`([+-]\\d{2}:?\\d{2})`);
regex = `${regex}(${opts.join("|")})`;
return new RegExp(`^${regex}$`);
}
function isValidIP(ip, version) {
if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
return true;
}
if ((version === "v6" || !version) && ipv6Regex.test(ip)) {
return true;
}
return false;
}
function isValidJWT(jwt, alg) {
if (!jwtRegex.test(jwt))
return false;
try {
const [header] = jwt.split(".");
if (!header)
return false;
const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
const decoded = JSON.parse(atob(base64));
if (typeof decoded !== "object" || decoded === null)
return false;
if ("typ" in decoded && decoded?.typ !== "JWT")
return false;
if (!decoded.alg)
return false;
if (alg && decoded.alg !== alg)
return false;
return true;
} catch {
return false;
}
}
function isValidCidr(ip, version) {
if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) {
return true;
}
if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) {
return true;
}
return false;
}
var ZodString = class _ZodString extends ZodType {
_parse(input) {
if (this._def.coerce) {
input.data = String(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.string) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.string,
received: ctx2.parsedType
});
return INVALID;
}
const status = new ParseStatus();
let ctx = void 0;
for (const check of this._def.checks) {
if (check.kind === "min") {
if (input.data.length < check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: check.value,
type: "string",
inclusive: true,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "max") {
if (input.data.length > check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: check.value,
type: "string",
inclusive: true,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "length") {
const tooBig = input.data.length > check.value;
const tooSmall = input.data.length < check.value;
if (tooBig || tooSmall) {
ctx = this._getOrReturnCtx(input, ctx);
if (tooBig) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: check.value,
type: "string",
inclusive: true,
exact: true,
message: check.message
});
} else if (tooSmall) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: check.value,
type: "string",
inclusive: true,
exact: true,
message: check.message
});
}
status.dirty();
}
} else if (check.kind === "email") {
if (!emailRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "email",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "emoji") {
if (!emojiRegex) {
emojiRegex = new RegExp(_emojiRegex, "u");
}
if (!emojiRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "emoji",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "uuid") {
if (!uuidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "uuid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "nanoid") {
if (!nanoidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "nanoid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "cuid") {
if (!cuidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "cuid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "cuid2") {
if (!cuid2Regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "cuid2",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "ulid") {
if (!ulidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "ulid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "url") {
try {
new URL(input.data);
} catch {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "url",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "regex") {
check.regex.lastIndex = 0;
const testResult = check.regex.test(input.data);
if (!testResult) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "regex",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "trim") {
input.data = input.data.trim();
} else if (check.kind === "includes") {
if (!input.data.includes(check.value, check.position)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: { includes: check.value, position: check.position },
message: check.message
});
status.dirty();
}
} else if (check.kind === "toLowerCase") {
input.data = input.data.toLowerCase();
} else if (check.kind === "toUpperCase") {
input.data = input.data.toUpperCase();
} else if (check.kind === "startsWith") {
if (!input.data.startsWith(check.value)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: { startsWith: check.value },
message: check.message
});
status.dirty();
}
} else if (check.kind === "endsWith") {
if (!input.data.endsWith(check.value)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: { endsWith: check.value },
message: check.message
});
status.dirty();
}
} else if (check.kind === "datetime") {
const regex = datetimeRegex(check);
if (!regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: "datetime",
message: check.message
});
status.dirty();
}
} else if (check.kind === "date") {
const regex = dateRegex;
if (!regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: "date",
message: check.message
});
status.dirty();
}
} else if (check.kind === "time") {
const regex = timeRegex(check);
if (!regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: "time",
message: check.message
});
status.dirty();
}
} else if (check.kind === "duration") {
if (!durationRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "duration",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "ip") {
if (!isValidIP(input.data, check.version)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "ip",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "jwt") {
if (!isValidJWT(input.data, check.alg)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "jwt",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "cidr") {
if (!isValidCidr(input.data, check.version)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "cidr",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "base64") {
if (!base64Regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "base64",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "base64url") {
if (!base64urlRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "base64url",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else {
util2.assertNever(check);
}
}
return { status: status.value, value: input.data };
}
_regex(regex, validation, message) {
return this.refinement((data) => regex.test(data), {
validation,
code: ZodIssueCode.invalid_string,
...errorUtil.errToObj(message)
});
}
_addCheck(check) {
return new _ZodString({
...this._def,
checks: [...this._def.checks, check]
});
}
email(message) {
return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
}
url(message) {
return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
}
emoji(message) {
return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
}
uuid(message) {
return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
}
nanoid(message) {
return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
}
cuid(message) {
return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
}
cuid2(message) {
return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
}
ulid(message) {
return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
}
base64(message) {
return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
}
base64url(message) {
return this._addCheck({
kind: "base64url",
...errorUtil.errToObj(message)
});
}
jwt(options) {
return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) });
}
ip(options) {
return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
}
cidr(options) {
return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
}
datetime(options) {
if (typeof options === "string") {
return this._addCheck({
kind: "datetime",
precision: null,
offset: false,
local: false,
message: options
});
}
return this._addCheck({
kind: "datetime",
precision: typeof options?.precision === "undefined" ? null : options?.precision,
offset: options?.offset ?? false,
local: options?.local ?? false,
...errorUtil.errToObj(options?.message)
});
}
date(message) {
return this._addCheck({ kind: "date", message });
}
time(options) {
if (typeof options === "string") {
return this._addCheck({
kind: "time",
precision: null,
message: options
});
}
return this._addCheck({
kind: "time",
precision: typeof options?.precision === "undefined" ? null : options?.precision,
...errorUtil.errToObj(options?.message)
});
}
duration(message) {
return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
}
regex(regex, message) {
return this._addCheck({
kind: "regex",
regex,
...errorUtil.errToObj(message)
});
}
includes(value, options) {
return this._addCheck({
kind: "includes",
value,
position: options?.position,
...errorUtil.errToObj(options?.message)
});
}
startsWith(value, message) {
return this._addCheck({
kind: "startsWith",
value,
...errorUtil.errToObj(message)
});
}
endsWith(value, message) {
return this._addCheck({
kind: "endsWith",
value,
...errorUtil.errToObj(message)
});
}
min(minLength, message) {
return this._addCheck({
kind: "min",
value: minLength,
...errorUtil.errToObj(message)
});
}
max(maxLength, message) {
return this._addCheck({
kind: "max",
value: maxLength,
...errorUtil.errToObj(message)
});
}
length(len, message) {
return this._addCheck({
kind: "length",
value: len,
...errorUtil.errToObj(message)
});
}
/**
* Equivalent to `.min(1)`
*/
nonempty(message) {
return this.min(1, errorUtil.errToObj(message));
}
trim() {
return new _ZodString({
...this._def,
checks: [...this._def.checks, { kind: "trim" }]
});
}
toLowerCase() {
return new _ZodString({
...this._def,
checks: [...this._def.checks, { kind: "toLowerCase" }]
});
}
toUpperCase() {
return new _ZodString({
...this._def,
checks: [...this._def.checks, { kind: "toUpperCase" }]
});
}
get isDatetime() {
return !!this._def.checks.find((ch) => ch.kind === "datetime");
}
get isDate() {
return !!this._def.checks.find((ch) => ch.kind === "date");
}
get isTime() {
return !!this._def.checks.find((ch) => ch.kind === "time");
}
get isDuration() {
return !!this._def.checks.find((ch) => ch.kind === "duration");
}
get isEmail() {
return !!this._def.checks.find((ch) => ch.kind === "email");
}
get isURL() {
return !!this._def.checks.find((ch) => ch.kind === "url");
}
get isEmoji() {
return !!this._def.checks.find((ch) => ch.kind === "emoji");
}
get isUUID() {
return !!this._def.checks.find((ch) => ch.kind === "uuid");
}
get isNANOID() {
return !!this._def.checks.find((ch) => ch.kind === "nanoid");
}
get isCUID() {
return !!this._def.checks.find((ch) => ch.kind === "cuid");
}
get isCUID2() {
return !!this._def.checks.find((ch) => ch.kind === "cuid2");
}
get isULID() {
return !!this._def.checks.find((ch) => ch.kind === "ulid");
}
get isIP() {
return !!this._def.checks.find((ch) => ch.kind === "ip");
}
get isCIDR() {
return !!this._def.checks.find((ch) => ch.kind === "cidr");
}
get isBase64() {
return !!this._def.checks.find((ch) => ch.kind === "base64");
}
get isBase64url() {
return !!this._def.checks.find((ch) => ch.kind === "base64url");
}
get minLength() {
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
}
}
return min;
}
get maxLength() {
let max = null;
for (const ch of this._def.checks) {
if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return max;
}
};
ZodString.create = (params) => {
return new ZodString({
checks: [],
typeName: ZodFirstPartyTypeKind.ZodString,
coerce: params?.coerce ?? false,
...processCreateParams(params)
});
};
function floatSafeRemainder(val, step) {
const valDecCount = (val.toString().split(".")[1] || "").length;
const stepDecCount = (step.toString().split(".")[1] || "").length;
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
return valInt % stepInt / 10 ** decCount;
}
var ZodNumber = class _ZodNumber extends ZodType {
constructor() {
super(...arguments);
this.min = this.gte;
this.max = this.lte;
this.step = this.multipleOf;
}
_parse(input) {
if (this._def.coerce) {
input.data = Number(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.number) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.number,
received: ctx2.parsedType
});
return INVALID;
}
let ctx = void 0;
const status = new ParseStatus();
for (const check of this._def.checks) {
if (check.kind === "int") {
if (!util2.isInteger(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: "integer",
received: "float",
message: check.message
});
status.dirty();
}
} else if (check.kind === "min") {
const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
if (tooSmall) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: check.value,
type: "number",
inclusive: check.inclusive,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "max") {
const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
if (tooBig) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: check.value,
type: "number",
inclusive: check.inclusive,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "multipleOf") {
if (floatSafeRemainder(input.data, check.value) !== 0) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.not_multiple_of,
multipleOf: check.value,
message: check.message
});
status.dirty();
}
} else if (check.kind === "finite") {
if (!Number.isFinite(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.not_finite,
message: check.message
});
status.dirty();
}
} else {
util2.assertNever(check);
}
}
return { status: status.value, value: input.data };
}
gte(value, message) {
return this.setLimit("min", value, true, errorUtil.toString(message));
}
gt(value, message) {
return this.setLimit("min", value, false, errorUtil.toString(message));
}
lte(value, message) {
return this.setLimit("max", value, true, errorUtil.toString(message));
}
lt(value, message) {
return this.setLimit("max", value, false, errorUtil.toString(message));
}
setLimit(kind, value, inclusive, message) {
return new _ZodNumber({
...this._def,
checks: [
...this._def.checks,
{
kind,
value,
inclusive,
message: errorUtil.toString(message)
}
]
});
}
_addCheck(check) {
return new _ZodNumber({
...this._def,
checks: [...this._def.checks, check]
});
}
int(message) {
return this._addCheck({
kind: "int",
message: errorUtil.toString(message)
});
}
positive(message) {
return this._addCheck({
kind: "min",
value: 0,
inclusive: false,
message: errorUtil.toString(message)
});
}
negative(message) {
return this._addCheck({
kind: "max",
value: 0,
inclusive: false,
message: errorUtil.toString(message)
});
}
nonpositive(message) {
return this._addCheck({
kind: "max",
value: 0,
inclusive: true,
message: errorUtil.toString(message)
});
}
nonnegative(message) {
return this._addCheck({
kind: "min",
value: 0,
inclusive: true,
message: errorUtil.toString(message)
});
}
multipleOf(value, message) {
return this._addCheck({
kind: "multipleOf",
value,
message: errorUtil.toString(message)
});
}
finite(message) {
return this._addCheck({
kind: "finite",
message: errorUtil.toString(message)
});
}
safe(message) {
return this._addCheck({
kind: "min",
inclusive: true,
value: Number.MIN_SAFE_INTEGER,
message: errorUtil.toString(message)
})._addCheck({
kind: "max",
inclusive: true,
value: Number.MAX_SAFE_INTEGER,
message: errorUtil.toString(message)
});
}
get minValue() {
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
}
}
return min;
}
get maxValue() {
let max = null;
for (const ch of this._def.checks) {
if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return max;
}
get isInt() {
return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util2.isInteger(ch.value));
}
get isFinite() {
let max = null;
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
return true;
} else if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
} else if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return Number.isFinite(min) && Number.isFinite(max);
}
};
ZodNumber.create = (params) => {
return new ZodNumber({
checks: [],
typeName: ZodFirstPartyTypeKind.ZodNumber,
coerce: params?.coerce || false,
...processCreateParams(params)
});
};
var ZodBigInt = class _ZodBigInt extends ZodType {
constructor() {
super(...arguments);
this.min = this.gte;
this.max = this.lte;
}
_parse(input) {
if (this._def.coerce) {
try {
input.data = BigInt(input.data);
} catch {
return this._getInvalidInput(input);
}
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.bigint) {
return this._getInvalidInput(input);
}
let ctx = void 0;
const status = new ParseStatus();
for (const check of this._def.checks) {
if (check.kind === "min") {
const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
if (tooSmall) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
type: "bigint",
minimum: check.value,
inclusive: check.inclusive,
message: check.message
});
status.dirty();
}
} else if (check.kind === "max") {
const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
if (tooBig) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
type: "bigint",
maximum: check.value,
inclusive: check.inclusive,
message: check.message
});
status.dirty();
}
} else if (check.kind === "multipleOf") {
if (input.data % check.value !== BigInt(0)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.not_multiple_of,
multipleOf: check.value,
message: check.message
});
status.dirty();
}
} else {
util2.assertNever(check);
}
}
return { status: status.value, value: input.data };
}
_getInvalidInput(input) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.bigint,
received: ctx.parsedType
});
return INVALID;
}
gte(value, message) {
return this.setLimit("min", value, true, errorUtil.toString(message));
}
gt(value, message) {
return this.setLimit("min", value, false, errorUtil.toString(message));
}
lte(value, message) {
return this.setLimit("max", value, true, errorUtil.toString(message));
}
lt(value, message) {
return this.setLimit("max", value, false, errorUtil.toString(message));
}
setLimit(kind, value, inclusive, message) {
return new _ZodBigInt({
...this._def,
checks: [
...this._def.checks,
{
kind,
value,
inclusive,
message: errorUtil.toString(message)
}
]
});
}
_addCheck(check) {
return new _ZodBigInt({
...this._def,
checks: [...this._def.checks, check]
});
}
positive(message) {
return this._addCheck({
kind: "min",
value: BigInt(0),
inclusive: false,
message: errorUtil.toString(message)
});
}
negative(message) {
return this._addCheck({
kind: "max",
value: BigInt(0),
inclusive: false,
message: errorUtil.toString(message)
});
}
nonpositive(message) {
return this._addCheck({
kind: "max",
value: BigInt(0),
inclusive: true,
message: errorUtil.toString(message)
});
}
nonnegative(message) {
return this._addCheck({
kind: "min",
value: BigInt(0),
inclusive: true,
message: errorUtil.toString(message)
});
}
multipleOf(value, message) {
return this._addCheck({
kind: "multipleOf",
value,
message: errorUtil.toString(message)
});
}
get minValue() {
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
}
}
return min;
}
get maxValue() {
let max = null;
for (const ch of this._def.checks) {
if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return max;
}
};
ZodBigInt.create = (params) => {
return new ZodBigInt({
checks: [],
typeName: ZodFirstPartyTypeKind.ZodBigInt,
coerce: params?.coerce ?? false,
...processCreateParams(params)
});
};
var ZodBoolean = class extends ZodType {
_parse(input) {
if (this._def.coerce) {
input.data = Boolean(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.boolean) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.boolean,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
};
ZodBoolean.create = (params) => {
return new ZodBoolean({
typeName: ZodFirstPartyTypeKind.ZodBoolean,
coerce: params?.coerce || false,
...processCreateParams(params)
});
};
var ZodDate = class _ZodDate extends ZodType {
_parse(input) {
if (this._def.coerce) {
input.data = new Date(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.date) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.date,
received: ctx2.parsedType
});
return INVALID;
}
if (Number.isNaN(input.data.getTime())) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_date
});
return INVALID;
}
const status = new ParseStatus();
let ctx = void 0;
for (const check of this._def.checks) {
if (check.kind === "min") {
if (input.data.getTime() < check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
message: check.message,
inclusive: true,
exact: false,
minimum: check.value,
type: "date"
});
status.dirty();
}
} else if (check.kind === "max") {
if (input.data.getTime() > check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
message: check.message,
inclusive: true,
exact: false,
maximum: check.value,
type: "date"
});
status.dirty();
}
} else {
util2.assertNever(check);
}
}
return {
status: status.value,
value: new Date(input.data.getTime())
};
}
_addCheck(check) {
return new _ZodDate({
...this._def,
checks: [...this._def.checks, check]
});
}
min(minDate, message) {
return this._addCheck({
kind: "min",
value: minDate.getTime(),
message: errorUtil.toString(message)
});
}
max(maxDate, message) {
return this._addCheck({
kind: "max",
value: maxDate.getTime(),
message: errorUtil.toString(message)
});
}
get minDate() {
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
}
}
return min != null ? new Date(min) : null;
}
get maxDate() {
let max = null;
for (const ch of this._def.checks) {
if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return max != null ? new Date(max) : null;
}
};
ZodDate.create = (params) => {
return new ZodDate({
checks: [],
coerce: params?.coerce || false,
typeName: ZodFirstPartyTypeKind.ZodDate,
...processCreateParams(params)
});
};
var ZodSymbol = class extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.symbol) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.symbol,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
};
ZodSymbol.create = (params) => {
return new ZodSymbol({
typeName: ZodFirstPartyTypeKind.ZodSymbol,
...processCreateParams(params)
});
};
var ZodUndefined = class extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.undefined) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.undefined,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
};
ZodUndefined.create = (params) => {
return new ZodUndefined({
typeName: ZodFirstPartyTypeKind.ZodUndefined,
...processCreateParams(params)
});
};
var ZodNull = class extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.null) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.null,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
};
ZodNull.create = (params) => {
return new ZodNull({
typeName: ZodFirstPartyTypeKind.ZodNull,
...processCreateParams(params)
});
};
var ZodAny = class extends ZodType {
constructor() {
super(...arguments);
this._any = true;
}
_parse(input) {
return OK(input.data);
}
};
ZodAny.create = (params) => {
return new ZodAny({
typeName: ZodFirstPartyTypeKind.ZodAny,
...processCreateParams(params)
});
};
var ZodUnknown = class extends ZodType {
constructor() {
super(...arguments);
this._unknown = true;
}
_parse(input) {
return OK(input.data);
}
};
ZodUnknown.create = (params) => {
return new ZodUnknown({
typeName: ZodFirstPartyTypeKind.ZodUnknown,
...processCreateParams(params)
});
};
var ZodNever = class extends ZodType {
_parse(input) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.never,
received: ctx.parsedType
});
return INVALID;
}
};
ZodNever.create = (params) => {
return new ZodNever({
typeName: ZodFirstPartyTypeKind.ZodNever,
...processCreateParams(params)
});
};
var ZodVoid = class extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.undefined) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.void,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
};
ZodVoid.create = (params) => {
return new ZodVoid({
typeName: ZodFirstPartyTypeKind.ZodVoid,
...processCreateParams(params)
});
};
var ZodArray = class _ZodArray extends ZodType {
_parse(input) {
const { ctx, status } = this._processInputParams(input);
const def = this._def;
if (ctx.parsedType !== ZodParsedType.array) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.array,
received: ctx.parsedType
});
return INVALID;
}
if (def.exactLength !== null) {
const tooBig = ctx.data.length > def.exactLength.value;
const tooSmall = ctx.data.length < def.exactLength.value;
if (tooBig || tooSmall) {
addIssueToContext(ctx, {
code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
minimum: tooSmall ? def.exactLength.value : void 0,
maximum: tooBig ? def.exactLength.value : void 0,
type: "array",
inclusive: true,
exact: true,
message: def.exactLength.message
});
status.dirty();
}
}
if (def.minLength !== null) {
if (ctx.data.length < def.minLength.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: def.minLength.value,
type: "array",
inclusive: true,
exact: false,
message: def.minLength.message
});
status.dirty();
}
}
if (def.maxLength !== null) {
if (ctx.data.length > def.maxLength.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: def.maxLength.value,
type: "array",
inclusive: true,
exact: false,
message: def.maxLength.message
});
status.dirty();
}
}
if (ctx.common.async) {
return Promise.all([...ctx.data].map((item, i) => {
return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
})).then((result2) => {
return ParseStatus.mergeArray(status, result2);
});
}
const result = [...ctx.data].map((item, i) => {
return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
});
return ParseStatus.mergeArray(status, result);
}
get element() {
return this._def.type;
}
min(minLength, message) {
return new _ZodArray({
...this._def,
minLength: { value: minLength, message: errorUtil.toString(message) }
});
}
max(maxLength, message) {
return new _ZodArray({
...this._def,
maxLength: { value: maxLength, message: errorUtil.toString(message) }
});
}
length(len, message) {
return new _ZodArray({
...this._def,
exactLength: { value: len, message: errorUtil.toString(message) }
});
}
nonempty(message) {
return this.min(1, message);
}
};
ZodArray.create = (schema, params) => {
return new ZodArray({
type: schema,
minLength: null,
maxLength: null,
exactLength: null,
typeName: ZodFirstPartyTypeKind.ZodArray,
...processCreateParams(params)
});
};
function deepPartialify(schema) {
if (schema instanceof ZodObject) {
const newShape = {};
for (const key in schema.shape) {
const fieldSchema = schema.shape[key];
newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
}
return new ZodObject({
...schema._def,
shape: () => newShape
});
} else if (schema instanceof ZodArray) {
return new ZodArray({
...schema._def,
type: deepPartialify(schema.element)
});
} else if (schema instanceof ZodOptional) {
return ZodOptional.create(deepPartialify(schema.unwrap()));
} else if (schema instanceof ZodNullable) {
return ZodNullable.create(deepPartialify(schema.unwrap()));
} else if (schema instanceof ZodTuple) {
return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
} else {
return schema;
}
}
var ZodObject = class _ZodObject extends ZodType {
constructor() {
super(...arguments);
this._cached = null;
this.nonstrict = this.passthrough;
this.augment = this.extend;
}
_getCached() {
if (this._cached !== null)
return this._cached;
const shape = this._def.shape();
const keys = util2.objectKeys(shape);
this._cached = { shape, keys };
return this._cached;
}
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.object) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.object,
received: ctx2.parsedType
});
return INVALID;
}
const { status, ctx } = this._processInputParams(input);
const { shape, keys: shapeKeys } = this._getCached();
const extraKeys = [];
if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
for (const key in ctx.data) {
if (!shapeKeys.includes(key)) {
extraKeys.push(key);
}
}
}
const pairs = [];
for (const key of shapeKeys) {
const keyValidator = shape[key];
const value = ctx.data[key];
pairs.push({
key: { status: "valid", value: key },
value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
alwaysSet: key in ctx.data
});
}
if (this._def.catchall instanceof ZodNever) {
const unknownKeys = this._def.unknownKeys;
if (unknownKeys === "passthrough") {
for (const key of extraKeys) {
pairs.push({
key: { status: "valid", value: key },
value: { status: "valid", value: ctx.data[key] }
});
}
} else if (unknownKeys === "strict") {
if (extraKeys.length > 0) {
addIssueToContext(ctx, {
code: ZodIssueCode.unrecognized_keys,
keys: extraKeys
});
status.dirty();
}
} else if (unknownKeys === "strip") {
} else {
throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
}
} else {
const catchall = this._def.catchall;
for (const key of extraKeys) {
const value = ctx.data[key];
pairs.push({
key: { status: "valid", value: key },
value: catchall._parse(
new ParseInputLazyPath(ctx, value, ctx.path, key)
//, ctx.child(key), value, getParsedType(value)
),
alwaysSet: key in ctx.data
});
}
}
if (ctx.common.async) {
return Promise.resolve().then(async () => {
const syncPairs = [];
for (const pair of pairs) {
const key = await pair.key;
const value = await pair.value;
syncPairs.push({
key,
value,
alwaysSet: pair.alwaysSet
});
}
return syncPairs;
}).then((syncPairs) => {
return ParseStatus.mergeObjectSync(status, syncPairs);
});
} else {
return ParseStatus.mergeObjectSync(status, pairs);
}
}
get shape() {
return this._def.shape();
}
strict(message) {
errorUtil.errToObj;
return new _ZodObject({
...this._def,
unknownKeys: "strict",
...message !== void 0 ? {
errorMap: (issue, ctx) => {
const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
if (issue.code === "unrecognized_keys")
return {
message: errorUtil.errToObj(message).message ?? defaultError
};
return {
message: defaultError
};
}
} : {}
});
}
strip() {
return new _ZodObject({
...this._def,
unknownKeys: "strip"
});
}
passthrough() {
return new _ZodObject({
...this._def,
unknownKeys: "passthrough"
});
}
// const AugmentFactory =
// <Def extends ZodObjectDef>(def: Def) =>
// <Augmentation extends ZodRawShape>(
// augmentation: Augmentation
// ): ZodObject<
// extendShape<ReturnType<Def["shape"]>, Augmentation>,
// Def["unknownKeys"],
// Def["catchall"]
// > => {
// return new ZodObject({
// ...def,
// shape: () => ({
// ...def.shape(),
// ...augmentation,
// }),
// }) as any;
// };
extend(augmentation) {
return new _ZodObject({
...this._def,
shape: () => ({
...this._def.shape(),
...augmentation
})
});
}
/**
* Prior to zod@1.0.12 there was a bug in the
* inferred type of merged objects. Please
* upgrade if you are experiencing issues.
*/
merge(merging) {
const merged = new _ZodObject({
unknownKeys: merging._def.unknownKeys,
catchall: merging._def.catchall,
shape: () => ({
...this._def.shape(),
...merging._def.shape()
}),
typeName: ZodFirstPartyTypeKind.ZodObject
});
return merged;
}
// merge<
// Incoming extends AnyZodObject,
// Augmentation extends Incoming["shape"],
// NewOutput extends {
// [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
// ? Augmentation[k]["_output"]
// : k extends keyof Output
// ? Output[k]
// : never;
// },
// NewInput extends {
// [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
// ? Augmentation[k]["_input"]
// : k extends keyof Input
// ? Input[k]
// : never;
// }
// >(
// merging: Incoming
// ): ZodObject<
// extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
// Incoming["_def"]["unknownKeys"],
// Incoming["_def"]["catchall"],
// NewOutput,
// NewInput
// > {
// const merged: any = new ZodObject({
// unknownKeys: merging._def.unknownKeys,
// catchall: merging._def.catchall,
// shape: () =>
// objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
// typeName: ZodFirstPartyTypeKind.ZodObject,
// }) as any;
// return merged;
// }
setKey(key, schema) {
return this.augment({ [key]: schema });
}
// merge<Incoming extends AnyZodObject>(
// merging: Incoming
// ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
// ZodObject<
// extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
// Incoming["_def"]["unknownKeys"],
// Incoming["_def"]["catchall"]
// > {
// // const mergedShape = objectUtil.mergeShapes(
// // this._def.shape(),
// // merging._def.shape()
// // );
// const merged: any = new ZodObject({
// unknownKeys: merging._def.unknownKeys,
// catchall: merging._def.catchall,
// shape: () =>
// objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
// typeName: ZodFirstPartyTypeKind.ZodObject,
// }) as any;
// return merged;
// }
catchall(index) {
return new _ZodObject({
...this._def,
catchall: index
});
}
pick(mask) {
const shape = {};
for (const key of util2.objectKeys(mask)) {
if (mask[key] && this.shape[key]) {
shape[key] = this.shape[key];
}
}
return new _ZodObject({
...this._def,
shape: () => shape
});
}
omit(mask) {
const shape = {};
for (const key of util2.objectKeys(this.shape)) {
if (!mask[key]) {
shape[key] = this.shape[key];
}
}
return new _ZodObject({
...this._def,
shape: () => shape
});
}
/**
* @deprecated
*/
deepPartial() {
return deepPartialify(this);
}
partial(mask) {
const newShape = {};
for (const key of util2.objectKeys(this.shape)) {
const fieldSchema = this.shape[key];
if (mask && !mask[key]) {
newShape[key] = fieldSchema;
} else {
newShape[key] = fieldSchema.optional();
}
}
return new _ZodObject({
...this._def,
shape: () => newShape
});
}
required(mask) {
const newShape = {};
for (const key of util2.objectKeys(this.shape)) {
if (mask && !mask[key]) {
newShape[key] = this.shape[key];
} else {
const fieldSchema = this.shape[key];
let newField = fieldSchema;
while (newField instanceof ZodOptional) {
newField = newField._def.innerType;
}
newShape[key] = newField;
}
}
return new _ZodObject({
...this._def,
shape: () => newShape
});
}
keyof() {
return createZodEnum(util2.objectKeys(this.shape));
}
};
ZodObject.create = (shape, params) => {
return new ZodObject({
shape: () => shape,
unknownKeys: "strip",
catchall: ZodNever.create(),
typeName: ZodFirstPartyTypeKind.ZodObject,
...processCreateParams(params)
});
};
ZodObject.strictCreate = (shape, params) => {
return new ZodObject({
shape: () => shape,
unknownKeys: "strict",
catchall: ZodNever.create(),
typeName: ZodFirstPartyTypeKind.ZodObject,
...processCreateParams(params)
});
};
ZodObject.lazycreate = (shape, params) => {
return new ZodObject({
shape,
unknownKeys: "strip",
catchall: ZodNever.create(),
typeName: ZodFirstPartyTypeKind.ZodObject,
...processCreateParams(params)
});
};
var ZodUnion = class extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
const options = this._def.options;
function handleResults(results) {
for (const result of results) {
if (result.result.status === "valid") {
return result.result;
}
}
for (const result of results) {
if (result.result.status === "dirty") {
ctx.common.issues.push(...result.ctx.common.issues);
return result.result;
}
}
const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_union,
unionErrors
});
return INVALID;
}
if (ctx.common.async) {
return Promise.all(options.map(async (option) => {
const childCtx = {
...ctx,
common: {
...ctx.common,
issues: []
},
parent: null
};
return {
result: await option._parseAsync({
data: ctx.data,
path: ctx.path,
parent: childCtx
}),
ctx: childCtx
};
})).then(handleResults);
} else {
let dirty = void 0;
const issues = [];
for (const option of options) {
const childCtx = {
...ctx,
common: {
...ctx.common,
issues: []
},
parent: null
};
const result = option._parseSync({
data: ctx.data,
path: ctx.path,
parent: childCtx
});
if (result.status === "valid") {
return result;
} else if (result.status === "dirty" && !dirty) {
dirty = { result, ctx: childCtx };
}
if (childCtx.common.issues.length) {
issues.push(childCtx.common.issues);
}
}
if (dirty) {
ctx.common.issues.push(...dirty.ctx.common.issues);
return dirty.result;
}
const unionErrors = issues.map((issues2) => new ZodError(issues2));
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_union,
unionErrors
});
return INVALID;
}
}
get options() {
return this._def.options;
}
};
ZodUnion.create = (types, params) => {
return new ZodUnion({
options: types,
typeName: ZodFirstPartyTypeKind.ZodUnion,
...processCreateParams(params)
});
};
var getDiscriminator = (type) => {
if (type instanceof ZodLazy) {
return getDiscriminator(type.schema);
} else if (type instanceof ZodEffects) {
return getDiscriminator(type.innerType());
} else if (type instanceof ZodLiteral) {
return [type.value];
} else if (type instanceof ZodEnum) {
return type.options;
} else if (type instanceof ZodNativeEnum) {
return util2.objectValues(type.enum);
} else if (type instanceof ZodDefault) {
return getDiscriminator(type._def.innerType);
} else if (type instanceof ZodUndefined) {
return [void 0];
} else if (type instanceof ZodNull) {
return [null];
} else if (type instanceof ZodOptional) {
return [void 0, ...getDiscriminator(type.unwrap())];
} else if (type instanceof ZodNullable) {
return [null, ...getDiscriminator(type.unwrap())];
} else if (type instanceof ZodBranded) {
return getDiscriminator(type.unwrap());
} else if (type instanceof ZodReadonly) {
return getDiscriminator(type.unwrap());
} else if (type instanceof ZodCatch) {
return getDiscriminator(type._def.innerType);
} else {
return [];
}
};
var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.object) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.object,
received: ctx.parsedType
});
return INVALID;
}
const discriminator = this.discriminator;
const discriminatorValue = ctx.data[discriminator];
const option = this.optionsMap.get(discriminatorValue);
if (!option) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_union_discriminator,
options: Array.from(this.optionsMap.keys()),
path: [discriminator]
});
return INVALID;
}
if (ctx.common.async) {
return option._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
} else {
return option._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
}
}
get discriminator() {
return this._def.discriminator;
}
get options() {
return this._def.options;
}
get optionsMap() {
return this._def.optionsMap;
}
/**
* The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
* However, it only allows a union of objects, all of which need to share a discriminator property. This property must
* have a different value for each object in the union.
* @param discriminator the name of the discriminator property
* @param types an array of object schemas
* @param params
*/
static create(discriminator, options, params) {
const optionsMap = /* @__PURE__ */ new Map();
for (const type of options) {
const discriminatorValues = getDiscriminator(type.shape[discriminator]);
if (!discriminatorValues.length) {
throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
}
for (const value of discriminatorValues) {
if (optionsMap.has(value)) {
throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
}
optionsMap.set(value, type);
}
}
return new _ZodDiscriminatedUnion({
typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
discriminator,
options,
optionsMap,
...processCreateParams(params)
});
}
};
function mergeValues(a, b) {
const aType = getParsedType(a);
const bType = getParsedType(b);
if (a === b) {
return { valid: true, data: a };
} else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
const bKeys = util2.objectKeys(b);
const sharedKeys = util2.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
const newObj = { ...a, ...b };
for (const key of sharedKeys) {
const sharedValue = mergeValues(a[key], b[key]);
if (!sharedValue.valid) {
return { valid: false };
}
newObj[key] = sharedValue.data;
}
return { valid: true, data: newObj };
} else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
if (a.length !== b.length) {
return { valid: false };
}
const newArray = [];
for (let index = 0; index < a.length; index++) {
const itemA = a[index];
const itemB = b[index];
const sharedValue = mergeValues(itemA, itemB);
if (!sharedValue.valid) {
return { valid: false };
}
newArray.push(sharedValue.data);
}
return { valid: true, data: newArray };
} else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
return { valid: true, data: a };
} else {
return { valid: false };
}
}
var ZodIntersection = class extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
const handleParsed = (parsedLeft, parsedRight) => {
if (isAborted(parsedLeft) || isAborted(parsedRight)) {
return INVALID;
}
const merged = mergeValues(parsedLeft.value, parsedRight.value);
if (!merged.valid) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_intersection_types
});
return INVALID;
}
if (isDirty(parsedLeft) || isDirty(parsedRight)) {
status.dirty();
}
return { status: status.value, value: merged.data };
};
if (ctx.common.async) {
return Promise.all([
this._def.left._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
}),
this._def.right._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
})
]).then(([left, right]) => handleParsed(left, right));
} else {
return handleParsed(this._def.left._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
}), this._def.right._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
}));
}
}
};
ZodIntersection.create = (left, right, params) => {
return new ZodIntersection({
left,
right,
typeName: ZodFirstPartyTypeKind.ZodIntersection,
...processCreateParams(params)
});
};
var ZodTuple = class _ZodTuple extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.array) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.array,
received: ctx.parsedType
});
return INVALID;
}
if (ctx.data.length < this._def.items.length) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: this._def.items.length,
inclusive: true,
exact: false,
type: "array"
});
return INVALID;
}
const rest = this._def.rest;
if (!rest && ctx.data.length > this._def.items.length) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: this._def.items.length,
inclusive: true,
exact: false,
type: "array"
});
status.dirty();
}
const items = [...ctx.data].map((item, itemIndex) => {
const schema = this._def.items[itemIndex] || this._def.rest;
if (!schema)
return null;
return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
}).filter((x) => !!x);
if (ctx.common.async) {
return Promise.all(items).then((results) => {
return ParseStatus.mergeArray(status, results);
});
} else {
return ParseStatus.mergeArray(status, items);
}
}
get items() {
return this._def.items;
}
rest(rest) {
return new _ZodTuple({
...this._def,
rest
});
}
};
ZodTuple.create = (schemas, params) => {
if (!Array.isArray(schemas)) {
throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
}
return new ZodTuple({
items: schemas,
typeName: ZodFirstPartyTypeKind.ZodTuple,
rest: null,
...processCreateParams(params)
});
};
var ZodRecord = class _ZodRecord extends ZodType {
get keySchema() {
return this._def.keyType;
}
get valueSchema() {
return this._def.valueType;
}
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.object) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.object,
received: ctx.parsedType
});
return INVALID;
}
const pairs = [];
const keyType = this._def.keyType;
const valueType = this._def.valueType;
for (const key in ctx.data) {
pairs.push({
key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
alwaysSet: key in ctx.data
});
}
if (ctx.common.async) {
return ParseStatus.mergeObjectAsync(status, pairs);
} else {
return ParseStatus.mergeObjectSync(status, pairs);
}
}
get element() {
return this._def.valueType;
}
static create(first, second, third) {
if (second instanceof ZodType) {
return new _ZodRecord({
keyType: first,
valueType: second,
typeName: ZodFirstPartyTypeKind.ZodRecord,
...processCreateParams(third)
});
}
return new _ZodRecord({
keyType: ZodString.create(),
valueType: first,
typeName: ZodFirstPartyTypeKind.ZodRecord,
...processCreateParams(second)
});
}
};
var ZodMap = class extends ZodType {
get keySchema() {
return this._def.keyType;
}
get valueSchema() {
return this._def.valueType;
}
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.map) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.map,
received: ctx.parsedType
});
return INVALID;
}
const keyType = this._def.keyType;
const valueType = this._def.valueType;
const pairs = [...ctx.data.entries()].map(([key, value], index) => {
return {
key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
};
});
if (ctx.common.async) {
const finalMap = /* @__PURE__ */ new Map();
return Promise.resolve().then(async () => {
for (const pair of pairs) {
const key = await pair.key;
const value = await pair.value;
if (key.status === "aborted" || value.status === "aborted") {
return INVALID;
}
if (key.status === "dirty" || value.status === "dirty") {
status.dirty();
}
finalMap.set(key.value, value.value);
}
return { status: status.value, value: finalMap };
});
} else {
const finalMap = /* @__PURE__ */ new Map();
for (const pair of pairs) {
const key = pair.key;
const value = pair.value;
if (key.status === "aborted" || value.status === "aborted") {
return INVALID;
}
if (key.status === "dirty" || value.status === "dirty") {
status.dirty();
}
finalMap.set(key.value, value.value);
}
return { status: status.value, value: finalMap };
}
}
};
ZodMap.create = (keyType, valueType, params) => {
return new ZodMap({
valueType,
keyType,
typeName: ZodFirstPartyTypeKind.ZodMap,
...processCreateParams(params)
});
};
var ZodSet = class _ZodSet extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.set) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.set,
received: ctx.parsedType
});
return INVALID;
}
const def = this._def;
if (def.minSize !== null) {
if (ctx.data.size < def.minSize.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: def.minSize.value,
type: "set",
inclusive: true,
exact: false,
message: def.minSize.message
});
status.dirty();
}
}
if (def.maxSize !== null) {
if (ctx.data.size > def.maxSize.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: def.maxSize.value,
type: "set",
inclusive: true,
exact: false,
message: def.maxSize.message
});
status.dirty();
}
}
const valueType = this._def.valueType;
function finalizeSet(elements2) {
const parsedSet = /* @__PURE__ */ new Set();
for (const element of elements2) {
if (element.status === "aborted")
return INVALID;
if (element.status === "dirty")
status.dirty();
parsedSet.add(element.value);
}
return { status: status.value, value: parsedSet };
}
const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
if (ctx.common.async) {
return Promise.all(elements).then((elements2) => finalizeSet(elements2));
} else {
return finalizeSet(elements);
}
}
min(minSize, message) {
return new _ZodSet({
...this._def,
minSize: { value: minSize, message: errorUtil.toString(message) }
});
}
max(maxSize, message) {
return new _ZodSet({
...this._def,
maxSize: { value: maxSize, message: errorUtil.toString(message) }
});
}
size(size, message) {
return this.min(size, message).max(size, message);
}
nonempty(message) {
return this.min(1, message);
}
};
ZodSet.create = (valueType, params) => {
return new ZodSet({
valueType,
minSize: null,
maxSize: null,
typeName: ZodFirstPartyTypeKind.ZodSet,
...processCreateParams(params)
});
};
var ZodFunction = class _ZodFunction extends ZodType {
constructor() {
super(...arguments);
this.validate = this.implement;
}
_parse(input) {
const { ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.function) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.function,
received: ctx.parsedType
});
return INVALID;
}
function makeArgsIssue(args, error) {
return makeIssue({
data: args,
path: ctx.path,
errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
issueData: {
code: ZodIssueCode.invalid_arguments,
argumentsError: error
}
});
}
function makeReturnsIssue(returns, error) {
return makeIssue({
data: returns,
path: ctx.path,
errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
issueData: {
code: ZodIssueCode.invalid_return_type,
returnTypeError: error
}
});
}
const params = { errorMap: ctx.common.contextualErrorMap };
const fn = ctx.data;
if (this._def.returns instanceof ZodPromise) {
const me = this;
return OK(async function(...args) {
const error = new ZodError([]);
const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
error.addIssue(makeArgsIssue(args, e));
throw error;
});
const result = await Reflect.apply(fn, this, parsedArgs);
const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
error.addIssue(makeReturnsIssue(result, e));
throw error;
});
return parsedReturns;
});
} else {
const me = this;
return OK(function(...args) {
const parsedArgs = me._def.args.safeParse(args, params);
if (!parsedArgs.success) {
throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
}
const result = Reflect.apply(fn, this, parsedArgs.data);
const parsedReturns = me._def.returns.safeParse(result, params);
if (!parsedReturns.success) {
throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
}
return parsedReturns.data;
});
}
}
parameters() {
return this._def.args;
}
returnType() {
return this._def.returns;
}
args(...items) {
return new _ZodFunction({
...this._def,
args: ZodTuple.create(items).rest(ZodUnknown.create())
});
}
returns(returnType) {
return new _ZodFunction({
...this._def,
returns: returnType
});
}
implement(func) {
const validatedFunc = this.parse(func);
return validatedFunc;
}
strictImplement(func) {
const validatedFunc = this.parse(func);
return validatedFunc;
}
static create(args, returns, params) {
return new _ZodFunction({
args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
returns: returns || ZodUnknown.create(),
typeName: ZodFirstPartyTypeKind.ZodFunction,
...processCreateParams(params)
});
}
};
var ZodLazy = class extends ZodType {
get schema() {
return this._def.getter();
}
_parse(input) {
const { ctx } = this._processInputParams(input);
const lazySchema = this._def.getter();
return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
}
};
ZodLazy.create = (getter, params) => {
return new ZodLazy({
getter,
typeName: ZodFirstPartyTypeKind.ZodLazy,
...processCreateParams(params)
});
};
var ZodLiteral = class extends ZodType {
_parse(input) {
if (input.data !== this._def.value) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
received: ctx.data,
code: ZodIssueCode.invalid_literal,
expected: this._def.value
});
return INVALID;
}
return { status: "valid", value: input.data };
}
get value() {
return this._def.value;
}
};
ZodLiteral.create = (value, params) => {
return new ZodLiteral({
value,
typeName: ZodFirstPartyTypeKind.ZodLiteral,
...processCreateParams(params)
});
};
function createZodEnum(values, params) {
return new ZodEnum({
values,
typeName: ZodFirstPartyTypeKind.ZodEnum,
...processCreateParams(params)
});
}
var ZodEnum = class _ZodEnum extends ZodType {
_parse(input) {
if (typeof input.data !== "string") {
const ctx = this._getOrReturnCtx(input);
const expectedValues = this._def.values;
addIssueToContext(ctx, {
expected: util2.joinValues(expectedValues),
received: ctx.parsedType,
code: ZodIssueCode.invalid_type
});
return INVALID;
}
if (!this._cache) {
this._cache = new Set(this._def.values);
}
if (!this._cache.has(input.data)) {
const ctx = this._getOrReturnCtx(input);
const expectedValues = this._def.values;
addIssueToContext(ctx, {
received: ctx.data,
code: ZodIssueCode.invalid_enum_value,
options: expectedValues
});
return INVALID;
}
return OK(input.data);
}
get options() {
return this._def.values;
}
get enum() {
const enumValues = {};
for (const val of this._def.values) {
enumValues[val] = val;
}
return enumValues;
}
get Values() {
const enumValues = {};
for (const val of this._def.values) {
enumValues[val] = val;
}
return enumValues;
}
get Enum() {
const enumValues = {};
for (const val of this._def.values) {
enumValues[val] = val;
}
return enumValues;
}
extract(values, newDef = this._def) {
return _ZodEnum.create(values, {
...this._def,
...newDef
});
}
exclude(values, newDef = this._def) {
return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
...this._def,
...newDef
});
}
};
ZodEnum.create = createZodEnum;
var ZodNativeEnum = class extends ZodType {
_parse(input) {
const nativeEnumValues = util2.getValidEnumValues(this._def.values);
const ctx = this._getOrReturnCtx(input);
if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
const expectedValues = util2.objectValues(nativeEnumValues);
addIssueToContext(ctx, {
expected: util2.joinValues(expectedValues),
received: ctx.parsedType,
code: ZodIssueCode.invalid_type
});
return INVALID;
}
if (!this._cache) {
this._cache = new Set(util2.getValidEnumValues(this._def.values));
}
if (!this._cache.has(input.data)) {
const expectedValues = util2.objectValues(nativeEnumValues);
addIssueToContext(ctx, {
received: ctx.data,
code: ZodIssueCode.invalid_enum_value,
options: expectedValues
});
return INVALID;
}
return OK(input.data);
}
get enum() {
return this._def.values;
}
};
ZodNativeEnum.create = (values, params) => {
return new ZodNativeEnum({
values,
typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
...processCreateParams(params)
});
};
var ZodPromise = class extends ZodType {
unwrap() {
return this._def.type;
}
_parse(input) {
const { ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.promise,
received: ctx.parsedType
});
return INVALID;
}
const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
return OK(promisified.then((data) => {
return this._def.type.parseAsync(data, {
path: ctx.path,
errorMap: ctx.common.contextualErrorMap
});
}));
}
};
ZodPromise.create = (schema, params) => {
return new ZodPromise({
type: schema,
typeName: ZodFirstPartyTypeKind.ZodPromise,
...processCreateParams(params)
});
};
var ZodEffects = class extends ZodType {
innerType() {
return this._def.schema;
}
sourceType() {
return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
}
_parse(input) {
const { status, ctx } = this._processInputParams(input);
const effect = this._def.effect || null;
const checkCtx = {
addIssue: (arg) => {
addIssueToContext(ctx, arg);
if (arg.fatal) {
status.abort();
} else {
status.dirty();
}
},
get path() {
return ctx.path;
}
};
checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
if (effect.type === "preprocess") {
const processed = effect.transform(ctx.data, checkCtx);
if (ctx.common.async) {
return Promise.resolve(processed).then(async (processed2) => {
if (status.value === "aborted")
return INVALID;
const result = await this._def.schema._parseAsync({
data: processed2,
path: ctx.path,
parent: ctx
});
if (result.status === "aborted")
return INVALID;
if (result.status === "dirty")
return DIRTY(result.value);
if (status.value === "dirty")
return DIRTY(result.value);
return result;
});
} else {
if (status.value === "aborted")
return INVALID;
const result = this._def.schema._parseSync({
data: processed,
path: ctx.path,
parent: ctx
});
if (result.status === "aborted")
return INVALID;
if (result.status === "dirty")
return DIRTY(result.value);
if (status.value === "dirty")
return DIRTY(result.value);
return result;
}
}
if (effect.type === "refinement") {
const executeRefinement = (acc) => {
const result = effect.refinement(acc, checkCtx);
if (ctx.common.async) {
return Promise.resolve(result);
}
if (result instanceof Promise) {
throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
}
return acc;
};
if (ctx.common.async === false) {
const inner = this._def.schema._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (inner.status === "aborted")
return INVALID;
if (inner.status === "dirty")
status.dirty();
executeRefinement(inner.value);
return { status: status.value, value: inner.value };
} else {
return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
if (inner.status === "aborted")
return INVALID;
if (inner.status === "dirty")
status.dirty();
return executeRefinement(inner.value).then(() => {
return { status: status.value, value: inner.value };
});
});
}
}
if (effect.type === "transform") {
if (ctx.common.async === false) {
const base = this._def.schema._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (!isValid(base))
return INVALID;
const result = effect.transform(base.value, checkCtx);
if (result instanceof Promise) {
throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
}
return { status: status.value, value: result };
} else {
return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
if (!isValid(base))
return INVALID;
return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
status: status.value,
value: result
}));
});
}
}
util2.assertNever(effect);
}
};
ZodEffects.create = (schema, effect, params) => {
return new ZodEffects({
schema,
typeName: ZodFirstPartyTypeKind.ZodEffects,
effect,
...processCreateParams(params)
});
};
ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
return new ZodEffects({
schema,
effect: { type: "preprocess", transform: preprocess },
typeName: ZodFirstPartyTypeKind.ZodEffects,
...processCreateParams(params)
});
};
var ZodOptional = class extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType === ZodParsedType.undefined) {
return OK(void 0);
}
return this._def.innerType._parse(input);
}
unwrap() {
return this._def.innerType;
}
};
ZodOptional.create = (type, params) => {
return new ZodOptional({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodOptional,
...processCreateParams(params)
});
};
var ZodNullable = class extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType === ZodParsedType.null) {
return OK(null);
}
return this._def.innerType._parse(input);
}
unwrap() {
return this._def.innerType;
}
};
ZodNullable.create = (type, params) => {
return new ZodNullable({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodNullable,
...processCreateParams(params)
});
};
var ZodDefault = class extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
let data = ctx.data;
if (ctx.parsedType === ZodParsedType.undefined) {
data = this._def.defaultValue();
}
return this._def.innerType._parse({
data,
path: ctx.path,
parent: ctx
});
}
removeDefault() {
return this._def.innerType;
}
};
ZodDefault.create = (type, params) => {
return new ZodDefault({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodDefault,
defaultValue: typeof params.default === "function" ? params.default : () => params.default,
...processCreateParams(params)
});
};
var ZodCatch = class extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
const newCtx = {
...ctx,
common: {
...ctx.common,
issues: []
}
};
const result = this._def.innerType._parse({
data: newCtx.data,
path: newCtx.path,
parent: {
...newCtx
}
});
if (isAsync(result)) {
return result.then((result2) => {
return {
status: "valid",
value: result2.status === "valid" ? result2.value : this._def.catchValue({
get error() {
return new ZodError(newCtx.common.issues);
},
input: newCtx.data
})
};
});
} else {
return {
status: "valid",
value: result.status === "valid" ? result.value : this._def.catchValue({
get error() {
return new ZodError(newCtx.common.issues);
},
input: newCtx.data
})
};
}
}
removeCatch() {
return this._def.innerType;
}
};
ZodCatch.create = (type, params) => {
return new ZodCatch({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodCatch,
catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
...processCreateParams(params)
});
};
var ZodNaN = class extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.nan) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.nan,
received: ctx.parsedType
});
return INVALID;
}
return { status: "valid", value: input.data };
}
};
ZodNaN.create = (params) => {
return new ZodNaN({
typeName: ZodFirstPartyTypeKind.ZodNaN,
...processCreateParams(params)
});
};
var BRAND = Symbol("zod_brand");
var ZodBranded = class extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
const data = ctx.data;
return this._def.type._parse({
data,
path: ctx.path,
parent: ctx
});
}
unwrap() {
return this._def.type;
}
};
var ZodPipeline = class _ZodPipeline extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.common.async) {
const handleAsync = async () => {
const inResult = await this._def.in._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (inResult.status === "aborted")
return INVALID;
if (inResult.status === "dirty") {
status.dirty();
return DIRTY(inResult.value);
} else {
return this._def.out._parseAsync({
data: inResult.value,
path: ctx.path,
parent: ctx
});
}
};
return handleAsync();
} else {
const inResult = this._def.in._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (inResult.status === "aborted")
return INVALID;
if (inResult.status === "dirty") {
status.dirty();
return {
status: "dirty",
value: inResult.value
};
} else {
return this._def.out._parseSync({
data: inResult.value,
path: ctx.path,
parent: ctx
});
}
}
}
static create(a, b) {
return new _ZodPipeline({
in: a,
out: b,
typeName: ZodFirstPartyTypeKind.ZodPipeline
});
}
};
var ZodReadonly = class extends ZodType {
_parse(input) {
const result = this._def.innerType._parse(input);
const freeze = (data) => {
if (isValid(data)) {
data.value = Object.freeze(data.value);
}
return data;
};
return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
}
unwrap() {
return this._def.innerType;
}
};
ZodReadonly.create = (type, params) => {
return new ZodReadonly({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodReadonly,
...processCreateParams(params)
});
};
function cleanParams(params, data) {
const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
const p2 = typeof p === "string" ? { message: p } : p;
return p2;
}
function custom(check, _params = {}, fatal) {
if (check)
return ZodAny.create().superRefine((data, ctx) => {
const r = check(data);
if (r instanceof Promise) {
return r.then((r2) => {
if (!r2) {
const params = cleanParams(_params, data);
const _fatal = params.fatal ?? fatal ?? true;
ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
}
});
}
if (!r) {
const params = cleanParams(_params, data);
const _fatal = params.fatal ?? fatal ?? true;
ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
}
return;
});
return ZodAny.create();
}
var late = {
object: ZodObject.lazycreate
};
var ZodFirstPartyTypeKind;
(function(ZodFirstPartyTypeKind2) {
ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
var instanceOfType = (cls, params = {
message: `Input not instance of ${cls.name}`
}) => custom((data) => data instanceof cls, params);
var stringType = ZodString.create;
var numberType = ZodNumber.create;
var nanType = ZodNaN.create;
var bigIntType = ZodBigInt.create;
var booleanType = ZodBoolean.create;
var dateType = ZodDate.create;
var symbolType = ZodSymbol.create;
var undefinedType = ZodUndefined.create;
var nullType = ZodNull.create;
var anyType = ZodAny.create;
var unknownType = ZodUnknown.create;
var neverType = ZodNever.create;
var voidType = ZodVoid.create;
var arrayType = ZodArray.create;
var objectType = ZodObject.create;
var strictObjectType = ZodObject.strictCreate;
var unionType = ZodUnion.create;
var discriminatedUnionType = ZodDiscriminatedUnion.create;
var intersectionType = ZodIntersection.create;
var tupleType = ZodTuple.create;
var recordType = ZodRecord.create;
var mapType = ZodMap.create;
var setType = ZodSet.create;
var functionType = ZodFunction.create;
var lazyType = ZodLazy.create;
var literalType = ZodLiteral.create;
var enumType = ZodEnum.create;
var nativeEnumType = ZodNativeEnum.create;
var promiseType = ZodPromise.create;
var effectsType = ZodEffects.create;
var optionalType = ZodOptional.create;
var nullableType = ZodNullable.create;
var preprocessType = ZodEffects.createWithPreprocess;
var pipelineType = ZodPipeline.create;
var ostring = () => stringType().optional();
var onumber = () => numberType().optional();
var oboolean = () => booleanType().optional();
var coerce = {
string: (arg) => ZodString.create({ ...arg, coerce: true }),
number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
boolean: (arg) => ZodBoolean.create({
...arg,
coerce: true
}),
bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
date: (arg) => ZodDate.create({ ...arg, coerce: true })
};
var NEVER = INVALID;
// packages/core/src/config/projectRegistry.ts
var registryDataSchema = external_exports.object({
projects: external_exports.record(external_exports.string(), external_exports.string().regex(/^[a-z0-9-]+$/))
});
var PROJECT_ROOT_FILE = ".project_root";
var LOCK_TIMEOUT_MS = 1e4;
var LOCK_RETRY_DELAY_MS = 100;
var ProjectRegistry = class {
registryPath;
baseDirs;
data;
initPromise;
constructor(registryPath, baseDirs = []) {
this.registryPath = registryPath;
this.baseDirs = baseDirs;
}
/**
* Initializes the registry by loading data from disk.
*/
async initialize() {
if (this.initPromise) {
return this.initPromise;
}
this.initPromise = (async () => {
if (this.data) {
return;
}
this.data = await this.loadData();
})();
return this.initPromise;
}
async loadData() {
try {
const content = await fs5.promises.readFile(this.registryPath, "utf8");
const parsed = JSON.parse(content);
if (this.isValidRegistryData(parsed)) {
return parsed;
}
debugLogger.warn(
`Project registry at ${this.registryPath} has an invalid schema, resetting to empty.`
);
return { projects: {} };
} catch (error) {
if (isNodeError(error) && error.code === "ENOENT") {
return { projects: {} };
}
if (error instanceof SyntaxError) {
debugLogger.warn(
"Failed to load registry (JSON corrupted), resetting to empty: ",
error
);
return { projects: {} };
}
debugLogger.error("Critical failure reading project registry:", error);
throw error;
}
}
normalizePath(projectPath) {
let resolved = path4.resolve(projectPath);
if (os2.platform() === "win32") {
resolved = resolved.toLowerCase();
}
return resolved;
}
async save(data) {
const dir = path4.dirname(this.registryPath);
if (!fs5.existsSync(dir)) {
await fs5.promises.mkdir(dir, { recursive: true });
}
const tmpPath = this.registryPath + "." + randomUUID2() + ".tmp";
let savedSuccessfully = false;
try {
await fs5.promises.mkdir(dir, { recursive: true });
const content = JSON.stringify(data, null, 2);
await fs5.promises.writeFile(tmpPath, content, "utf8");
const maxRetries = 5;
for (let attempt = 0; attempt < maxRetries; attempt++) {
try {
await fs5.promises.rename(tmpPath, this.registryPath);
savedSuccessfully = true;
break;
} catch (error) {
const code = isNodeError(error) ? error.code : "";
const isRetryable = code === "EBUSY" || code === "EPERM";
if (!isRetryable || attempt === maxRetries - 1) {
throw error;
}
const delayMs = Math.pow(2, attempt) * 50;
debugLogger.debug(
`Rename failed with ${code}, retrying in ${delayMs}ms (attempt ${attempt + 1}/${maxRetries})...`
);
await new Promise((resolve5) => setTimeout(resolve5, delayMs));
}
}
} catch (error) {
debugLogger.error(
`Failed to save project registry to ${this.registryPath}:`,
error
);
throw error;
} finally {
if (!savedSuccessfully) {
try {
await fs5.promises.unlink(tmpPath);
} catch {
}
}
}
}
/**
* Returns a short identifier for the given project path.
* If the project is not already in the registry, a new identifier is generated and saved.
*/
async getShortId(projectPath) {
if (!this.data) {
throw new Error("ProjectRegistry must be initialized before use");
}
const normalizedPath = this.normalizePath(projectPath);
const dir = path4.dirname(this.registryPath);
if (!fs5.existsSync(dir)) {
await fs5.promises.mkdir(dir, { recursive: true });
}
if (!fs5.existsSync(this.registryPath)) {
try {
await this.save({ projects: {} });
} catch (e) {
if (!fs5.existsSync(this.registryPath)) {
throw e;
}
}
}
const release = await (0, import_proper_lockfile.lock)(this.registryPath, {
retries: {
retries: Math.floor(LOCK_TIMEOUT_MS / LOCK_RETRY_DELAY_MS),
minTimeout: LOCK_RETRY_DELAY_MS
}
});
try {
const currentData = await this.loadData();
this.data = currentData;
let shortId = currentData.projects[normalizedPath];
if (shortId) {
if (await this.verifySlugOwnership(shortId, normalizedPath)) {
await this.ensureOwnershipMarkers(shortId, normalizedPath);
return shortId;
}
delete currentData.projects[normalizedPath];
}
shortId = await this.findExistingSlugForPath(normalizedPath);
if (!shortId) {
shortId = await this.claimNewSlug(normalizedPath, currentData.projects);
}
currentData.projects[normalizedPath] = shortId;
await this.save(currentData);
return shortId;
} finally {
try {
await release();
} catch (e) {
debugLogger.error("Failed to release project registry lock:", e);
}
}
}
async verifySlugOwnership(slug, projectPath) {
if (this.baseDirs.length === 0) {
return true;
}
for (const baseDir of this.baseDirs) {
const markerPath = path4.join(baseDir, slug, PROJECT_ROOT_FILE);
try {
const owner = (await fs5.promises.readFile(markerPath, "utf8")).trim();
if (this.normalizePath(owner) !== this.normalizePath(projectPath)) {
return false;
}
} catch (e) {
if (isNodeError(e) && e.code === "ENOENT") {
continue;
}
debugLogger.debug(`Failed to read ownership marker ${markerPath}:`, e);
return false;
}
}
return true;
}
async findExistingSlugForPath(projectPath) {
if (this.baseDirs.length === 0) {
return void 0;
}
const normalizedTarget = this.normalizePath(projectPath);
for (const baseDir of this.baseDirs) {
if (!fs5.existsSync(baseDir)) {
continue;
}
try {
const candidates = await fs5.promises.readdir(baseDir);
for (const candidate of candidates) {
const markerPath = path4.join(baseDir, candidate, PROJECT_ROOT_FILE);
if (fs5.existsSync(markerPath)) {
const owner = (await fs5.promises.readFile(markerPath, "utf8")).trim();
if (this.normalizePath(owner) === normalizedTarget) {
await this.ensureOwnershipMarkers(candidate, normalizedTarget);
return candidate;
}
}
}
} catch (e) {
debugLogger.debug(`Failed to scan base dir ${baseDir}:`, e);
}
}
return void 0;
}
async claimNewSlug(projectPath, existingMappings) {
const baseName = path4.basename(projectPath) || "project";
const slug = this.slugify(baseName);
let counter = 0;
const existingIds = new Set(Object.values(existingMappings));
while (true) {
const candidate = counter === 0 ? slug : `${slug}-${counter}`;
counter++;
if (existingIds.has(candidate)) {
continue;
}
let diskCollision = false;
for (const baseDir of this.baseDirs) {
const markerPath = path4.join(baseDir, candidate, PROJECT_ROOT_FILE);
if (fs5.existsSync(markerPath)) {
try {
const owner = (await fs5.promises.readFile(markerPath, "utf8")).trim();
if (this.normalizePath(owner) !== this.normalizePath(projectPath)) {
diskCollision = true;
break;
}
} catch {
diskCollision = true;
break;
}
}
}
if (diskCollision) {
continue;
}
try {
await this.ensureOwnershipMarkers(candidate, projectPath);
return candidate;
} catch (error) {
const code = isNodeError(error) ? error.code : "";
const isCollision = code === "EEXIST" || error instanceof Error && error.message.includes("already owned by");
if (isCollision) {
debugLogger.debug(`Slug collision for ${candidate}, trying next...`);
continue;
}
throw error;
}
}
}
async ensureOwnershipMarkers(slug, projectPath) {
const normalizedProject = this.normalizePath(projectPath);
for (const baseDir of this.baseDirs) {
const slugDir = path4.join(baseDir, slug);
if (!fs5.existsSync(slugDir)) {
await fs5.promises.mkdir(slugDir, { recursive: true });
}
const markerPath = path4.join(slugDir, PROJECT_ROOT_FILE);
if (fs5.existsSync(markerPath)) {
const owner = (await fs5.promises.readFile(markerPath, "utf8")).trim();
if (this.normalizePath(owner) === normalizedProject) {
continue;
}
const error = Object.assign(
new Error(`Slug ${slug} is already owned by ${owner}`),
{ code: "EEXIST" }
);
throw error;
}
try {
await fs5.promises.writeFile(markerPath, normalizedProject, {
encoding: "utf8",
flag: "wx"
});
} catch (e) {
if (isNodeError(e) && e.code === "EEXIST") {
const owner = (await fs5.promises.readFile(markerPath, "utf8")).trim();
if (this.normalizePath(owner) === normalizedProject) {
continue;
}
}
throw e;
}
}
}
slugify(text) {
return text.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "project";
}
isValidRegistryData(data) {
return registryDataSchema.safeParse(data).success;
}
};
// packages/core/src/config/storageMigration.ts
import * as fs6 from "node:fs";
import * as path5 from "node:path";
var StorageMigration = class {
/**
* Migrates a directory from an old path to a new path if the old one exists and the new one doesn't.
* @param oldPath The old directory path (hash-based).
* @param newPath The new directory path (slug-based).
*/
static async migrateDirectory(oldPath, newPath) {
try {
if (!fs6.existsSync(oldPath)) {
return;
}
if (fs6.existsSync(newPath)) {
const files = await fs6.promises.readdir(newPath);
if (files.length > 1 || files.length === 1 && files[0] !== ".project_root") {
return;
}
}
const parentDir = path5.dirname(newPath);
await fs6.promises.mkdir(parentDir, { recursive: true });
await fs6.promises.cp(oldPath, newPath, { recursive: true });
} catch (e) {
debugLogger.debug(
`Storage Migration: Failed to move ${oldPath} to ${newPath}:`,
e
);
}
}
};
// packages/core/src/config/storage.ts
var OAUTH_FILE = "oauth_creds.json";
var TRUSTED_FOLDERS_FILENAME2 = "trustedFolders.json";
var TMP_DIR_NAME = "tmp";
var BIN_DIR_NAME = "bin";
var AGENTS_DIR_NAME = ".agents";
var AUTO_SAVED_POLICY_FILENAME = "auto-saved.toml";
var Storage = class _Storage {
targetDir;
sessionId;
projectIdentifier;
initPromise;
customPlansDir;
constructor(targetDir, sessionId) {
this.targetDir = targetDir;
this.sessionId = sessionId;
}
setCustomPlansDir(dir) {
this.customPlansDir = dir;
}
setSessionId(sessionId) {
this.sessionId = sessionId;
}
isInitialized() {
return !!this.projectIdentifier;
}
static getGlobalGeminiDir() {
const homeDir = homedir();
if (!homeDir) {
return path6.join(os3.tmpdir(), GEMINI_DIR);
}
return path6.join(homeDir, GEMINI_DIR);
}
static getGlobalAgentsDir() {
const homeDir = homedir();
if (!homeDir) {
return "";
}
return path6.join(homeDir, AGENTS_DIR_NAME);
}
static getMcpOAuthTokensPath() {
return path6.join(_Storage.getGlobalGeminiDir(), "mcp-oauth-tokens.json");
}
static getA2AOAuthTokensPath() {
return path6.join(_Storage.getGlobalGeminiDir(), "a2a-oauth-tokens.json");
}
static getGlobalSettingsPath() {
return path6.join(_Storage.getGlobalGeminiDir(), "settings.json");
}
static getInstallationIdPath() {
return path6.join(_Storage.getGlobalGeminiDir(), "installation_id");
}
static getGoogleAccountsPath() {
return path6.join(_Storage.getGlobalGeminiDir(), GOOGLE_ACCOUNTS_FILENAME);
}
static getTrustedFoldersPath() {
if (process.env["GEMINI_CLI_TRUSTED_FOLDERS_PATH"]) {
return process.env["GEMINI_CLI_TRUSTED_FOLDERS_PATH"];
}
return path6.join(_Storage.getGlobalGeminiDir(), TRUSTED_FOLDERS_FILENAME2);
}
static getUserCommandsDir() {
return path6.join(_Storage.getGlobalGeminiDir(), "commands");
}
static getUserSkillsDir() {
return path6.join(_Storage.getGlobalGeminiDir(), "skills");
}
static getUserAgentSkillsDir() {
return path6.join(_Storage.getGlobalAgentsDir(), "skills");
}
static getUserPoliciesDir() {
return path6.join(_Storage.getGlobalGeminiDir(), "policies");
}
static getUserKeybindingsPath() {
return path6.join(_Storage.getGlobalGeminiDir(), "keybindings.json");
}
static getUserAgentsDir() {
return path6.join(_Storage.getGlobalGeminiDir(), "agents");
}
static getAcknowledgedAgentsPath() {
return path6.join(
_Storage.getGlobalGeminiDir(),
"acknowledgments",
"agents.json"
);
}
static getPolicyIntegrityStoragePath() {
return path6.join(_Storage.getGlobalGeminiDir(), "policy_integrity.json");
}
static getSystemConfigDir() {
if (os3.platform() === "darwin") {
return "/Library/Application Support/GeminiCli";
} else if (os3.platform() === "win32") {
return "C:\\ProgramData\\gemini-cli";
} else {
return "/etc/gemini-cli";
}
}
static getSystemSettingsPath() {
if (process.env["GEMINI_CLI_SYSTEM_SETTINGS_PATH"]) {
return process.env["GEMINI_CLI_SYSTEM_SETTINGS_PATH"];
}
return path6.join(_Storage.getSystemConfigDir(), "settings.json");
}
static getSystemPoliciesDir() {
return path6.join(_Storage.getSystemConfigDir(), "policies");
}
static getGlobalTempDir() {
return path6.join(_Storage.getGlobalGeminiDir(), TMP_DIR_NAME);
}
static getGlobalBinDir() {
return path6.join(_Storage.getGlobalTempDir(), BIN_DIR_NAME);
}
getGeminiDir() {
return path6.join(this.targetDir, GEMINI_DIR);
}
/**
* Checks if the current workspace storage location is the same as the global/user storage location.
* This handles symlinks and platform-specific path normalization.
*/
isWorkspaceHomeDir() {
return normalizePath(resolveToRealPath(this.targetDir)) === normalizePath(resolveToRealPath(homedir()));
}
getAgentsDir() {
return path6.join(this.targetDir, AGENTS_DIR_NAME);
}
getProjectTempDir() {
const identifier = this.getProjectIdentifier();
const tempDir = _Storage.getGlobalTempDir();
return path6.join(tempDir, identifier);
}
getWorkspacePoliciesDir() {
return path6.join(this.getGeminiDir(), "policies");
}
getWorkspaceAutoSavedPolicyPath() {
return path6.join(
this.getWorkspacePoliciesDir(),
AUTO_SAVED_POLICY_FILENAME
);
}
getAutoSavedPolicyPath() {
return path6.join(_Storage.getUserPoliciesDir(), AUTO_SAVED_POLICY_FILENAME);
}
ensureProjectTempDirExists() {
fs7.mkdirSync(this.getProjectTempDir(), { recursive: true });
}
static getOAuthCredsPath() {
return path6.join(_Storage.getGlobalGeminiDir(), OAUTH_FILE);
}
getProjectRoot() {
return this.targetDir;
}
getFilePathHash(filePath) {
return crypto3.createHash("sha256").update(filePath).digest("hex");
}
getProjectIdentifier() {
if (!this.projectIdentifier) {
throw new Error("Storage must be initialized before use");
}
return this.projectIdentifier;
}
/**
* Initializes storage by setting up the project registry and performing migrations.
*/
async initialize() {
if (this.initPromise) {
return this.initPromise;
}
this.initPromise = (async () => {
if (this.projectIdentifier) {
return;
}
const registryPath = path6.join(
_Storage.getGlobalGeminiDir(),
"projects.json"
);
const registry = new ProjectRegistry(registryPath, [
_Storage.getGlobalTempDir(),
path6.join(_Storage.getGlobalGeminiDir(), "history")
]);
await registry.initialize();
this.projectIdentifier = await registry.getShortId(this.getProjectRoot());
await this.performMigration();
})();
return this.initPromise;
}
/**
* Performs migration of legacy hash-based directories to the new slug-based format.
* This is called internally by initialize().
*/
async performMigration() {
const shortId = this.getProjectIdentifier();
const oldHash = this.getFilePathHash(this.getProjectRoot());
const newTempDir = path6.join(_Storage.getGlobalTempDir(), shortId);
const oldTempDir = path6.join(_Storage.getGlobalTempDir(), oldHash);
await StorageMigration.migrateDirectory(oldTempDir, newTempDir);
const historyDir = path6.join(_Storage.getGlobalGeminiDir(), "history");
const newHistoryDir = path6.join(historyDir, shortId);
const oldHistoryDir = path6.join(historyDir, oldHash);
await StorageMigration.migrateDirectory(oldHistoryDir, newHistoryDir);
}
getHistoryDir() {
const identifier = this.getProjectIdentifier();
const historyDir = path6.join(_Storage.getGlobalGeminiDir(), "history");
return path6.join(historyDir, identifier);
}
getProjectMemoryDir() {
return this.getProjectMemoryTempDir();
}
getProjectMemoryTempDir() {
return path6.join(this.getProjectTempDir(), "memory");
}
getProjectSkillsMemoryDir() {
return path6.join(this.getProjectMemoryTempDir(), "skills");
}
getWorkspaceSettingsPath() {
return path6.join(this.getGeminiDir(), "settings.json");
}
getProjectCommandsDir() {
return path6.join(this.getGeminiDir(), "commands");
}
getProjectSkillsDir() {
return path6.join(this.getGeminiDir(), "skills");
}
getProjectAgentSkillsDir() {
return path6.join(this.getAgentsDir(), "skills");
}
getProjectAgentsDir() {
return path6.join(this.getGeminiDir(), "agents");
}
getProjectTempCheckpointsDir() {
return path6.join(this.getProjectTempDir(), "checkpoints");
}
getProjectTempLogsDir() {
return path6.join(this.getProjectTempDir(), "logs");
}
getProjectTempPlansDir() {
if (this.sessionId) {
return path6.join(this.getProjectTempDir(), this.sessionId, "plans");
}
return path6.join(this.getProjectTempDir(), "plans");
}
getProjectTempTrackerDir() {
if (this.sessionId) {
return path6.join(this.getProjectTempDir(), this.sessionId, "tracker");
}
return path6.join(this.getProjectTempDir(), "tracker");
}
getPlansDir() {
if (this.customPlansDir) {
const resolvedPath = path6.resolve(
this.getProjectRoot(),
this.customPlansDir
);
const realProjectRoot = resolveToRealPath(this.getProjectRoot());
const realResolvedPath = resolveToRealPath(resolvedPath);
if (!isSubpath(realProjectRoot, realResolvedPath)) {
throw new Error(
`Custom plans directory '${this.customPlansDir}' resolves to '${realResolvedPath}', which is outside the project root '${realProjectRoot}'.`
);
}
return resolvedPath;
}
return this.getProjectTempPlansDir();
}
getProjectTempTasksDir() {
if (this.sessionId) {
return path6.join(this.getProjectTempDir(), this.sessionId, "tasks");
}
return path6.join(this.getProjectTempDir(), "tasks");
}
async listProjectChatFiles() {
const chatsDir = path6.join(this.getProjectTempDir(), "chats");
try {
const files = await fs7.promises.readdir(chatsDir);
const jsonFiles = files.filter(
(f) => f.endsWith(".json") || f.endsWith(".jsonl")
);
const sessions = await Promise.all(
jsonFiles.map(async (file) => {
const absolutePath = path6.join(chatsDir, file);
const stats = await fs7.promises.stat(absolutePath);
return {
filePath: path6.join("chats", file),
lastUpdated: stats.mtime.toISOString(),
mtimeMs: stats.mtimeMs
};
})
);
return sessions.sort((a, b) => b.mtimeMs - a.mtimeMs).map(({ filePath, lastUpdated }) => ({ filePath, lastUpdated }));
} catch (e) {
if (e instanceof Error && "code" in e && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
e.code === "ENOENT") {
return [];
}
throw e;
}
}
async loadProjectTempFile(filePath) {
const absolutePath = path6.join(this.getProjectTempDir(), filePath);
try {
const content = await fs7.promises.readFile(absolutePath, "utf8");
return JSON.parse(content);
} catch (e) {
if (e instanceof Error && "code" in e && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
e.code === "ENOENT") {
return null;
}
throw e;
}
}
getExtensionsDir() {
return path6.join(this.getGeminiDir(), "extensions");
}
getExtensionsConfigPath() {
return path6.join(this.getExtensionsDir(), "gemini-extension.json");
}
getHistoryFilePath() {
return path6.join(this.getProjectTempDir(), "shell_history");
}
};
// node_modules/diff/libesm/diff/base.js
var Diff = class {
diff(oldStr, newStr, options = {}) {
let callback;
if (typeof options === "function") {
callback = options;
options = {};
} else if ("callback" in options) {
callback = options.callback;
}
const oldString = this.castInput(oldStr, options);
const newString = this.castInput(newStr, options);
const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
const newTokens = this.removeEmpty(this.tokenize(newString, options));
return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
}
diffWithOptionsObj(oldTokens, newTokens, options, callback) {
var _a;
const done = (value) => {
value = this.postProcess(value, options);
if (callback) {
setTimeout(function() {
callback(value);
}, 0);
return void 0;
} else {
return value;
}
};
const newLen = newTokens.length, oldLen = oldTokens.length;
let editLength = 1;
let maxEditLength = newLen + oldLen;
if (options.maxEditLength != null) {
maxEditLength = Math.min(maxEditLength, options.maxEditLength);
}
const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
const abortAfterTimestamp = Date.now() + maxExecutionTime;
const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
}
let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
const execEditLength = () => {
for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
let basePath;
const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
if (removePath) {
bestPath[diagonalPath - 1] = void 0;
}
let canAdd = false;
if (addPath) {
const addPathNewPos = addPath.oldPos - diagonalPath;
canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
}
const canRemove = removePath && removePath.oldPos + 1 < oldLen;
if (!canAdd && !canRemove) {
bestPath[diagonalPath] = void 0;
continue;
}
if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
basePath = this.addToPath(addPath, true, false, 0, options);
} else {
basePath = this.addToPath(removePath, false, true, 1, options);
}
newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
} else {
bestPath[diagonalPath] = basePath;
if (basePath.oldPos + 1 >= oldLen) {
maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
}
if (newPos + 1 >= newLen) {
minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
}
}
}
editLength++;
};
if (callback) {
(function exec() {
setTimeout(function() {
if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
return callback(void 0);
}
if (!execEditLength()) {
exec();
}
}, 0);
})();
} else {
while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
const ret = execEditLength();
if (ret) {
return ret;
}
}
}
}
addToPath(path10, added, removed, oldPosInc, options) {
const last = path10.lastComponent;
if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
return {
oldPos: path10.oldPos + oldPosInc,
lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
};
} else {
return {
oldPos: path10.oldPos + oldPosInc,
lastComponent: { count: 1, added, removed, previousComponent: last }
};
}
}
extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
const newLen = newTokens.length, oldLen = oldTokens.length;
let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
newPos++;
oldPos++;
commonCount++;
if (options.oneChangePerToken) {
basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
}
}
if (commonCount && !options.oneChangePerToken) {
basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
}
basePath.oldPos = oldPos;
return newPos;
}
equals(left, right, options) {
if (options.comparator) {
return options.comparator(left, right);
} else {
return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
}
}
removeEmpty(array) {
const ret = [];
for (let i = 0; i < array.length; i++) {
if (array[i]) {
ret.push(array[i]);
}
}
return ret;
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
castInput(value, options) {
return value;
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
tokenize(value, options) {
return Array.from(value);
}
join(chars) {
return chars.join("");
}
postProcess(changeObjects, options) {
return changeObjects;
}
get useLongestToken() {
return false;
}
buildValues(lastComponent, newTokens, oldTokens) {
const components = [];
let nextComponent;
while (lastComponent) {
components.push(lastComponent);
nextComponent = lastComponent.previousComponent;
delete lastComponent.previousComponent;
lastComponent = nextComponent;
}
components.reverse();
const componentLen = components.length;
let componentPos = 0, newPos = 0, oldPos = 0;
for (; componentPos < componentLen; componentPos++) {
const component = components[componentPos];
if (!component.removed) {
if (!component.added && this.useLongestToken) {
let value = newTokens.slice(newPos, newPos + component.count);
value = value.map(function(value2, i) {
const oldValue = oldTokens[oldPos + i];
return oldValue.length > value2.length ? oldValue : value2;
});
component.value = this.join(value);
} else {
component.value = this.join(newTokens.slice(newPos, newPos + component.count));
}
newPos += component.count;
if (!component.added) {
oldPos += component.count;
}
} else {
component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
oldPos += component.count;
}
}
return components;
}
};
// node_modules/diff/libesm/util/string.js
function hasOnlyWinLineEndings(string) {
return string.includes("\r\n") && !string.startsWith("\n") && !string.match(/[^\r]\n/);
}
function hasOnlyUnixLineEndings(string) {
return !string.includes("\r\n") && string.includes("\n");
}
// node_modules/diff/libesm/diff/line.js
var LineDiff = class extends Diff {
constructor() {
super(...arguments);
this.tokenize = tokenize;
}
equals(left, right, options) {
if (options.ignoreWhitespace) {
if (!options.newlineIsToken || !left.includes("\n")) {
left = left.trim();
}
if (!options.newlineIsToken || !right.includes("\n")) {
right = right.trim();
}
} else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
if (left.endsWith("\n")) {
left = left.slice(0, -1);
}
if (right.endsWith("\n")) {
right = right.slice(0, -1);
}
}
return super.equals(left, right, options);
}
};
var lineDiff = new LineDiff();
function diffLines(oldStr, newStr, options) {
return lineDiff.diff(oldStr, newStr, options);
}
function tokenize(value, options) {
if (options.stripTrailingCr) {
value = value.replace(/\r\n/g, "\n");
}
const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
if (!linesAndNewlines[linesAndNewlines.length - 1]) {
linesAndNewlines.pop();
}
for (let i = 0; i < linesAndNewlines.length; i++) {
const line = linesAndNewlines[i];
if (i % 2 && !options.newlineIsToken) {
retLines[retLines.length - 1] += line;
} else {
retLines.push(line);
}
}
return retLines;
}
// node_modules/diff/libesm/patch/line-endings.js
function unixToWin(patch) {
if (Array.isArray(patch)) {
return patch.map((p) => unixToWin(p));
}
return Object.assign(Object.assign({}, patch), { hunks: patch.hunks.map((hunk) => Object.assign(Object.assign({}, hunk), { lines: hunk.lines.map((line, i) => {
var _a;
return line.startsWith("\\") || line.endsWith("\r") || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith("\\")) ? line : line + "\r";
}) })) });
}
function winToUnix(patch) {
if (Array.isArray(patch)) {
return patch.map((p) => winToUnix(p));
}
return Object.assign(Object.assign({}, patch), { hunks: patch.hunks.map((hunk) => Object.assign(Object.assign({}, hunk), { lines: hunk.lines.map((line) => line.endsWith("\r") ? line.substring(0, line.length - 1) : line) })) });
}
function isUnix(patch) {
if (!Array.isArray(patch)) {
patch = [patch];
}
return !patch.some((index) => index.hunks.some((hunk) => hunk.lines.some((line) => !line.startsWith("\\") && line.endsWith("\r"))));
}
function isWin(patch) {
if (!Array.isArray(patch)) {
patch = [patch];
}
return patch.some((index) => index.hunks.some((hunk) => hunk.lines.some((line) => line.endsWith("\r")))) && patch.every((index) => index.hunks.every((hunk) => hunk.lines.every((line, i) => {
var _a;
return line.startsWith("\\") || line.endsWith("\r") || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith("\\"));
})));
}
// node_modules/diff/libesm/patch/parse.js
function parsePatch(uniDiff) {
const diffstr = uniDiff.split(/\n/), list = [];
let i = 0;
function parseIndex() {
const index = {};
list.push(index);
while (i < diffstr.length) {
const line = diffstr[i];
if (/^(---|\+\+\+|@@)\s/.test(line)) {
break;
}
const headerMatch = /^(?:Index:|diff(?: -r \w+)+)\s+/.exec(line);
if (headerMatch) {
index.index = line.substring(headerMatch[0].length).trim();
}
i++;
}
parseFileHeader(index);
parseFileHeader(index);
index.hunks = [];
while (i < diffstr.length) {
const line = diffstr[i];
if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
break;
} else if (/^@@/.test(line)) {
index.hunks.push(parseHunk());
} else if (line) {
throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
} else {
i++;
}
}
}
function parseFileHeader(index) {
const fileHeaderMatch = /^(---|\+\+\+)\s+/.exec(diffstr[i]);
if (fileHeaderMatch) {
const prefix = fileHeaderMatch[1], data = diffstr[i].substring(3).trim().split(" ", 2), header = (data[1] || "").trim();
let fileName = data[0].replace(/\\\\/g, "\\");
if (fileName.startsWith('"') && fileName.endsWith('"')) {
fileName = fileName.substr(1, fileName.length - 2);
}
if (prefix === "---") {
index.oldFileName = fileName;
index.oldHeader = header;
} else {
index.newFileName = fileName;
index.newHeader = header;
}
i++;
}
}
function parseHunk() {
var _a;
const chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
const hunk = {
oldStart: +chunkHeader[1],
oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
newStart: +chunkHeader[3],
newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
lines: []
};
if (hunk.oldLines === 0) {
hunk.oldStart += 1;
}
if (hunk.newLines === 0) {
hunk.newStart += 1;
}
let addCount = 0, removeCount = 0;
for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a = diffstr[i]) === null || _a === void 0 ? void 0 : _a.startsWith("\\"))); i++) {
const operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
hunk.lines.push(diffstr[i]);
if (operation === "+") {
addCount++;
} else if (operation === "-") {
removeCount++;
} else if (operation === " ") {
addCount++;
removeCount++;
}
} else {
throw new Error(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${diffstr[i]}`);
}
}
if (!addCount && hunk.newLines === 1) {
hunk.newLines = 0;
}
if (!removeCount && hunk.oldLines === 1) {
hunk.oldLines = 0;
}
if (addCount !== hunk.newLines) {
throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
}
if (removeCount !== hunk.oldLines) {
throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
}
return hunk;
}
while (i < diffstr.length) {
parseIndex();
}
return list;
}
// node_modules/diff/libesm/util/distance-iterator.js
function distance_iterator_default(start, minLine, maxLine) {
let wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;
return function iterator() {
if (wantForward && !forwardExhausted) {
if (backwardExhausted) {
localOffset++;
} else {
wantForward = false;
}
if (start + localOffset <= maxLine) {
return start + localOffset;
}
forwardExhausted = true;
}
if (!backwardExhausted) {
if (!forwardExhausted) {
wantForward = true;
}
if (minLine <= start - localOffset) {
return start - localOffset++;
}
backwardExhausted = true;
return iterator();
}
return void 0;
};
}
// node_modules/diff/libesm/patch/apply.js
function applyPatch(source, patch, options = {}) {
let patches;
if (typeof patch === "string") {
patches = parsePatch(patch);
} else if (Array.isArray(patch)) {
patches = patch;
} else {
patches = [patch];
}
if (patches.length > 1) {
throw new Error("applyPatch only works with a single input.");
}
return applyStructuredPatch(source, patches[0], options);
}
function applyStructuredPatch(source, patch, options = {}) {
if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {
if (hasOnlyWinLineEndings(source) && isUnix(patch)) {
patch = unixToWin(patch);
} else if (hasOnlyUnixLineEndings(source) && isWin(patch)) {
patch = winToUnix(patch);
}
}
const lines = source.split("\n"), hunks = patch.hunks, compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent), fuzzFactor = options.fuzzFactor || 0;
let minLine = 0;
if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {
throw new Error("fuzzFactor must be a non-negative integer");
}
if (!hunks.length) {
return source;
}
let prevLine = "", removeEOFNL = false, addEOFNL = false;
for (let i = 0; i < hunks[hunks.length - 1].lines.length; i++) {
const line = hunks[hunks.length - 1].lines[i];
if (line[0] == "\\") {
if (prevLine[0] == "+") {
removeEOFNL = true;
} else if (prevLine[0] == "-") {
addEOFNL = true;
}
}
prevLine = line;
}
if (removeEOFNL) {
if (addEOFNL) {
if (!fuzzFactor && lines[lines.length - 1] == "") {
return false;
}
} else if (lines[lines.length - 1] == "") {
lines.pop();
} else if (!fuzzFactor) {
return false;
}
} else if (addEOFNL) {
if (lines[lines.length - 1] != "") {
lines.push("");
} else if (!fuzzFactor) {
return false;
}
}
function applyHunk(hunkLines, toPos, maxErrors, hunkLinesI = 0, lastContextLineMatched = true, patchedLines = [], patchedLinesLength = 0) {
let nConsecutiveOldContextLines = 0;
let nextContextLineMustMatch = false;
for (; hunkLinesI < hunkLines.length; hunkLinesI++) {
const hunkLine = hunkLines[hunkLinesI], operation = hunkLine.length > 0 ? hunkLine[0] : " ", content = hunkLine.length > 0 ? hunkLine.substr(1) : hunkLine;
if (operation === "-") {
if (compareLine(toPos + 1, lines[toPos], operation, content)) {
toPos++;
nConsecutiveOldContextLines = 0;
} else {
if (!maxErrors || lines[toPos] == null) {
return null;
}
patchedLines[patchedLinesLength] = lines[toPos];
return applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1);
}
}
if (operation === "+") {
if (!lastContextLineMatched) {
return null;
}
patchedLines[patchedLinesLength] = content;
patchedLinesLength++;
nConsecutiveOldContextLines = 0;
nextContextLineMustMatch = true;
}
if (operation === " ") {
nConsecutiveOldContextLines++;
patchedLines[patchedLinesLength] = lines[toPos];
if (compareLine(toPos + 1, lines[toPos], operation, content)) {
patchedLinesLength++;
lastContextLineMatched = true;
nextContextLineMustMatch = false;
toPos++;
} else {
if (nextContextLineMustMatch || !maxErrors) {
return null;
}
return lines[toPos] && (applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength + 1) || applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1)) || applyHunk(hunkLines, toPos, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength);
}
}
}
patchedLinesLength -= nConsecutiveOldContextLines;
toPos -= nConsecutiveOldContextLines;
patchedLines.length = patchedLinesLength;
return {
patchedLines,
oldLineLastI: toPos - 1
};
}
const resultLines = [];
let prevHunkOffset = 0;
for (let i = 0; i < hunks.length; i++) {
const hunk = hunks[i];
let hunkResult;
const maxLine = lines.length - hunk.oldLines + fuzzFactor;
let toPos;
for (let maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {
toPos = hunk.oldStart + prevHunkOffset - 1;
const iterator = distance_iterator_default(toPos, minLine, maxLine);
for (; toPos !== void 0; toPos = iterator()) {
hunkResult = applyHunk(hunk.lines, toPos, maxErrors);
if (hunkResult) {
break;
}
}
if (hunkResult) {
break;
}
}
if (!hunkResult) {
return false;
}
for (let i2 = minLine; i2 < toPos; i2++) {
resultLines.push(lines[i2]);
}
for (let i2 = 0; i2 < hunkResult.patchedLines.length; i2++) {
const line = hunkResult.patchedLines[i2];
resultLines.push(line);
}
minLine = hunkResult.oldLineLastI + 1;
prevHunkOffset = toPos + 1 - hunk.oldStart;
}
for (let i = minLine; i < lines.length; i++) {
resultLines.push(lines[i]);
}
return resultLines.join("\n");
}
// node_modules/diff/libesm/patch/create.js
var INCLUDE_HEADERS = {
includeIndex: true,
includeUnderline: true,
includeFileHeaders: true
};
function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
let optionsObj;
if (!options) {
optionsObj = {};
} else if (typeof options === "function") {
optionsObj = { callback: options };
} else {
optionsObj = options;
}
if (typeof optionsObj.context === "undefined") {
optionsObj.context = 4;
}
const context = optionsObj.context;
if (optionsObj.newlineIsToken) {
throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
}
if (!optionsObj.callback) {
return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
} else {
const { callback } = optionsObj;
diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
const patch = diffLinesResultToPatch(diff);
callback(patch);
} }));
}
function diffLinesResultToPatch(diff) {
if (!diff) {
return;
}
diff.push({ value: "", lines: [] });
function contextLines(lines) {
return lines.map(function(entry) {
return " " + entry;
});
}
const hunks = [];
let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
for (let i = 0; i < diff.length; i++) {
const current = diff[i], lines = current.lines || splitLines(current.value);
current.lines = lines;
if (current.added || current.removed) {
if (!oldRangeStart) {
const prev = diff[i - 1];
oldRangeStart = oldLine;
newRangeStart = newLine;
if (prev) {
curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
oldRangeStart -= curRange.length;
newRangeStart -= curRange.length;
}
}
for (const line of lines) {
curRange.push((current.added ? "+" : "-") + line);
}
if (current.added) {
newLine += lines.length;
} else {
oldLine += lines.length;
}
} else {
if (oldRangeStart) {
if (lines.length <= context * 2 && i < diff.length - 2) {
for (const line of contextLines(lines)) {
curRange.push(line);
}
} else {
const contextSize = Math.min(lines.length, context);
for (const line of contextLines(lines.slice(0, contextSize))) {
curRange.push(line);
}
const hunk = {
oldStart: oldRangeStart,
oldLines: oldLine - oldRangeStart + contextSize,
newStart: newRangeStart,
newLines: newLine - newRangeStart + contextSize,
lines: curRange
};
hunks.push(hunk);
oldRangeStart = 0;
newRangeStart = 0;
curRange = [];
}
}
oldLine += lines.length;
newLine += lines.length;
}
}
for (const hunk of hunks) {
for (let i = 0; i < hunk.lines.length; i++) {
if (hunk.lines[i].endsWith("\n")) {
hunk.lines[i] = hunk.lines[i].slice(0, -1);
} else {
hunk.lines.splice(i + 1, 0, "\\ No newline at end of file");
i++;
}
}
}
return {
oldFileName,
newFileName,
oldHeader,
newHeader,
hunks
};
}
}
function formatPatch(patch, headerOptions) {
if (!headerOptions) {
headerOptions = INCLUDE_HEADERS;
}
if (Array.isArray(patch)) {
if (patch.length > 1 && !headerOptions.includeFileHeaders) {
throw new Error("Cannot omit file headers on a multi-file patch. (The result would be unparseable; how would a tool trying to apply the patch know which changes are to which file?)");
}
return patch.map((p) => formatPatch(p, headerOptions)).join("\n");
}
const ret = [];
if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {
ret.push("Index: " + patch.oldFileName);
}
if (headerOptions.includeUnderline) {
ret.push("===================================================================");
}
if (headerOptions.includeFileHeaders) {
ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : " " + patch.oldHeader));
ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : " " + patch.newHeader));
}
for (let i = 0; i < patch.hunks.length; i++) {
const hunk = patch.hunks[i];
if (hunk.oldLines === 0) {
hunk.oldStart -= 1;
}
if (hunk.newLines === 0) {
hunk.newStart -= 1;
}
ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
for (const line of hunk.lines) {
ret.push(line);
}
}
return ret.join("\n") + "\n";
}
function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
if (typeof options === "function") {
options = { callback: options };
}
if (!(options === null || options === void 0 ? void 0 : options.callback)) {
const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
if (!patchObj) {
return;
}
return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);
} else {
const { callback } = options;
structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
if (!patchObj) {
callback(void 0);
} else {
callback(formatPatch(patchObj, options.headerOptions));
}
} }));
}
}
function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
}
function splitLines(text) {
const hasTrailingNl = text.endsWith("\n");
const result = text.split("\n").map((line) => line + "\n");
if (hasTrailingNl) {
result.pop();
} else {
result.push(result.pop().slice(0, -1));
}
return result;
}
// packages/core/src/tools/diffOptions.ts
var DEFAULT_STRUCTURED_PATCH_OPTS = {
context: 3,
ignoreWhitespace: false
};
var DEFAULT_DIFF_OPTIONS = {
context: 3,
ignoreWhitespace: false
};
function getDiffStat(fileName, oldStr, aiStr, userStr) {
const getStats = (patch) => {
let addedLines = 0;
let removedLines = 0;
let addedChars = 0;
let removedChars = 0;
patch.hunks.forEach((hunk) => {
hunk.lines.forEach((line) => {
if (line.startsWith("+")) {
addedLines++;
addedChars += line.length - 1;
} else if (line.startsWith("-")) {
removedLines++;
removedChars += line.length - 1;
}
});
});
return { addedLines, removedLines, addedChars, removedChars };
};
const modelPatch = structuredPatch(
fileName,
fileName,
oldStr,
aiStr,
"Current",
"Proposed",
DEFAULT_STRUCTURED_PATCH_OPTS
);
const modelStats = getStats(modelPatch);
const userPatch = structuredPatch(
fileName,
fileName,
aiStr,
userStr,
"Proposed",
"User",
DEFAULT_STRUCTURED_PATCH_OPTS
);
const userStats = getStats(userPatch);
return {
model_added_lines: modelStats.addedLines,
model_removed_lines: modelStats.removedLines,
model_added_chars: modelStats.addedChars,
model_removed_chars: modelStats.removedChars,
user_added_lines: userStats.addedLines,
user_removed_lines: userStats.removedLines,
user_added_chars: userStats.addedChars,
user_removed_chars: userStats.removedChars
};
}
function getDiffStatFromPatch(patch) {
let addedLines = 0;
let removedLines = 0;
let addedChars = 0;
let removedChars = 0;
const lines = patch.split("\n");
for (const line of lines) {
if (line.startsWith("+") && !line.startsWith("+++")) {
addedLines++;
addedChars += line.length - 1;
} else if (line.startsWith("-") && !line.startsWith("---")) {
removedLines++;
removedChars += line.length - 1;
}
}
return {
model_added_lines: addedLines,
model_removed_lines: removedLines,
model_added_chars: addedChars,
model_removed_chars: removedChars,
user_added_lines: 0,
user_removed_lines: 0,
user_added_chars: 0,
user_removed_chars: 0
};
}
// packages/core/src/config/models.ts
var PREVIEW_GEMINI_MODEL = "gemini-3-pro-preview";
var PREVIEW_GEMINI_3_1_MODEL = "gemini-3.1-pro-preview";
var PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL = "gemini-3.1-pro-preview-customtools";
var PREVIEW_GEMINI_FLASH_MODEL = "gemini-3-flash-preview";
var PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL = "gemini-3.1-flash-lite-preview";
var DEFAULT_GEMINI_MODEL = "gemini-2.5-pro";
var DEFAULT_GEMINI_FLASH_MODEL = "gemini-2.5-flash";
var DEFAULT_GEMINI_FLASH_LITE_MODEL = "gemini-2.5-flash-lite";
var GEMMA_4_31B_IT_MODEL = "gemma-4-31b-it";
var GEMMA_4_26B_A4B_IT_MODEL = "gemma-4-26b-a4b-it";
var VALID_GEMINI_MODELS = /* @__PURE__ */ new Set([
PREVIEW_GEMINI_MODEL,
PREVIEW_GEMINI_3_1_MODEL,
PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL,
PREVIEW_GEMINI_FLASH_MODEL,
PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL,
DEFAULT_GEMINI_MODEL,
DEFAULT_GEMINI_FLASH_MODEL,
DEFAULT_GEMINI_FLASH_LITE_MODEL,
GEMMA_4_31B_IT_MODEL,
GEMMA_4_26B_A4B_IT_MODEL
]);
var PREVIEW_GEMINI_MODEL_AUTO = "auto-gemini-3";
var DEFAULT_GEMINI_MODEL_AUTO = "auto-gemini-2.5";
var GEMINI_MODEL_ALIAS_AUTO = "auto";
var GEMINI_MODEL_ALIAS_PRO = "pro";
var GEMINI_MODEL_ALIAS_FLASH = "flash";
var GEMINI_MODEL_ALIAS_FLASH_LITE = "flash-lite";
var DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
var DEFAULT_THINKING_MODE = 8192;
function resolveModel(requestedModel, useGemini3_1 = false, useGemini3_1FlashLite = false, useCustomToolModel = false, hasAccessToPreview = true, config) {
const normalizedModel = Array.isArray(requestedModel) ? String(requestedModel.at(-1) ?? "").trim() || "" : typeof requestedModel !== "string" ? String(requestedModel ?? "").trim() || "" : requestedModel.trim() || "";
if (config?.getExperimentalDynamicModelConfiguration?.() === true) {
const resolved2 = config.modelConfigService.resolveModelId(normalizedModel, {
useGemini3_1,
useGemini3_1FlashLite,
useCustomTools: useCustomToolModel,
hasAccessToPreview
});
if (!hasAccessToPreview && isPreviewModel(resolved2, config)) {
if (resolved2.includes("flash-lite")) {
return DEFAULT_GEMINI_FLASH_LITE_MODEL;
}
if (resolved2.includes("flash")) {
return DEFAULT_GEMINI_FLASH_MODEL;
}
return DEFAULT_GEMINI_MODEL;
}
return resolved2;
}
let resolved;
switch (normalizedModel) {
case PREVIEW_GEMINI_MODEL:
case PREVIEW_GEMINI_MODEL_AUTO:
case GEMINI_MODEL_ALIAS_AUTO:
case GEMINI_MODEL_ALIAS_PRO: {
if (useGemini3_1) {
resolved = useCustomToolModel ? PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL : PREVIEW_GEMINI_3_1_MODEL;
} else {
resolved = PREVIEW_GEMINI_MODEL;
}
break;
}
case DEFAULT_GEMINI_MODEL_AUTO: {
resolved = DEFAULT_GEMINI_MODEL;
break;
}
case GEMINI_MODEL_ALIAS_FLASH: {
resolved = PREVIEW_GEMINI_FLASH_MODEL;
break;
}
case GEMINI_MODEL_ALIAS_FLASH_LITE: {
resolved = useGemini3_1FlashLite ? PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL : DEFAULT_GEMINI_FLASH_LITE_MODEL;
break;
}
default: {
resolved = normalizedModel;
break;
}
}
if (!hasAccessToPreview && isPreviewModel(resolved)) {
switch (resolved) {
case PREVIEW_GEMINI_FLASH_MODEL:
return DEFAULT_GEMINI_FLASH_MODEL;
case PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL:
return DEFAULT_GEMINI_FLASH_LITE_MODEL;
case PREVIEW_GEMINI_MODEL:
case PREVIEW_GEMINI_3_1_MODEL:
case PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL:
return DEFAULT_GEMINI_MODEL;
default:
if (resolved.includes("flash-lite")) {
return DEFAULT_GEMINI_FLASH_LITE_MODEL;
}
if (resolved.includes("flash")) {
return DEFAULT_GEMINI_FLASH_MODEL;
}
return DEFAULT_GEMINI_MODEL;
}
}
return resolved;
}
function resolveClassifierModel(requestedModel, modelAlias, useGemini3_1 = false, useGemini3_1FlashLite = false, useCustomToolModel = false, hasAccessToPreview = true, config) {
if (config?.getExperimentalDynamicModelConfiguration?.() === true) {
return config.modelConfigService.resolveClassifierModelId(
modelAlias,
requestedModel,
{
useGemini3_1,
useGemini3_1FlashLite,
useCustomTools: useCustomToolModel,
hasAccessToPreview
}
);
}
if (modelAlias === GEMINI_MODEL_ALIAS_FLASH) {
if (requestedModel === DEFAULT_GEMINI_MODEL_AUTO || requestedModel === DEFAULT_GEMINI_MODEL) {
return DEFAULT_GEMINI_FLASH_MODEL;
}
if (requestedModel === PREVIEW_GEMINI_MODEL_AUTO || requestedModel === PREVIEW_GEMINI_MODEL) {
return PREVIEW_GEMINI_FLASH_MODEL;
}
return resolveModel(GEMINI_MODEL_ALIAS_FLASH);
}
return resolveModel(
requestedModel,
useGemini3_1,
useGemini3_1FlashLite,
useCustomToolModel
);
}
function getDisplayString(model, config) {
if (config?.getExperimentalDynamicModelConfiguration?.() === true) {
const definition = config.modelConfigService.getModelDefinition(model);
if (definition?.displayName) {
return definition.displayName;
}
}
switch (model) {
case PREVIEW_GEMINI_MODEL_AUTO:
return "Auto (Gemini 3)";
case DEFAULT_GEMINI_MODEL_AUTO:
return "Auto (Gemini 2.5)";
case GEMMA_4_31B_IT_MODEL:
return GEMMA_4_31B_IT_MODEL;
case GEMMA_4_26B_A4B_IT_MODEL:
return GEMMA_4_26B_A4B_IT_MODEL;
case GEMINI_MODEL_ALIAS_PRO:
return PREVIEW_GEMINI_MODEL;
case GEMINI_MODEL_ALIAS_FLASH:
return PREVIEW_GEMINI_FLASH_MODEL;
case PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL:
return PREVIEW_GEMINI_3_1_MODEL;
case PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL:
return PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL;
default:
return model;
}
}
function isPreviewModel(model, config) {
if (config?.getExperimentalDynamicModelConfiguration?.() === true) {
return config.modelConfigService.getModelDefinition(model)?.isPreview === true;
}
return model === PREVIEW_GEMINI_MODEL || model === PREVIEW_GEMINI_3_1_MODEL || model === PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL || model === PREVIEW_GEMINI_FLASH_MODEL || model === PREVIEW_GEMINI_MODEL_AUTO || model === GEMINI_MODEL_ALIAS_AUTO || model === PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL;
}
function isProModel(model, config) {
if (config?.getExperimentalDynamicModelConfiguration?.() === true) {
return config.modelConfigService.getModelDefinition(model)?.tier === "pro";
}
return model.toLowerCase().includes("pro");
}
function isGemini3Model(model, config) {
if (config?.getExperimentalDynamicModelConfiguration?.() === true) {
const resolved2 = resolveModel(model, false, false, false, true, config);
return config.modelConfigService.getModelDefinition(resolved2)?.family === "gemini-3";
}
const resolved = resolveModel(model);
return /^gemini-3(\.|-|$)/.test(resolved);
}
function isGemini2Model(model) {
return /^gemini-2(\.|$)/.test(model);
}
function isCustomModel(model, config) {
if (config?.getExperimentalDynamicModelConfiguration?.() === true) {
const resolved2 = resolveModel(model, false, false, false, true, config);
return config.modelConfigService.getModelDefinition(resolved2)?.tier === "custom" || !resolved2.startsWith("gemini-");
}
const resolved = resolveModel(model);
return !resolved.startsWith("gemini-");
}
function supportsModernFeatures(model) {
if (isGemini3Model(model)) return true;
return isCustomModel(model);
}
function isAutoModel(model, config) {
if (config?.getExperimentalDynamicModelConfiguration?.() === true) {
return config.modelConfigService.getModelDefinition(model)?.tier === "auto";
}
return model === GEMINI_MODEL_ALIAS_AUTO || model === PREVIEW_GEMINI_MODEL_AUTO || model === DEFAULT_GEMINI_MODEL_AUTO;
}
function supportsMultimodalFunctionResponse(model, config) {
if (config?.getExperimentalDynamicModelConfiguration?.() === true) {
return config.modelConfigService.getModelDefinition(model)?.features?.multimodalToolUse === true;
}
return model.startsWith("gemini-3-");
}
function isActiveModel(model, useGemini3_1 = false, useGemini3_1FlashLite = false, useCustomToolModel = false, experimentalGemma = true) {
if (!VALID_GEMINI_MODELS.has(model)) {
return false;
}
if (model === GEMMA_4_31B_IT_MODEL || model === GEMMA_4_26B_A4B_IT_MODEL) {
return experimentalGemma;
}
if (model === PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL) {
return useGemini3_1FlashLite;
}
if (useGemini3_1) {
if (model === PREVIEW_GEMINI_MODEL) {
return false;
}
if (useCustomToolModel) {
return model !== PREVIEW_GEMINI_3_1_MODEL;
} else {
return model !== PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL;
}
} else {
return model !== PREVIEW_GEMINI_3_1_MODEL && model !== PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL;
}
}
// packages/core/src/tools/definitions/modelFamilyService.ts
function getToolFamily(modelId) {
if (!modelId) {
return "default-legacy";
}
if (isGemini3Model(modelId)) {
return "gemini-3";
}
return "default-legacy";
}
// packages/core/src/tools/definitions/base-declarations.ts
var PARAM_FILE_PATH = "file_path";
var PARAM_DIR_PATH = "dir_path";
var PARAM_PATTERN = "pattern";
var PARAM_CASE_SENSITIVE = "case_sensitive";
var PARAM_RESPECT_GIT_IGNORE = "respect_git_ignore";
var PARAM_RESPECT_GEMINI_IGNORE = "respect_gemini_ignore";
var PARAM_FILE_FILTERING_OPTIONS = "file_filtering_options";
var PARAM_DESCRIPTION = "description";
var GLOB_TOOL_NAME = "glob";
var GREP_TOOL_NAME = "grep_search";
var GREP_PARAM_INCLUDE_PATTERN = "include_pattern";
var GREP_PARAM_EXCLUDE_PATTERN = "exclude_pattern";
var GREP_PARAM_NAMES_ONLY = "names_only";
var GREP_PARAM_MAX_MATCHES_PER_FILE = "max_matches_per_file";
var GREP_PARAM_TOTAL_MAX_MATCHES = "total_max_matches";
var GREP_PARAM_FIXED_STRINGS = "fixed_strings";
var GREP_PARAM_CONTEXT = "context";
var GREP_PARAM_AFTER = "after";
var GREP_PARAM_BEFORE = "before";
var GREP_PARAM_NO_IGNORE = "no_ignore";
var LS_TOOL_NAME = "list_directory";
var LS_PARAM_IGNORE = "ignore";
var READ_FILE_TOOL_NAME = "read_file";
var READ_FILE_PARAM_START_LINE = "start_line";
var READ_FILE_PARAM_END_LINE = "end_line";
var SHELL_TOOL_NAME = "run_shell_command";
var SHELL_PARAM_COMMAND = "command";
var SHELL_PARAM_IS_BACKGROUND = "is_background";
var WRITE_FILE_TOOL_NAME = "write_file";
var WRITE_FILE_PARAM_CONTENT = "content";
var EDIT_TOOL_NAME = "replace";
var EDIT_PARAM_INSTRUCTION = "instruction";
var EDIT_PARAM_OLD_STRING = "old_string";
var EDIT_PARAM_NEW_STRING = "new_string";
var EDIT_PARAM_ALLOW_MULTIPLE = "allow_multiple";
var WEB_SEARCH_TOOL_NAME = "google_web_search";
var WEB_SEARCH_PARAM_QUERY = "query";
var WRITE_TODOS_TOOL_NAME = "write_todos";
var TODOS_PARAM_TODOS = "todos";
var TODOS_ITEM_PARAM_DESCRIPTION = "description";
var TODOS_ITEM_PARAM_STATUS = "status";
var WEB_FETCH_TOOL_NAME = "web_fetch";
var WEB_FETCH_PARAM_PROMPT = "prompt";
var READ_MANY_FILES_TOOL_NAME = "read_many_files";
var READ_MANY_PARAM_INCLUDE = "include";
var READ_MANY_PARAM_EXCLUDE = "exclude";
var READ_MANY_PARAM_RECURSIVE = "recursive";
var READ_MANY_PARAM_USE_DEFAULT_EXCLUDES = "useDefaultExcludes";
var MEMORY_TOOL_NAME = "save_memory";
var MEMORY_PARAM_FACT = "fact";
var MEMORY_PARAM_SCOPE = "scope";
var GET_INTERNAL_DOCS_TOOL_NAME = "get_internal_docs";
var DOCS_PARAM_PATH = "path";
var ACTIVATE_SKILL_TOOL_NAME = "activate_skill";
var SKILL_PARAM_NAME = "name";
var ASK_USER_TOOL_NAME = "ask_user";
var ASK_USER_PARAM_QUESTIONS = "questions";
var ASK_USER_QUESTION_PARAM_QUESTION = "question";
var ASK_USER_QUESTION_PARAM_HEADER = "header";
var ASK_USER_QUESTION_PARAM_TYPE = "type";
var ASK_USER_QUESTION_PARAM_OPTIONS = "options";
var ASK_USER_QUESTION_PARAM_MULTI_SELECT = "multiSelect";
var ASK_USER_QUESTION_PARAM_PLACEHOLDER = "placeholder";
var ASK_USER_OPTION_PARAM_LABEL = "label";
var ASK_USER_OPTION_PARAM_DESCRIPTION = "description";
var EXIT_PLAN_MODE_TOOL_NAME = "exit_plan_mode";
var EXIT_PLAN_PARAM_PLAN_FILENAME = "plan_filename";
var ENTER_PLAN_MODE_TOOL_NAME = "enter_plan_mode";
var PLAN_MODE_PARAM_REASON = "reason";
var PARAM_ADDITIONAL_PERMISSIONS = "additional_permissions";
var UPDATE_TOPIC_TOOL_NAME = "update_topic";
var UPDATE_TOPIC_DISPLAY_NAME = "Update Topic Context";
var TOPIC_PARAM_TITLE = "title";
var TOPIC_PARAM_SUMMARY = "summary";
var TOPIC_PARAM_STRATEGIC_INTENT = "strategic_intent";
var COMPLETE_TASK_TOOL_NAME = "complete_task";
var COMPLETE_TASK_DISPLAY_NAME = "Complete Task";
var READ_MCP_RESOURCE_TOOL_NAME = "read_mcp_resource";
var LIST_MCP_RESOURCES_TOOL_NAME = "list_mcp_resources";
// packages/core/src/tools/definitions/dynamic-declaration-helpers.ts
import * as os4 from "node:os";
// node_modules/zod-to-json-schema/dist/esm/Options.js
var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
var defaultOptions = {
name: void 0,
$refStrategy: "root",
basePath: ["#"],
effectStrategy: "input",
pipeStrategy: "all",
dateStrategy: "format:date-time",
mapStrategy: "entries",
removeAdditionalStrategy: "passthrough",
allowedAdditionalProperties: true,
rejectedAdditionalProperties: false,
definitionPath: "definitions",
target: "jsonSchema7",
strictUnions: false,
definitions: {},
errorMessages: false,
markdownDescription: false,
patternStrategy: "escape",
applyRegexFlags: false,
emailStrategy: "format:email",
base64Strategy: "contentEncoding:base64",
nameStrategy: "ref",
openAiAnyTypeName: "OpenAiAnyType"
};
var getDefaultOptions = (options) => typeof options === "string" ? {
...defaultOptions,
name: options
} : {
...defaultOptions,
...options
};
// node_modules/zod-to-json-schema/dist/esm/Refs.js
var getRefs = (options) => {
const _options = getDefaultOptions(options);
const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
return {
..._options,
flags: { hasReferencedOpenAiAnyType: false },
currentPath,
propertyPath: void 0,
seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
def._def,
{
def: def._def,
path: [..._options.basePath, _options.definitionPath, name],
// Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
jsonSchema: void 0
}
]))
};
};
// node_modules/zod-to-json-schema/dist/esm/errorMessages.js
function addErrorMessage(res, key, errorMessage, refs) {
if (!refs?.errorMessages)
return;
if (errorMessage) {
res.errorMessage = {
...res.errorMessage,
[key]: errorMessage
};
}
}
function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
res[key] = value;
addErrorMessage(res, key, errorMessage, refs);
}
// node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
var getRelativePath = (pathA, pathB) => {
let i = 0;
for (; i < pathA.length && i < pathB.length; i++) {
if (pathA[i] !== pathB[i])
break;
}
return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
};
// node_modules/zod-to-json-schema/dist/esm/parsers/any.js
function parseAnyDef(refs) {
if (refs.target !== "openAi") {
return {};
}
const anyDefinitionPath = [
...refs.basePath,
refs.definitionPath,
refs.openAiAnyTypeName
];
refs.flags.hasReferencedOpenAiAnyType = true;
return {
$ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/array.js
function parseArrayDef(def, refs) {
const res = {
type: "array"
};
if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
res.items = parseDef(def.type._def, {
...refs,
currentPath: [...refs.currentPath, "items"]
});
}
if (def.minLength) {
setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
}
if (def.maxLength) {
setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
}
if (def.exactLength) {
setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
}
return res;
}
// node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
function parseBigintDef(def, refs) {
const res = {
type: "integer",
format: "int64"
};
if (!def.checks)
return res;
for (const check of def.checks) {
switch (check.kind) {
case "min":
if (refs.target === "jsonSchema7") {
if (check.inclusive) {
setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
} else {
setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
}
} else {
if (!check.inclusive) {
res.exclusiveMinimum = true;
}
setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
}
break;
case "max":
if (refs.target === "jsonSchema7") {
if (check.inclusive) {
setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
} else {
setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
}
} else {
if (!check.inclusive) {
res.exclusiveMaximum = true;
}
setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
}
break;
case "multipleOf":
setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
break;
}
}
return res;
}
// node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
function parseBooleanDef() {
return {
type: "boolean"
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
function parseBrandedDef(_def, refs) {
return parseDef(_def.type._def, refs);
}
// node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
var parseCatchDef = (def, refs) => {
return parseDef(def.innerType._def, refs);
};
// node_modules/zod-to-json-schema/dist/esm/parsers/date.js
function parseDateDef(def, refs, overrideDateStrategy) {
const strategy = overrideDateStrategy ?? refs.dateStrategy;
if (Array.isArray(strategy)) {
return {
anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
};
}
switch (strategy) {
case "string":
case "format:date-time":
return {
type: "string",
format: "date-time"
};
case "format:date":
return {
type: "string",
format: "date"
};
case "integer":
return integerDateParser(def, refs);
}
}
var integerDateParser = (def, refs) => {
const res = {
type: "integer",
format: "unix-time"
};
if (refs.target === "openApi3") {
return res;
}
for (const check of def.checks) {
switch (check.kind) {
case "min":
setResponseValueAndErrors(
res,
"minimum",
check.value,
// This is in milliseconds
check.message,
refs
);
break;
case "max":
setResponseValueAndErrors(
res,
"maximum",
check.value,
// This is in milliseconds
check.message,
refs
);
break;
}
}
return res;
};
// node_modules/zod-to-json-schema/dist/esm/parsers/default.js
function parseDefaultDef(_def, refs) {
return {
...parseDef(_def.innerType._def, refs),
default: _def.defaultValue()
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
function parseEffectsDef(_def, refs) {
return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
}
// node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
function parseEnumDef(def) {
return {
type: "string",
enum: Array.from(def.values)
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
var isJsonSchema7AllOfType = (type) => {
if ("type" in type && type.type === "string")
return false;
return "allOf" in type;
};
function parseIntersectionDef(def, refs) {
const allOf = [
parseDef(def.left._def, {
...refs,
currentPath: [...refs.currentPath, "allOf", "0"]
}),
parseDef(def.right._def, {
...refs,
currentPath: [...refs.currentPath, "allOf", "1"]
})
].filter((x) => !!x);
let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
const mergedAllOf = [];
allOf.forEach((schema) => {
if (isJsonSchema7AllOfType(schema)) {
mergedAllOf.push(...schema.allOf);
if (schema.unevaluatedProperties === void 0) {
unevaluatedProperties = void 0;
}
} else {
let nestedSchema = schema;
if ("additionalProperties" in schema && schema.additionalProperties === false) {
const { additionalProperties, ...rest } = schema;
nestedSchema = rest;
} else {
unevaluatedProperties = void 0;
}
mergedAllOf.push(nestedSchema);
}
});
return mergedAllOf.length ? {
allOf: mergedAllOf,
...unevaluatedProperties
} : void 0;
}
// node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
function parseLiteralDef(def, refs) {
const parsedType = typeof def.value;
if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
return {
type: Array.isArray(def.value) ? "array" : "object"
};
}
if (refs.target === "openApi3") {
return {
type: parsedType === "bigint" ? "integer" : parsedType,
enum: [def.value]
};
}
return {
type: parsedType === "bigint" ? "integer" : parsedType,
const: def.value
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/string.js
var emojiRegex2 = void 0;
var zodPatterns = {
/**
* `c` was changed to `[cC]` to replicate /i flag
*/
cuid: /^[cC][^\s-]{8,}$/,
cuid2: /^[0-9a-z]+$/,
ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
/**
* `a-z` was added to replicate /i flag
*/
email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
/**
* Constructed a valid Unicode RegExp
*
* Lazily instantiate since this type of regex isn't supported
* in all envs (e.g. React Native).
*
* See:
* https://github.com/colinhacks/zod/issues/2433
* Fix in Zod:
* https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
*/
emoji: () => {
if (emojiRegex2 === void 0) {
emojiRegex2 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
}
return emojiRegex2;
},
/**
* Unused
*/
uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
/**
* Unused
*/
ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
/**
* Unused
*/
ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
nanoid: /^[a-zA-Z0-9_-]{21}$/,
jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
};
function parseStringDef(def, refs) {
const res = {
type: "string"
};
if (def.checks) {
for (const check of def.checks) {
switch (check.kind) {
case "min":
setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
break;
case "max":
setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
break;
case "email":
switch (refs.emailStrategy) {
case "format:email":
addFormat(res, "email", check.message, refs);
break;
case "format:idn-email":
addFormat(res, "idn-email", check.message, refs);
break;
case "pattern:zod":
addPattern(res, zodPatterns.email, check.message, refs);
break;
}
break;
case "url":
addFormat(res, "uri", check.message, refs);
break;
case "uuid":
addFormat(res, "uuid", check.message, refs);
break;
case "regex":
addPattern(res, check.regex, check.message, refs);
break;
case "cuid":
addPattern(res, zodPatterns.cuid, check.message, refs);
break;
case "cuid2":
addPattern(res, zodPatterns.cuid2, check.message, refs);
break;
case "startsWith":
addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
break;
case "endsWith":
addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
break;
case "datetime":
addFormat(res, "date-time", check.message, refs);
break;
case "date":
addFormat(res, "date", check.message, refs);
break;
case "time":
addFormat(res, "time", check.message, refs);
break;
case "duration":
addFormat(res, "duration", check.message, refs);
break;
case "length":
setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
break;
case "includes": {
addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
break;
}
case "ip": {
if (check.version !== "v6") {
addFormat(res, "ipv4", check.message, refs);
}
if (check.version !== "v4") {
addFormat(res, "ipv6", check.message, refs);
}
break;
}
case "base64url":
addPattern(res, zodPatterns.base64url, check.message, refs);
break;
case "jwt":
addPattern(res, zodPatterns.jwt, check.message, refs);
break;
case "cidr": {
if (check.version !== "v6") {
addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
}
if (check.version !== "v4") {
addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
}
break;
}
case "emoji":
addPattern(res, zodPatterns.emoji(), check.message, refs);
break;
case "ulid": {
addPattern(res, zodPatterns.ulid, check.message, refs);
break;
}
case "base64": {
switch (refs.base64Strategy) {
case "format:binary": {
addFormat(res, "binary", check.message, refs);
break;
}
case "contentEncoding:base64": {
setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
break;
}
case "pattern:zod": {
addPattern(res, zodPatterns.base64, check.message, refs);
break;
}
}
break;
}
case "nanoid": {
addPattern(res, zodPatterns.nanoid, check.message, refs);
}
case "toLowerCase":
case "toUpperCase":
case "trim":
break;
default:
/* @__PURE__ */ ((_) => {
})(check);
}
}
}
return res;
}
function escapeLiteralCheckValue(literal, refs) {
return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
}
var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
function escapeNonAlphaNumeric(source) {
let result = "";
for (let i = 0; i < source.length; i++) {
if (!ALPHA_NUMERIC.has(source[i])) {
result += "\\";
}
result += source[i];
}
return result;
}
function addFormat(schema, value, message, refs) {
if (schema.format || schema.anyOf?.some((x) => x.format)) {
if (!schema.anyOf) {
schema.anyOf = [];
}
if (schema.format) {
schema.anyOf.push({
format: schema.format,
...schema.errorMessage && refs.errorMessages && {
errorMessage: { format: schema.errorMessage.format }
}
});
delete schema.format;
if (schema.errorMessage) {
delete schema.errorMessage.format;
if (Object.keys(schema.errorMessage).length === 0) {
delete schema.errorMessage;
}
}
}
schema.anyOf.push({
format: value,
...message && refs.errorMessages && { errorMessage: { format: message } }
});
} else {
setResponseValueAndErrors(schema, "format", value, message, refs);
}
}
function addPattern(schema, regex, message, refs) {
if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
if (!schema.allOf) {
schema.allOf = [];
}
if (schema.pattern) {
schema.allOf.push({
pattern: schema.pattern,
...schema.errorMessage && refs.errorMessages && {
errorMessage: { pattern: schema.errorMessage.pattern }
}
});
delete schema.pattern;
if (schema.errorMessage) {
delete schema.errorMessage.pattern;
if (Object.keys(schema.errorMessage).length === 0) {
delete schema.errorMessage;
}
}
}
schema.allOf.push({
pattern: stringifyRegExpWithFlags(regex, refs),
...message && refs.errorMessages && { errorMessage: { pattern: message } }
});
} else {
setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
}
}
function stringifyRegExpWithFlags(regex, refs) {
if (!refs.applyRegexFlags || !regex.flags) {
return regex.source;
}
const flags = {
i: regex.flags.includes("i"),
m: regex.flags.includes("m"),
s: regex.flags.includes("s")
// `.` matches newlines
};
const source = flags.i ? regex.source.toLowerCase() : regex.source;
let pattern = "";
let isEscaped = false;
let inCharGroup = false;
let inCharRange = false;
for (let i = 0; i < source.length; i++) {
if (isEscaped) {
pattern += source[i];
isEscaped = false;
continue;
}
if (flags.i) {
if (inCharGroup) {
if (source[i].match(/[a-z]/)) {
if (inCharRange) {
pattern += source[i];
pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
inCharRange = false;
} else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
pattern += source[i];
inCharRange = true;
} else {
pattern += `${source[i]}${source[i].toUpperCase()}`;
}
continue;
}
} else if (source[i].match(/[a-z]/)) {
pattern += `[${source[i]}${source[i].toUpperCase()}]`;
continue;
}
}
if (flags.m) {
if (source[i] === "^") {
pattern += `(^|(?<=[\r
]))`;
continue;
} else if (source[i] === "$") {
pattern += `($|(?=[\r
]))`;
continue;
}
}
if (flags.s && source[i] === ".") {
pattern += inCharGroup ? `${source[i]}\r
` : `[${source[i]}\r
]`;
continue;
}
pattern += source[i];
if (source[i] === "\\") {
isEscaped = true;
} else if (inCharGroup && source[i] === "]") {
inCharGroup = false;
} else if (!inCharGroup && source[i] === "[") {
inCharGroup = true;
}
}
try {
new RegExp(pattern);
} catch {
console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
return regex.source;
}
return pattern;
}
// node_modules/zod-to-json-schema/dist/esm/parsers/record.js
function parseRecordDef(def, refs) {
if (refs.target === "openAi") {
console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
}
if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
return {
type: "object",
required: def.keyType._def.values,
properties: def.keyType._def.values.reduce((acc, key) => ({
...acc,
[key]: parseDef(def.valueType._def, {
...refs,
currentPath: [...refs.currentPath, "properties", key]
}) ?? parseAnyDef(refs)
}), {}),
additionalProperties: refs.rejectedAdditionalProperties
};
}
const schema = {
type: "object",
additionalProperties: parseDef(def.valueType._def, {
...refs,
currentPath: [...refs.currentPath, "additionalProperties"]
}) ?? refs.allowedAdditionalProperties
};
if (refs.target === "openApi3") {
return schema;
}
if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
return {
...schema,
propertyNames: keyType
};
} else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
return {
...schema,
propertyNames: {
enum: def.keyType._def.values
}
};
} else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
return {
...schema,
propertyNames: keyType
};
}
return schema;
}
// node_modules/zod-to-json-schema/dist/esm/parsers/map.js
function parseMapDef(def, refs) {
if (refs.mapStrategy === "record") {
return parseRecordDef(def, refs);
}
const keys = parseDef(def.keyType._def, {
...refs,
currentPath: [...refs.currentPath, "items", "items", "0"]
}) || parseAnyDef(refs);
const values = parseDef(def.valueType._def, {
...refs,
currentPath: [...refs.currentPath, "items", "items", "1"]
}) || parseAnyDef(refs);
return {
type: "array",
maxItems: 125,
items: {
type: "array",
items: [keys, values],
minItems: 2,
maxItems: 2
}
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
function parseNativeEnumDef(def) {
const object = def.values;
const actualKeys = Object.keys(def.values).filter((key) => {
return typeof object[object[key]] !== "number";
});
const actualValues = actualKeys.map((key) => object[key]);
const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
return {
type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
enum: actualValues
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/never.js
function parseNeverDef(refs) {
return refs.target === "openAi" ? void 0 : {
not: parseAnyDef({
...refs,
currentPath: [...refs.currentPath, "not"]
})
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/null.js
function parseNullDef(refs) {
return refs.target === "openApi3" ? {
enum: ["null"],
nullable: true
} : {
type: "null"
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/union.js
var primitiveMappings = {
ZodString: "string",
ZodNumber: "number",
ZodBigInt: "integer",
ZodBoolean: "boolean",
ZodNull: "null"
};
function parseUnionDef(def, refs) {
if (refs.target === "openApi3")
return asAnyOf(def, refs);
const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
const types = options.reduce((types2, x) => {
const type = primitiveMappings[x._def.typeName];
return type && !types2.includes(type) ? [...types2, type] : types2;
}, []);
return {
type: types.length > 1 ? types : types[0]
};
} else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
const types = options.reduce((acc, x) => {
const type = typeof x._def.value;
switch (type) {
case "string":
case "number":
case "boolean":
return [...acc, type];
case "bigint":
return [...acc, "integer"];
case "object":
if (x._def.value === null)
return [...acc, "null"];
case "symbol":
case "undefined":
case "function":
default:
return acc;
}
}, []);
if (types.length === options.length) {
const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
return {
type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
enum: options.reduce((acc, x) => {
return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
}, [])
};
}
} else if (options.every((x) => x._def.typeName === "ZodEnum")) {
return {
type: "string",
enum: options.reduce((acc, x) => [
...acc,
...x._def.values.filter((x2) => !acc.includes(x2))
], [])
};
}
return asAnyOf(def, refs);
}
var asAnyOf = (def, refs) => {
const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
...refs,
currentPath: [...refs.currentPath, "anyOf", `${i}`]
})).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
return anyOf.length ? { anyOf } : void 0;
};
// node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
function parseNullableDef(def, refs) {
if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
if (refs.target === "openApi3") {
return {
type: primitiveMappings[def.innerType._def.typeName],
nullable: true
};
}
return {
type: [
primitiveMappings[def.innerType._def.typeName],
"null"
]
};
}
if (refs.target === "openApi3") {
const base2 = parseDef(def.innerType._def, {
...refs,
currentPath: [...refs.currentPath]
});
if (base2 && "$ref" in base2)
return { allOf: [base2], nullable: true };
return base2 && { ...base2, nullable: true };
}
const base = parseDef(def.innerType._def, {
...refs,
currentPath: [...refs.currentPath, "anyOf", "0"]
});
return base && { anyOf: [base, { type: "null" }] };
}
// node_modules/zod-to-json-schema/dist/esm/parsers/number.js
function parseNumberDef(def, refs) {
const res = {
type: "number"
};
if (!def.checks)
return res;
for (const check of def.checks) {
switch (check.kind) {
case "int":
res.type = "integer";
addErrorMessage(res, "type", check.message, refs);
break;
case "min":
if (refs.target === "jsonSchema7") {
if (check.inclusive) {
setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
} else {
setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
}
} else {
if (!check.inclusive) {
res.exclusiveMinimum = true;
}
setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
}
break;
case "max":
if (refs.target === "jsonSchema7") {
if (check.inclusive) {
setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
} else {
setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
}
} else {
if (!check.inclusive) {
res.exclusiveMaximum = true;
}
setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
}
break;
case "multipleOf":
setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
break;
}
}
return res;
}
// node_modules/zod-to-json-schema/dist/esm/parsers/object.js
function parseObjectDef(def, refs) {
const forceOptionalIntoNullable = refs.target === "openAi";
const result = {
type: "object",
properties: {}
};
const required = [];
const shape = def.shape();
for (const propName in shape) {
let propDef = shape[propName];
if (propDef === void 0 || propDef._def === void 0) {
continue;
}
let propOptional = safeIsOptional(propDef);
if (propOptional && forceOptionalIntoNullable) {
if (propDef._def.typeName === "ZodOptional") {
propDef = propDef._def.innerType;
}
if (!propDef.isNullable()) {
propDef = propDef.nullable();
}
propOptional = false;
}
const parsedDef = parseDef(propDef._def, {
...refs,
currentPath: [...refs.currentPath, "properties", propName],
propertyPath: [...refs.currentPath, "properties", propName]
});
if (parsedDef === void 0) {
continue;
}
result.properties[propName] = parsedDef;
if (!propOptional) {
required.push(propName);
}
}
if (required.length) {
result.required = required;
}
const additionalProperties = decideAdditionalProperties(def, refs);
if (additionalProperties !== void 0) {
result.additionalProperties = additionalProperties;
}
return result;
}
function decideAdditionalProperties(def, refs) {
if (def.catchall._def.typeName !== "ZodNever") {
return parseDef(def.catchall._def, {
...refs,
currentPath: [...refs.currentPath, "additionalProperties"]
});
}
switch (def.unknownKeys) {
case "passthrough":
return refs.allowedAdditionalProperties;
case "strict":
return refs.rejectedAdditionalProperties;
case "strip":
return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
}
}
function safeIsOptional(schema) {
try {
return schema.isOptional();
} catch {
return true;
}
}
// node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
var parseOptionalDef = (def, refs) => {
if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
return parseDef(def.innerType._def, refs);
}
const innerSchema = parseDef(def.innerType._def, {
...refs,
currentPath: [...refs.currentPath, "anyOf", "1"]
});
return innerSchema ? {
anyOf: [
{
not: parseAnyDef(refs)
},
innerSchema
]
} : parseAnyDef(refs);
};
// node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
var parsePipelineDef = (def, refs) => {
if (refs.pipeStrategy === "input") {
return parseDef(def.in._def, refs);
} else if (refs.pipeStrategy === "output") {
return parseDef(def.out._def, refs);
}
const a = parseDef(def.in._def, {
...refs,
currentPath: [...refs.currentPath, "allOf", "0"]
});
const b = parseDef(def.out._def, {
...refs,
currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
});
return {
allOf: [a, b].filter((x) => x !== void 0)
};
};
// node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
function parsePromiseDef(def, refs) {
return parseDef(def.type._def, refs);
}
// node_modules/zod-to-json-schema/dist/esm/parsers/set.js
function parseSetDef(def, refs) {
const items = parseDef(def.valueType._def, {
...refs,
currentPath: [...refs.currentPath, "items"]
});
const schema = {
type: "array",
uniqueItems: true,
items
};
if (def.minSize) {
setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
}
if (def.maxSize) {
setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
}
return schema;
}
// node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
function parseTupleDef(def, refs) {
if (def.rest) {
return {
type: "array",
minItems: def.items.length,
items: def.items.map((x, i) => parseDef(x._def, {
...refs,
currentPath: [...refs.currentPath, "items", `${i}`]
})).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
additionalItems: parseDef(def.rest._def, {
...refs,
currentPath: [...refs.currentPath, "additionalItems"]
})
};
} else {
return {
type: "array",
minItems: def.items.length,
maxItems: def.items.length,
items: def.items.map((x, i) => parseDef(x._def, {
...refs,
currentPath: [...refs.currentPath, "items", `${i}`]
})).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
};
}
}
// node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
function parseUndefinedDef(refs) {
return {
not: parseAnyDef(refs)
};
}
// node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
function parseUnknownDef(refs) {
return parseAnyDef(refs);
}
// node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
var parseReadonlyDef = (def, refs) => {
return parseDef(def.innerType._def, refs);
};
// node_modules/zod-to-json-schema/dist/esm/selectParser.js
var selectParser = (def, typeName, refs) => {
switch (typeName) {
case ZodFirstPartyTypeKind.ZodString:
return parseStringDef(def, refs);
case ZodFirstPartyTypeKind.ZodNumber:
return parseNumberDef(def, refs);
case ZodFirstPartyTypeKind.ZodObject:
return parseObjectDef(def, refs);
case ZodFirstPartyTypeKind.ZodBigInt:
return parseBigintDef(def, refs);
case ZodFirstPartyTypeKind.ZodBoolean:
return parseBooleanDef();
case ZodFirstPartyTypeKind.ZodDate:
return parseDateDef(def, refs);
case ZodFirstPartyTypeKind.ZodUndefined:
return parseUndefinedDef(refs);
case ZodFirstPartyTypeKind.ZodNull:
return parseNullDef(refs);
case ZodFirstPartyTypeKind.ZodArray:
return parseArrayDef(def, refs);
case ZodFirstPartyTypeKind.ZodUnion:
case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
return parseUnionDef(def, refs);
case ZodFirstPartyTypeKind.ZodIntersection:
return parseIntersectionDef(def, refs);
case ZodFirstPartyTypeKind.ZodTuple:
return parseTupleDef(def, refs);
case ZodFirstPartyTypeKind.ZodRecord:
return parseRecordDef(def, refs);
case ZodFirstPartyTypeKind.ZodLiteral:
return parseLiteralDef(def, refs);
case ZodFirstPartyTypeKind.ZodEnum:
return parseEnumDef(def);
case ZodFirstPartyTypeKind.ZodNativeEnum:
return parseNativeEnumDef(def);
case ZodFirstPartyTypeKind.ZodNullable:
return parseNullableDef(def, refs);
case ZodFirstPartyTypeKind.ZodOptional:
return parseOptionalDef(def, refs);
case ZodFirstPartyTypeKind.ZodMap:
return parseMapDef(def, refs);
case ZodFirstPartyTypeKind.ZodSet:
return parseSetDef(def, refs);
case ZodFirstPartyTypeKind.ZodLazy:
return () => def.getter()._def;
case ZodFirstPartyTypeKind.ZodPromise:
return parsePromiseDef(def, refs);
case ZodFirstPartyTypeKind.ZodNaN:
case ZodFirstPartyTypeKind.ZodNever:
return parseNeverDef(refs);
case ZodFirstPartyTypeKind.ZodEffects:
return parseEffectsDef(def, refs);
case ZodFirstPartyTypeKind.ZodAny:
return parseAnyDef(refs);
case ZodFirstPartyTypeKind.ZodUnknown:
return parseUnknownDef(refs);
case ZodFirstPartyTypeKind.ZodDefault:
return parseDefaultDef(def, refs);
case ZodFirstPartyTypeKind.ZodBranded:
return parseBrandedDef(def, refs);
case ZodFirstPartyTypeKind.ZodReadonly:
return parseReadonlyDef(def, refs);
case ZodFirstPartyTypeKind.ZodCatch:
return parseCatchDef(def, refs);
case ZodFirstPartyTypeKind.ZodPipeline:
return parsePipelineDef(def, refs);
case ZodFirstPartyTypeKind.ZodFunction:
case ZodFirstPartyTypeKind.ZodVoid:
case ZodFirstPartyTypeKind.ZodSymbol:
return void 0;
default:
return /* @__PURE__ */ ((_) => void 0)(typeName);
}
};
// node_modules/zod-to-json-schema/dist/esm/parseDef.js
function parseDef(def, refs, forceResolution = false) {
const seenItem = refs.seen.get(def);
if (refs.override) {
const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
if (overrideResult !== ignoreOverride) {
return overrideResult;
}
}
if (seenItem && !forceResolution) {
const seenSchema = get$ref(seenItem, refs);
if (seenSchema !== void 0) {
return seenSchema;
}
}
const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
refs.seen.set(def, newItem);
const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
if (jsonSchema) {
addMeta(def, refs, jsonSchema);
}
if (refs.postProcess) {
const postProcessResult = refs.postProcess(jsonSchema, def, refs);
newItem.jsonSchema = jsonSchema;
return postProcessResult;
}
newItem.jsonSchema = jsonSchema;
return jsonSchema;
}
var get$ref = (item, refs) => {
switch (refs.$refStrategy) {
case "root":
return { $ref: item.path.join("/") };
case "relative":
return { $ref: getRelativePath(refs.currentPath, item.path) };
case "none":
case "seen": {
if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
return parseAnyDef(refs);
}
return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
}
}
};
var addMeta = (def, refs, jsonSchema) => {
if (def.description) {
jsonSchema.description = def.description;
if (refs.markdownDescription) {
jsonSchema.markdownDescription = def.description;
}
}
return jsonSchema;
};
// node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
var zodToJsonSchema = (schema, options) => {
const refs = getRefs(options);
let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
...acc,
[name2]: parseDef(schema2._def, {
...refs,
currentPath: [...refs.basePath, refs.definitionPath, name2]
}, true) ?? parseAnyDef(refs)
}), {}) : void 0;
const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
const main = parseDef(schema._def, name === void 0 ? refs : {
...refs,
currentPath: [...refs.basePath, refs.definitionPath, name]
}, false) ?? parseAnyDef(refs);
const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
if (title !== void 0) {
main.title = title;
}
if (refs.flags.hasReferencedOpenAiAnyType) {
if (!definitions) {
definitions = {};
}
if (!definitions[refs.openAiAnyTypeName]) {
definitions[refs.openAiAnyTypeName] = {
// Skipping "object" as no properties can be defined and additionalProperties must be "false"
type: ["string", "number", "integer", "boolean", "array", "null"],
items: {
$ref: refs.$refStrategy === "relative" ? "1" : [
...refs.basePath,
refs.definitionPath,
refs.openAiAnyTypeName
].join("/")
}
};
}
}
const combined = name === void 0 ? definitions ? {
...main,
[refs.definitionPath]: definitions
} : main : {
$ref: [
...refs.$refStrategy === "relative" ? [] : refs.basePath,
refs.definitionPath,
name
].join("/"),
[refs.definitionPath]: {
...definitions,
[name]: main
}
};
if (refs.target === "jsonSchema7") {
combined.$schema = "http://json-schema.org/draft-07/schema#";
} else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
}
if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
}
return combined;
};
// packages/core/src/tools/definitions/dynamic-declaration-helpers.ts
function getShellToolDescription(enableInteractiveShell, enableEfficiency) {
const efficiencyGuidelines = enableEfficiency ? `
Efficiency Guidelines:
- Quiet Flags: Always prefer silent or quiet flags (e.g., \`npm install --silent\`, \`git --no-pager\`) to reduce output volume while still capturing necessary information.
- Pagination: Always disable terminal pagination to ensure commands terminate (e.g., use \`git --no-pager\`, \`systemctl --no-pager\`, or set \`PAGER=cat\`).` : "";
const returnedInfo = `
The following information is returned:
Output: Combined stdout/stderr. Can be \`(empty)\` or partial on error and for any unwaited background processes.
Exit Code: Only included if non-zero (command failed).
Error: Only included if a process-level error occurred (e.g., spawn failure).
Signal: Only included if process was terminated by a signal.
Background PIDs: Only included if background processes were started.
Process Group PGID: Only included if available.`;
if (os4.platform() === "win32") {
const backgroundInstructions = enableInteractiveShell ? `To run a command in the background, set the \`${SHELL_PARAM_IS_BACKGROUND}\` parameter to true. Do NOT use PowerShell background constructs.` : "Command can start background processes using PowerShell constructs such as `Start-Process -NoNewWindow` or `Start-Job`.";
return `This tool executes a given shell command as \`powershell.exe -NoProfile -Command <command>\`. ${backgroundInstructions}${efficiencyGuidelines}${returnedInfo}`;
} else {
const backgroundInstructions = enableInteractiveShell ? `To run a command in the background, set the \`${SHELL_PARAM_IS_BACKGROUND}\` parameter to true. Do NOT use \`&\` to background commands.` : "Command can start background processes using `&`.";
return `This tool executes a given shell command as \`bash -c <command>\`. ${backgroundInstructions} Command is executed as a subprocess that leads its own process group. Command process group can be terminated as \`kill -- -PGID\` or signaled as \`kill -s SIGNAL -- -PGID\`.${efficiencyGuidelines}${returnedInfo}`;
}
}
function getCommandDescription() {
if (os4.platform() === "win32") {
return "Exact command to execute as `powershell.exe -NoProfile -Command <command>`";
}
return "Exact bash command to execute as `bash -c <command>`";
}
function getShellDeclaration(enableInteractiveShell, enableEfficiency, enableToolSandboxing = false) {
return {
name: SHELL_TOOL_NAME,
description: getShellToolDescription(
enableInteractiveShell,
enableEfficiency
),
parametersJsonSchema: {
type: "object",
properties: {
[SHELL_PARAM_COMMAND]: {
type: "string",
description: getCommandDescription()
},
[PARAM_DESCRIPTION]: {
type: "string",
description: "Brief description of the command for the user. Be specific and concise. Ideally a single sentence. Can be up to 3 sentences for clarity. No line breaks."
},
[PARAM_DIR_PATH]: {
type: "string",
description: "(OPTIONAL) The path of the directory to run the command in. If not provided, the project root directory is used. Must be a directory within the workspace and must already exist."
},
[SHELL_PARAM_IS_BACKGROUND]: {
type: "boolean",
description: "Set to true if this command should be run in the background (e.g. for long-running servers or watchers). The command will be started, allowed to run for a brief moment to check for immediate errors, and then moved to the background."
},
delay_ms: {
type: "integer",
description: "Optional. Delay in milliseconds to wait after starting the process in the background. Useful to allow the process to start and generate initial output before returning."
},
...enableToolSandboxing ? {
[PARAM_ADDITIONAL_PERMISSIONS]: {
type: "object",
description: 'Sandbox permissions for the command. Use this to request additional sandboxed filesystem or network permissions if a previous command failed with "Operation not permitted".',
properties: {
network: {
type: "boolean",
description: "Set to true to enable network access for this command."
},
fileSystem: {
type: "object",
properties: {
read: {
type: "array",
items: { type: "string" },
description: "List of additional absolute paths to allow reading."
},
write: {
type: "array",
items: { type: "string" },
description: "List of additional absolute paths to allow writing."
}
}
}
}
}
} : {}
},
required: [SHELL_PARAM_COMMAND]
}
};
}
function getExitPlanModeDeclaration() {
return {
name: EXIT_PLAN_MODE_TOOL_NAME,
description: "Finalizes the planning phase and transitions to implementation by presenting the plan for formal user approval. You MUST reach an informal agreement with the user in the chat regarding the proposed strategy BEFORE calling this tool. This tool MUST be used to exit Plan Mode before any source code edits can be performed.",
parametersJsonSchema: {
type: "object",
required: [EXIT_PLAN_PARAM_PLAN_FILENAME],
properties: {
[EXIT_PLAN_PARAM_PLAN_FILENAME]: {
type: "string",
description: `The filename of the finalized plan (e.g., "feature-x.md"). Do not provide an absolute path.`
}
}
}
};
}
function getActivateSkillDeclaration(skillNames) {
const availableSkillsHint = skillNames.length > 0 ? ` (Available: ${skillNames.map((n) => `'${n}'`).join(", ")})` : "";
let schema;
if (skillNames.length === 0) {
schema = external_exports.object({
[SKILL_PARAM_NAME]: external_exports.string().describe("No skills are currently available.")
});
} else {
schema = external_exports.object({
[SKILL_PARAM_NAME]: external_exports.enum(skillNames).describe("The name of the skill to activate.")
});
}
return {
name: ACTIVATE_SKILL_TOOL_NAME,
description: `Activates a specialized agent skill by name${availableSkillsHint}. Returns the skill's instructions wrapped in \`<activated_skill>\` tags. These provide specialized guidance for the current task. Use this when you identify a task that matches a skill's description. ONLY use names exactly as they appear in the \`<available_skills>\` section.`,
parametersJsonSchema: zodToJsonSchema(schema)
};
}
function getUpdateTopicDeclaration() {
return {
name: UPDATE_TOPIC_TOOL_NAME,
description: "Manages your narrative flow. Include `title` and `summary` only when starting a new Chapter (logical phase) or shifting strategic intent.",
parametersJsonSchema: {
type: "object",
properties: {
[TOPIC_PARAM_TITLE]: {
type: "string",
description: "The title of the new topic or chapter."
},
[TOPIC_PARAM_SUMMARY]: {
type: "string",
description: "(OPTIONAL) A detailed summary (5-10 sentences) covering both the work completed in the previous topic and the strategic intent of the new topic. This is required when transitioning between topics to maintain continuity."
},
[TOPIC_PARAM_STRATEGIC_INTENT]: {
type: "string",
description: "A mandatory one-sentence statement of your immediate intent."
}
},
required: [TOPIC_PARAM_STRATEGIC_INTENT]
}
};
}
// packages/core/src/tools/definitions/model-family-sets/default-legacy.ts
var DEFAULT_LEGACY_SET = {
read_file: {
name: READ_FILE_TOOL_NAME,
description: `Reads and returns the content of a specified file. If the file is large, the content will be truncated. The tool's response will clearly indicate if truncation has occurred and will provide details on how to read more of the file using the 'start_line' and 'end_line' parameters. Handles text, images (PNG, JPG, GIF, WEBP, SVG, BMP), audio files (MP3, WAV, AIFF, AAC, OGG, FLAC), and PDF files. For text files, it can read specific line ranges.`,
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_FILE_PATH]: {
description: "The path to the file to read.",
type: "string"
},
[READ_FILE_PARAM_START_LINE]: {
description: "Optional: The 1-based line number to start reading from.",
type: "integer",
minimum: 1
},
[READ_FILE_PARAM_END_LINE]: {
description: "Optional: The 1-based line number to end reading at (inclusive).",
type: "integer",
minimum: 1
}
},
required: [PARAM_FILE_PATH]
}
},
write_file: {
name: WRITE_FILE_TOOL_NAME,
description: `Writes content to a specified file in the local filesystem.
The user has the ability to modify \`content\`. If modified, this will be stated in the response.`,
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_FILE_PATH]: {
description: "The path to the file to write to.",
type: "string"
},
[WRITE_FILE_PARAM_CONTENT]: {
description: "The content to write to the file. Do not use omission placeholders like '(rest of methods ...)', '...', or 'unchanged code'; provide complete literal content.",
type: "string"
}
},
required: [PARAM_FILE_PATH, WRITE_FILE_PARAM_CONTENT]
}
},
grep_search: {
name: GREP_TOOL_NAME,
description: "Searches for a regular expression pattern within file contents. Max 100 matches.",
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_PATTERN]: {
description: `The regular expression (regex) pattern to search for within file contents (e.g., 'function\\s+myFunction', 'import\\s+\\{.*\\}\\s+from\\s+.*').`,
type: "string"
},
[PARAM_DIR_PATH]: {
description: "Optional: The absolute path to the directory to search within. If omitted, searches the current working directory.",
type: "string"
},
[GREP_PARAM_INCLUDE_PATTERN]: {
description: `Optional: A glob pattern to filter which files are searched (e.g., '*.js', '*.{ts,tsx}', 'src/**'). If omitted, searches all files (respecting potential global ignores).`,
type: "string"
},
[GREP_PARAM_EXCLUDE_PATTERN]: {
description: "Optional: A regular expression pattern to exclude from the search results. If a line matches both the pattern and the exclude_pattern, it will be omitted.",
type: "string"
},
[GREP_PARAM_NAMES_ONLY]: {
description: "Optional: If true, only the file paths of the matches will be returned, without the line content or line numbers. This is useful for gathering a list of files.",
type: "boolean"
},
[GREP_PARAM_MAX_MATCHES_PER_FILE]: {
description: "Optional: Maximum number of matches to return per file. Use this to prevent being overwhelmed by repetitive matches in large files.",
type: "integer",
minimum: 1
},
[GREP_PARAM_TOTAL_MAX_MATCHES]: {
description: "Optional: Maximum number of total matches to return. Use this to limit the overall size of the response. Defaults to 100 if omitted.",
type: "integer",
minimum: 1
}
},
required: [PARAM_PATTERN]
}
},
grep_search_ripgrep: {
name: GREP_TOOL_NAME,
description: "Searches for a regular expression pattern within file contents.",
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_PATTERN]: {
description: `The pattern to search for. By default, treated as a Rust-flavored regular expression. Use '\\b' for precise symbol matching (e.g., '\\bMatchMe\\b').`,
type: "string"
},
[PARAM_DIR_PATH]: {
description: "Directory or file to search. Directories are searched recursively. Relative paths are resolved against current working directory. Defaults to current working directory ('.') if omitted.",
type: "string"
},
[GREP_PARAM_INCLUDE_PATTERN]: {
description: "Glob pattern to filter files (e.g., '*.ts', 'src/**'). Recommended for large repositories to reduce noise. Defaults to all files if omitted.",
type: "string"
},
[GREP_PARAM_EXCLUDE_PATTERN]: {
description: "Optional: A regular expression pattern to exclude from the search results. If a line matches both the pattern and the exclude_pattern, it will be omitted.",
type: "string"
},
[GREP_PARAM_NAMES_ONLY]: {
description: "Optional: If true, only the file paths of the matches will be returned, without the line content or line numbers. This is useful for gathering a list of files.",
type: "boolean"
},
[PARAM_CASE_SENSITIVE]: {
description: "If true, search is case-sensitive. Defaults to false (ignore case) if omitted.",
type: "boolean"
},
[GREP_PARAM_FIXED_STRINGS]: {
description: "If true, treats the `pattern` as a literal string instead of a regular expression. Defaults to false (basic regex) if omitted.",
type: "boolean"
},
[GREP_PARAM_CONTEXT]: {
description: "Show this many lines of context around each match (equivalent to grep -C). Defaults to 0 if omitted.",
type: "integer",
minimum: 0
},
[GREP_PARAM_AFTER]: {
description: "Show this many lines after each match (equivalent to grep -A). Defaults to 0 if omitted.",
type: "integer",
minimum: 0
},
[GREP_PARAM_BEFORE]: {
description: "Show this many lines before each match (equivalent to grep -B). Defaults to 0 if omitted.",
type: "integer",
minimum: 0
},
[GREP_PARAM_NO_IGNORE]: {
description: "If true, searches all files including those usually ignored (like in .gitignore, build/, dist/, etc). Defaults to false if omitted.",
type: "boolean"
},
[GREP_PARAM_MAX_MATCHES_PER_FILE]: {
description: "Optional: Maximum number of matches to return per file. Use this to prevent being overwhelmed by repetitive matches in large files.",
type: "integer",
minimum: 1
},
[GREP_PARAM_TOTAL_MAX_MATCHES]: {
description: "Optional: Maximum number of total matches to return. Use this to limit the overall size of the response. Defaults to 100 if omitted.",
type: "integer",
minimum: 1
}
},
required: [PARAM_PATTERN]
}
},
glob: {
name: GLOB_TOOL_NAME,
description: "Efficiently finds files matching specific glob patterns (e.g., `src/**/*.ts`, `**/*.md`), returning absolute paths sorted by modification time (newest first). Ideal for quickly locating files based on their name or path structure, especially in large codebases.",
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_PATTERN]: {
description: "The glob pattern to match against (e.g., '**/*.py', 'docs/*.md').",
type: "string"
},
[PARAM_DIR_PATH]: {
description: "Optional: The absolute path to the directory to search within. If omitted, searches the root directory.",
type: "string"
},
[PARAM_CASE_SENSITIVE]: {
description: "Optional: Whether the search should be case-sensitive. Defaults to false.",
type: "boolean"
},
[PARAM_RESPECT_GIT_IGNORE]: {
description: "Optional: Whether to respect .gitignore patterns when finding files. Only available in git repositories. Defaults to true.",
type: "boolean"
},
[PARAM_RESPECT_GEMINI_IGNORE]: {
description: "Optional: Whether to respect .geminiignore patterns when finding files. Defaults to true.",
type: "boolean"
}
},
required: [PARAM_PATTERN]
}
},
list_directory: {
name: LS_TOOL_NAME,
description: "Lists the names of files and subdirectories directly within a specified directory path. Can optionally ignore entries matching provided glob patterns.",
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_DIR_PATH]: {
description: "The path to the directory to list",
type: "string"
},
[LS_PARAM_IGNORE]: {
description: "List of glob patterns to ignore",
items: {
type: "string"
},
type: "array"
},
[PARAM_FILE_FILTERING_OPTIONS]: {
description: "Optional: Whether to respect ignore patterns from .gitignore or .geminiignore",
type: "object",
properties: {
[PARAM_RESPECT_GIT_IGNORE]: {
description: "Optional: Whether to respect .gitignore patterns when listing files. Only available in git repositories. Defaults to true.",
type: "boolean"
},
[PARAM_RESPECT_GEMINI_IGNORE]: {
description: "Optional: Whether to respect .geminiignore patterns when listing files. Defaults to true.",
type: "boolean"
}
}
}
},
required: [PARAM_DIR_PATH]
}
},
run_shell_command: (enableInteractiveShell, enableEfficiency, enableToolSandboxing) => getShellDeclaration(
enableInteractiveShell,
enableEfficiency,
enableToolSandboxing
),
replace: {
name: EDIT_TOOL_NAME,
description: `Replaces text within a file. By default, the tool expects to find and replace exactly ONE occurrence of \`old_string\`. If you want to replace multiple occurrences of the exact same string, set \`allow_multiple\` to true. This tool requires providing significant context around the change to ensure precise targeting. Always use the ${READ_FILE_TOOL_NAME} tool to examine the file's current content before attempting a text replacement.
The user has the ability to modify the \`new_string\` content. If modified, this will be stated in the response.
Expectation for required parameters:
1. \`old_string\` MUST be the exact literal text to replace (including all whitespace, indentation, newlines, and surrounding code etc.).
2. \`new_string\` MUST be the exact literal text to replace \`old_string\` with (also including all whitespace, indentation, newlines, and surrounding code etc.). Ensure the resulting code is correct and idiomatic and that \`old_string\` and \`new_string\` are different.
3. \`instruction\` is the detailed instruction of what needs to be changed. It is important to Make it specific and detailed so developers or large language models can understand what needs to be changed and perform the changes on their own if necessary.
4. NEVER escape \`old_string\` or \`new_string\`, that would break the exact literal text requirement.
**Important:** If ANY of the above are not satisfied, the tool will fail. CRITICAL for \`old_string\`: Must uniquely identify the instance(s) to change. Include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. If this string matches multiple locations and \`allow_multiple\` is not true, the tool will fail.
5. Prefer to break down complex and long changes into multiple smaller atomic calls to this tool. Always check the content of the file after changes or not finding a string to match.
**Multiple replacements:** Set \`allow_multiple\` to true if you want to replace ALL occurrences that match \`old_string\` exactly.`,
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_FILE_PATH]: {
description: "The path to the file to modify.",
type: "string"
},
[EDIT_PARAM_INSTRUCTION]: {
description: `A clear, semantic instruction for the code change, acting as a high-quality prompt for an expert LLM assistant. It must be self-contained and explain the goal of the change.
A good instruction should concisely answer:
1. WHY is the change needed? (e.g., "To fix a bug where users can be null...")
2. WHERE should the change happen? (e.g., "...in the 'renderUserProfile' function...")
3. WHAT is the high-level change? (e.g., "...add a null check for the 'user' object...")
4. WHAT is the desired outcome? (e.g., "...so that it displays a loading spinner instead of crashing.")
**GOOD Example:** "In the 'calculateTotal' function, correct the sales tax calculation by updating the 'taxRate' constant from 0.05 to 0.075 to reflect the new regional tax laws."
**BAD Examples:**
- "Change the text." (Too vague)
- "Fix the bug." (Doesn't explain the bug or the fix)
- "Replace the line with this new line." (Brittle, just repeats the other parameters)
`,
type: "string"
},
[EDIT_PARAM_OLD_STRING]: {
description: "The exact literal text to replace, preferably unescaped. For single replacements (default), include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. If this string is not the exact literal text (i.e. you escaped it) or does not match exactly, the tool will fail.",
type: "string"
},
[EDIT_PARAM_NEW_STRING]: {
description: "The exact literal text to replace `old_string` with, preferably unescaped. Provide the EXACT text. Ensure the resulting code is correct and idiomatic. Do not use omission placeholders like '(rest of methods ...)', '...', or 'unchanged code'; provide exact literal code.",
type: "string"
},
[EDIT_PARAM_ALLOW_MULTIPLE]: {
type: "boolean",
description: "If true, the tool will replace all occurrences of `old_string`. If false (default), it will only succeed if exactly one occurrence is found."
}
},
required: [
PARAM_FILE_PATH,
EDIT_PARAM_INSTRUCTION,
EDIT_PARAM_OLD_STRING,
EDIT_PARAM_NEW_STRING
]
}
},
google_web_search: {
name: WEB_SEARCH_TOOL_NAME,
description: "Performs a web search using Google Search (via the Gemini API) and returns the results. This tool is useful for finding information on the internet based on a query.",
parametersJsonSchema: {
type: "object",
properties: {
[WEB_SEARCH_PARAM_QUERY]: {
type: "string",
description: "The search query to find information on the web."
}
},
required: [WEB_SEARCH_PARAM_QUERY]
}
},
web_fetch: {
name: WEB_FETCH_TOOL_NAME,
description: "Processes content from URL(s), including local and private network addresses (e.g., localhost), embedded in a prompt. Include up to 20 URLs and instructions (e.g., summarize, extract specific data) directly in the 'prompt' parameter.",
parametersJsonSchema: {
type: "object",
properties: {
[WEB_FETCH_PARAM_PROMPT]: {
description: 'A comprehensive prompt that includes the URL(s) (up to 20) to fetch and specific instructions on how to process their content (e.g., "Summarize https://example.com/article and extract key points from https://another.com/data"). All URLs to be fetched must be valid and complete, starting with "http://" or "https://", and be fully-formed with a valid hostname (e.g., a domain name like "example.com" or an IP address). For example, "https://example.com" is valid, but "example.com" is not.',
type: "string"
}
},
required: [WEB_FETCH_PARAM_PROMPT]
}
},
read_many_files: {
name: READ_MANY_FILES_TOOL_NAME,
description: `Reads content from multiple files specified by glob patterns within a configured target directory. For text files, it concatenates their content into a single string. It is primarily designed for text-based files. However, it can also process image (e.g., .png, .jpg), audio (e.g., .mp3, .wav), and PDF (.pdf) files if their file names or extensions are explicitly included in the 'include' argument. For these explicitly requested non-text files, their data is read and included in a format suitable for model consumption (e.g., base64 encoded).
This tool is useful when you need to understand or analyze a collection of files, such as:
- Getting an overview of a codebase or parts of it (e.g., all TypeScript files in the 'src' directory).
- Finding where specific functionality is implemented if the user asks broad questions about code.
- Reviewing documentation files (e.g., all Markdown files in the 'docs' directory).
- Gathering context from multiple configuration files.
- When the user asks to "read all files in X directory" or "show me the content of all Y files".
Use this tool when the user's query implies needing the content of several files simultaneously for context, analysis, or summarization. For text files, it uses default UTF-8 encoding and a '--- {filePath} ---' separator between file contents. The tool inserts a '--- End of content ---' after the last file. Ensure glob patterns are relative to the target directory. Glob patterns like 'src/**/*.js' are supported. Avoid using for single files if a more specific single-file reading tool is available, unless the user specifically requests to process a list containing just one file via this tool. Other binary files (not explicitly requested as image/audio/PDF) are generally skipped. Default excludes apply to common non-text files (except for explicitly requested images/audio/PDFs) and large dependency directories unless 'useDefaultExcludes' is false.`,
parametersJsonSchema: {
type: "object",
properties: {
[READ_MANY_PARAM_INCLUDE]: {
type: "array",
items: {
type: "string",
minLength: 1
},
minItems: 1,
description: 'An array of glob patterns or paths. Examples: ["src/**/*.ts"], ["README.md", "docs/"]'
},
[READ_MANY_PARAM_EXCLUDE]: {
type: "array",
items: {
type: "string",
minLength: 1
},
description: 'Optional. Glob patterns for files/directories to exclude. Added to default excludes if useDefaultExcludes is true. Example: "**/*.log", "temp/"',
default: []
},
[READ_MANY_PARAM_RECURSIVE]: {
type: "boolean",
description: "Optional. Whether to search recursively (primarily controlled by `**` in glob patterns). Defaults to true.",
default: true
},
[READ_MANY_PARAM_USE_DEFAULT_EXCLUDES]: {
type: "boolean",
description: "Optional. Whether to apply a list of default exclusion patterns (e.g., node_modules, .git, binary files). Defaults to true.",
default: true
},
[PARAM_FILE_FILTERING_OPTIONS]: {
description: "Whether to respect ignore patterns from .gitignore or .geminiignore",
type: "object",
properties: {
[PARAM_RESPECT_GIT_IGNORE]: {
description: "Optional: Whether to respect .gitignore patterns when listing files. Only available in git repositories. Defaults to true.",
type: "boolean"
},
[PARAM_RESPECT_GEMINI_IGNORE]: {
description: "Optional: Whether to respect .geminiignore patterns when listing files. Defaults to true.",
type: "boolean"
}
}
}
},
required: [READ_MANY_PARAM_INCLUDE]
}
},
save_memory: {
name: MEMORY_TOOL_NAME,
description: `
Saves concise user context (preferences, facts) for use across future sessions.
Supports two scopes:
- **global** (default): Cross-project preferences loaded in every workspace. Use for "Remember X" or clear personal facts.
- **project**: Facts specific to the current workspace, private to the user (not committed to the repo). Use for local dev setup notes, project-specific workflows, or personal reminders about this codebase.
Do NOT use for session-specific context or temporary data.`,
parametersJsonSchema: {
type: "object",
properties: {
[MEMORY_PARAM_FACT]: {
type: "string",
description: "The specific fact or piece of information to remember. Should be a clear, self-contained statement."
},
[MEMORY_PARAM_SCOPE]: {
type: "string",
enum: ["global", "project"],
description: "Where to save the memory. 'global' (default) saves to a file loaded in every workspace. 'project' saves to a project-specific file private to the user, not committed to the repo."
}
},
required: [MEMORY_PARAM_FACT],
additionalProperties: false
}
},
write_todos: {
name: WRITE_TODOS_TOOL_NAME,
description: `This tool can help you list out the current subtasks that are required to be completed for a given user request. The list of subtasks helps you keep track of the current task, organize complex queries and help ensure that you don't miss any steps. With this list, the user can also see the current progress you are making in executing a given task.
Depending on the task complexity, you should first divide a given task into subtasks and then use this tool to list out the subtasks that are required to be completed for a given user request.
Each of the subtasks should be clear and distinct.
Use this tool for complex queries that require multiple steps. If you find that the request is actually complex after you have started executing the user task, create a todo list and use it. If execution of the user task requires multiple steps, planning and generally is higher complexity than a simple Q&A, use this tool.
DO NOT use this tool for simple tasks that can be completed in less than 2 steps. If the user query is simple and straightforward, do not use the tool. If you can respond with an answer in a single turn then this tool is not required.
## Task state definitions
- pending: Work has not begun on a given subtask.
- in_progress: Marked just prior to beginning work on a given subtask. You should only have one subtask as in_progress at a time.
- completed: Subtask was successfully completed with no errors or issues. If the subtask required more steps to complete, update the todo list with the subtasks. All steps should be identified as completed only when they are completed.
- cancelled: As you update the todo list, some tasks are not required anymore due to the dynamic nature of the task. In this case, mark the subtasks as cancelled.
- blocked: Subtask is blocked and cannot be completed at this time.
## Methodology for using this tool
1. Use this todo list as soon as you receive a user request based on the complexity of the task.
2. Keep track of every subtask that you update the list with.
3. Mark a subtask as in_progress before you begin working on it. You should only have one subtask as in_progress at a time.
4. Update the subtask list as you proceed in executing the task. The subtask list is not static and should reflect your progress and current plans, which may evolve as you acquire new information.
5. Mark a subtask as completed when you have completed it.
6. Mark a subtask as cancelled if the subtask is no longer needed.
7. You must update the todo list as soon as you start, stop or cancel a subtask. Don't batch or wait to update the todo list.
## Examples of When to Use the Todo List
<example>
User request: Create a website with a React for creating fancy logos using gemini-2.5-flash-image
ToDo list created by the agent:
1. Initialize a new React project environment (e.g., using Vite).
2. Design and build the core UI components: a text input (prompt field) for the logo description, selection controls for style parameters (if the API supports them), and an image preview area.
3. Implement state management (e.g., React Context or Zustand) to manage the user's input prompt, the API loading status (pending, success, error), and the resulting image data.
4. Create an API service module within the React app (using "fetch" or "axios") to securely format and send the prompt data via an HTTP POST request to the specified "gemini-2.5-flash-image" (Gemini model) endpoint.
5. Implement asynchronous logic to handle the API call: show a loading indicator while the request is pending, retrieve the generated image (e.g., as a URL or base64 string) upon success, and display any errors.
6. Display the returned "fancy logo" from the API response in the preview area component.
7. Add functionality (e.g., a "Download" button) to allow the user to save the generated image file.
8. Deploy the application to a web server or hosting platform.
<reasoning>
The agent used the todo list to break the task into distinct, manageable steps:
1. Building an entire interactive web application from scratch is a highly complex, multi-stage process involving setup, UI development, logic integration, and deployment.
2. The agent inferred the core functionality required for a "logo creator," such as UI controls for customization (Task 3) and an export feature (Task 7), which must be tracked as distinct goals.
3. The agent rightly inferred the requirement of an API service model for interacting with the image model endpoint.
</reasoning>
</example>
## Examples of When NOT to Use the Todo List
<example>
User request: Ensure that the test <test file> passes.
Agent:
<Goes into a loop of running the test, identifying errors, and updating the code until the test passes.>
<reasoning>
The agent did not use the todo list because this task could be completed by a tight loop of execute test->edit->execute test.
</reasoning>
</example>`,
parametersJsonSchema: {
type: "object",
properties: {
[TODOS_PARAM_TODOS]: {
type: "array",
description: "The complete list of todo items. This will replace the existing list.",
items: {
type: "object",
description: "A single todo item.",
properties: {
[TODOS_ITEM_PARAM_DESCRIPTION]: {
type: "string",
description: "The description of the task."
},
[TODOS_ITEM_PARAM_STATUS]: {
type: "string",
description: "The current status of the task.",
enum: [
"pending",
"in_progress",
"completed",
"cancelled",
"blocked"
]
}
},
required: [TODOS_ITEM_PARAM_DESCRIPTION, TODOS_ITEM_PARAM_STATUS],
additionalProperties: false
}
}
},
required: [TODOS_PARAM_TODOS],
additionalProperties: false
}
},
get_internal_docs: {
name: GET_INTERNAL_DOCS_TOOL_NAME,
description: "Returns the content of Gemini CLI internal documentation files. If no path is provided, returns a list of all available documentation paths.",
parametersJsonSchema: {
type: "object",
properties: {
[DOCS_PARAM_PATH]: {
description: "The relative path to the documentation file (e.g., 'cli/commands.md'). If omitted, lists all available documentation.",
type: "string"
}
}
}
},
ask_user: {
name: ASK_USER_TOOL_NAME,
description: "Ask the user one or more questions to gather preferences, clarify requirements, or make decisions.",
parametersJsonSchema: {
type: "object",
required: [ASK_USER_PARAM_QUESTIONS],
properties: {
[ASK_USER_PARAM_QUESTIONS]: {
type: "array",
minItems: 1,
maxItems: 4,
items: {
type: "object",
required: [
ASK_USER_QUESTION_PARAM_QUESTION,
ASK_USER_QUESTION_PARAM_HEADER,
ASK_USER_QUESTION_PARAM_TYPE
],
properties: {
[ASK_USER_QUESTION_PARAM_QUESTION]: {
type: "string",
description: "The complete question to ask the user. Should be clear, specific, and end with a question mark."
},
[ASK_USER_QUESTION_PARAM_HEADER]: {
type: "string",
description: 'Very short label displayed as a chip/tag. Use abbreviations: "Auth" not "Authentication", "Config" not "Configuration". Examples: "Auth method", "Library", "Approach", "Database".'
},
[ASK_USER_QUESTION_PARAM_TYPE]: {
type: "string",
enum: ["choice", "text", "yesno"],
default: "choice",
description: "Question type: 'choice' (default) for multiple-choice with options, 'text' for free-form input, 'yesno' for Yes/No confirmation with optional 'Other' feedback."
},
[ASK_USER_QUESTION_PARAM_OPTIONS]: {
type: "array",
description: "The selectable choices for 'choice' type questions. Provide 2-4 options. An 'Other' option is automatically added for 'choice' and 'yesno' types. Not needed for 'text' or 'yesno'.",
items: {
type: "object",
required: [
ASK_USER_OPTION_PARAM_LABEL,
ASK_USER_OPTION_PARAM_DESCRIPTION
],
properties: {
[ASK_USER_OPTION_PARAM_LABEL]: {
type: "string",
description: 'The display text for this option (1-5 words). Example: "OAuth 2.0"'
},
[ASK_USER_OPTION_PARAM_DESCRIPTION]: {
type: "string",
description: 'Brief explanation of this option. Example: "Industry standard, supports SSO"'
}
}
}
},
[ASK_USER_QUESTION_PARAM_MULTI_SELECT]: {
type: "boolean",
description: "Only applies when type='choice'. Set to true to allow selecting multiple options."
},
[ASK_USER_QUESTION_PARAM_PLACEHOLDER]: {
type: "string",
description: "Hint text shown in the input field. For type='text', shown in the main input. For type='choice' and 'yesno', shown in the 'Other' custom input."
}
}
}
}
}
}
},
enter_plan_mode: {
name: ENTER_PLAN_MODE_TOOL_NAME,
description: "Switch to Plan Mode to safely research, design, and plan complex changes using read-only tools.",
parametersJsonSchema: {
type: "object",
properties: {
[PLAN_MODE_PARAM_REASON]: {
type: "string",
description: "Short reason explaining why you are entering plan mode."
}
}
}
},
exit_plan_mode: () => getExitPlanModeDeclaration(),
activate_skill: (skillNames) => getActivateSkillDeclaration(skillNames),
read_mcp_resource: {
name: READ_MCP_RESOURCE_TOOL_NAME,
description: "Reads the content of a specified Model Context Protocol (MCP) resource.",
parametersJsonSchema: {
type: "object",
properties: {
uri: {
description: "The URI of the MCP resource to read.",
type: "string"
}
},
required: ["uri"]
}
},
list_mcp_resources: {
name: LIST_MCP_RESOURCES_TOOL_NAME,
description: "Lists all available resources exposed by connected MCP servers.",
parametersJsonSchema: {
type: "object",
properties: {
serverName: {
description: "Optional filter to list resources from a specific server.",
type: "string"
}
},
required: []
}
}
};
// packages/core/src/utils/constants.ts
var REFERENCE_CONTENT_START = "--- Content from referenced files ---";
var REFERENCE_CONTENT_END = "--- End of content ---";
var DEFAULT_MAX_LINES_TEXT_FILE = 2e3;
var MAX_LINE_LENGTH_TEXT_FILE = 2e3;
var MAX_FILE_SIZE_MB = 20;
// packages/core/src/tools/definitions/model-family-sets/gemini-3.ts
var GEMINI_3_SET = {
read_file: {
name: READ_FILE_TOOL_NAME,
description: `Reads and returns the content of a specified file. To maintain context efficiency, you MUST use 'start_line' and 'end_line' for targeted, surgical reads of specific sections. For your safety, the tool will automatically truncate output exceeding ${DEFAULT_MAX_LINES_TEXT_FILE} lines, ${MAX_LINE_LENGTH_TEXT_FILE} characters per line, or ${MAX_FILE_SIZE_MB}MB in size; however, triggering these limits is considered token-inefficient. Always retrieve only the minimum content necessary for your next step. Handles text, images (PNG, JPG, GIF, WEBP, SVG, BMP), audio files (MP3, WAV, AIFF, AAC, OGG, FLAC), and PDF files.`,
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_FILE_PATH]: {
description: "The path to the file to read.",
type: "string"
},
[READ_FILE_PARAM_START_LINE]: {
description: "Optional: The 1-based line number to start reading from.",
type: "integer",
minimum: 1
},
[READ_FILE_PARAM_END_LINE]: {
description: "Optional: The 1-based line number to end reading at (inclusive).",
type: "integer",
minimum: 1
}
},
required: [PARAM_FILE_PATH]
}
},
write_file: {
name: WRITE_FILE_TOOL_NAME,
description: `Writes the complete content to a file, automatically creating missing parent directories. Overwrites existing files. The user has the ability to modify 'content' before it is saved. Best for new or small files; use '${EDIT_TOOL_NAME}' for targeted edits to large files to minimize token usage and simplify reviews.`,
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_FILE_PATH]: {
description: "Path to the file.",
type: "string"
},
[WRITE_FILE_PARAM_CONTENT]: {
description: "The complete content to write. Provide the full file; do not use placeholders like '// ... rest of code'.",
type: "string"
}
},
required: [PARAM_FILE_PATH, WRITE_FILE_PARAM_CONTENT]
}
},
grep_search: {
name: GREP_TOOL_NAME,
description: "Searches for a regular expression pattern within file contents. Max 100 matches.",
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_PATTERN]: {
description: `The regular expression (regex) pattern to search for within file contents (e.g., 'function\\s+myFunction', 'import\\s+\\{.*\\}\\s+from\\s+.*').`,
type: "string"
},
[PARAM_DIR_PATH]: {
description: "Optional: The absolute path to the directory to search within. If omitted, searches the current working directory.",
type: "string"
},
[GREP_PARAM_INCLUDE_PATTERN]: {
description: `Optional: A glob pattern to filter which files are searched (e.g., '*.js', '*.{ts,tsx}', 'src/**'). If omitted, searches all files (respecting potential global ignores).`,
type: "string"
},
[GREP_PARAM_EXCLUDE_PATTERN]: {
description: "Optional: A regular expression pattern to exclude from the search results. If a line matches both the pattern and the exclude_pattern, it will be omitted.",
type: "string"
},
[GREP_PARAM_NAMES_ONLY]: {
description: "Optional: If true, only the file paths of the matches will be returned, without the line content or line numbers. This is useful for gathering a list of files.",
type: "boolean"
},
[GREP_PARAM_MAX_MATCHES_PER_FILE]: {
description: "Optional: Maximum number of matches to return per file. Use this to prevent being overwhelmed by repetitive matches in large files.",
type: "integer",
minimum: 1
},
[GREP_PARAM_TOTAL_MAX_MATCHES]: {
description: "Optional: Maximum number of total matches to return. Use this to limit the overall size of the response. Defaults to 100 if omitted.",
type: "integer",
minimum: 1
}
},
required: [PARAM_PATTERN]
}
},
grep_search_ripgrep: {
name: GREP_TOOL_NAME,
description: 'Searches for a regular expression pattern within file contents. This tool is FAST and optimized, powered by ripgrep. PREFERRED over standard `run_shell_command("grep ...")` due to better performance and automatic output limiting (defaults to 100 matches, but can be increased via `total_max_matches`).',
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_PATTERN]: {
description: `The pattern to search for. By default, treated as a Rust-flavored regular expression. Use '\\b' for precise symbol matching (e.g., '\\bMatchMe\\b').`,
type: "string"
},
[PARAM_DIR_PATH]: {
description: "Directory or file to search. Directories are searched recursively. Relative paths are resolved against current working directory. Defaults to current working directory ('.') if omitted.",
type: "string"
},
[GREP_PARAM_INCLUDE_PATTERN]: {
description: "Glob pattern to filter files (e.g., '*.ts', 'src/**'). Recommended for large repositories to reduce noise. Defaults to all files if omitted.",
type: "string"
},
[GREP_PARAM_EXCLUDE_PATTERN]: {
description: "Optional: A regular expression pattern to exclude from the search results. If a line matches both the pattern and the exclude_pattern, it will be omitted.",
type: "string"
},
[GREP_PARAM_NAMES_ONLY]: {
description: "Optional: If true, only the file paths of the matches will be returned, without the line content or line numbers. This is useful for gathering a list of files.",
type: "boolean"
},
[PARAM_CASE_SENSITIVE]: {
description: "If true, search is case-sensitive. Defaults to false (ignore case) if omitted.",
type: "boolean"
},
[GREP_PARAM_FIXED_STRINGS]: {
description: "If true, treats the `pattern` as a literal string instead of a regular expression. Defaults to false (basic regex) if omitted.",
type: "boolean"
},
[GREP_PARAM_CONTEXT]: {
description: "Show this many lines of context around each match (equivalent to grep -C). Defaults to 0 if omitted.",
type: "integer",
minimum: 0
},
[GREP_PARAM_AFTER]: {
description: "Show this many lines after each match (equivalent to grep -A). Defaults to 0 if omitted.",
type: "integer",
minimum: 0
},
[GREP_PARAM_BEFORE]: {
description: "Show this many lines before each match (equivalent to grep -B). Defaults to 0 if omitted.",
type: "integer",
minimum: 0
},
[GREP_PARAM_NO_IGNORE]: {
description: "If true, searches all files including those usually ignored (like in .gitignore, build/, dist/, etc). Defaults to false if omitted.",
type: "boolean"
},
[GREP_PARAM_MAX_MATCHES_PER_FILE]: {
description: "Optional: Maximum number of matches to return per file. Use this to prevent being overwhelmed by repetitive matches in large files.",
type: "integer",
minimum: 1
},
[GREP_PARAM_TOTAL_MAX_MATCHES]: {
description: "Optional: Maximum number of total matches to return. Use this to limit the overall size of the response. Defaults to 100 if omitted.",
type: "integer",
minimum: 1
}
},
required: [PARAM_PATTERN]
}
},
glob: {
name: GLOB_TOOL_NAME,
description: "Efficiently finds files matching specific glob patterns (e.g., `src/**/*.ts`, `**/*.md`), returning absolute paths sorted by modification time (newest first). Ideal for quickly locating files based on their name or path structure, especially in large codebases.",
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_PATTERN]: {
description: "The glob pattern to match against (e.g., '**/*.py', 'docs/*.md').",
type: "string"
},
[PARAM_DIR_PATH]: {
description: "Optional: The absolute path to the directory to search within. If omitted, searches the root directory.",
type: "string"
},
[PARAM_CASE_SENSITIVE]: {
description: "Optional: Whether the search should be case-sensitive. Defaults to false.",
type: "boolean"
},
[PARAM_RESPECT_GIT_IGNORE]: {
description: "Optional: Whether to respect .gitignore patterns when finding files. Only available in git repositories. Defaults to true.",
type: "boolean"
},
[PARAM_RESPECT_GEMINI_IGNORE]: {
description: "Optional: Whether to respect .geminiignore patterns when finding files. Defaults to true.",
type: "boolean"
}
},
required: [PARAM_PATTERN]
}
},
list_directory: {
name: LS_TOOL_NAME,
description: "Lists the names of files and subdirectories directly within a specified directory path. Can optionally ignore entries matching provided glob patterns.",
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_DIR_PATH]: {
description: "The path to the directory to list",
type: "string"
},
[LS_PARAM_IGNORE]: {
description: "List of glob patterns to ignore",
items: {
type: "string"
},
type: "array"
},
[PARAM_FILE_FILTERING_OPTIONS]: {
description: "Optional: Whether to respect ignore patterns from .gitignore or .geminiignore",
type: "object",
properties: {
[PARAM_RESPECT_GIT_IGNORE]: {
description: "Optional: Whether to respect .gitignore patterns when listing files. Only available in git repositories. Defaults to true.",
type: "boolean"
},
[PARAM_RESPECT_GEMINI_IGNORE]: {
description: "Optional: Whether to respect .geminiignore patterns when listing files. Defaults to true.",
type: "boolean"
}
}
}
},
required: [PARAM_DIR_PATH]
}
},
run_shell_command: (enableInteractiveShell, enableEfficiency, enableToolSandboxing) => getShellDeclaration(
enableInteractiveShell,
enableEfficiency,
enableToolSandboxing
),
replace: {
name: EDIT_TOOL_NAME,
description: `Replaces text within a file. By default, the tool expects to find and replace exactly ONE occurrence of \`old_string\`. If you want to replace multiple occurrences of the exact same string, set \`allow_multiple\` to true. This tool is preferred for surgical edits to existing files as it minimizes token usage, simplifies code reviews, and avoids accidental deletions. This tool requires providing significant context around the change to ensure precise targeting.
The user has the ability to modify the \`new_string\` content. If modified, this will be stated in the response.`,
parametersJsonSchema: {
type: "object",
properties: {
[PARAM_FILE_PATH]: {
description: "The path to the file to modify.",
type: "string"
},
[EDIT_PARAM_INSTRUCTION]: {
description: `A clear, semantic instruction for the code change, acting as a high-quality prompt for an expert LLM assistant. It must be self-contained and explain the goal of the change.`,
type: "string"
},
[EDIT_PARAM_OLD_STRING]: {
description: "The exact literal text to replace, unescaped. If this string is not the exact literal text (i.e. you escaped it) or does not match exactly, the tool will fail.",
type: "string"
},
[EDIT_PARAM_NEW_STRING]: {
description: "The exact literal text to replace `old_string` with, unescaped. Provide the EXACT text. Ensure the resulting code is correct and idiomatic. Do not use omission placeholders like '(rest of methods ...)', '...', or 'unchanged code'; provide exact literal code.",
type: "string"
},
[EDIT_PARAM_ALLOW_MULTIPLE]: {
type: "boolean",
description: "If true, the tool will replace all occurrences of `old_string`. If false (default), it will only succeed if exactly one occurrence is found."
}
},
required: [
PARAM_FILE_PATH,
EDIT_PARAM_INSTRUCTION,
EDIT_PARAM_OLD_STRING,
EDIT_PARAM_NEW_STRING
]
}
},
google_web_search: {
name: WEB_SEARCH_TOOL_NAME,
description: `Performs a grounded Google Search to find information across the internet. Returns a synthesized answer with citations (e.g., [1]) and source URIs. Best for finding up-to-date documentation, troubleshooting obscure errors, or broad research. Use this when you don't have a specific URL. If a search result requires deeper analysis, follow up by using '${WEB_FETCH_TOOL_NAME}' on the provided URI.`,
parametersJsonSchema: {
type: "object",
properties: {
[WEB_SEARCH_PARAM_QUERY]: {
type: "string",
description: "The search query. Supports natural language questions (e.g., 'Latest breaking changes in React 19') or specific technical queries."
}
},
required: [WEB_SEARCH_PARAM_QUERY]
}
},
web_fetch: {
name: WEB_FETCH_TOOL_NAME,
description: "Analyzes and extracts information from up to 20 URLs. Ideal for documentation review, technical research, or reading raw code from GitHub. You can provide specific, complex instructions for the extraction (e.g., 'Summarize the breaking changes'). Provides cited answers based on the content. GitHub 'blob' URLs are automatically converted to raw versions for better processing. Supports HTTP/HTTPS only.",
parametersJsonSchema: {
type: "object",
properties: {
[WEB_FETCH_PARAM_PROMPT]: {
description: "A string containing the URL(s) and your specific analysis instructions. Be clear about what information you want to find or summarize. Supports up to 20 URLs.",
type: "string"
}
},
required: [WEB_FETCH_PARAM_PROMPT]
}
},
read_many_files: {
name: READ_MANY_FILES_TOOL_NAME,
description: `Reads content from multiple files specified by glob patterns within a configured target directory. For text files, it concatenates their content into a single string. It is primarily designed for text-based files. However, it can also process image (e.g., .png, .jpg), audio (e.g., .mp3, .wav), and PDF (.pdf) files if their file names or extensions are explicitly included in the 'include' argument. For these explicitly requested non-text files, their data is read and included in a format suitable for model consumption (e.g., base64 encoded).
This tool is useful when you need to understand or analyze a collection of files, such as:
- Getting an overview of a codebase or parts of it (e.g., all TypeScript files in the 'src' directory).
- Finding where specific functionality is implemented if the user asks broad questions about code.
- Reviewing documentation files (e.g., all Markdown files in the 'docs' directory).
- Gathering context from multiple configuration files.
- When the user asks to "read all files in X directory" or "show me the content of all Y files".
Use this tool when the user's query implies needing the content of several files simultaneously for context, analysis, or summarization. For text files, it uses default UTF-8 encoding and a '--- {filePath} ---' separator between file contents. The tool inserts a '--- End of content ---' after the last file. Ensure glob patterns are relative to the target directory. Glob patterns like 'src/**/*.js' are supported. Avoid using for single files if a more specific single-file reading tool is available, unless the user specifically requests to process a list containing just one file via this tool. Other binary files (not explicitly requested as image/audio/PDF) are generally skipped. Default excludes apply to common non-text files (except for explicitly requested images/audio/PDFs) and large dependency directories unless 'useDefaultExcludes' is false.`,
parametersJsonSchema: {
type: "object",
properties: {
[READ_MANY_PARAM_INCLUDE]: {
type: "array",
items: {
type: "string",
minLength: 1
},
minItems: 1,
description: 'An array of glob patterns or paths. Examples: ["src/**/*.ts"], ["README.md", "docs/"]'
},
[READ_MANY_PARAM_EXCLUDE]: {
type: "array",
items: {
type: "string",
minLength: 1
},
description: 'Optional. Glob patterns for files/directories to exclude. Added to default excludes if useDefaultExcludes is true. Example: "**/*.log", "temp/"',
default: []
},
[READ_MANY_PARAM_RECURSIVE]: {
type: "boolean",
description: "Optional. Whether to search recursively (primarily controlled by `**` in glob patterns). Defaults to true.",
default: true
},
[READ_MANY_PARAM_USE_DEFAULT_EXCLUDES]: {
type: "boolean",
description: "Optional. Whether to apply a list of default exclusion patterns (e.g., node_modules, .git, binary files). Defaults to true.",
default: true
},
[PARAM_FILE_FILTERING_OPTIONS]: {
description: "Whether to respect ignore patterns from .gitignore or .geminiignore",
type: "object",
properties: {
[PARAM_RESPECT_GIT_IGNORE]: {
description: "Optional: Whether to respect .gitignore patterns when listing files. Only available in git repositories. Defaults to true.",
type: "boolean"
},
[PARAM_RESPECT_GEMINI_IGNORE]: {
description: "Optional: Whether to respect .geminiignore patterns when listing files. Defaults to true.",
type: "boolean"
}
}
}
},
required: [READ_MANY_PARAM_INCLUDE]
}
},
save_memory: {
name: MEMORY_TOOL_NAME,
description: `Persists preferences or facts across ALL future sessions. Supports two scopes: 'global' (default) for cross-project preferences loaded in every workspace, and 'project' for facts specific to the current workspace that are private to the user (not committed to the repo). Use 'project' scope for things like local dev setup notes, project-specific workflows, or personal reminders about this codebase. CRITICAL: Do not use for session-specific context or temporary data.`,
parametersJsonSchema: {
type: "object",
properties: {
[MEMORY_PARAM_FACT]: {
type: "string",
description: "A concise fact or preference to remember. Should be a clear, self-contained statement."
},
[MEMORY_PARAM_SCOPE]: {
type: "string",
enum: ["global", "project"],
description: "Where to save the memory. 'global' (default) saves to a file loaded in every workspace. 'project' saves to a project-specific file private to the user, not committed to the repo."
}
},
required: [MEMORY_PARAM_FACT],
additionalProperties: false
}
},
write_todos: {
name: WRITE_TODOS_TOOL_NAME,
description: `This tool can help you list out the current subtasks that are required to be completed for a given user request. The list of subtasks helps you keep track of the current task, organize complex queries and help ensure that you don't miss any steps. With this list, the user can also see the current progress you are making in executing a given task.
Depending on the task complexity, you should first divide a given task into subtasks and then use this tool to list out the subtasks that are required to be completed for a given user request.
Each of the subtasks should be clear and distinct.
Use this tool for complex queries that require multiple steps. If you find that the request is actually complex after you have started executing the user task, create a todo list and use it. If execution of the user task requires multiple steps, planning and generally is higher complexity than a simple Q&A, use this tool.
DO NOT use this tool for simple tasks that can be completed in less than 2 steps. If the user query is simple and straightforward, do not use the tool. If you can respond with an answer in a single turn then this tool is not required.
## Task state definitions
- pending: Work has not begun on a given subtask.
- in_progress: Marked just prior to beginning work on a given subtask. You should only have one subtask as in_progress at a time.
- completed: Subtask was successfully completed with no errors or issues. If the subtask required more steps to complete, update the todo list with the subtasks. All steps should be identified as completed only when they are completed.
- cancelled: As you update the todo list, some tasks are not required anymore due to the dynamic nature of the task. In this case, mark the subtasks as cancelled.
- blocked: Subtask is blocked and cannot be completed at this time.
## Methodology for using this tool
1. Use this todo list as soon as you receive a user request based on the complexity of the task.
2. Keep track of every subtask that you update the list with.
3. Mark a subtask as in_progress before you begin working on it. You should only have one subtask as in_progress at a time.
4. Update the subtask list as you proceed in executing the task. The subtask list is not static and should reflect your progress and current plans, which may evolve as you acquire new information.
5. Mark a subtask as completed when you have completed it.
6. Mark a subtask as cancelled if the subtask is no longer needed.
7. You must update the todo list as soon as you start, stop or cancel a subtask. Don't batch or wait to update the todo list.
## Examples of When to Use the Todo List
<example>
User request: Create a website with a React for creating fancy logos using gemini-2.5-flash-image
ToDo list created by the agent:
1. Initialize a new React project environment (e.g., using Vite).
2. Design and build the core UI components: a text input (prompt field) for the logo description, selection controls for style parameters (if the API supports them), and an image preview area.
3. Implement state management (e.g., React Context or Zustand) to manage the user's input prompt, the API loading status (pending, success, error), and the resulting image data.
4. Create an API service module within the React app (using "fetch" or "axios") to securely format and send the prompt data via an HTTP POST request to the specified "gemini-2.5-flash-image" (Gemini model) endpoint.
5. Implement asynchronous logic to handle the API call: show a loading indicator while the request is pending, retrieve the generated image (e.g., as a URL or base64 string) upon success, and display any errors.
6. Display the returned "fancy logo" from the API response in the preview area component.
7. Add functionality (e.g., a "Download" button) to allow the user to save the generated image file.
8. Deploy the application to a web server or hosting platform.
<reasoning>
The agent used the todo list to break the task into distinct, manageable steps:
1. Building an entire interactive web application from scratch is a highly complex, multi-stage process involving setup, UI development, logic integration, and deployment.
2. The agent inferred the core functionality required for a "logo creator," such as UI controls for customization (Task 3) and an export feature (Task 7), which must be tracked as distinct goals.
3. The agent rightly inferred the requirement of an API service model for interacting with the image model endpoint.
</reasoning>
</example>
## Examples of When NOT to Use the Todo List
<example>
User request: Ensure that the test <test file> passes.
Agent:
<Goes into a loop of running the test, identifying errors, and updating the code until the test passes.>
<reasoning>
The agent did not use the todo list because this task could be completed by a tight loop of execute test->edit->execute test.
</reasoning>
</example>`,
parametersJsonSchema: {
type: "object",
properties: {
[TODOS_PARAM_TODOS]: {
type: "array",
description: "The complete list of todo items. This will replace the existing list.",
items: {
type: "object",
description: "A single todo item.",
properties: {
[TODOS_ITEM_PARAM_DESCRIPTION]: {
type: "string",
description: "The description of the task."
},
[TODOS_ITEM_PARAM_STATUS]: {
type: "string",
description: "The current status of the task.",
enum: [
"pending",
"in_progress",
"completed",
"cancelled",
"blocked"
]
}
},
required: [TODOS_ITEM_PARAM_DESCRIPTION, TODOS_ITEM_PARAM_STATUS],
additionalProperties: false
}
}
},
required: [TODOS_PARAM_TODOS],
additionalProperties: false
}
},
get_internal_docs: {
name: GET_INTERNAL_DOCS_TOOL_NAME,
description: "Returns the content of Gemini CLI internal documentation files. If no path is provided, returns a list of all available documentation paths.",
parametersJsonSchema: {
type: "object",
properties: {
[DOCS_PARAM_PATH]: {
description: "The relative path to the documentation file (e.g., 'cli/commands.md'). If omitted, lists all available documentation.",
type: "string"
}
}
}
},
ask_user: {
name: ASK_USER_TOOL_NAME,
description: "Ask the user one or more questions to gather preferences, clarify requirements, or make decisions. When using this tool, prefer providing multiple-choice options with detailed descriptions and enable multi-select where appropriate to provide maximum flexibility.",
parametersJsonSchema: {
type: "object",
required: [ASK_USER_PARAM_QUESTIONS],
properties: {
[ASK_USER_PARAM_QUESTIONS]: {
type: "array",
minItems: 1,
maxItems: 4,
items: {
type: "object",
required: [
ASK_USER_QUESTION_PARAM_QUESTION,
ASK_USER_QUESTION_PARAM_HEADER,
ASK_USER_QUESTION_PARAM_TYPE
],
properties: {
[ASK_USER_QUESTION_PARAM_QUESTION]: {
type: "string",
description: "The complete question to ask the user. Should be clear, specific, and end with a question mark."
},
[ASK_USER_QUESTION_PARAM_HEADER]: {
type: "string",
description: 'Very short label displayed as a chip/tag. Use abbreviations: "Auth" not "Authentication", "Config" not "Configuration". Examples: "Auth method", "Library", "Approach", "Database".'
},
[ASK_USER_QUESTION_PARAM_TYPE]: {
type: "string",
enum: ["choice", "text", "yesno"],
default: "choice",
description: "Question type: 'choice' (default) for multiple-choice with options, 'text' for free-form input, 'yesno' for Yes/No confirmation with optional 'Other' feedback."
},
[ASK_USER_QUESTION_PARAM_OPTIONS]: {
type: "array",
description: "The selectable choices for 'choice' type questions. Provide 2-4 options. An 'Other' option is automatically added for 'choice' and 'yesno' types. Not needed for 'text' or 'yesno'.",
items: {
type: "object",
required: [
ASK_USER_OPTION_PARAM_LABEL,
ASK_USER_OPTION_PARAM_DESCRIPTION
],
properties: {
[ASK_USER_OPTION_PARAM_LABEL]: {
type: "string",
description: 'The display text for this option (1-5 words). Example: "OAuth 2.0"'
},
[ASK_USER_OPTION_PARAM_DESCRIPTION]: {
type: "string",
description: 'Brief explanation of this option. Example: "Industry standard, supports SSO"'
}
}
}
},
[ASK_USER_QUESTION_PARAM_MULTI_SELECT]: {
type: "boolean",
description: "Only applies when type='choice'. Set to true to allow selecting multiple options."
},
[ASK_USER_QUESTION_PARAM_PLACEHOLDER]: {
type: "string",
description: "Hint text shown in the input field. For type='text', shown in the main input. For type='choice' and 'yesno', shown in the 'Other' custom input."
}
}
}
}
}
}
},
enter_plan_mode: {
name: ENTER_PLAN_MODE_TOOL_NAME,
description: "Switch to Plan Mode to safely research, design, and plan complex changes using read-only tools.",
parametersJsonSchema: {
type: "object",
properties: {
[PLAN_MODE_PARAM_REASON]: {
type: "string",
description: "Short reason explaining why you are entering plan mode."
}
}
}
},
exit_plan_mode: () => getExitPlanModeDeclaration(),
activate_skill: (skillNames) => getActivateSkillDeclaration(skillNames),
update_topic: getUpdateTopicDeclaration(),
read_mcp_resource: {
name: READ_MCP_RESOURCE_TOOL_NAME,
description: "Reads the content of a specified Model Context Protocol (MCP) resource.",
parametersJsonSchema: {
type: "object",
properties: {
uri: {
description: "The URI of the MCP resource to read.",
type: "string"
}
},
required: ["uri"]
}
},
list_mcp_resources: {
name: LIST_MCP_RESOURCES_TOOL_NAME,
description: "Lists all available resources exposed by connected MCP servers.",
parametersJsonSchema: {
type: "object",
properties: {
serverName: {
description: "Optional filter to list resources from a specific server.",
type: "string"
}
},
required: []
}
}
};
// packages/core/src/tools/definitions/coreTools.ts
function getToolSet(modelId) {
const family = getToolFamily(modelId);
switch (family) {
case "gemini-3":
return GEMINI_3_SET;
case "default-legacy":
default:
return DEFAULT_LEGACY_SET;
}
}
var READ_FILE_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.read_file;
},
overrides: (modelId) => getToolSet(modelId).read_file
};
var WRITE_FILE_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.write_file;
},
overrides: (modelId) => getToolSet(modelId).write_file
};
var GREP_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.grep_search;
},
overrides: (modelId) => getToolSet(modelId).grep_search
};
var RIP_GREP_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.grep_search_ripgrep;
},
overrides: (modelId) => getToolSet(modelId).grep_search_ripgrep
};
var WEB_SEARCH_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.google_web_search;
},
overrides: (modelId) => getToolSet(modelId).google_web_search
};
var EDIT_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.replace;
},
overrides: (modelId) => getToolSet(modelId).replace
};
var GLOB_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.glob;
},
overrides: (modelId) => getToolSet(modelId).glob
};
var LS_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.list_directory;
},
overrides: (modelId) => getToolSet(modelId).list_directory
};
var WEB_FETCH_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.web_fetch;
},
overrides: (modelId) => getToolSet(modelId).web_fetch
};
var READ_MANY_FILES_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.read_many_files;
},
overrides: (modelId) => getToolSet(modelId).read_many_files
};
var MEMORY_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.save_memory;
},
overrides: (modelId) => getToolSet(modelId).save_memory
};
var WRITE_TODOS_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.write_todos;
},
overrides: (modelId) => getToolSet(modelId).write_todos
};
var GET_INTERNAL_DOCS_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.get_internal_docs;
},
overrides: (modelId) => getToolSet(modelId).get_internal_docs
};
var ASK_USER_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.ask_user;
},
overrides: (modelId) => getToolSet(modelId).ask_user
};
var ENTER_PLAN_MODE_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.enter_plan_mode;
},
overrides: (modelId) => getToolSet(modelId).enter_plan_mode
};
function getShellDefinition(enableInteractiveShell, enableEfficiency, enableToolSandboxing = false) {
return {
base: getShellDeclaration(
enableInteractiveShell,
enableEfficiency,
enableToolSandboxing
),
overrides: (modelId) => getToolSet(modelId).run_shell_command(
enableInteractiveShell,
enableEfficiency,
enableToolSandboxing
)
};
}
function getExitPlanModeDefinition() {
return {
base: getExitPlanModeDeclaration(),
overrides: (modelId) => getToolSet(modelId).exit_plan_mode()
};
}
function getActivateSkillDefinition(skillNames) {
return {
base: getActivateSkillDeclaration(skillNames),
overrides: (modelId) => getToolSet(modelId).activate_skill(skillNames)
};
}
var READ_MCP_RESOURCE_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.read_mcp_resource;
},
overrides: (modelId) => getToolSet(modelId).read_mcp_resource
};
var LIST_MCP_RESOURCES_DEFINITION = {
get base() {
return DEFAULT_LEGACY_SET.list_mcp_resources;
},
overrides: (modelId) => getToolSet(modelId).list_mcp_resources
};
// packages/core/src/utils/safeJsonStringify.ts
function safeJsonStringify(obj, space) {
const seen = /* @__PURE__ */ new WeakSet();
return JSON.stringify(
obj,
(key, value) => {
if (typeof value === "object" && value !== null) {
if (seen.has(value)) {
return "[Circular]";
}
seen.add(value);
}
return value;
},
space
);
}
function removeEmptyObjects(data) {
const cleanedObject = {};
for (const k in data) {
const v = data[k];
if (v !== null && v !== void 0 && typeof v === "boolean") {
cleanedObject[k] = v;
}
}
return cleanedObject;
}
function safeJsonStringifyBooleanValuesOnly(obj) {
let configSeen = false;
return JSON.stringify(removeEmptyObjects(obj), (key, value) => {
if (value !== null && !configSeen) {
configSeen = true;
return value;
}
if (typeof value === "boolean") {
return value;
}
return "";
});
}
// packages/core/src/tools/mcp-tool.ts
var MCP_QUALIFIED_NAME_SEPARATOR = "_";
var MCP_TOOL_PREFIX = "mcp_";
function isMcpToolName(name) {
return name.startsWith(MCP_TOOL_PREFIX);
}
function parseMcpToolName(name) {
if (!isMcpToolName(name)) {
return {};
}
const withoutPrefix = name.slice(MCP_TOOL_PREFIX.length);
const match = withoutPrefix.match(/^([^_]+)_(.+)$/);
if (match) {
return {
serverName: match[1],
toolName: match[2]
};
}
return {};
}
function formatMcpToolName(serverName, toolName) {
if (serverName === "*" && (toolName === void 0 || toolName === "*")) {
return `${MCP_TOOL_PREFIX}*`;
} else if (serverName === "*") {
return `${MCP_TOOL_PREFIX}*_${toolName}`;
} else if (toolName === void 0 || toolName === "*") {
return `${MCP_TOOL_PREFIX}${serverName}_*`;
} else {
return `${MCP_TOOL_PREFIX}${serverName}_${toolName}`;
}
}
function isMcpToolAnnotation(annotation) {
if (typeof annotation !== "object" || annotation === null) {
return false;
}
const record = annotation;
const serverName = record["_serverName"];
return typeof serverName === "string";
}
var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends BaseToolInvocation {
constructor(mcpTool, serverName, serverToolName, displayName, messageBus, trust, params = {}, cliConfig, toolDescription, toolParameterSchema, toolAnnotationsData) {
super(
params,
messageBus,
generateValidName(
`${serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${serverToolName}`
),
displayName,
generateValidName(serverName),
toolAnnotationsData
);
this.mcpTool = mcpTool;
this.serverName = serverName;
this.serverToolName = serverToolName;
this.displayName = displayName;
this.trust = trust;
this.cliConfig = cliConfig;
this.toolDescription = toolDescription;
this.toolParameterSchema = toolParameterSchema;
}
static allowlist = /* @__PURE__ */ new Set();
getPolicyUpdateOptions(_outcome) {
return {
mcpName: this.serverName,
toolName: this.serverToolName
};
}
async getConfirmationDetails(_abortSignal) {
const serverAllowListKey = this.serverName;
const toolAllowListKey = `${this.serverName}.${this.serverToolName}`;
if (this.cliConfig?.isTrustedFolder() && this.trust) {
return false;
}
if (_DiscoveredMCPToolInvocation.allowlist.has(serverAllowListKey) || _DiscoveredMCPToolInvocation.allowlist.has(toolAllowListKey)) {
return false;
}
const confirmationDetails = {
type: "mcp",
title: "Confirm MCP Tool Execution",
serverName: this.serverName,
toolName: this.serverToolName,
// Display original tool name in confirmation
toolDisplayName: this.displayName,
// Display global registry name exposed to model and user
toolArgs: this.params,
toolDescription: this.toolDescription,
toolParameterSchema: this.toolParameterSchema,
onConfirm: async (outcome) => {
if (outcome === "proceed_always_server" /* ProceedAlwaysServer */) {
_DiscoveredMCPToolInvocation.allowlist.add(serverAllowListKey);
} else if (outcome === "proceed_always_tool" /* ProceedAlwaysTool */) {
_DiscoveredMCPToolInvocation.allowlist.add(toolAllowListKey);
} else if (outcome === "proceed_always_and_save" /* ProceedAlwaysAndSave */) {
_DiscoveredMCPToolInvocation.allowlist.add(toolAllowListKey);
}
}
};
return confirmationDetails;
}
// Determine if the response contains tool errors
// This is needed because CallToolResults should return errors inside the response.
// ref: https://modelcontextprotocol.io/specification/2025-06-18/schema#calltoolresult
isMCPToolError(rawResponseParts) {
const functionResponse = rawResponseParts?.[0]?.functionResponse;
const response = functionResponse?.response;
if (response) {
const isErrorTop = response.isError;
if (isErrorTop === true || isErrorTop === "true") {
return true;
}
const error = response?.error;
const isError = error?.isError;
if (error && (isError === true || isError === "true")) {
return true;
}
}
return false;
}
async execute({ abortSignal: signal }) {
this.cliConfig?.setUserInteractedWithMcp?.();
const functionCalls = [
{
name: this.serverToolName,
args: this.params
}
];
const rawResponseParts = await new Promise((resolve5, reject) => {
if (signal.aborted) {
const error = new Error("Tool call aborted");
error.name = "AbortError";
reject(error);
return;
}
const onAbort = () => {
cleanup();
const error = new Error("Tool call aborted");
error.name = "AbortError";
reject(error);
};
const cleanup = () => {
signal.removeEventListener("abort", onAbort);
};
signal.addEventListener("abort", onAbort, { once: true });
this.mcpTool.callTool(functionCalls).then((res) => {
cleanup();
resolve5(res);
}).catch((err) => {
cleanup();
reject(err);
});
});
if (this.isMCPToolError(rawResponseParts)) {
const errorMessage = `MCP tool '${this.serverToolName}' reported tool error for function call: ${safeJsonStringify(
functionCalls[0]
)} with response: ${safeJsonStringify(rawResponseParts)}`;
return {
llmContent: errorMessage,
returnDisplay: `Error: MCP tool '${this.serverToolName}' reported an error.`,
error: {
message: errorMessage,
type: "mcp_tool_error" /* MCP_TOOL_ERROR */
}
};
}
const transformedParts = transformMcpContentToParts(rawResponseParts);
return {
llmContent: transformedParts,
returnDisplay: getStringifiedResultForDisplay(rawResponseParts)
};
}
getDescription() {
return safeJsonStringify(this.params);
}
getDisplayTitle() {
const command = this.params["command"];
if (typeof command === "string") {
return command;
}
return this.displayName || this.serverToolName;
}
getExplanation() {
const MAX_EXPLANATION_LENGTH = 500;
const stringified = safeJsonStringify(this.params);
if (stringified.length > MAX_EXPLANATION_LENGTH) {
const keys = Object.keys(this.params);
const displayedKeys = keys.slice(0, 5);
const keysDesc = displayedKeys.length > 0 ? ` with parameters: ${displayedKeys.join(", ")}${keys.length > 5 ? ", ..." : ""}` : "";
return `[Payload omitted due to length${keysDesc}]`;
}
return stringified;
}
};
var DiscoveredMCPTool = class extends BaseDeclarativeTool {
constructor(mcpTool, serverName, serverToolName, description, parameterSchema, messageBus, trust, isReadOnly, nameOverride, cliConfig, extensionName, extensionId, _toolAnnotations) {
super(
nameOverride ?? generateValidName(
`${serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${serverToolName}`
),
`${serverToolName} (${serverName} MCP Server)`,
description,
"other" /* Other */,
parameterSchema,
messageBus,
true,
// isOutputMarkdown
false,
// canUpdateOutput,
extensionName,
extensionId
);
this.mcpTool = mcpTool;
this.serverName = serverName;
this.serverToolName = serverToolName;
this.parameterSchema = parameterSchema;
this.trust = trust;
this.cliConfig = cliConfig;
this.extensionName = extensionName;
this.extensionId = extensionId;
this._toolAnnotations = _toolAnnotations;
this._isReadOnly = isReadOnly;
}
_isReadOnly;
get isReadOnly() {
if (this._isReadOnly !== void 0) {
return this._isReadOnly;
}
return super.isReadOnly;
}
get toolAnnotations() {
return this._toolAnnotations;
}
getFullyQualifiedPrefix() {
return generateValidName(
`${this.serverName}${MCP_QUALIFIED_NAME_SEPARATOR}`
);
}
getFullyQualifiedName() {
return generateValidName(
`${this.serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${this.serverToolName}`
);
}
createInvocation(params, messageBus, _toolName, _displayName) {
return new DiscoveredMCPToolInvocation(
this.mcpTool,
this.serverName,
this.serverToolName,
_displayName ?? this.displayName,
messageBus,
this.trust,
params,
this.cliConfig,
this.description,
this.parameterSchema,
this._toolAnnotations
);
}
};
function transformTextBlock(block) {
return { text: block.text };
}
function transformImageAudioBlock(block, toolName) {
return [
{
text: `[Tool '${toolName}' provided the following ${block.type} data with mime-type: ${block.mimeType}]`
},
{
inlineData: {
mimeType: block.mimeType,
data: block.data
}
}
];
}
function transformResourceBlock(block, toolName) {
const resource = block.resource;
if (resource?.text) {
return { text: resource.text };
}
if (resource?.blob) {
const mimeType = resource.mimeType || "application/octet-stream";
return [
{
text: `[Tool '${toolName}' provided the following embedded resource with mime-type: ${mimeType}]`
},
{
inlineData: {
mimeType,
data: resource.blob
}
}
];
}
return null;
}
function transformResourceLinkBlock(block) {
return {
text: `Resource Link: ${block.title || block.name} at ${block.uri}`
};
}
function transformMcpContentToParts(sdkResponse) {
const funcResponse = sdkResponse?.[0]?.functionResponse;
const mcpContent = funcResponse?.response?.["content"];
const toolName = funcResponse?.name || "unknown tool";
if (!Array.isArray(mcpContent)) {
return [{ text: "[Error: Could not parse tool response]" }];
}
const transformed = mcpContent.flatMap(
(block) => {
switch (block.type) {
case "text":
return transformTextBlock(block);
case "image":
case "audio":
return transformImageAudioBlock(block, toolName);
case "resource":
return transformResourceBlock(block, toolName);
case "resource_link":
return transformResourceLinkBlock(block);
default:
return null;
}
}
);
return transformed.filter((part) => part !== null);
}
function getStringifiedResultForDisplay(rawResponse) {
const mcpContent = rawResponse?.[0]?.functionResponse?.response?.["content"];
if (!Array.isArray(mcpContent)) {
return "```json\n" + JSON.stringify(rawResponse, null, 2) + "\n```";
}
const displayParts = mcpContent.map((block) => {
switch (block.type) {
case "text":
return block.text;
case "image":
return `[Image: ${block.mimeType}]`;
case "audio":
return `[Audio: ${block.mimeType}]`;
case "resource_link":
return `[Link to ${block.title || block.name}: ${block.uri}]`;
case "resource":
if (block.resource?.text) {
return block.resource.text;
}
return `[Embedded Resource: ${block.resource?.mimeType || "unknown type"}]`;
default:
return `[Unknown content type: ${block.type}]`;
}
});
return displayParts.join("\n");
}
var MAX_FUNCTION_NAME_LENGTH = 64;
function generateValidName(name) {
let validToolname = name.startsWith("mcp_") ? name : `mcp_${name}`;
validToolname = validToolname.replace(/[^a-zA-Z0-9_\-.:]/g, "_");
if (/^[^a-zA-Z_]/.test(validToolname)) {
validToolname = `_${validToolname}`;
}
const safeLimit = MAX_FUNCTION_NAME_LENGTH - 1;
if (validToolname.length > safeLimit) {
debugLogger.warn(
`Truncating MCP tool name "${validToolname}" to fit within the 64 character limit. This tool may require user approval.`
);
validToolname = validToolname.slice(0, 30) + "..." + validToolname.slice(-30);
}
return validToolname;
}
// packages/core/src/tools/tool-names.ts
var EDIT_TOOL_NAMES = /* @__PURE__ */ new Set([EDIT_TOOL_NAME, WRITE_FILE_TOOL_NAME]);
var TOOLS_REQUIRING_NARROWING = /* @__PURE__ */ new Set([
GLOB_TOOL_NAME,
GREP_TOOL_NAME,
READ_MANY_FILES_TOOL_NAME,
READ_FILE_TOOL_NAME,
LS_TOOL_NAME,
WRITE_FILE_TOOL_NAME,
EDIT_TOOL_NAME,
SHELL_TOOL_NAME
]);
var TRACKER_CREATE_TASK_TOOL_NAME = "tracker_create_task";
var TRACKER_UPDATE_TASK_TOOL_NAME = "tracker_update_task";
var TRACKER_GET_TASK_TOOL_NAME = "tracker_get_task";
var TRACKER_LIST_TASKS_TOOL_NAME = "tracker_list_tasks";
var TRACKER_ADD_DEPENDENCY_TOOL_NAME = "tracker_add_dependency";
var TRACKER_VISUALIZE_TOOL_NAME = "tracker_visualize";
var AGENT_TOOL_NAME = "invoke_agent";
var WRITE_FILE_DISPLAY_NAME = "WriteFile";
var EDIT_DISPLAY_NAME = "Edit";
var ASK_USER_DISPLAY_NAME = "Ask User";
var READ_FILE_DISPLAY_NAME = "ReadFile";
var GLOB_DISPLAY_NAME = "FindFiles";
var LS_DISPLAY_NAME = "ReadFolder";
var GREP_DISPLAY_NAME = "SearchText";
var WEB_SEARCH_DISPLAY_NAME = "GoogleSearch";
var WEB_FETCH_DISPLAY_NAME = "WebFetch";
var READ_MANY_FILES_DISPLAY_NAME = "ReadManyFiles";
var TOOL_LEGACY_ALIASES = {
// Add future renames here, e.g.:
search_file_content: GREP_TOOL_NAME
};
function getToolAliases(name) {
const aliases = /* @__PURE__ */ new Set([name]);
const canonicalName = TOOL_LEGACY_ALIASES[name] ?? name;
aliases.add(canonicalName);
for (const [legacyName, currentName] of Object.entries(TOOL_LEGACY_ALIASES)) {
if (currentName === canonicalName) {
aliases.add(legacyName);
}
}
return Array.from(aliases);
}
var DISCOVERED_TOOL_PREFIX = "discovered_tool_";
var ALL_BUILTIN_TOOL_NAMES = [
GLOB_TOOL_NAME,
WRITE_TODOS_TOOL_NAME,
WRITE_FILE_TOOL_NAME,
WEB_SEARCH_TOOL_NAME,
WEB_FETCH_TOOL_NAME,
EDIT_TOOL_NAME,
SHELL_TOOL_NAME,
GREP_TOOL_NAME,
READ_MANY_FILES_TOOL_NAME,
READ_FILE_TOOL_NAME,
LS_TOOL_NAME,
MEMORY_TOOL_NAME,
ACTIVATE_SKILL_TOOL_NAME,
ASK_USER_TOOL_NAME,
TRACKER_CREATE_TASK_TOOL_NAME,
TRACKER_UPDATE_TASK_TOOL_NAME,
TRACKER_GET_TASK_TOOL_NAME,
TRACKER_LIST_TASKS_TOOL_NAME,
TRACKER_ADD_DEPENDENCY_TOOL_NAME,
TRACKER_VISUALIZE_TOOL_NAME,
GET_INTERNAL_DOCS_TOOL_NAME,
ENTER_PLAN_MODE_TOOL_NAME,
EXIT_PLAN_MODE_TOOL_NAME,
UPDATE_TOPIC_TOOL_NAME,
COMPLETE_TASK_TOOL_NAME,
AGENT_TOOL_NAME,
READ_MCP_RESOURCE_TOOL_NAME,
LIST_MCP_RESOURCES_TOOL_NAME
];
var PLAN_MODE_TOOLS = [
GLOB_TOOL_NAME,
GREP_TOOL_NAME,
READ_FILE_TOOL_NAME,
LS_TOOL_NAME,
WEB_SEARCH_TOOL_NAME,
ASK_USER_TOOL_NAME,
ACTIVATE_SKILL_TOOL_NAME,
GET_INTERNAL_DOCS_TOOL_NAME,
UPDATE_TOPIC_TOOL_NAME,
"codebase_investigator",
"cli_help",
READ_MCP_RESOURCE_TOOL_NAME,
LIST_MCP_RESOURCES_TOOL_NAME
];
function isValidToolName(name, options = {}) {
if (ALL_BUILTIN_TOOL_NAMES.includes(name)) {
return true;
}
if (TOOL_LEGACY_ALIASES[name]) {
return true;
}
if (name.startsWith(DISCOVERED_TOOL_PREFIX)) {
return true;
}
if (options.allowWildcards && name === "*") {
return true;
}
if (isMcpToolName(name)) {
if (name === `${MCP_TOOL_PREFIX}*` && options.allowWildcards) {
return true;
}
if (name.startsWith(`${MCP_TOOL_PREFIX}_`)) {
return false;
}
const parsed = parseMcpToolName(name);
if (parsed.serverName && parsed.toolName) {
const slugRegex = /^[a-z0-9_.:-]+$/i;
if (!slugRegex.test(parsed.serverName)) {
return false;
}
if (parsed.toolName === "*") {
return options.allowWildcards === true;
}
if (/^_*$/.test(parsed.toolName)) {
return false;
}
return slugRegex.test(parsed.toolName);
}
return false;
}
return false;
}
// packages/core/src/tools/definitions/resolver.ts
function resolveToolDeclaration(definition, modelId) {
if (!modelId || !definition.overrides) {
return definition.base;
}
const override = definition.overrides(modelId);
if (!override) {
return definition.base;
}
return {
...definition.base,
...override
};
}
// packages/core/src/tools/memoryTool.ts
var DEFAULT_CONTEXT_FILENAME = "GEMINI.md";
var MEMORY_SECTION_HEADER = "## Gemini Added Memories";
var PROJECT_MEMORY_INDEX_FILENAME = "MEMORY.md";
var currentGeminiMdFilename = DEFAULT_CONTEXT_FILENAME;
function setGeminiMdFilename(newFilename) {
if (Array.isArray(newFilename)) {
if (newFilename.length > 0) {
currentGeminiMdFilename = newFilename.map((name) => name.trim());
}
} else if (newFilename && newFilename.trim() !== "") {
currentGeminiMdFilename = newFilename.trim();
}
}
function getCurrentGeminiMdFilename() {
if (Array.isArray(currentGeminiMdFilename)) {
return currentGeminiMdFilename[0];
}
return currentGeminiMdFilename;
}
function getAllGeminiMdFilenames() {
if (Array.isArray(currentGeminiMdFilename)) {
return currentGeminiMdFilename;
}
return [currentGeminiMdFilename];
}
function getGlobalMemoryFilePath() {
return path7.join(Storage.getGlobalGeminiDir(), getCurrentGeminiMdFilename());
}
function getProjectMemoryIndexFilePath(storage) {
return path7.join(
storage.getProjectMemoryDir(),
PROJECT_MEMORY_INDEX_FILENAME
);
}
function ensureNewlineSeparation(currentContent) {
if (currentContent.length === 0) return "";
if (currentContent.endsWith("\n\n") || currentContent.endsWith("\r\n\r\n"))
return "";
if (currentContent.endsWith("\n") || currentContent.endsWith("\r\n"))
return "\n";
return "\n\n";
}
async function readMemoryFileContent(filePath) {
try {
return await fs8.readFile(filePath, "utf-8");
} catch (err) {
const error = err;
if (!(error instanceof Error) || error.code !== "ENOENT") throw err;
return "";
}
}
function sanitizeFact(fact) {
let processedText = fact.replace(/[\r\n]/g, " ").trim();
processedText = processedText.replace(/^(-+\s*)+/, "").trim();
processedText = processedText.replace(/[<>]/g, " ");
return processedText;
}
function computeGlobalMemoryContent(currentContent, fact) {
const processedText = sanitizeFact(fact);
const newMemoryItem = `- ${processedText}`;
const headerIndex = currentContent.indexOf(MEMORY_SECTION_HEADER);
if (headerIndex === -1) {
const separator = ensureNewlineSeparation(currentContent);
return currentContent + `${separator}${MEMORY_SECTION_HEADER}
${newMemoryItem}
`;
} else {
const startOfSectionContent = headerIndex + MEMORY_SECTION_HEADER.length;
let endOfSectionIndex = currentContent.indexOf(
"\n## ",
startOfSectionContent
);
if (endOfSectionIndex === -1) {
endOfSectionIndex = currentContent.length;
}
const beforeSectionMarker = currentContent.substring(0, startOfSectionContent).trimEnd();
let sectionContent = currentContent.substring(startOfSectionContent, endOfSectionIndex).trimEnd();
const afterSectionMarker = currentContent.substring(endOfSectionIndex);
sectionContent += `
${newMemoryItem}`;
return `${beforeSectionMarker}
${sectionContent.trimStart()}
${afterSectionMarker}`.trimEnd() + "\n";
}
}
function computeProjectMemoryContent(currentContent, fact) {
const processedText = sanitizeFact(fact);
const newMemoryItem = `- ${processedText}`;
if (currentContent.length === 0) {
return `${newMemoryItem}
`;
}
if (currentContent.endsWith("\n") || currentContent.endsWith("\r\n")) {
return `${currentContent}${newMemoryItem}
`;
}
return `${currentContent}
${newMemoryItem}
`;
}
function computeNewContent(currentContent, fact, scope) {
if (scope === "project") {
return computeProjectMemoryContent(currentContent, fact);
}
return computeGlobalMemoryContent(currentContent, fact);
}
var MemoryToolInvocation = class _MemoryToolInvocation extends BaseToolInvocation {
static allowlist = /* @__PURE__ */ new Set();
proposedNewContent;
storage;
constructor(params, messageBus, toolName, displayName, storage) {
super(params, messageBus, toolName, displayName);
this.storage = storage;
}
getMemoryFilePath() {
if (this.params.scope === "project" && this.storage) {
return getProjectMemoryIndexFilePath(this.storage);
}
return getGlobalMemoryFilePath();
}
getDescription() {
const memoryFilePath = this.getMemoryFilePath();
return `in ${tildeifyPath(memoryFilePath)}`;
}
async getConfirmationDetails(_abortSignal) {
const memoryFilePath = this.getMemoryFilePath();
const allowlistKey = memoryFilePath;
if (_MemoryToolInvocation.allowlist.has(allowlistKey)) {
return false;
}
const currentContent = await readMemoryFileContent(memoryFilePath);
const { fact, modified_by_user, modified_content } = this.params;
const contentForDiff = modified_by_user && modified_content !== void 0 ? modified_content : computeNewContent(currentContent, fact, this.params.scope);
this.proposedNewContent = contentForDiff;
const fileName = path7.basename(memoryFilePath);
const fileDiff = createPatch(
fileName,
currentContent,
this.proposedNewContent,
"Current",
"Proposed",
DEFAULT_DIFF_OPTIONS
);
const confirmationDetails = {
type: "edit",
title: `Confirm Memory Save: ${tildeifyPath(memoryFilePath)}`,
fileName: memoryFilePath,
filePath: memoryFilePath,
fileDiff,
originalContent: currentContent,
newContent: this.proposedNewContent,
onConfirm: async (outcome) => {
if (outcome === "proceed_always" /* ProceedAlways */) {
_MemoryToolInvocation.allowlist.add(allowlistKey);
}
}
};
return confirmationDetails;
}
async execute({ abortSignal: _signal }) {
const { fact, modified_by_user, modified_content } = this.params;
const memoryFilePath = this.getMemoryFilePath();
try {
let contentToWrite;
let successMessage;
const sanitizedFact = sanitizeFact(fact);
if (modified_by_user && modified_content !== void 0) {
contentToWrite = modified_content;
successMessage = `Okay, I've updated the memory file with your modifications.`;
} else {
if (this.proposedNewContent === void 0) {
const currentContent = await readMemoryFileContent(memoryFilePath);
this.proposedNewContent = computeNewContent(
currentContent,
fact,
this.params.scope
);
}
contentToWrite = this.proposedNewContent;
successMessage = `Okay, I've remembered that: "${sanitizedFact}"`;
}
await fs8.mkdir(path7.dirname(memoryFilePath), {
recursive: true
});
await fs8.writeFile(memoryFilePath, contentToWrite, "utf-8");
return {
llmContent: JSON.stringify({
success: true,
message: successMessage
}),
returnDisplay: successMessage
};
} catch (error) {
const errorMessage = error instanceof Error ? error.message : String(error);
return {
llmContent: JSON.stringify({
success: false,
error: `Failed to save memory. Detail: ${errorMessage}`
}),
returnDisplay: `Error saving memory: ${errorMessage}`,
error: {
message: errorMessage,
type: "memory_tool_execution_error" /* MEMORY_TOOL_EXECUTION_ERROR */
}
};
}
}
};
var MemoryTool = class _MemoryTool extends BaseDeclarativeTool {
static Name = MEMORY_TOOL_NAME;
storage;
constructor(messageBus, storage) {
super(
_MemoryTool.Name,
"SaveMemory",
MEMORY_DEFINITION.base.description,
"think" /* Think */,
MEMORY_DEFINITION.base.parametersJsonSchema,
messageBus,
true,
false
);
this.storage = storage;
}
resolveMemoryFilePath(params) {
if (params.scope === "project" && this.storage) {
return getProjectMemoryIndexFilePath(this.storage);
}
return getGlobalMemoryFilePath();
}
validateToolParamValues(params) {
if (params.fact.trim() === "") {
return 'Parameter "fact" must be a non-empty string.';
}
if (params.scope === "project" && !this.storage) {
return "Project-level memory is not available: storage is not initialized.";
}
return null;
}
createInvocation(params, messageBus, toolName, displayName) {
return new MemoryToolInvocation(
params,
messageBus,
toolName ?? this.name,
displayName ?? this.displayName,
this.storage
);
}
getSchema(modelId) {
return resolveToolDeclaration(MEMORY_DEFINITION, modelId);
}
getModifyContext(_abortSignal) {
return {
getFilePath: (params) => this.resolveMemoryFilePath(params),
getCurrentContent: async (params) => readMemoryFileContent(this.resolveMemoryFilePath(params)),
getProposedContent: async (params) => {
const filePath = this.resolveMemoryFilePath(params);
const currentContent = await readMemoryFileContent(filePath);
const { fact, modified_by_user, modified_content } = params;
return modified_by_user && modified_content !== void 0 ? modified_content : computeNewContent(currentContent, fact, params.scope);
},
createUpdatedParams: (_oldContent, modifiedProposedContent, originalParams) => ({
...originalParams,
modified_by_user: true,
modified_content: modifiedProposedContent
})
};
}
};
// packages/core/src/utils/memoryImportProcessor.ts
import * as fs9 from "node:fs/promises";
import * as path8 from "node:path";
var logger2 = {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
debug: (...args) => debugLogger.debug("[DEBUG] [ImportProcessor]", ...args),
// eslint-disable-next-line @typescript-eslint/no-explicit-any
warn: (...args) => debugLogger.warn("[WARN] [ImportProcessor]", ...args),
// eslint-disable-next-line @typescript-eslint/no-explicit-any
error: (...args) => debugLogger.error("[ERROR] [ImportProcessor]", ...args)
};
async function findProjectRoot(startDir, boundaryMarkers = [".git"]) {
if (boundaryMarkers.length === 0) {
return path8.resolve(startDir);
}
let currentDir = path8.resolve(startDir);
while (true) {
for (const marker of boundaryMarkers) {
if (path8.isAbsolute(marker) || marker.includes("..")) {
continue;
}
const markerPath = path8.join(currentDir, marker);
try {
await fs9.access(markerPath);
return currentDir;
} catch {
}
}
const parentDir = path8.dirname(currentDir);
if (parentDir === currentDir) {
break;
}
currentDir = parentDir;
}
return path8.resolve(startDir);
}
function hasMessage(err) {
return typeof err === "object" && err !== null && "message" in err && typeof err.message === "string";
}
function findImports(content) {
const imports = [];
let i = 0;
const len = content.length;
while (i < len) {
i = content.indexOf("@", i);
if (i === -1) break;
if (i > 0 && !isWhitespace(content[i - 1])) {
i++;
continue;
}
let j = i + 1;
while (j < len && !isWhitespace(content[j]) && content[j] !== "\n" && content[j] !== "\r") {
j++;
}
const importPath = content.slice(i + 1, j);
if (importPath.length > 0 && (importPath[0] === "." || importPath[0] === "/" || isLetter(importPath[0]))) {
imports.push({
start: i,
_end: j,
path: importPath
});
}
i = j + 1;
}
return imports;
}
function isWhitespace(char) {
return char === " " || char === " " || char === "\n" || char === "\r";
}
function isLetter(char) {
const code = char.charCodeAt(0);
return code >= 65 && code <= 90 || // A-Z
code >= 97 && code <= 122;
}
function findCodeRegions(content) {
const regions = [];
const regex = /(`+)([\s\S]*?)\1/g;
let match;
while ((match = regex.exec(content)) !== null) {
regions.push([match.index, match.index + match[0].length]);
}
return regions;
}
async function processImports(content, basePath, debugMode = false, importState = {
processedFiles: /* @__PURE__ */ new Set(),
maxDepth: 5,
currentDepth: 0
}, projectRoot, importFormat = "tree", boundaryMarkers = [".git"]) {
if (!projectRoot) {
projectRoot = await findProjectRoot(basePath, boundaryMarkers);
}
if (importState.currentDepth >= importState.maxDepth) {
if (debugMode) {
logger2.warn(
`Maximum import depth (${importState.maxDepth}) reached. Stopping import processing.`
);
}
return {
content,
importTree: { path: importState.currentFile || "unknown" }
};
}
if (importFormat === "flat") {
const flatFiles = [];
const processedFiles = /* @__PURE__ */ new Set();
async function processFlat(fileContent, fileBasePath, filePath, depth) {
const normalizedPath = path8.normalize(filePath);
if (processedFiles.has(normalizedPath)) return;
processedFiles.add(normalizedPath);
flatFiles.push({ path: normalizedPath, content: fileContent });
const codeRegions2 = findCodeRegions(fileContent);
const imports2 = findImports(fileContent);
for (let i = imports2.length - 1; i >= 0; i--) {
const { start, path: importPath } = imports2[i];
if (codeRegions2.some(
([regionStart, regionEnd]) => start >= regionStart && start < regionEnd
)) {
continue;
}
if (!validateImportPath(importPath, fileBasePath, [projectRoot || ""])) {
continue;
}
const fullPath = path8.resolve(fileBasePath, importPath);
const normalizedFullPath = path8.normalize(fullPath);
if (processedFiles.has(normalizedFullPath)) continue;
try {
await fs9.access(fullPath);
const importedContent = await fs9.readFile(fullPath, "utf-8");
await processFlat(
importedContent,
path8.dirname(fullPath),
normalizedFullPath,
depth + 1
);
} catch (error) {
if (debugMode) {
logger2.warn(
`Failed to import ${fullPath}: ${hasMessage(error) ? error.message : "Unknown error"}`
);
}
}
}
}
const rootPath = path8.normalize(
importState.currentFile || path8.resolve(basePath)
);
await processFlat(content, basePath, rootPath, 0);
const flatContent = flatFiles.map(
(f) => `--- File: ${f.path} ---
${f.content.trim()}
--- End of File: ${f.path} ---`
).join("\n\n");
return {
content: flatContent,
importTree: { path: rootPath }
// Tree not meaningful in flat mode
};
}
const codeRegions = findCodeRegions(content);
let result = "";
let lastIndex = 0;
const imports = [];
const importsList = findImports(content);
for (const { start, _end, path: importPath } of importsList) {
result += content.substring(lastIndex, start);
lastIndex = _end;
if (codeRegions.some(([s, e]) => start >= s && start < e)) {
result += `@${importPath}`;
continue;
}
if (!validateImportPath(importPath, basePath, [projectRoot || ""])) {
result += `<!-- Import failed: ${importPath} - Path traversal attempt -->`;
continue;
}
const fullPath = path8.resolve(basePath, importPath);
if (importState.processedFiles.has(fullPath)) {
result += `<!-- File already processed: ${importPath} -->`;
continue;
}
try {
await fs9.access(fullPath);
const fileContent = await fs9.readFile(fullPath, "utf-8");
const newImportState = {
...importState,
processedFiles: new Set(importState.processedFiles),
currentDepth: importState.currentDepth + 1,
currentFile: fullPath
};
newImportState.processedFiles.add(fullPath);
const imported = await processImports(
fileContent,
path8.dirname(fullPath),
debugMode,
newImportState,
projectRoot,
importFormat,
boundaryMarkers
);
result += `<!-- Imported from: ${importPath} -->
${imported.content}
<!-- End of import from: ${importPath} -->`;
imports.push(imported.importTree);
} catch (err) {
let message = "Unknown error";
if (hasMessage(err)) {
message = err.message;
} else if (typeof err === "string") {
message = err;
}
logger2.error(`Failed to import ${importPath}: ${message}`);
result += `<!-- Import failed: ${importPath} - ${message} -->`;
}
}
result += content.substring(lastIndex);
return {
content: result,
importTree: {
path: importState.currentFile || "unknown",
imports: imports.length > 0 ? imports : void 0
}
};
}
function validateImportPath(importPath, basePath, allowedDirectories) {
if (/^(file|https?):\/\//.test(importPath)) {
return false;
}
const resolvedPath = path8.resolve(basePath, importPath);
return allowedDirectories.some(
(allowedDir) => isSubpath(allowedDir, resolvedPath)
);
}
// packages/core/src/config/constants.ts
var DEFAULT_MEMORY_FILE_FILTERING_OPTIONS = {
respectGitIgnore: false,
respectGeminiIgnore: true,
enableFileWatcher: false,
maxFileCount: 2e4,
searchTimeout: 5e3,
customIgnoreFilePaths: []
};
var DEFAULT_FILE_FILTERING_OPTIONS = {
respectGitIgnore: true,
respectGeminiIgnore: true,
enableFileWatcher: false,
maxFileCount: 2e4,
searchTimeout: 5e3,
customIgnoreFilePaths: []
};
var GEMINI_IGNORE_FILE_NAME = ".geminiignore";
var INTEGRITY_FILENAME = "extension_integrity.json";
var INTEGRITY_KEY_FILENAME = "integrity.key";
var KEYCHAIN_SERVICE_NAME = "gemini-cli-extension-integrity";
var SECRET_KEY_ACCOUNT = "secret-key";
// packages/core/src/utils/events.ts
import { EventEmitter } from "node:events";
var CoreEvent = /* @__PURE__ */ ((CoreEvent2) => {
CoreEvent2["UserFeedback"] = "user-feedback";
CoreEvent2["ModelChanged"] = "model-changed";
CoreEvent2["ApprovalModeChanged"] = "approval-mode-changed";
CoreEvent2["ConsoleLog"] = "console-log";
CoreEvent2["Output"] = "output";
CoreEvent2["MemoryChanged"] = "memory-changed";
CoreEvent2["ExternalEditorClosed"] = "external-editor-closed";
CoreEvent2["McpClientUpdate"] = "mcp-client-update";
CoreEvent2["OauthDisplayMessage"] = "oauth-display-message";
CoreEvent2["SettingsChanged"] = "settings-changed";
CoreEvent2["HookStart"] = "hook-start";
CoreEvent2["HookEnd"] = "hook-end";
CoreEvent2["HookSystemMessage"] = "hook-system-message";
CoreEvent2["AgentsRefreshed"] = "agents-refreshed";
CoreEvent2["AdminSettingsChanged"] = "admin-settings-changed";
CoreEvent2["RetryAttempt"] = "retry-attempt";
CoreEvent2["ConsentRequest"] = "consent-request";
CoreEvent2["McpProgress"] = "mcp-progress";
CoreEvent2["AgentsDiscovered"] = "agents-discovered";
CoreEvent2["RequestEditorSelection"] = "request-editor-selection";
CoreEvent2["EditorSelected"] = "editor-selected";
CoreEvent2["SlashCommandConflicts"] = "slash-command-conflicts";
CoreEvent2["QuotaChanged"] = "quota-changed";
CoreEvent2["TelemetryKeychainAvailability"] = "telemetry-keychain-availability";
CoreEvent2["TelemetryTokenStorageType"] = "telemetry-token-storage-type";
return CoreEvent2;
})(CoreEvent || {});
var CoreEventEmitter = class _CoreEventEmitter extends EventEmitter {
_eventBacklog = [];
_backlogHead = 0;
static MAX_BACKLOG_SIZE = 1e4;
constructor() {
super();
}
_emitOrQueue(event, ...args) {
if (this.listenerCount(event) === 0) {
const backlogSize = this._eventBacklog.length - this._backlogHead;
if (backlogSize >= _CoreEventEmitter.MAX_BACKLOG_SIZE) {
this._eventBacklog[this._backlogHead] = void 0;
this._backlogHead++;
if (this._backlogHead >= _CoreEventEmitter.MAX_BACKLOG_SIZE / 2) {
this._eventBacklog = this._eventBacklog.slice(this._backlogHead);
this._backlogHead = 0;
}
}
this._eventBacklog.push({ event, args });
} else {
this.emit(
event,
...args
);
}
}
/**
* Sends actionable feedback to the user.
* Buffers automatically if the UI hasn't subscribed yet.
*/
emitFeedback(severity, message, error) {
const payload = { severity, message, error };
this._emitOrQueue("user-feedback" /* UserFeedback */, payload);
}
/**
* Broadcasts a console log message.
*/
emitConsoleLog(type, content) {
const payload = { type, content };
this._emitOrQueue("console-log" /* ConsoleLog */, payload);
}
/**
* Broadcasts stdout/stderr output.
*/
emitOutput(isStderr, chunk, encoding) {
const payload = { isStderr, chunk, encoding };
this._emitOrQueue("output" /* Output */, payload);
}
/**
* Notifies subscribers that the model has changed.
*/
emitModelChanged(model) {
const payload = { model };
this.emit("model-changed" /* ModelChanged */, payload);
}
/**
* Notifies subscribers that the approval mode has changed.
*/
emitApprovalModeChanged(sessionId, mode) {
const payload = { sessionId, mode };
this.emit("approval-mode-changed" /* ApprovalModeChanged */, payload);
}
/**
* Notifies subscribers that settings have been modified.
*/
emitSettingsChanged() {
this.emit("settings-changed" /* SettingsChanged */);
}
/**
* Notifies subscribers that a hook execution has started.
*/
emitHookStart(payload) {
this.emit("hook-start" /* HookStart */, payload);
}
/**
* Notifies subscribers that a hook execution has ended.
*/
emitHookEnd(payload) {
this.emit("hook-end" /* HookEnd */, payload);
}
/**
* Notifies subscribers that a hook has provided a system message.
*/
emitHookSystemMessage(payload) {
this.emit("hook-system-message" /* HookSystemMessage */, payload);
}
/**
* Notifies subscribers that agents have been refreshed.
*/
emitAgentsRefreshed() {
this.emit("agents-refreshed" /* AgentsRefreshed */);
}
/**
* Notifies subscribers that admin settings have changed.
*/
emitAdminSettingsChanged() {
this.emit("admin-settings-changed" /* AdminSettingsChanged */);
}
/**
* Notifies subscribers that a retry attempt is happening.
*/
emitRetryAttempt(payload) {
this.emit("retry-attempt" /* RetryAttempt */, payload);
}
/**
* Requests consent from the user via the UI.
*/
emitConsentRequest(payload) {
this._emitOrQueue("consent-request" /* ConsentRequest */, payload);
}
/**
* Notifies subscribers that progress has been made on an MCP tool call.
*/
emitMcpProgress(payload) {
if (!Number.isFinite(payload.progress) || payload.progress < 0) {
debugLogger.log(`Invalid progress value: ${payload.progress}`);
return;
}
this.emit("mcp-progress" /* McpProgress */, payload);
}
/**
* Notifies subscribers that new unacknowledged agents have been discovered.
*/
emitAgentsDiscovered(agents) {
const payload = { agents };
this._emitOrQueue("agents-discovered" /* AgentsDiscovered */, payload);
}
emitSlashCommandConflicts(conflicts) {
const payload = { conflicts };
this._emitOrQueue("slash-command-conflicts" /* SlashCommandConflicts */, payload);
}
/**
* Notifies subscribers that the quota has changed.
*/
emitQuotaChanged(remaining, limit, resetTime) {
const payload = { remaining, limit, resetTime };
this.emit("quota-changed" /* QuotaChanged */, payload);
}
/**
* Flushes buffered messages. Call this immediately after primary UI listener
* subscribes.
*
* @param transform - Optional function to transform events before they are emitted.
*/
drainBacklogs(transform) {
const backlog = this._eventBacklog;
const head = this._backlogHead;
this._eventBacklog = [];
this._backlogHead = 0;
for (let i = head; i < backlog.length; i++) {
const item = backlog[i];
if (item === void 0) continue;
let eventToEmit = item.event;
let argsToEmit = item.args;
if (transform) {
const transformed = transform(item.event, item.args);
if (!transformed) continue;
eventToEmit = transformed.event;
argsToEmit = transformed.args;
}
this.emit(
eventToEmit,
...argsToEmit
);
}
}
emitTelemetryKeychainAvailability(event) {
this._emitOrQueue("telemetry-keychain-availability" /* TelemetryKeychainAvailability */, event);
}
emitTelemetryTokenStorageType(event) {
this._emitOrQueue("telemetry-token-storage-type" /* TelemetryTokenStorageType */, event);
}
};
var coreEvents = new CoreEventEmitter();
// packages/core/src/utils/memoryDiscovery.ts
var logger3 = {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
debug: (...args) => debugLogger.debug("[DEBUG] [MemoryDiscovery]", ...args),
// eslint-disable-next-line @typescript-eslint/no-explicit-any
warn: (...args) => debugLogger.warn("[WARN] [MemoryDiscovery]", ...args),
// eslint-disable-next-line @typescript-eslint/no-explicit-any
error: (...args) => debugLogger.error("[ERROR] [MemoryDiscovery]", ...args)
};
async function deduplicatePathsByFileIdentity(filePaths) {
if (filePaths.length === 0) {
return {
paths: [],
identityMap: /* @__PURE__ */ new Map()
};
}
const uniqueFilePaths = Array.from(new Set(filePaths));
const fileIdentityMap = /* @__PURE__ */ new Map();
const deduplicatedPaths = [];
const CONCURRENT_LIMIT = 20;
const results = [];
for (let i = 0; i < uniqueFilePaths.length; i += CONCURRENT_LIMIT) {
const batch = uniqueFilePaths.slice(i, i + CONCURRENT_LIMIT);
const batchPromises = batch.map(async (filePath) => {
try {
const stats = await fs10.stat(filePath);
return {
path: filePath,
dev: stats.dev,
ino: stats.ino
};
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
logger3.debug(
`could not stat file for deduplication: ${filePath}. error: ${message}`
);
return {
path: filePath,
dev: null,
ino: null
};
}
});
const batchResults = await Promise.allSettled(batchPromises);
for (const result of batchResults) {
if (result.status === "fulfilled") {
results.push(result.value);
} else {
const message = getErrorMessage(result.reason);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] unexpected error during deduplication stat:",
message
);
}
}
}
const pathToIdentityMap = /* @__PURE__ */ new Map();
for (const { path: path10, dev, ino } of results) {
if (dev !== null && ino !== null) {
const identityKey = `${dev.toString()}:${ino.toString()}`;
pathToIdentityMap.set(path10, identityKey);
if (!fileIdentityMap.has(identityKey)) {
fileIdentityMap.set(identityKey, path10);
deduplicatedPaths.push(path10);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] deduplication: keeping",
path10,
`(dev: ${dev}, ino: ${ino})`
);
} else {
const existingPath = fileIdentityMap.get(identityKey);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] deduplication: skipping",
path10,
`(same file as ${existingPath})`
);
}
} else {
deduplicatedPaths.push(path10);
}
}
return {
paths: deduplicatedPaths,
identityMap: pathToIdentityMap
};
}
async function findProjectRoot2(startDir, boundaryMarkers = [".git"]) {
if (boundaryMarkers.length === 0) {
return null;
}
let currentDir = toAbsolutePath(startDir);
while (true) {
for (const marker of boundaryMarkers) {
if (path9.isAbsolute(marker) || marker.includes("..")) {
continue;
}
const markerPath = path9.join(currentDir, marker);
try {
await fs10.access(markerPath);
return currentDir;
} catch (error) {
const isENOENT = typeof error === "object" && error !== null && "code" in error && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
error.code === "ENOENT";
const isTestEnv = process.env["VITEST"];
if (!isENOENT && !isTestEnv) {
if (typeof error === "object" && error !== null && "code" in error) {
const fsError = error;
logger3.warn(
`Error checking for ${marker} at ${markerPath}: ${fsError.message}`
);
} else {
logger3.warn(
`Non-standard error checking for ${marker} at ${markerPath}: ${String(error)}`
);
}
}
}
}
const parentDir = path9.dirname(currentDir);
if (parentDir === currentDir) {
return null;
}
currentDir = parentDir;
}
}
async function getGeminiMdFilePathsInternal(currentWorkingDirectory, includeDirectoriesToReadGemini, userHomePath, fileService, folderTrust, fileFilteringOptions, maxDirs, boundaryMarkers = [".git"]) {
const dirs = /* @__PURE__ */ new Set([
...includeDirectoriesToReadGemini,
currentWorkingDirectory
]);
const CONCURRENT_LIMIT = 10;
const dirsArray = Array.from(dirs);
const globalPaths = /* @__PURE__ */ new Set();
const projectPaths = /* @__PURE__ */ new Set();
for (let i = 0; i < dirsArray.length; i += CONCURRENT_LIMIT) {
const batch = dirsArray.slice(i, i + CONCURRENT_LIMIT);
const batchPromises = batch.map(
(dir) => getGeminiMdFilePathsInternalForEachDir(
dir,
userHomePath,
fileService,
folderTrust,
fileFilteringOptions,
maxDirs,
boundaryMarkers
)
);
const batchResults = await Promise.allSettled(batchPromises);
for (const result of batchResults) {
if (result.status === "fulfilled") {
result.value.global.forEach((p) => globalPaths.add(p));
result.value.project.forEach((p) => projectPaths.add(p));
} else {
const error = result.reason;
const message = error instanceof Error ? error.message : String(error);
logger3.error(`Error discovering files in directory: ${message}`);
}
}
}
return {
global: Array.from(globalPaths),
project: Array.from(projectPaths)
};
}
async function getGeminiMdFilePathsInternalForEachDir(dir, userHomePath, fileService, folderTrust, fileFilteringOptions, maxDirs, boundaryMarkers = [".git"]) {
const globalPaths = /* @__PURE__ */ new Set();
const projectPaths = /* @__PURE__ */ new Set();
const geminiMdFilenames = getAllGeminiMdFilenames();
for (const geminiMdFilename of geminiMdFilenames) {
const resolvedHome = toAbsolutePath(userHomePath);
const globalGeminiDir = toAbsolutePath(path9.join(resolvedHome, GEMINI_DIR));
const globalMemoryPath = toAbsolutePath(
path9.join(globalGeminiDir, geminiMdFilename)
);
const globalMemoryKey = normalizePath(globalMemoryPath);
const globalGeminiDirKey = normalizePath(globalGeminiDir);
try {
await fs10.access(globalMemoryPath, fsSync2.constants.R_OK);
globalPaths.add(globalMemoryPath);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Found readable global",
geminiMdFilename + ":",
globalMemoryPath
);
} catch {
}
if (dir && folderTrust) {
const resolvedCwd = toAbsolutePath(dir);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Searching for",
geminiMdFilename,
"starting from CWD:",
resolvedCwd
);
const projectRoot = await findProjectRoot2(resolvedCwd, boundaryMarkers);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Determined project root:",
projectRoot ?? "None"
);
const upwardPaths = [];
let currentDir = resolvedCwd;
const ultimateStopDirKey = projectRoot ? normalizePath(path9.dirname(projectRoot)) : normalizePath(path9.dirname(resolvedHome));
while (currentDir && currentDir !== path9.dirname(currentDir)) {
if (normalizePath(currentDir) === globalGeminiDirKey) {
break;
}
const potentialPath = toAbsolutePath(
path9.join(currentDir, geminiMdFilename)
);
try {
await fs10.access(potentialPath, fsSync2.constants.R_OK);
if (normalizePath(potentialPath) !== globalMemoryKey) {
upwardPaths.unshift(potentialPath);
}
} catch {
}
if (normalizePath(currentDir) === ultimateStopDirKey) {
break;
}
currentDir = path9.dirname(currentDir);
}
upwardPaths.forEach((p) => projectPaths.add(p));
const mergedOptions = {
...DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
...fileFilteringOptions
};
const downwardPaths = await bfsFileSearch(resolvedCwd, {
fileName: geminiMdFilename,
maxDirs,
fileService,
fileFilteringOptions: mergedOptions
});
downwardPaths.sort();
for (const dPath of downwardPaths) {
projectPaths.add(toAbsolutePath(dPath));
}
}
}
return {
global: Array.from(globalPaths),
project: Array.from(projectPaths)
};
}
async function readGeminiMdFiles(filePaths, importFormat = "tree", boundaryMarkers = [".git"]) {
const CONCURRENT_LIMIT = 20;
const results = [];
for (let i = 0; i < filePaths.length; i += CONCURRENT_LIMIT) {
const batch = filePaths.slice(i, i + CONCURRENT_LIMIT);
const batchPromises = batch.map(
async (filePath) => {
try {
const content = await fs10.readFile(filePath, "utf-8");
const processedResult = await processImports(
content,
path9.dirname(filePath),
false,
void 0,
void 0,
importFormat,
boundaryMarkers
);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Successfully read and processed imports:",
filePath,
`(Length: ${processedResult.content.length})`
);
return { filePath, content: processedResult.content };
} catch (error) {
const isEISDIR = error instanceof Error && error.code === "EISDIR";
if (isEISDIR) {
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Skipping directory at GEMINI.md path:",
filePath
);
} else {
const isTestEnv = process.env["VITEST"];
if (!isTestEnv) {
const message = error instanceof Error ? error.message : String(error);
logger3.warn(
`Warning: Could not read ${getAllGeminiMdFilenames()} file at ${filePath}. Error: ${message}`
);
}
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Failed to read:",
filePath
);
}
return { filePath, content: null };
}
}
);
const batchResults = await Promise.allSettled(batchPromises);
for (const result of batchResults) {
if (result.status === "fulfilled") {
results.push(result.value);
} else {
const error = result.reason;
const message = error instanceof Error ? error.message : String(error);
logger3.error(`Unexpected error processing file: ${message}`);
}
}
}
return results;
}
function concatenateInstructions(instructionContents) {
return instructionContents.filter((item) => typeof item.content === "string").map((item) => {
const trimmedContent = item.content.trim();
if (trimmedContent.length === 0) {
return null;
}
return `--- Context from: ${item.filePath} ---
${trimmedContent}
--- End of Context from: ${item.filePath} ---`;
}).filter((block) => block !== null).join("\n\n");
}
async function getGlobalMemoryPaths() {
const userHome = homedir();
const geminiMdFilenames = getAllGeminiMdFilenames();
const accessChecks = geminiMdFilenames.map(async (filename) => {
const globalPath = toAbsolutePath(
path9.join(userHome, GEMINI_DIR, filename)
);
try {
await fs10.access(globalPath, fsSync2.constants.R_OK);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Found global memory file:",
globalPath
);
return globalPath;
} catch {
return null;
}
});
return (await Promise.all(accessChecks)).filter(
(p) => p !== null
);
}
async function getUserProjectMemoryPaths(projectMemoryDir) {
const preferredMemoryPath = toAbsolutePath(
path9.join(projectMemoryDir, PROJECT_MEMORY_INDEX_FILENAME)
);
try {
await fs10.access(preferredMemoryPath, fsSync2.constants.R_OK);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Found user project memory index:",
preferredMemoryPath
);
return [preferredMemoryPath];
} catch {
}
const geminiMdFilenames = getAllGeminiMdFilenames();
const accessChecks = geminiMdFilenames.map(async (filename) => {
const legacyMemoryPath = toAbsolutePath(
path9.join(projectMemoryDir, filename)
);
try {
await fs10.access(legacyMemoryPath, fsSync2.constants.R_OK);
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Found legacy user project memory file:",
legacyMemoryPath
);
return legacyMemoryPath;
} catch {
return null;
}
});
return (await Promise.all(accessChecks)).filter(
(p) => p !== null
);
}
function getExtensionMemoryPaths(extensionLoader) {
const extensionPaths = extensionLoader.getExtensions().filter((ext) => ext.isActive).flatMap((ext) => ext.contextFiles).map((p) => toAbsolutePath(p));
const seenKeys = /* @__PURE__ */ new Set();
const unique = [];
for (const p of extensionPaths) {
const key = normalizePath(p);
if (seenKeys.has(key)) continue;
seenKeys.add(key);
unique.push(p);
}
return unique.sort();
}
async function getEnvironmentMemoryPaths(trustedRoots, boundaryMarkers = [".git"]) {
const traversalPromises = trustedRoots.map(async (root) => {
const resolvedRoot = toAbsolutePath(root);
const gitRoot = await findProjectRoot2(resolvedRoot, boundaryMarkers);
const ceiling = gitRoot ?? resolvedRoot;
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Loading environment memory for trusted root:",
resolvedRoot,
"(Stopping at",
gitRoot ? `git root: ${ceiling})` : `trusted root: ${ceiling} \u2014 no git root found)`
);
return findUpwardGeminiFiles(resolvedRoot, ceiling);
});
const pathArrays = await Promise.all(traversalPromises);
const { paths: unique } = await deduplicatePathsByFileIdentity(
pathArrays.flat()
);
return unique.sort();
}
function categorizeAndConcatenate(paths, contentsMap) {
const getConcatenated = (pList) => concatenateInstructions(
pList.map((p) => contentsMap.get(p)).filter((c) => !!c)
);
return {
global: getConcatenated(paths.global),
extension: getConcatenated(paths.extension),
project: getConcatenated(paths.project),
userProjectMemory: getConcatenated(paths.userProjectMemory ?? [])
};
}
async function findUpwardGeminiFiles(startDir, stopDir) {
const upwardPaths = [];
let currentDir = toAbsolutePath(startDir);
const resolvedStopDirKey = normalizePath(stopDir);
const geminiMdFilenames = getAllGeminiMdFilenames();
const globalGeminiDirKey = normalizePath(path9.join(homedir(), GEMINI_DIR));
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Starting upward search from",
currentDir,
"stopping at",
stopDir
);
while (true) {
if (normalizePath(currentDir) === globalGeminiDirKey) {
break;
}
const accessChecks = geminiMdFilenames.map(async (filename) => {
const potentialPath = toAbsolutePath(path9.join(currentDir, filename));
try {
await fs10.access(potentialPath, fsSync2.constants.R_OK);
return potentialPath;
} catch {
return null;
}
});
const foundPathsInDir = (await Promise.all(accessChecks)).filter(
(p) => p !== null
);
upwardPaths.unshift(...foundPathsInDir);
const parentDir = path9.dirname(currentDir);
const currentKey = normalizePath(currentDir);
if (currentKey === resolvedStopDirKey || currentDir === parentDir) {
break;
}
currentDir = parentDir;
}
return upwardPaths;
}
async function loadServerHierarchicalMemory(currentWorkingDirectory, includeDirectoriesToReadGemini, fileService, extensionLoader, folderTrust, importFormat = "tree", fileFilteringOptions, maxDirs = 200, boundaryMarkers = [".git"]) {
const realCwd = normalizePath(
await fs10.realpath(path9.resolve(currentWorkingDirectory))
);
const realHome = normalizePath(await fs10.realpath(path9.resolve(homedir())));
const isHomeDirectory = realCwd === realHome;
currentWorkingDirectory = isHomeDirectory ? "" : currentWorkingDirectory;
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Loading server hierarchical memory for CWD:",
currentWorkingDirectory,
`(importFormat: ${importFormat})`
);
const userHomePath = homedir();
const [discoveryResult, extensionPaths] = await Promise.all([
getGeminiMdFilePathsInternal(
currentWorkingDirectory,
includeDirectoriesToReadGemini,
userHomePath,
fileService,
folderTrust,
fileFilteringOptions || DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
maxDirs,
boundaryMarkers
),
Promise.resolve(getExtensionMemoryPaths(extensionLoader))
]);
const allFilePathsStringDeduped = Array.from(
/* @__PURE__ */ new Set([
...discoveryResult.global,
...discoveryResult.project,
...extensionPaths
])
);
if (allFilePathsStringDeduped.length === 0) {
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] No GEMINI.md files found in hierarchy of the workspace."
);
return {
memoryContent: { global: "", extension: "", project: "" },
fileCount: 0,
filePaths: []
};
}
const { paths: allFilePaths } = await deduplicatePathsByFileIdentity(
allFilePathsStringDeduped
);
if (allFilePaths.length === 0) {
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] No unique GEMINI.md files found after deduplication by file identity."
);
return {
memoryContent: { global: "", extension: "", project: "" },
fileCount: 0,
filePaths: []
};
}
const allContents = await readGeminiMdFiles(
allFilePaths,
importFormat,
boundaryMarkers
);
const contentsMap = new Map(allContents.map((c) => [c.filePath, c]));
const hierarchicalMemory = categorizeAndConcatenate(
{
global: discoveryResult.global,
extension: extensionPaths,
project: discoveryResult.project
},
contentsMap
);
return {
memoryContent: hierarchicalMemory,
fileCount: allContents.filter((c) => c.content !== null).length,
filePaths: allFilePaths
};
}
async function refreshServerHierarchicalMemory(config) {
const result = await loadServerHierarchicalMemory(
config.getWorkingDir(),
config.shouldLoadMemoryFromIncludeDirectories() ? config.getWorkspaceContext().getDirectories() : [],
config.getFileService(),
config.getExtensionLoader(),
config.isTrustedFolder(),
config.getImportFormat(),
config.getFileFilteringOptions(),
config.getDiscoveryMaxDirs(),
config.getMemoryBoundaryMarkers()
);
const mcpInstructions = config.getMcpClientManager()?.getMcpInstructions() || "";
const finalMemory = {
...result.memoryContent,
project: [result.memoryContent.project, mcpInstructions.trimStart()].filter(Boolean).join("\n\n")
};
config.setUserMemory(finalMemory);
config.setGeminiMdFileCount(result.fileCount);
config.setGeminiMdFilePaths(result.filePaths);
coreEvents.emit("memory-changed" /* MemoryChanged */, { fileCount: result.fileCount });
return result;
}
async function loadJitSubdirectoryMemory(targetPath, trustedRoots, alreadyLoadedPaths, alreadyLoadedIdentities, boundaryMarkers = [".git"]) {
const resolvedTarget = toAbsolutePath(targetPath);
let bestRoot = null;
let bestRootKeyLength = -1;
for (const root of trustedRoots) {
if (isSubpath(root, targetPath)) {
const resolvedRoot = toAbsolutePath(root);
const rootKeyLength = normalizePath(resolvedRoot).length;
if (rootKeyLength > bestRootKeyLength) {
bestRoot = resolvedRoot;
bestRootKeyLength = rootKeyLength;
}
}
}
if (!bestRoot) {
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] JIT memory skipped:",
resolvedTarget,
"is not in any trusted root."
);
return { files: [], fileIdentities: [] };
}
const gitRoot = await findProjectRoot2(bestRoot, boundaryMarkers);
const resolvedCeiling = gitRoot ?? bestRoot;
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Loading JIT memory for",
resolvedTarget,
`(Trusted root: ${bestRoot}, Ceiling: ${resolvedCeiling}${gitRoot ? " [git root]" : " [trusted root, no git]"})`
);
let startDir = resolvedTarget;
try {
const stat3 = await fs10.stat(resolvedTarget);
if (stat3.isFile()) {
startDir = path9.dirname(resolvedTarget);
}
} catch {
startDir = path9.dirname(resolvedTarget);
}
const potentialPaths = await findUpwardGeminiFiles(startDir, resolvedCeiling);
if (potentialPaths.length === 0) {
return { files: [], fileIdentities: [] };
}
const { paths: deduplicatedNewPaths, identityMap: newPathsIdentityMap } = await deduplicatePathsByFileIdentity(potentialPaths);
const cachedIdentities = alreadyLoadedIdentities ?? /* @__PURE__ */ new Set();
if (!alreadyLoadedIdentities && alreadyLoadedPaths.size > 0) {
const CONCURRENT_LIMIT = 20;
const alreadyLoadedArray = Array.from(alreadyLoadedPaths);
for (let i = 0; i < alreadyLoadedArray.length; i += CONCURRENT_LIMIT) {
const batch = alreadyLoadedArray.slice(i, i + CONCURRENT_LIMIT);
const batchPromises = batch.map(async (filePath) => {
try {
const stats = await fs10.stat(filePath);
const identityKey = `${stats.dev.toString()}:${stats.ino.toString()}`;
cachedIdentities.add(identityKey);
} catch {
}
});
await Promise.allSettled(batchPromises);
}
}
const newPaths = [];
const newFileIdentities = [];
for (const filePath of deduplicatedNewPaths) {
const identityKey = newPathsIdentityMap.get(filePath);
if (identityKey && cachedIdentities.has(identityKey)) {
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] jit memory: skipping",
filePath,
"(already loaded with different case)"
);
continue;
}
newPaths.push(filePath);
if (identityKey) {
newFileIdentities.push(identityKey);
}
}
if (newPaths.length === 0) {
return { files: [], fileIdentities: [] };
}
debugLogger.debug(
"[DEBUG] [MemoryDiscovery] Found new JIT memory files:",
JSON.stringify(newPaths)
);
const contents = await readGeminiMdFiles(newPaths, "tree", boundaryMarkers);
return {
files: contents.filter((item) => item.content !== null).map((item) => ({
path: item.filePath,
// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
content: item.content
})),
fileIdentities: newFileIdentities
};
}
export {
external_exports,
debugLogger,
ToolErrorType,
isFatalToolError,
require_fast_deep_equal,
require_fast_uri,
require_dist,
SchemaValidator,
jsonToMarkdown,
safeJsonToMarkdown,
isRecord,
require_extend,
require_json_bigint,
require_base64_js,
require_safe_buffer,
require_ecdsa_sig_formatter,
require_jws,
Type,
ThinkingLevel,
FinishReason,
Environment,
FunctionCallingConfigMode,
createUserContent,
GenerateContentResponse,
EmbedContentResponse,
ApiError,
GoogleGenAI,
PolicyDecision,
getHookSource,
ApprovalMode,
MODES_BY_PERMISSIVENESS,
InProcessCheckerType,
PRIORITY_SUBAGENT_TOOL,
ALWAYS_ALLOW_PRIORITY_FRACTION,
ALWAYS_ALLOW_PRIORITY_OFFSET,
PRIORITY_YOLO_ALLOW_ALL,
MessageBusType,
QuestionType,
isBackgroundExecutionData,
BaseToolInvocation,
DeclarativeTool,
BaseDeclarativeTool,
isTool,
hasCycleInSchema,
isStructuredToolResult,
hasSummary,
isGrepResult,
isListResult,
isReadManyFilesResult,
isFileDiff,
ToolConfirmationOutcome,
Kind,
MUTATOR_KINDS,
READ_ONLY_KINDS,
GEMINI_DIR,
GOOGLE_ACCOUNTS_FILENAME,
TRUSTED_FOLDERS_FILENAME,
homedir,
tmpdir,
tildeifyPath,
shortenPath,
makeRelative,
escapePath,
unescapePath,
getProjectHash,
toAbsolutePath,
normalizePath,
isSubpath,
isValidPathString,
assertValidPathString,
resolveToRealPath,
deduplicateAbsolutePaths,
toPathKey,
require_proper_lockfile,
parseGoogleApiError,
isNodeError,
isAbortError,
getErrorMessage,
getErrorType,
FatalError,
FatalAuthenticationError,
FatalInputError,
FatalSandboxError,
FatalConfigError,
FatalTurnLimitedError,
FatalToolExecutionError,
FatalUntrustedWorkspaceError,
FatalCancellationError,
CanceledError,
ForbiddenError,
AccountSuspendedError,
UnauthorizedError,
BadRequestError,
ChangeAuthRequestedError,
toFriendlyError,
isAccountSuspendedError,
isAuthenticationError,
OAUTH_FILE,
Storage,
diffLines,
parsePatch,
applyPatch,
createPatch,
DEFAULT_DIFF_OPTIONS,
getDiffStat,
getDiffStatFromPatch,
PREVIEW_GEMINI_MODEL,
PREVIEW_GEMINI_3_1_MODEL,
PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL,
PREVIEW_GEMINI_FLASH_MODEL,
PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL,
DEFAULT_GEMINI_MODEL,
DEFAULT_GEMINI_FLASH_MODEL,
DEFAULT_GEMINI_FLASH_LITE_MODEL,
GEMMA_4_31B_IT_MODEL,
GEMMA_4_26B_A4B_IT_MODEL,
VALID_GEMINI_MODELS,
PREVIEW_GEMINI_MODEL_AUTO,
DEFAULT_GEMINI_MODEL_AUTO,
GEMINI_MODEL_ALIAS_AUTO,
GEMINI_MODEL_ALIAS_PRO,
GEMINI_MODEL_ALIAS_FLASH,
GEMINI_MODEL_ALIAS_FLASH_LITE,
DEFAULT_GEMINI_EMBEDDING_MODEL,
DEFAULT_THINKING_MODE,
resolveModel,
resolveClassifierModel,
getDisplayString,
isPreviewModel,
isProModel,
isGemini3Model,
isGemini2Model,
isCustomModel,
supportsModernFeatures,
isAutoModel,
supportsMultimodalFunctionResponse,
isActiveModel,
PARAM_FILE_PATH,
PARAM_DIR_PATH,
PARAM_PATTERN,
PARAM_CASE_SENSITIVE,
PARAM_RESPECT_GIT_IGNORE,
PARAM_RESPECT_GEMINI_IGNORE,
PARAM_FILE_FILTERING_OPTIONS,
PARAM_DESCRIPTION,
GLOB_TOOL_NAME,
GREP_TOOL_NAME,
GREP_PARAM_INCLUDE_PATTERN,
GREP_PARAM_EXCLUDE_PATTERN,
GREP_PARAM_NAMES_ONLY,
GREP_PARAM_MAX_MATCHES_PER_FILE,
GREP_PARAM_TOTAL_MAX_MATCHES,
GREP_PARAM_FIXED_STRINGS,
GREP_PARAM_CONTEXT,
GREP_PARAM_AFTER,
GREP_PARAM_BEFORE,
GREP_PARAM_NO_IGNORE,
LS_TOOL_NAME,
LS_PARAM_IGNORE,
READ_FILE_TOOL_NAME,
READ_FILE_PARAM_START_LINE,
READ_FILE_PARAM_END_LINE,
SHELL_TOOL_NAME,
SHELL_PARAM_COMMAND,
SHELL_PARAM_IS_BACKGROUND,
WRITE_FILE_TOOL_NAME,
WRITE_FILE_PARAM_CONTENT,
EDIT_TOOL_NAME,
EDIT_PARAM_INSTRUCTION,
EDIT_PARAM_OLD_STRING,
EDIT_PARAM_NEW_STRING,
EDIT_PARAM_ALLOW_MULTIPLE,
WEB_SEARCH_TOOL_NAME,
WEB_SEARCH_PARAM_QUERY,
WRITE_TODOS_TOOL_NAME,
TODOS_PARAM_TODOS,
TODOS_ITEM_PARAM_DESCRIPTION,
TODOS_ITEM_PARAM_STATUS,
WEB_FETCH_TOOL_NAME,
WEB_FETCH_PARAM_PROMPT,
READ_MANY_FILES_TOOL_NAME,
READ_MANY_PARAM_INCLUDE,
READ_MANY_PARAM_EXCLUDE,
READ_MANY_PARAM_RECURSIVE,
READ_MANY_PARAM_USE_DEFAULT_EXCLUDES,
MEMORY_TOOL_NAME,
MEMORY_PARAM_FACT,
GET_INTERNAL_DOCS_TOOL_NAME,
DOCS_PARAM_PATH,
ACTIVATE_SKILL_TOOL_NAME,
SKILL_PARAM_NAME,
ASK_USER_TOOL_NAME,
ASK_USER_PARAM_QUESTIONS,
ASK_USER_QUESTION_PARAM_QUESTION,
ASK_USER_QUESTION_PARAM_HEADER,
ASK_USER_QUESTION_PARAM_TYPE,
ASK_USER_QUESTION_PARAM_OPTIONS,
ASK_USER_QUESTION_PARAM_MULTI_SELECT,
ASK_USER_QUESTION_PARAM_PLACEHOLDER,
ASK_USER_OPTION_PARAM_LABEL,
ASK_USER_OPTION_PARAM_DESCRIPTION,
EXIT_PLAN_MODE_TOOL_NAME,
EXIT_PLAN_PARAM_PLAN_FILENAME,
ENTER_PLAN_MODE_TOOL_NAME,
PLAN_MODE_PARAM_REASON,
PARAM_ADDITIONAL_PERMISSIONS,
UPDATE_TOPIC_TOOL_NAME,
UPDATE_TOPIC_DISPLAY_NAME,
TOPIC_PARAM_TITLE,
TOPIC_PARAM_SUMMARY,
TOPIC_PARAM_STRATEGIC_INTENT,
COMPLETE_TASK_TOOL_NAME,
COMPLETE_TASK_DISPLAY_NAME,
READ_MCP_RESOURCE_TOOL_NAME,
LIST_MCP_RESOURCES_TOOL_NAME,
zodToJsonSchema,
getUpdateTopicDeclaration,
REFERENCE_CONTENT_START,
REFERENCE_CONTENT_END,
DEFAULT_MAX_LINES_TEXT_FILE,
MAX_LINE_LENGTH_TEXT_FILE,
MAX_FILE_SIZE_MB,
READ_FILE_DEFINITION,
WRITE_FILE_DEFINITION,
GREP_DEFINITION,
RIP_GREP_DEFINITION,
WEB_SEARCH_DEFINITION,
EDIT_DEFINITION,
GLOB_DEFINITION,
LS_DEFINITION,
WEB_FETCH_DEFINITION,
READ_MANY_FILES_DEFINITION,
WRITE_TODOS_DEFINITION,
GET_INTERNAL_DOCS_DEFINITION,
ASK_USER_DEFINITION,
ENTER_PLAN_MODE_DEFINITION,
getShellDefinition,
getExitPlanModeDefinition,
getActivateSkillDefinition,
READ_MCP_RESOURCE_DEFINITION,
LIST_MCP_RESOURCES_DEFINITION,
safeJsonStringify,
safeJsonStringifyBooleanValuesOnly,
MCP_QUALIFIED_NAME_SEPARATOR,
MCP_TOOL_PREFIX,
isMcpToolName,
parseMcpToolName,
formatMcpToolName,
isMcpToolAnnotation,
DiscoveredMCPToolInvocation,
DiscoveredMCPTool,
generateValidName,
EDIT_TOOL_NAMES,
TOOLS_REQUIRING_NARROWING,
TRACKER_CREATE_TASK_TOOL_NAME,
TRACKER_UPDATE_TASK_TOOL_NAME,
TRACKER_GET_TASK_TOOL_NAME,
TRACKER_LIST_TASKS_TOOL_NAME,
TRACKER_ADD_DEPENDENCY_TOOL_NAME,
TRACKER_VISUALIZE_TOOL_NAME,
AGENT_TOOL_NAME,
WRITE_FILE_DISPLAY_NAME,
EDIT_DISPLAY_NAME,
ASK_USER_DISPLAY_NAME,
READ_FILE_DISPLAY_NAME,
GLOB_DISPLAY_NAME,
LS_DISPLAY_NAME,
GREP_DISPLAY_NAME,
WEB_SEARCH_DISPLAY_NAME,
WEB_FETCH_DISPLAY_NAME,
READ_MANY_FILES_DISPLAY_NAME,
TOOL_LEGACY_ALIASES,
getToolAliases,
DISCOVERED_TOOL_PREFIX,
ALL_BUILTIN_TOOL_NAMES,
PLAN_MODE_TOOLS,
isValidToolName,
resolveToolDeclaration,
DEFAULT_CONTEXT_FILENAME,
MEMORY_SECTION_HEADER,
PROJECT_MEMORY_INDEX_FILENAME,
setGeminiMdFilename,
getCurrentGeminiMdFilename,
getAllGeminiMdFilenames,
getGlobalMemoryFilePath,
getProjectMemoryIndexFilePath,
MemoryTool,
CoreEvent,
CoreEventEmitter,
coreEvents,
bfsFileSearchSync,
DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
DEFAULT_FILE_FILTERING_OPTIONS,
GEMINI_IGNORE_FILE_NAME,
INTEGRITY_FILENAME,
INTEGRITY_KEY_FILENAME,
KEYCHAIN_SERVICE_NAME,
SECRET_KEY_ACCOUNT,
deduplicatePathsByFileIdentity,
readGeminiMdFiles,
concatenateInstructions,
getGlobalMemoryPaths,
getUserProjectMemoryPaths,
getExtensionMemoryPaths,
getEnvironmentMemoryPaths,
categorizeAndConcatenate,
loadServerHierarchicalMemory,
refreshServerHierarchicalMemory,
loadJitSubdirectoryMemory
};
/**
* @license
* Copyright 2025 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @license
* Copyright 2026 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/*! Bundled license information:
safe-buffer/index.js:
(*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
gtoken/build/cjs/src/index.cjs:
(*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE *)
@google/genai/dist/node/index.mjs:
@google/genai/dist/node/index.mjs:
@google/genai/dist/node/index.mjs:
@google/genai/dist/node/index.mjs:
@google/genai/dist/node/index.mjs:
(**
* @license
* Copyright 2025 Google LLC
* SPDX-License-Identifier: Apache-2.0
*)
*/