@botpress/adk-cli
Version:
Command-line interface for the Botpress Agent Development Kit (ADK)
20,669 lines • 737 kB
JavaScript
// @bun
import {
SqliteLogStore
} from "./chunk-ssjw4jwy.js";
import {
SqliteTraceStore
} from "./chunk-2re833ev.js";
import {
validateAndPromptConfig
} from "./chunk-sky56mbb.js";
import {
buildAndUploadComponents,
computeEvalManifestPlan,
globalReactPlugin,
refreshDependencySnapshotOnce,
runProdDeployPipeline,
style
} from "./chunk-xkcrb68a.js";
import {
adkBuild
} from "./chunk-ttvctaf1.js";
import {
open_default
} from "./chunk-fr1k79kd.js";
import {
SSEHub,
createSSEStream,
emitSecretsValuesChanged,
errorResponse,
getActiveEnvironment,
getAgent0RuntimeClient,
getCorsHeaders,
getDevBotRuntimeState,
getDevCommandStatus,
getLatestWorkerStats,
getLocalProdMetadataTarget,
getScopedServerCredentials,
getServerConfig,
getServerStartTime,
getTargetBotId,
handleCorsPreflightResponse,
handleFeatureFlags,
handleGetConfigSchemaDiff,
handleGetConfigVariables,
handlePatchConfigSchema,
handleProdBotApiRequest,
handlePutConfigVariables,
isProductionObservabilityEnabled,
jsonResponse,
onProjectReloaded,
parseEnv,
prodAgentMetadataService,
productionObservabilityDisabledResponse,
resolveEvalStore,
routeEvalRequest,
setActiveEnvironment,
startEventLoopLagMonitor,
successResponse,
updateWorkerStats,
validateBotId,
validateCredentials,
validateMethod,
validateProjectAndCredentials,
withRequestTiming
} from "./chunk-59ayvmxs.js";
import {
AgentMapSnapshotNotPublishedError,
buildAgentSnapshot,
prodAgentMapSnapshotService
} from "./chunk-r72adjnh.js";
import {
telemetry_default
} from "./chunk-kwmsaz7n.js";
import {
getAdkVersion
} from "./chunk-26vqkz52.js";
import {
findAgentRootOrFail
} from "./chunk-kk3h6qaj.js";
import {
createCliLogger
} from "./chunk-gzwt1qdr.js";
import {
CLI_VERSION
} from "./chunk-nxy2ya5r.js";
import {
AgentProject,
BP_CSS_SUFFIX,
BP_TSX_SUFFIX,
BP_TYPES_SUFFIX,
COMPONENTS_DIR,
ConfigWriter,
PreflightChecker,
SecretsManager,
assertNoBlockingDependencies,
auth,
buildIndexUpdate,
exports_dependencies,
findConflictingExport,
getProjectClient,
isAdkError,
summarizeBlockingDependencies,
validateSecretName
} from "./chunk-p0hjqn4r.js";
import {
ne
} from "./chunk-6w0knnta.js";
import {
Cognitive
} from "./chunk-rfm3jr1m.js";
import {
__commonJS,
__export,
__require,
__toESM
} from "./chunk-dhs2bg35.js";
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
var require_code = __commonJS((exports) => {
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 = undefined;
class _CodeOrName {
}
exports._CodeOrName = _CodeOrName;
exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
class Name 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;
class _Code 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 !== undefined ? _a : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
}
get names() {
var _a;
return (_a = this._names) !== null && _a !== undefined ? _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 !== undefined) {
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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/scope.js
var require_scope = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = undefined;
var code_1 = require_code();
class ValueError 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")
};
class Scope {
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 === undefined ? undefined : _a._prefixes) === null || _b === undefined ? undefined : _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;
class ValueScopeName 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`;
class ValueScope 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 === undefined)
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 !== undefined ? _a : value.ref;
let vs = this._values[prefix];
if (vs) {
const _name = vs.get(valueKey);
if (_name)
return _name;
} else {
vs = this._values[prefix] = 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 === undefined)
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 === undefined)
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] || 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 === undefined ? undefined : 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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/index.js
var require_codegen = __commonJS((exports) => {
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._ = undefined;
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("+")
};
class Node {
optimizeNodes() {
return this;
}
optimizeNames(_names, _constants) {
return this;
}
}
class Def 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 === undefined ? "" : ` = ${this.rhs}`;
return `${varKind} ${this.name}${rhs};` + _n;
}
optimizeNames(names, constants) {
if (!names[this.name.str])
return;
if (this.rhs)
this.rhs = optimizeExpr(this.rhs, names, constants);
return this;
}
get names() {
return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
}
}
class Assign 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, constants) {
if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
return;
this.rhs = optimizeExpr(this.rhs, names, constants);
return this;
}
get names() {
const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };
return addExprNames(names, this.rhs);
}
}
class AssignOp extends Assign {
constructor(lhs, op, rhs, sideEffects) {
super(lhs, rhs, sideEffects);
this.op = op;
}
render({ _n }) {
return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
}
}
class Label extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
return `${this.label}:` + _n;
}
}
class Break extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
const label = this.label ? ` ${this.label}` : "";
return `break${label};` + _n;
}
}
class Throw extends Node {
constructor(error2) {
super();
this.error = error2;
}
render({ _n }) {
return `throw ${this.error};` + _n;
}
get names() {
return this.error.names;
}
}
class AnyCode extends Node {
constructor(code) {
super();
this.code = code;
}
render({ _n }) {
return `${this.code};` + _n;
}
optimizeNodes() {
return `${this.code}` ? this : undefined;
}
optimizeNames(names, constants) {
this.code = optimizeExpr(this.code, names, constants);
return this;
}
get names() {
return this.code instanceof code_1._CodeOrName ? this.code.names : {};
}
}
class ParentNode 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 : undefined;
}
optimizeNames(names, constants) {
const { nodes } = this;
let i = nodes.length;
while (i--) {
const n = nodes[i];
if (n.optimizeNames(names, constants))
continue;
subtractNames(names, n.names);
nodes.splice(i, 1);
}
return nodes.length > 0 ? this : undefined;
}
get names() {
return this.nodes.reduce((names, n) => addNames(names, n.names), {});
}
}
class BlockNode extends ParentNode {
render(opts) {
return "{" + opts._n + super.render(opts) + "}" + opts._n;
}
}
class Root extends ParentNode {
}
class Else extends BlockNode {
}
Else.kind = "else";
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;
return this;
}
optimizeNames(names, constants) {
var _a;
this.else = (_a = this.else) === null || _a === undefined ? undefined : _a.optimizeNames(names, constants);
if (!(super.optimizeNames(names, constants) || this.else))
return;
this.condition = optimizeExpr(this.condition, names, constants);
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";
class For extends BlockNode {
}
For.kind = "for";
class ForLoop extends For {
constructor(iteration) {
super();
this.iteration = iteration;
}
render(opts) {
return `for(${this.iteration})` + super.render(opts);
}
optimizeNames(names, constants) {
if (!super.optimizeNames(names, constants))
return;
this.iteration = optimizeExpr(this.iteration, names, constants);
return this;
}
get names() {
return addNames(super.names, this.iteration.names);
}
}
class ForRange 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);
}
}
class ForIter 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, constants) {
if (!super.optimizeNames(names, constants))
return;
this.iterable = optimizeExpr(this.iterable, names, constants);
return this;
}
get names() {
return addNames(super.names, this.iterable.names);
}
}
class Func 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";
class Return extends ParentNode {
render(opts) {
return "return " + super.render(opts);
}
}
Return.kind = "return";
class Try 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 === undefined || _a.optimizeNodes();
(_b = this.finally) === null || _b === undefined || _b.optimizeNodes();
return this;
}
optimizeNames(names, constants) {
var _a, _b;
super.optimizeNames(names, constants);
(_a = this.catch) === null || _a === undefined || _a.optimizeNames(names, constants);
(_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants);
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;
}
}
class Catch extends BlockNode {
constructor(error2) {
super();
this.error = error2;
}
render(opts) {
return `catch(${this.error})` + super.render(opts);
}
}
Catch.kind = "catch";
class Finally extends BlockNode {
render(opts) {
return "finally" + super.render(opts);
}
}
Finally.kind = "finally";
class CodeGen {
constructor(extScope, opts = {}) {
this._values = {};
this._blockStarts = [];
this._constants = {};
this.opts = { ...opts, _n: opts.lines ? `
` : "" };
this._extScope = extScope;
this._scope = new scope_1.Scope({ parent: extScope });
this._nodes = [new Root];
}
toString() {
return this._root.render(this.opts);
}
name(prefix) {
return this._scope.name(prefix);
}
scopeName(prefix) {
return this._extScope.name(prefix);
}
scopeValue(prefixOrName, value) {
const name = this._extScope.value(prefixOrName, value);
const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set);
vs.add(name);
return name;
}
getScopeValue(prefix, keyOrRef) {
return this._extScope.getValue(prefix, keyOrRef);
}
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 !== undefined && constant)
this._constants[name.str] = rhs;
this._leafNode(new Def(varKind, name, rhs));
return name;
}
const(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
}
let(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
}
var(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
}
assign(lhs, rhs, sideEffects) {
return this._leafNode(new Assign(lhs, rhs, sideEffects));
}
add(lhs, rhs) {
return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
}
code(c) {
if (typeof c == "function")
c();
else if (c !== code_1.nil)
this._leafNode(new AnyCode(c));
return this;
}
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(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;
}
elseIf(condition) {
return this._elseNode(new If(condition));
}
else() {
return this._elseNode(new Else);
}
endIf() {
return this._endBlockNode(If, Else);
}
_for(node, forBody) {
this._blockNode(node);
if (forBody)
this.code(forBody).endFor();
return this;
}
for(iteration, forBody) {
return this._for(new ForLoop(iteration), forBody);
}
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));
}
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));
}
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));
}
endFor() {
return this._endBlockNode(For);
}
label(label) {
return this._leafNode(new Label(label));
}
break(label) {
return this._leafNode(new Break(label));
}
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(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 error2 = this.name("e");
this._currNode = node.catch = new Catch(error2);
catchCode(error2);
}
if (finallyCode) {
this._currNode = node.finally = new Finally;
this.code(finallyCode);
}
return this._endBlockNode(Catch, Finally);
}
throw(error2) {
return this._leafNode(new Throw(error2));
}
block(body, nodeCount) {
this._blockStarts.push(this._nodes.length);
if (body)
this.code(body).endBlock(nodeCount);
return this;
}
endBlock(nodeCount) {
const len = this._blockStarts.pop();
if (len === undefined)
throw new Error("CodeGen: not in self-balancing block");
const toClose = this._nodes.length - len;
if (toClose < 0 || nodeCount !== undefined && toClose !== nodeCount) {
throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
}
this._nodes.length = len;
return this;
}
func(name, args = code_1.nil, async, funcBody) {
this._blockNode(new Func(name, args, async));
if (funcBody)
this.code(funcBody).endFunc();
return this;
}
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, constants) {
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 = constants[n.str];
if (c === undefined || 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 && constants[c.str] !== undefined);
}
}
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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/util.js
var require_util = __commonJS((exports) => {
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 = undefined;
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 } = it;
if (!opts.strictSchema)
return;
if (typeof schema === "boolean")
return;
const rules = self.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 === undefined ? 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 !== undefined)
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 Type;
(function(Type2) {
Type2[Type2["Num"] = 0] = "Num";
Type2[Type2["Str"] = 1] = "Str";
})(Type || (exports.Type = Type = {}));
function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
if (dataProp instanceof codegen_1.Name) {
const isNumber = dataPropType === Type.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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/names.js
var require_names = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var names = {
data: new codegen_1.Name("data"),
valCxt: new codegen_1.Name("valCxt"),
instancePath: new codegen_1.Name("instancePath"),
parentData: new codegen_1.Name("parentData"),
parentDataProperty: new codegen_1.Name("parentDataProperty"),
rootData: new codegen_1.Name("rootData"),
dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
vErrors: new codegen_1.Name("vErrors"),
errors: new codegen_1.Name("errors"),
this: new codegen_1.Name("this"),
self: new codegen_1.Name("self"),
scope: new codegen_1.Name("scope"),
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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/errors.js
var require_errors = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = undefined;
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, error2 = exports.keywordError, errorPaths, overrideAllErrors) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
const errObj = errorObjectCode(cxt, error2, errorPaths);
if (overrideAllErrors !== null && overrideAllErrors !== undefined ? overrideAllErrors : compositeRule || allErrors) {
addError(gen, errObj);
} else {
returnErrors(it, (0, codegen_1._)`[${errObj}]`);
}
}
exports.reportError = reportError;
function reportExtraError(cxt, error2 = exports.keywordError, errorPaths) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
const errObj = errorObjectCode(cxt, error2, 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 === undefined)
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"),
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, error2, errorPaths) {
const { createErrors } = cxt.it;
if (createErrors === false)
return (0, codegen_1._)`{}`;
return errorObject(cxt, error2, errorPaths);
}
function errorObject(cxt, error2, errorPaths = {}) {
const { gen, it } = cxt;
const keyValues = [
errorInstancePath(it, errorPaths),
errorSchemaPath(cxt, errorPaths)
];
extraErrorProps(cxt, error2, 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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/validate/boolSchema.js
var require_boolSchema = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = undefined;
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, undefined, overrideAllErrors);
}
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/rules.js
var require_rules = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.getRules = exports.isJSONType = undefined;
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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/validate/applicability.js
var require_applicability = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = undefined;
function schemaHasRulesForType({ schema, self }, type) {
const group = self.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] !== undefined || ((_a = rule.definition.implements) === null || _a === undefined ? undefined : _a.some((kwd) => schema[kwd] !== undefined));
}
exports.shouldUseRule = shouldUseRule;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/validate/dataType.js
var require_dataType = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = undefined;
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 !== undefined) {
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 = 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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/validate/defaults.js
var require_defaults = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.assignDefaults = undefined;
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 === undefined)
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/code.js
var require_code2 = __commonJS((exports) => {
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 = undefined;
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", {
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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/validate/keyword.js
var require_keyword = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = undefined;
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 !== undefined ? _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(errors3) {
var _a2;
gen.if((0, codegen_1.not)((_a2 = def.valid) !== null && _a2 !== undefined ? _a2 : valid), errors3);
}
}
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 === undefined)
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, 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 === undefined ? undefined : 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}": ` + self.errorsText(def.validateSchema.errors);
if (opts.validateSchema === "log")
self.logger.error(msg);
else
throw new Error(msg);
}
}
}
exports.validateKeywordUsage = validateKeywordUsage;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/validate/subschema.js
var require_subschema = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = undefined;
var codegen_1 = require_codegen();
var util_1 = require_util();
function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
if (keyword !== undefined && schema !== undefined) {
throw new Error('both "keyword" and "schema" passed, only one allowed');
}
if (keyword !== undefined) {
const sch = it.schema[keyword];
return schemaProp === undefined ? {
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 !== undefined) {
if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {
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 !== undefined && dataProp !== undefined) {
throw new Error('both "data" and "dataProp" passed, only one allowed');
}
const { gen } = it;
if (dataProp !== undefined) {
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 !== undefined) {
const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true);
dataContextProps(nextData);
if (propertyName !== undefined)
subschema.propertyName = propertyName;
}
if (dataTypes)
subschema.dataTypes = dataTypes;
function dataContextProps(_nextData) {
subschema.data = _nextData;
subschema.dataLevel = it.dataLevel + 1;
subschema.dataTypes = [];
it.definedProperties = new Set;
subschema.parentData = it.data;
subschema.dataNames = [...it.dataNames, _nextData];
}
}
exports.extendSubschemaData = extendSubschemaData;
function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
if (compositeRule !== undefined)
subschema.compositeRule = compositeRule;
if (createErrors !== undefined)
subschema.createErrors = createErrors;
if (allErrors !== undefined)
subschema.allErrors = allErrors;
subschema.jtdDiscriminator = jtdDiscriminator;
subschema.jtdMetadata = jtdMetadata;
}
exports.extendSubschemaMode = extendSubschemaMode;
});
// ../../node_modules/.bun/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
var require_fast_deep_equal = __commonJS((exports, module) => {
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;
};
});
// ../../node_modules/.bun/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
var require_json_schema_traverse = __commonJS((exports, module) => {
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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/resolve.js
var require_resolve = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = undefined;
var util_1 = require_util();
var equal = require_fast_deep_equal();
var traverse = require_json_schema_traverse();
var SIMPLE_INLINED = 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 = 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 = "", normalize) {
if (normalize !== 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 = new Set;
traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
if (parentJsonPtr === undefined)
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 !== undefined && !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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/validate/index.js
var require_validate = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.getData = exports.KeywordCxt = exports.validateFunctionCode = undefined;
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 }) {
if (typeof schema == "boolean")
return !schema;
for (const key in schema)
if (self.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 } = it;
if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) {
self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
}
}
function checkNoDefault(it) {
const { schema, opts } = it;
if (schema.default !== undefined && 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 } = it;
const { RULES } = self;
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);
}
class KeywordCxt {
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), undefined, failAction);
}
fail(condition) {
if (condition === undefined) {
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 === undefined)
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: undefined, props: undefined };
subschemaCode(nextContext, valid);
return nextContext;
}
mergeEvaluated(schemaCxt, toName) {
const { it, gen } = this;
if (!it.opts.unevaluated)
return;
if (it.props !== true && schemaCxt.props !== undefined) {
it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
}
if (it.items !== true && schemaCxt.items !== undefined) {
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/.bun/ajv@8.20.0/node_modules/ajv/dist/runtime/validation_error.js
var require_validation_error = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
class ValidationError extends Error {
constructor(errors3) {
super("validation failed");
this.errors = errors3;
this.ajv = this.validation = true;
}
}
exports.default = ValidationError;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/ref_error.js
var require_ref_error = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var resolve_1 = require_resolve();
class MissingRefError 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/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/index.js
var require_compile = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = undefined;
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();
class SchemaEnv {
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 !== undefined ? _a : (0, resolve_1.normalizeId)(schema === null || schema === undefined ? undefined : schema[env.schemaId || "$id"]);
this.schemaPath = env.schemaPath;
this.localRefs = env.localRefs;
this.meta = env.meta;
this.$async = schema === null || schema === undefined ? undefined : 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],
dataLevel: 0,
dataTypes: [],
definedProperties: 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 ? undefined : props,
items: items instanceof codegen_1.Name ? undefined : 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 = resolve7.call(this, root, ref);
if (_sch === undefined) {
const schema = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
const { schemaId } = this.opts;
if (schema)
_sch = new SchemaEnv({ schema, schemaId, root, baseId });
}
if (_sch === undefined)
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 resolve7(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, undefined);
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 === undefined ? undefined : sch.schema) !== "object")
return;
return getJsonPointer.call(this, p, sch);
}
if (typeof (schOrRef === null || schOrRef === undefined ? undefined : 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 = new Set([
"properties",
"patternProperties",
"enum",
"dependencies",
"definitions"
]);
function getJsonPointer(parsedRef, { baseId, schema, root }) {
var _a;
if (((_a = parsedRef.fragment) === null || _a === undefined ? undefined : _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 === undefined)
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;
}
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/refs/data.json
var require_data = __commonJS((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/.bun/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
var require_utils = __commonJS((exports, module) => {
var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
var isIPv4 = RegExp.prototype.test.bind(/^(?:(?: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 stringArrayToHexStripped(input) {
let acc = "";
let code = 0;
let i = 0;
for (i = 0;i < input.length; i++) {
code = input[i].charCodeAt(0);
if (code === 48) {
continue;
}
if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
return "";
}
acc += input[i];
break;
}
for (i += 1;i < input.length; i++) {
code = input[i].charCodeAt(0);
if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
return "";
}
acc += input[i];
}
return acc;
}
var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
function consumeIsZone(buffer) {
buffer.length = 0;
return true;
}
function consumeHextets(buffer, address, output) {
if (buffer.length) {
const hex = stringArrayToHexStripped(buffer);
if (hex !== "") {
address.push(hex);
} else {
output.error = true;
return false;
}
buffer.length = 0;
}
return true;
}
function getIPV6(input) {
let tokenCount = 0;
const output = { error: false, address: "", zone: "" };
const address = [];
const buffer = [];
let endipv6Encountered = false;
let endIpv6 = false;
let consume = consumeHextets;
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(buffer, address, output)) {
break;
}
if (++tokenCount > 7) {
output.error = true;
break;
}
if (i > 0 && input[i - 1] === ":") {
endipv6Encountered = true;
}
address.push(":");
continue;
} else if (cursor === "%") {
if (!consume(buffer, address, output)) {
break;
}
consume = consumeIsZone;
} else {
buffer.push(cursor);
continue;
}
}
if (buffer.length) {
if (consume === consumeIsZone) {
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 ipv62 = getIPV6(host);
if (!ipv62.error) {
let newHost = ipv62.address;
let escapedHost = ipv62.address;
if (ipv62.zone) {
newHost += "%" + ipv62.zone;
escapedHost += "%25" + ipv62.zone;
}
return { host: newHost, isIPV6: true, escapedHost };
} else {
return { host, isIPV6: false };
}
}
function findToken(str, token) {
let ind = 0;
for (let i = 0;i < str.length; i++) {
if (str[i] === token)
ind++;
}
return ind;
}
function removeDotSegments(path) {
let input = path;
const output = [];
let nextSlash = -1;
let len = 0;
while (len = input.length) {
if (len === 1) {
if (input === ".") {
break;
} else if (input === "/") {
output.push("/");
break;
} else {
output.push(input);
break;
}
} else if (len === 2) {
if (input[0] === ".") {
if (input[1] === ".") {
break;
} else if (input[1] === "/") {
input = input.slice(2);
continue;
}
} else if (input[0] === "/") {
if (input[1] === "." || input[1] === "/") {
output.push("/");
break;
}
}
} else if (len === 3) {
if (input === "/..") {
if (output.length !== 0) {
output.pop();
}
output.push("/");
break;
}
}
if (input[0] === ".") {
if (input[1] === ".") {
if (input[2] === "/") {
input = input.slice(3);
continue;
}
} else if (input[1] === "/") {
input = input.slice(2);
continue;
}
} else if (input[0] === "/") {
if (input[1] === ".") {
if (input[2] === "/") {
input = input.slice(2);
continue;
} else if (input[2] === ".") {
if (input[3] === "/") {
input = input.slice(3);
if (output.length !== 0) {
output.pop();
}
continue;
}
}
}
}
if ((nextSlash = input.indexOf("/", 1)) === -1) {
output.push(input);
break;
} else {
output.push(input.slice(0, nextSlash));
input = input.slice(nextSlash);
}
}
return output.join("");
}
function normalizeComponentEncoding(component, esc2) {
const func = esc2 !== true ? escape : unescape;
if (component.scheme !== undefined) {
component.scheme = func(component.scheme);
}
if (component.userinfo !== undefined) {
component.userinfo = func(component.userinfo);
}
if (component.host !== undefined) {
component.host = func(component.host);
}
if (component.path !== undefined) {
component.path = func(component.path);
}
if (component.query !== undefined) {
component.query = func(component.query);
}
if (component.fragment !== undefined) {
component.fragment = func(component.fragment);
}
return component;
}
function recomposeAuthority(component) {
const uriTokens = [];
if (component.userinfo !== undefined) {
uriTokens.push(component.userinfo);
uriTokens.push("@");
}
if (component.host !== undefined) {
let host = unescape(component.host);
if (!isIPv4(host)) {
const ipV6res = normalizeIPv6(host);
if (ipV6res.isIPV6 === true) {
host = `[${ipV6res.escapedHost}]`;
} else {
host = component.host;
}
}
uriTokens.push(host);
}
if (typeof component.port === "number" || typeof component.port === "string") {
uriTokens.push(":");
uriTokens.push(String(component.port));
}
return uriTokens.length ? uriTokens.join("") : undefined;
}
module.exports = {
nonSimpleDomain,
recomposeAuthority,
normalizeComponentEncoding,
removeDotSegments,
isIPv4,
isUUID,
normalizeIPv6,
stringArrayToHexStripped
};
});
// ../../node_modules/.bun/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js
var require_schemes = __commonJS((exports, module) => {
var { isUUID } = require_utils();
var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
var supportedSchemeNames = [
"http",
"https",
"ws",
"wss",
"urn",
"urn:uuid"
];
function isValidSchemeName(name) {
return supportedSchemeNames.indexOf(name) !== -1;
}
function wsIsSecure(wsComponent) {
if (wsComponent.secure === true) {
return true;
} else if (wsComponent.secure === false) {
return false;
} else if (wsComponent.scheme) {
return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S");
} else {
return false;
}
}
function httpParse(component) {
if (!component.host) {
component.error = component.error || "HTTP URIs must have a host.";
}
return component;
}
function httpSerialize(component) {
const secure = String(component.scheme).toLowerCase() === "https";
if (component.port === (secure ? 443 : 80) || component.port === "") {
component.port = undefined;
}
if (!component.path) {
component.path = "/";
}
return component;
}
function wsParse(wsComponent) {
wsComponent.secure = wsIsSecure(wsComponent);
wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : "");
wsComponent.path = undefined;
wsComponent.query = undefined;
return wsComponent;
}
function wsSerialize(wsComponent) {
if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") {
wsComponent.port = undefined;
}
if (typeof wsComponent.secure === "boolean") {
wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
wsComponent.secure = undefined;
}
if (wsComponent.resourceName) {
const [path, query] = wsComponent.resourceName.split("?");
wsComponent.path = path && path !== "/" ? path : undefined;
wsComponent.query = query;
wsComponent.resourceName = undefined;
}
wsComponent.fragment = undefined;
return wsComponent;
}
function urnParse(urnComponent, options) {
if (!urnComponent.path) {
urnComponent.error = "URN can not be parsed";
return urnComponent;
}
const matches = urnComponent.path.match(URN_REG);
if (matches) {
const scheme = options.scheme || urnComponent.scheme || "urn";
urnComponent.nid = matches[1].toLowerCase();
urnComponent.nss = matches[2];
const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`;
const schemeHandler = getSchemeHandler(urnScheme);
urnComponent.path = undefined;
if (schemeHandler) {
urnComponent = schemeHandler.parse(urnComponent, options);
}
} else {
urnComponent.error = urnComponent.error || "URN can not be parsed.";
}
return urnComponent;
}
function urnSerialize(urnComponent, options) {
if (urnComponent.nid === undefined) {
throw new Error("URN without nid cannot be serialized");
}
const scheme = options.scheme || urnComponent.scheme || "urn";
const nid = urnComponent.nid.toLowerCase();
const urnScheme = `${scheme}:${options.nid || nid}`;
const schemeHandler = getSchemeHandler(urnScheme);
if (schemeHandler) {
urnComponent = schemeHandler.serialize(urnComponent, options);
}
const uriComponent = urnComponent;
const nss = urnComponent.nss;
uriComponent.path = `${nid || options.nid}:${nss}`;
options.skipEscape = true;
return uriComponent;
}
function urnuuidParse(urnComponent, options) {
const uuidComponent = urnComponent;
uuidComponent.uuid = uuidComponent.nss;
uuidComponent.nss = undefined;
if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) {
uuidComponent.error = uuidComponent.error || "UUID is not valid.";
}
return uuidComponent;
}
function urnuuidSerialize(uuidComponent) {
const urnComponent = uuidComponent;
urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
return urnComponent;
}
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
};
Object.setPrototypeOf(SCHEMES, null);
function getSchemeHandler(scheme) {
return scheme && (SCHEMES[scheme] || SCHEMES[scheme.toLowerCase()]) || undefined;
}
module.exports = {
wsIsSecure,
SCHEMES,
isValidSchemeName,
getSchemeHandler
};
});
// ../../node_modules/.bun/fast-uri@3.1.0/node_modules/fast-uri/index.js
var require_fast_uri = __commonJS((exports, module) => {
var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
var { SCHEMES, getSchemeHandler } = require_schemes();
function normalize(uri, options) {
if (typeof uri === "string") {
uri = serialize(parse5(uri, options), options);
} else if (typeof uri === "object") {
uri = parse5(serialize(uri, options), options);
}
return uri;
}
function resolve7(baseURI, relativeURI, options) {
const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
const resolved = resolveComponent(parse5(baseURI, schemelessOptions), parse5(relativeURI, schemelessOptions), schemelessOptions, true);
schemelessOptions.skipEscape = true;
return serialize(resolved, schemelessOptions);
}
function resolveComponent(base, relative6, options, skipNormalization) {
const target = {};
if (!skipNormalization) {
base = parse5(serialize(base, options), options);
relative6 = parse5(serialize(relative6, options), options);
}
options = options || {};
if (!options.tolerant && relative6.scheme) {
target.scheme = relative6.scheme;
target.userinfo = relative6.userinfo;
target.host = relative6.host;
target.port = relative6.port;
target.path = removeDotSegments(relative6.path || "");
target.query = relative6.query;
} else {
if (relative6.userinfo !== undefined || relative6.host !== undefined || relative6.port !== undefined) {
target.userinfo = relative6.userinfo;
target.host = relative6.host;
target.port = relative6.port;
target.path = removeDotSegments(relative6.path || "");
target.query = relative6.query;
} else {
if (!relative6.path) {
target.path = base.path;
if (relative6.query !== undefined) {
target.query = relative6.query;
} else {
target.query = base.query;
}
} else {
if (relative6.path[0] === "/") {
target.path = removeDotSegments(relative6.path);
} else {
if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
target.path = "/" + relative6.path;
} else if (!base.path) {
target.path = relative6.path;
} else {
target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative6.path;
}
target.path = removeDotSegments(target.path);
}
target.query = relative6.query;
}
target.userinfo = base.userinfo;
target.host = base.host;
target.port = base.port;
}
target.scheme = base.scheme;
}
target.fragment = relative6.fragment;
return target;
}
function equal(uriA, uriB, options) {
if (typeof uriA === "string") {
uriA = unescape(uriA);
uriA = serialize(normalizeComponentEncoding(parse5(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(parse5(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 component = {
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 = getSchemeHandler(options.scheme || component.scheme);
if (schemeHandler && schemeHandler.serialize)
schemeHandler.serialize(component, options);
if (component.path !== undefined) {
if (!options.skipEscape) {
component.path = escape(component.path);
if (component.scheme !== undefined) {
component.path = component.path.split("%3A").join(":");
}
} else {
component.path = unescape(component.path);
}
}
if (options.reference !== "suffix" && component.scheme) {
uriTokens.push(component.scheme, ":");
}
const authority = recomposeAuthority(component);
if (authority !== undefined) {
if (options.reference !== "suffix") {
uriTokens.push("//");
}
uriTokens.push(authority);
if (component.path && component.path[0] !== "/") {
uriTokens.push("/");
}
}
if (component.path !== undefined) {
let s = component.path;
if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
s = removeDotSegments(s);
}
if (authority === undefined && s[0] === "/" && s[1] === "/") {
s = "/%2F" + s.slice(2);
}
uriTokens.push(s);
}
if (component.query !== undefined) {
uriTokens.push("?", component.query);
}
if (component.fragment !== undefined) {
uriTokens.push("#", component.fragment);
}
return uriTokens.join("");
}
var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
function parse5(uri, opts) {
const options = Object.assign({}, opts);
const parsed = {
scheme: undefined,
userinfo: undefined,
host: "",
port: undefined,
path: "",
query: undefined,
fragment: undefined
};
let isIP = false;
if (options.reference === "suffix") {
if (options.scheme) {
uri = options.scheme + ":" + uri;
} else {
uri = "//" + 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 = isIPv4(parsed.host);
if (ipv4result === false) {
const ipv6result = normalizeIPv6(parsed.host);
parsed.host = ipv6result.host.toLowerCase();
isIP = ipv6result.isIPV6;
} else {
isIP = true;
}
}
if (parsed.scheme === undefined && parsed.userinfo === undefined && parsed.host === undefined && parsed.port === undefined && parsed.query === undefined && !parsed.path) {
parsed.reference = "same-document";
} else if (parsed.scheme === undefined) {
parsed.reference = "relative";
} else if (parsed.fragment === undefined) {
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 = getSchemeHandler(options.scheme || parsed.scheme);
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 (uri.indexOf("%") !== -1) {
if (parsed.scheme !== undefined) {
parsed.scheme = unescape(parsed.scheme);
}
if (parsed.host !== undefined) {
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,
resolve: resolve7,
resolveComponent,
equal,
serialize,
parse: parse5
};
module.exports = fastUri;
module.exports.default = fastUri;
module.exports.fastUri = fastUri;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/runtime/uri.js
var require_uri = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var uri = require_fast_uri();
uri.code = 'require("ajv/dist/runtime/uri").default';
exports.default = uri;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/core.js
var require_core = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = undefined;
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 = 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 === undefined ? undefined : _a.optimize;
const optimize = _optz === true || _optz === undefined ? 1 : _optz || 0;
const regExp = (_c = (_b = o.code) === null || _b === undefined ? undefined : _b.regExp) !== null && _c !== undefined ? _c : defaultRegExp;
const uriResolver = (_d = o.uriResolver) !== null && _d !== undefined ? _d : uri_1.default;
return {
strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== undefined ? _e : s) !== null && _f !== undefined ? _f : true,
strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== undefined ? _g : s) !== null && _h !== undefined ? _h : true,
strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== undefined ? _j : s) !== null && _k !== undefined ? _k : "log",
strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== undefined ? _l : s) !== null && _m !== undefined ? _m : "log",
strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== undefined ? _o : s) !== null && _p !== undefined ? _p : false,
code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },
loopRequired: (_q = o.loopRequired) !== null && _q !== undefined ? _q : MAX_EXPRESSION,
loopEnum: (_r = o.loopEnum) !== null && _r !== undefined ? _r : MAX_EXPRESSION,
meta: (_s = o.meta) !== null && _s !== undefined ? _s : true,
messages: (_t = o.messages) !== null && _t !== undefined ? _t : true,
inlineRefs: (_u = o.inlineRefs) !== null && _u !== undefined ? _u : true,
schemaId: (_v = o.schemaId) !== null && _v !== undefined ? _v : "$id",
addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== undefined ? _w : true,
validateSchema: (_x = o.validateSchema) !== null && _x !== undefined ? _x : true,
validateFormats: (_y = o.validateFormats) !== null && _y !== undefined ? _y : true,
unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== undefined ? _z : true,
int32range: (_0 = o.int32range) !== null && _0 !== undefined ? _0 : true,
uriResolver
};
}
class Ajv {
constructor(opts = {}) {
this.schemas = {};
this.refs = {};
this.formats = Object.create(null);
this._compilations = new Set;
this._loading = {};
this._cache = 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 : undefined;
}
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];
}
}
}
addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
if (Array.isArray(schema)) {
for (const sch of schema)
this.addSchema(sch, undefined, _meta, _validateSchema);
return this;
}
let id;
if (typeof schema === "object") {
const { schemaId } = this.opts;
id = schema[schemaId];
if (id !== undefined && 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;
}
addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
this.addSchema(schema, key, true, _validateSchema);
return this;
}
validateSchema(schema, throwOrLogError) {
if (typeof schema == "boolean")
return true;
let $schema;
$schema = schema.$schema;
if ($schema !== undefined && 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;
}
getSchema(keyRef) {
let sch;
while (typeof (sch = getSchEnv.call(this, keyRef)) == "string")
keyRef = sch;
if (sch === undefined) {
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);
}
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");
}
}
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 === undefined) {
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;
}
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;
}
addFormat(name, format) {
if (typeof format == "string")
format = new RegExp(format);
this.formats[name] = format;
return this;
}
errorsText(errors3 = this.errors, { separator = ", ", dataVar = "data" } = {}) {
if (!errors3 || errors3.length === 0)
return "No errors";
return errors3.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(schemas3, regex) {
for (const keyRef in schemas3) {
const sch = schemas3[keyRef];
if (!regex || regex.test(keyRef)) {
if (typeof sch == "string") {
delete schemas3[keyRef];
} else if (sch && !sch.meta) {
this._cache.delete(sch.schema);
delete schemas3[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 !== undefined)
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 format = this.opts.formats[name];
if (format)
this.addFormat(name, format);
}
}
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(logger7) {
if (logger7 === false)
return noLogs;
if (logger7 === undefined)
return console;
if (logger7.log && logger7.warn && logger7.error)
return logger7;
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 === undefined ? undefined : 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 === undefined || _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 === undefined)
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/id.js
var require_id = __commonJS((exports) => {
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/ref.js
var require_ref = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.callRef = exports.getValidate = undefined;
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 } = it;
const { root } = env;
if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
return callRootRef();
const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
if (schOrEnv === undefined)
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 === undefined ? undefined : sch.validate) === null || _a === undefined ? undefined : _a.evaluated;
if (it.props !== true) {
if (schEvaluated && !schEvaluated.dynamicProps) {
if (schEvaluated.props !== undefined) {
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 !== undefined) {
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/index.js
var require_core2 = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var id_1 = require_id();
var ref_1 = require_ref();
var core2 = [
"$schema",
"$id",
"$defs",
"$vocabulary",
{ keyword: "$comment" },
"definitions",
id_1.default,
ref_1.default
];
exports.default = core2;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
var require_limitNumber = __commonJS((exports) => {
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 error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
var require_multipleOf = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/runtime/ucs2length.js
var require_ucs2length = __commonJS((exports) => {
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js
var require_limitLength = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var ucs2length_1 = require_ucs2length();
var error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/pattern.js
var require_pattern = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code2();
var util_1 = require_util();
var codegen_1 = require_codegen();
var error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
var require_limitProperties = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/required.js
var require_required = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code2();
var codegen_1 = require_codegen();
var util_1 = require_util();
var error2 = {
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: error2,
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 === undefined ? undefined : props[requiredKey]) === undefined && !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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js
var require_limitItems = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/runtime/equal.js
var require_equal = __commonJS((exports) => {
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
var require_uniqueItems = __commonJS((exports) => {
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 error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/const.js
var require_const = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var equal_1 = require_equal();
var error2 = {
message: "must be equal to constant",
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
};
var def = {
keyword: "const",
$data: true,
error: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/enum.js
var require_enum = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var equal_1 = require_equal();
var error2 = {
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: error2,
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 !== undefined ? 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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/index.js
var require_validation = __commonJS((exports) => {
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 = [
limitNumber_1.default,
multipleOf_1.default,
limitLength_1.default,
pattern_1.default,
limitProperties_1.default,
required_1.default,
limitItems_1.default,
uniqueItems_1.default,
{ keyword: "type", schemaType: ["string", "array"] },
{ keyword: "nullable", schemaType: "boolean" },
const_1.default,
enum_1.default
];
exports.default = validation;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
var require_additionalItems = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAdditionalItems = undefined;
var codegen_1 = require_codegen();
var util_1 = require_util();
var error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items.js
var require_items = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateTuple = undefined;
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;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
var require_prefixItems = __commonJS((exports) => {
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;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js
var require_items2020 = __commonJS((exports) => {
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 error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/contains.js
var require_contains = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error2 = {
message: ({ params: { min, max } }) => max === undefined ? (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 === undefined ? (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: error2,
code(cxt) {
const { gen, schema, parentSchema, data, it } = cxt;
let min;
let max;
const { minContains, maxContains } = parentSchema;
if (it.opts.next) {
min = minContains === undefined ? 1 : minContains;
max = maxContains;
} else {
min = 1;
}
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
cxt.setParams({ min, max });
if (max === undefined && min === 0) {
(0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
return;
}
if (max !== undefined && 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 !== undefined)
cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
cxt.pass(cond);
return;
}
it.items = true;
const valid = gen.name("valid");
if (max === undefined && min === 1) {
validateItems(valid, () => gen.if(valid, () => gen.break()));
} else if (min === 0) {
gen.let(valid, true);
if (max !== undefined)
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 === undefined) {
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
var require_dependencies = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = undefined;
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}}`
};
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));
cxt.ok(valid);
}
}
exports.validateSchemaDeps = validateSchemaDeps;
exports.default = def;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
var require_propertyNames = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error2 = {
message: "property name must be valid",
params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
};
var def = {
keyword: "propertyNames",
type: "object",
schemaType: ["object", "boolean"],
error: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
var require_additionalProperties = __commonJS((exports) => {
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 error2 = {
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: error2,
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, errors3) {
const subschema = {
keyword: "additionalProperties",
dataProp: key,
dataPropType: util_1.Type.Str
};
if (errors3 === false) {
Object.assign(subschema, {
compositeRule: true,
createErrors: false,
allErrors: false
});
}
cxt.subschema(subschema, valid);
}
}
};
exports.default = def;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/properties.js
var require_properties = __commonJS((exports) => {
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 === undefined) {
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 !== undefined;
}
function applyPropertySchema(prop) {
cxt.subschema({
keyword: "properties",
schemaProp: prop,
dataProp: prop
}, valid);
}
}
};
exports.default = def;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
var require_patternProperties = __commonJS((exports) => {
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;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/not.js
var require_not = __commonJS((exports) => {
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;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
var require_anyOf = __commonJS((exports) => {
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;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
var require_oneOf = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error2 = {
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: error2,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/allOf.js
var require_allOf = __commonJS((exports) => {
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;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/if.js
var require_if = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error2 = {
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: error2,
code(cxt) {
const { gen, parentSchema, it } = cxt;
if (parentSchema.then === undefined && parentSchema.else === undefined) {
(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 !== undefined && !(0, util_1.alwaysValidSchema)(it, schema);
}
exports.default = def;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
var require_thenElse = __commonJS((exports) => {
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 === undefined)
(0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
}
};
exports.default = def;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/index.js
var require_applicator = __commonJS((exports) => {
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 = [
not_1.default,
anyOf_1.default,
oneOf_1.default,
allOf_1.default,
if_1.default,
thenElse_1.default,
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/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/format.js
var require_format = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error2 = {
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: error2,
code(cxt, ruleType) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
const { opts, errSchemaPath, schemaEnv, self } = it;
if (!opts.validateFormats)
return;
if ($data)
validate$DataFormat();
else
validateFormat();
function validate$DataFormat() {
const fmts = gen.scopeValue("formats", {
ref: self.formats,
code: opts.code.formats
});
const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
const fType = gen.let("fType");
const format = gen.let("format");
gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, 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} && !${format}`;
}
function invalidFmt() {
const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))` : (0, codegen_1._)`${format}(${data})`;
const validData = (0, codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
return (0, codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
}
}
function validateFormat() {
const formatDef = self.formats[schema];
if (!formatDef) {
unknownFormat();
return;
}
if (formatDef === true)
return;
const [fmtType, format, fmtRef] = getFormat(formatDef);
if (fmtType === ruleType)
cxt.pass(validCondition());
function unknownFormat() {
if (opts.strictSchema === false) {
self.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)}` : undefined;
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 format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
}
}
}
};
exports.default = def;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/index.js
var require_format2 = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var format_1 = require_format();
var format = [format_1.default];
exports.default = format;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/metadata.js
var require_metadata = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.contentVocabulary = exports.metadataVocabulary = undefined;
exports.metadataVocabulary = [
"title",
"description",
"default",
"deprecated",
"readOnly",
"writeOnly",
"examples"
];
exports.contentVocabulary = [
"contentMediaType",
"contentEncoding",
"contentSchema"
];
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/draft7.js
var require_draft7 = __commonJS((exports) => {
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;
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/types.js
var require_types = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.DiscrError = undefined;
var DiscrError;
(function(DiscrError2) {
DiscrError2["Tag"] = "tag";
DiscrError2["Mapping"] = "mapping";
})(DiscrError || (exports.DiscrError = DiscrError = {}));
});
// ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/index.js
var require_discriminator = __commonJS((exports) => {
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 error2 = {
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: error2,
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 === undefined ? undefined : 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 === undefined)
throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
}
const propSch = (_a = sch === null || sch === undefined ? undefined : sch.properties) === null || _a === undefined ? undefined : _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: required2 }) {
return Array.isArray(required2) && required2.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/.bun/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
var require_json_schema_draft_07 = __commonJS((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/.bun/ajv@8.20.0/node_modules/ajv/dist/ajv.js
var require_ajv = __commonJS((exports, module) => {
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 = undefined;
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";
class Ajv 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 : undefined);
}
}
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;
} });
});
// ../../node_modules/.bun/ajv-formats@3.0.1/node_modules/ajv-formats/dist/formats.js
var require_formats = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatNames = exports.fastFormats = exports.fullFormats = undefined;
function fmtDef(validate, compare) {
return { validate, compare };
}
exports.fullFormats = {
date: fmtDef(date4, compareDate),
time: fmtDef(getTime(true), compareTime),
"date-time": fmtDef(getDateTime(true), compareDateTime),
"iso-time": fmtDef(getTime(), compareIsoTime),
"iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
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": /^(?:(?:[^\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,
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,
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: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
"json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
"json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
"relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
byte,
int32: { type: "number", validate: validateInt32 },
int64: { type: "number", validate: validateInt64 },
float: { type: "number", validate: validateNumber },
double: { type: "number", validate: validateNumber },
password: true,
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: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
"uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
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 date4(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;
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 time3(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;
const t1 = new Date("2020-01-01T" + s1).valueOf();
const t2 = new Date("2020-01-01T" + s2).valueOf();
if (!(t1 && t2))
return;
return t1 - t2;
}
function compareIsoTime(t1, t2) {
if (!(t1 && t2))
return;
const a1 = TIME.exec(t1);
const a2 = TIME.exec(t2);
if (!(a1 && a2))
return;
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 time3 = getTime(strictTimeZone);
return function date_time(str) {
const dateTime = str.split(DATE_TIME_SEPARATOR);
return dateTime.length === 2 && date4(dateTime[0]) && time3(dateTime[1]);
};
}
function compareDateTime(dt1, dt2) {
if (!(dt1 && dt2))
return;
const d1 = new Date(dt1).valueOf();
const d2 = new Date(dt2).valueOf();
if (!(d1 && d2))
return;
return d1 - d2;
}
function compareIsoDateTime(dt1, dt2) {
if (!(dt1 && dt2))
return;
const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
const res = compareDate(d1, d2);
if (res === undefined)
return;
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/.bun/ajv-formats@3.0.1/node_modules/ajv-formats/dist/limit.js
var require_limit = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatLimitDefinition = undefined;
var ajv_1 = require_ajv();
var codegen_1 = require_codegen();
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 error2 = {
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: error2,
code(cxt) {
const { gen, data, schemaCode, keyword, it } = cxt;
const { opts, self } = it;
if (!opts.validateFormats)
return;
const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
if (fCxt.$data)
validate$DataFormat();
else
validateFormat();
function validate$DataFormat() {
const fmts = gen.scopeValue("formats", {
ref: self.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 format = fCxt.schema;
const fmtDef = self.formats[format];
if (!fmtDef || fmtDef === true)
return;
if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
}
const fmt = gen.scopeValue("formats", {
key: format,
ref: fmtDef,
code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : undefined
});
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/.bun/ajv-formats@3.0.1/node_modules/ajv-formats/dist/index.js
var require_dist = __commonJS((exports, module) => {
Object.defineProperty(exports, "__esModule", { value: true });
var formats_1 = require_formats();
var limit_1 = require_limit();
var codegen_1 = require_codegen();
var fullName = new codegen_1.Name("fullFormats");
var fastName = new codegen_1.Name("fastFormats");
var formatsPlugin = (ajv, opts = { keywords: true }) => {
if (Array.isArray(opts)) {
addFormats(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;
addFormats(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 addFormats(ajv, list, fs, exportName) {
var _a;
var _b;
(_a = (_b = ajv.opts.code).formats) !== null && _a !== undefined || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
for (const f of list)
ajv.addFormat(f, fs[f]);
}
module.exports = exports = formatsPlugin;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = formatsPlugin;
});
// src/server/handlers/logs.ts
var sink;
function initLogSink(deliver) {
sink = deliver;
}
function getLogSink() {
return sink;
}
function closeLogSink() {
sink = undefined;
}
var logStore;
function initLogStore(agentPath) {
if (logStore)
return;
logStore = new SqliteLogStore(agentPath);
logStore.clear();
}
function getLogStore() {
return logStore;
}
function closeLogStore() {
logStore?.close();
logStore = undefined;
}
async function handleLogsQuery(req) {
if (!logStore) {
return errorResponse("Log store not initialized", "Log store not initialized", 503);
}
const params = new URL(req.url).searchParams;
const intParam = (raw) => {
if (raw == null)
return;
const n = Number.parseInt(raw, 10);
return Number.isFinite(n) ? n : undefined;
};
const limit = intParam(params.get("limit")) ?? 100;
const since = intParam(params.get("since"));
const levelParam = params.get("level");
const level = levelParam === "error" || levelParam === "warning" || levelParam === "info" ? levelParam : undefined;
const entries = logStore.queryLogs({ level, since, limit });
return successResponse(entries);
}
// src/server/handlers/component-events.ts
var subscribers = new SSEHub;
function broadcastComponentChanged(event) {
subscribers.broadcast("component-changed", event);
}
function handleComponentEventsSSE(req) {
return createSSEStream(req, {
onConnect(client) {
const unsubscribe = subscribers.subscribe(client);
client.send("connected", {});
return unsubscribe;
}
});
}
// src/server/handlers/traces.ts
var logger = createCliLogger({ tag: "traces" });
var traceStore;
function initTraceStore(agentPath) {
if (traceStore)
return;
traceStore = new SqliteTraceStore(agentPath);
const swept = traceStore.sweepRunningSpans();
traceStore.pruneExpiredSpanPayloads();
if (swept > 0) {
logger.info(`Swept ${swept} stale running span(s) from previous session`);
}
}
function getTraceStore() {
return traceStore;
}
function closeTraceStore() {
traceStore?.close();
traceStore = undefined;
}
async function handleTracesQuery(req) {
if (!traceStore) {
return errorResponse("Trace store not initialized", "Trace store not initialized", 503);
}
const urlParams = new URL(req.url).searchParams;
const attributeName = urlParams.get("attributeName");
const attributeValue = urlParams.get("attributeValue");
const count = parseInt(urlParams.get("count") || "1000");
const startTs = urlParams.get("startTs") ? parseInt(urlParams.get("startTs")) : undefined;
const endTs = urlParams.get("endTs") ? parseInt(urlParams.get("endTs")) : undefined;
if (!attributeName || !attributeValue) {
let recentTraces = traceStore.getRecentTraces(count);
if (startTs || endTs) {
recentTraces = recentTraces.filter((span) => {
const spanTs = span.timing.startedAt;
if (startTs && spanTs < startTs)
return false;
if (endTs && spanTs > endTs)
return false;
return true;
});
}
return successResponse(recentTraces);
}
const queryTraces = traceStore.getTraceByAttribute(attributeName, attributeValue, startTs, endTs);
return successResponse(queryTraces.slice(-count));
}
async function handleTraceById(req) {
if (!traceStore) {
return errorResponse("Trace store not initialized", "Trace store not initialized", 503);
}
const traceId = new URL(req.url).searchParams.get("traceId");
if (!traceId) {
return errorResponse("traceId parameter required", "traceId parameter required", 400);
}
const traces = traceStore.getTraceById(traceId);
return successResponse(traces);
}
async function handleTracePayload(req) {
if (!traceStore) {
return errorResponse("Trace store not initialized", "Trace store not initialized", 503);
}
const params = new URL(req.url).searchParams;
const traceId = params.get("traceId");
const spanId = params.get("spanId");
const key = params.get("key");
if (!traceId || !spanId || !key) {
return errorResponse("Missing parameters", "traceId, spanId and key parameters are required", 400);
}
const payload = traceStore.getSpanPayload(traceId, spanId, key);
if (!payload) {
return errorResponse("Payload not found", "Full payload not found or expired", 404);
}
let value = payload.value;
if (payload.contentType === "application/json") {
try {
value = JSON.parse(payload.value);
} catch {
value = payload.value;
}
}
return successResponse({
key: payload.key,
contentType: payload.contentType,
sizeBytes: payload.sizeBytes,
value
});
}
async function handleRecentTraces(req) {
if (!traceStore) {
return errorResponse("Trace store not initialized", "Trace store not initialized", 503);
}
const limit = parseInt(new URL(req.url).searchParams.get("limit") || "100");
const recentTraces = traceStore.getRecentTraces(limit);
return successResponse(recentTraces);
}
async function handleGetConversationUserToken(req) {
if (!traceStore) {
return errorResponse("Trace store not initialized", "Trace store not initialized", 503);
}
const params = new URL(req.url).searchParams;
const botId = params.get("botId");
const conversationId = params.get("conversationId");
if (!botId) {
return errorResponse("botId parameter required", "botId parameter required", 400);
}
if (!conversationId) {
return errorResponse("conversationId parameter required", "conversationId parameter required", 400);
}
const userToken = traceStore.getConversationUser(botId, conversationId);
if (!userToken) {
return errorResponse("User token not found", "No user token stored for this conversation", 404);
}
return successResponse({ userToken });
}
async function handleSetConversationUserToken(req) {
if (!traceStore) {
return errorResponse("Trace store not initialized", "Trace store not initialized", 503);
}
const body = await req.json();
if (!body.botId || !body.conversationId || !body.userToken) {
return errorResponse("Missing fields", "botId, conversationId and userToken are required", 400);
}
traceStore.setConversationUser(body.botId, body.conversationId, body.userToken);
return successResponse({ ok: true });
}
async function handleTodayTraces() {
if (!traceStore) {
return errorResponse("Trace store not initialized", "Trace store not initialized", 503);
}
const todayTraces = traceStore.getAllTodayTraces();
return successResponse(todayTraces);
}
// src/server/utils/broadcaster.ts
function createBroadcaster(options = {}) {
const bufferSize = options.bufferSize ?? 0;
const listeners = new Set;
const buffer = [];
return {
broadcast(item) {
if (bufferSize > 0) {
buffer.push(item);
if (buffer.length >= bufferSize * 2) {
buffer.splice(0, buffer.length - bufferSize);
}
}
for (const listener of listeners) {
try {
listener(item);
} catch {}
}
},
subscribe(listener) {
listeners.add(listener);
return () => {
listeners.delete(listener);
};
},
snapshot() {
return buffer.length > bufferSize ? buffer.slice(buffer.length - bufferSize) : buffer.slice();
},
get size() {
return listeners.size;
}
};
}
// src/server/routes/streaming.ts
var spanBroadcaster = createBroadcaster();
function broadcastSpan(span) {
spanBroadcaster.broadcast(span);
}
var LOG_BUFFER_SIZE = 5000;
var logBroadcaster = createBroadcaster({ bufferSize: LOG_BUFFER_SIZE });
function broadcastLog(entry) {
logBroadcaster.broadcast(entry);
}
function handleSSEStream(req) {
const url = new URL(req.url);
const count = parseInt(url.searchParams.get("count") || "1000");
const attributeName = url.searchParams.get("attributeName");
const attributeValue = url.searchParams.get("attributeValue");
const startTs = url.searchParams.get("startTs") ? parseInt(url.searchParams.get("startTs")) : undefined;
const endTs = url.searchParams.get("endTs") ? parseInt(url.searchParams.get("endTs")) : undefined;
const traceStore2 = getTraceStore();
if (!traceStore2) {
return new Response(JSON.stringify({ error: "Trace store not initialized" }), {
status: 503,
headers: { "Content-Type": "application/json", ...getCorsHeaders(req) }
});
}
const hasAttributeFilter = !!(attributeName && attributeValue);
const matchingTraceIds = new Set;
const matchesTimeRange = (span) => {
if (startTs && span.timing.startedAt < startTs)
return false;
if (endTs && span.timing.startedAt > endTs)
return false;
return true;
};
return createSSEStream(req, {
onConnect(client) {
let id = 0;
try {
let spans;
if (hasAttributeFilter) {
spans = traceStore2.getTraceByAttribute(attributeName, attributeValue, startTs, endTs);
spans = spans.slice(-count);
for (const span of spans) {
matchingTraceIds.add(span.id.trace);
}
} else {
spans = traceStore2.getRecentTraces(count);
if (startTs || endTs) {
spans = spans.filter((span) => matchesTimeRange(span));
}
}
client.send("snapshot", { spans }, { id: id++ });
} catch {
client.send("snapshot", { spans: [] }, { id: id++ });
}
return spanBroadcaster.subscribe((span) => {
if (client.closed)
return;
try {
if (hasAttributeFilter && !matchingTraceIds.has(span.id.trace)) {
const freshSpans = traceStore2.getTraceByAttribute(attributeName, attributeValue, startTs, endTs);
for (const s of freshSpans) {
matchingTraceIds.add(s.id.trace);
}
}
if (!matchesTimeRange(span))
return;
if (hasAttributeFilter && !matchingTraceIds.has(span.id.trace))
return;
client.send("update", { span }, { id: id++ });
} catch {}
});
}
});
}
function streamLogs(req) {
return createSSEStream(req, {
onConnect(client) {
const buffered = logBroadcaster.snapshot();
if (buffered.length > 0) {
for (const entry of buffered) {
if (!client.sendData(entry))
return;
}
} else {
const store = getLogStore();
if (store) {
for (const entry of store.getRecentLogs(LOG_BUFFER_SIZE)) {
try {
if (!client.sendData(JSON.parse(entry.raw)))
return;
} catch {}
}
}
}
return logBroadcaster.subscribe((entry) => {
if (client.closed)
return;
client.sendData(entry);
});
}
});
}
// src/server/backend-server.ts
var {serve } = globalThis.Bun;
// src/server/handlers/health.ts
async function handleHealth() {
const config = getServerConfig();
const adkVersion = config?.adkVersion || getAdkVersion();
const serverStartTime = getServerStartTime();
return successResponse({
status: getDevCommandStatus(),
adkVersion,
agentPath: config?.agentPath ?? "",
startTime: serverStartTime.toISOString(),
uptime: Date.now() - serverStartTime.getTime()
});
}
// src/server/handlers/config.ts
async function handleConfigRequest() {
const serverConfig = getServerConfig();
let identity = {};
try {
const profile = await auth.getCurrentProfileDetails();
if (profile) {
identity = {
accountId: profile.accountId,
email: profile.email,
displayName: profile.displayName
};
}
} catch {}
return successResponse({
credentials: {
hasToken: !!serverConfig.credentials?.token,
token: serverConfig.credentials?.token,
apiUrl: serverConfig.credentials?.apiUrl,
workspaceId: serverConfig.credentials?.workspaceId,
devBotId: serverConfig.project?.agentInfo?.devId ?? serverConfig.credentials?.devBotId,
prodBotId: serverConfig.project?.agentInfo?.botId
},
agentPath: serverConfig.agentPath,
adkVersion: CLI_VERSION,
adkDevConsole: {
port: serverConfig.port,
url: `http://localhost:${serverConfig.port}`
},
devBot: getDevBotRuntimeState(),
identity,
telemetry: {
enabled: telemetry_default.isEnabled()
}
});
}
// src/server/handlers/worker-stats.ts
function handleWorkerStats() {
return successResponse(getLatestWorkerStats() || {
total: 0,
starting: 0,
idle: 0,
busy: 0,
terminated: 0,
queueSize: 0
});
}
async function handleWorkerStatsIngest(req) {
try {
const stats = await req.json();
updateWorkerStats(stats);
return new Response(null, { status: 200 });
} catch {
return new Response(null, { status: 500 });
}
}
// src/server/handlers/agent.ts
import { existsSync, readFileSync } from "fs";
import { join } from "path";
var logger2 = createCliLogger({ tag: "agent" });
var AGENT_NOT_DEPLOYED_MESSAGE = "Agent has not been deployed yet. Deploy with `adk deploy` to publish the production target.";
async function handleAgentInfo(environment = getActiveEnvironment()) {
const serverConfig = getServerConfig();
if (environment === "prod") {
const target = getLocalProdMetadataTarget(serverConfig);
if (!target) {
return errorResponse("Agent not deployed", AGENT_NOT_DEPLOYED_MESSAGE, 400);
}
try {
return successResponse(await prodAgentMetadataService.getAgentDefinition(target));
} catch (error) {
return errorResponse("Agent not deployed", error instanceof Error ? error.message : AGENT_NOT_DEPLOYED_MESSAGE, 404);
}
}
if (!serverConfig.project) {
const agentConfigPath = join(serverConfig.agentPath, "agent.config.ts");
const agentJsonPath = join(serverConfig.agentPath, "agent.json");
let agentInfo = {
path: serverConfig.agentPath
};
if (existsSync(agentConfigPath)) {
const configContent = readFileSync(agentConfigPath, "utf-8");
const nameMatch = configContent.match(/name:\s*['"`]([^'"`]+)['"`]/);
const versionMatch = configContent.match(/version:\s*['"`]([^'"`]+)['"`]/);
agentInfo.name = nameMatch?.[1] || "unknown";
agentInfo.version = versionMatch?.[1] || "0.0.0";
}
if (existsSync(agentJsonPath)) {
try {
const agentJson = JSON.parse(readFileSync(agentJsonPath, "utf-8"));
agentInfo = { ...agentInfo, ...agentJson };
} catch (error) {
logger2.warn(`Failed to parse ${agentJsonPath}: ${error instanceof Error ? error.message : String(error)}. ` + "Agent info will be incomplete; fix or re-link with `adk link`.");
}
}
return successResponse(agentInfo);
}
const agentDefinition = {
name: serverConfig.project.config?.name || "unknown",
version: serverConfig.project.config?.version || "0.0.0",
description: serverConfig.project.config?.description,
path: serverConfig.agentPath,
agentInfo: serverConfig.project.agentInfo,
workflows: serverConfig.project.workflows?.map((x) => ({
...x.definition,
path: x.path,
export: x.export
})) ?? [],
actions: serverConfig.project.actions?.map((x) => x.definition) ?? [],
tables: serverConfig.project.tables?.map((x) => x.definition) ?? [],
triggers: serverConfig.project.triggers?.map((x) => x.definition) ?? [],
conversations: serverConfig.project.conversations.map((x) => x.definition) ?? [],
knowledge: serverConfig.project.knowledge.map((x) => x.definition) ?? []
};
return successResponse(agentDefinition);
}
// src/server/handlers/agent-map/routes.ts
async function handleAgentMapSnapshot(req) {
const config = getServerConfig();
const url = new URL(req.url);
const environment = url.searchParams.get("env");
if (environment === "prod") {
const target = getLocalProdMetadataTarget(config);
if (!target) {
return errorResponse("Agent Map metadata unavailable", "No production bot is linked for this agent. Deploy or link a prod bot first.", 400);
}
try {
const snapshot = await prodAgentMapSnapshotService.getSnapshot(target);
return successResponse(snapshot);
} catch (err) {
return errorResponse(err instanceof AgentMapSnapshotNotPublishedError ? "Agent Map metadata not published" : "Snapshot failed", errorMessage(err), err instanceof AgentMapSnapshotNotPublishedError ? 404 : 500);
}
}
if (!config?.project) {
return errorResponse("Project not loaded", "No agent project is loaded on the server. Start the dev server inside an agent directory.", 503);
}
try {
const snapshot = buildAgentSnapshot(config.project);
return successResponse(snapshot);
} catch (err) {
return errorResponse("Snapshot failed", errorMessage(err), 500);
}
}
function errorMessage(err) {
if (err instanceof Error)
return err.message;
return String(err);
}
// src/server/handlers/agent-map/sse.ts
onProjectReloaded(() => scheduleBroadcast());
var subscribers2 = new SSEHub;
var coalesceTimer = null;
var COALESCE_MS = 50;
function scheduleBroadcast() {
if (coalesceTimer)
return;
coalesceTimer = setTimeout(() => {
coalesceTimer = null;
broadcastCanvasSnapshot();
}, COALESCE_MS);
}
function broadcastCanvasSnapshot() {
const config = getServerConfig();
if (!config?.project)
return;
if (subscribers2.size === 0)
return;
let payload;
try {
const snapshot = buildAgentSnapshot(config.project);
payload = { event: "snapshot", data: snapshot };
} catch (err) {
payload = {
event: "parse-error",
data: { reason: err instanceof Error ? err.message : String(err) }
};
}
subscribers2.broadcast(payload.event, payload.data);
}
function handleAgentMapSSE(req) {
const url = new URL(req.url);
if (url.searchParams.get("env") === "prod") {
return errorResponse("Agent Map stream unavailable", "Agent Map streaming is only available for local dev. Use /api/agent-map/snapshot?env=prod for prod.", 400);
}
return createSSEStream(req, {
onConnect(client) {
const unsubscribe = subscribers2.subscribe(client);
const config = getServerConfig();
if (config?.project) {
try {
const snapshot = buildAgentSnapshot(config.project);
client.send("snapshot", snapshot);
} catch (err) {
client.send("parse-error", {
reason: err instanceof Error ? err.message : String(err)
});
}
}
return unsubscribe;
}
});
}
// src/server/handlers/source-snippet.ts
import { readFileSync as readFileSync2 } from "fs";
import { relative, resolve, sep } from "path";
var MAX_LINES = 400;
var DEFAULT_CONTEXT = 3;
function inferLanguage(path) {
const p = path.toLowerCase();
if (p.endsWith(".tsx"))
return "tsx";
if (p.endsWith(".ts"))
return "typescript";
if (p.endsWith(".jsx"))
return "jsx";
if (p.endsWith(".js"))
return "javascript";
if (p.endsWith(".json"))
return "json";
if (p.endsWith(".md"))
return "markdown";
return "text";
}
function parseInt1Based(raw, fallback) {
if (raw === null || raw === "")
return fallback;
const n = Number.parseInt(raw, 10);
if (!Number.isFinite(n) || n < 1)
return;
return n;
}
function resolveSafePath(rawPath, projectRoot) {
if (!rawPath)
return null;
const projectAbs = resolve(projectRoot);
const target = resolve(projectAbs, rawPath);
const rel = relative(projectAbs, target);
if (rel.startsWith("..") || rel.startsWith(`..${sep}`))
return null;
return target;
}
function handleSourceSnippet(req) {
const serverConfig = getServerConfig();
const projectRoot = serverConfig.project?.path;
if (!projectRoot) {
return errorResponse("No project", "No project path configured", 404);
}
const url = new URL(req.url);
const params = url.searchParams;
const rawPath = params.get("path") ?? "";
const start = parseInt1Based(params.get("start"));
const end = parseInt1Based(params.get("end"), start);
const context = parseInt1Based(params.get("context"), DEFAULT_CONTEXT) ?? DEFAULT_CONTEXT;
if (!rawPath)
return errorResponse("Missing path", "Missing required `path` query parameter", 400);
if (start === undefined || end === undefined) {
return errorResponse("Missing range", "Missing or invalid `start` / `end` line numbers", 400);
}
if (end < start) {
return errorResponse("Invalid range", "`end` must be >= `start`", 400);
}
const absPath = resolveSafePath(rawPath, projectRoot);
if (!absPath) {
return errorResponse("Forbidden", "Requested path is outside the project root", 403);
}
let source;
try {
source = readFileSync2(absPath, "utf-8");
} catch {
return errorResponse("Not found", `Could not read source file at ${rawPath}`, 404);
}
const allLines = source.split(`
`);
const total = allLines.length;
const clampedStart = Math.max(1, Math.min(start, total));
const clampedEnd = Math.max(clampedStart, Math.min(end, total));
let firstLine = Math.max(1, clampedStart - context);
let lastLine = Math.min(total, clampedEnd + context);
if (lastLine - firstLine + 1 > MAX_LINES) {
lastLine = firstLine + MAX_LINES - 1;
}
const lines = allLines.slice(firstLine - 1, lastLine);
const relativePath = relative(projectRoot, absPath);
return successResponse({
relativePath,
language: inferLanguage(absPath),
startLine: clampedStart,
endLine: clampedEnd,
firstLine,
lastLine,
totalLines: total,
lines
});
}
// src/server/handlers/open-source.ts
import { existsSync as existsSync2 } from "fs";
import { relative as relative2, resolve as resolve2, sep as sep2 } from "path";
// src/utils/editor-detector.ts
import { exec } from "child_process";
import { promisify } from "util";
var execAsync = promisify(exec);
async function isCursorRunning() {
try {
if (process.platform === "darwin") {
const { stdout } = await execAsync("pgrep -f 'Cursor'");
return stdout.trim().length > 0;
} else if (process.platform === "win32") {
const { stdout } = await execAsync('tasklist /FI "IMAGENAME eq Cursor.exe" /NH');
return stdout.includes("Cursor.exe");
} else {
const { stdout } = await execAsync("pgrep -f cursor");
return stdout.trim().length > 0;
}
} catch {
return false;
}
}
async function isVSCodeRunning() {
try {
if (process.platform === "darwin") {
const { stdout } = await execAsync("pgrep -f 'Visual Studio Code'");
return stdout.trim().length > 0;
} else if (process.platform === "win32") {
const { stdout } = await execAsync('tasklist /FI "IMAGENAME eq Code.exe" /NH');
return stdout.includes("Code.exe");
} else {
const { stdout } = await execAsync("pgrep -f code");
return stdout.trim().length > 0;
}
} catch {
return false;
}
}
async function detectRunningEditor() {
const [cursorRunning, vscodeRunning] = await Promise.all([isCursorRunning(), isVSCodeRunning()]);
if (cursorRunning)
return "cursor";
if (vscodeRunning)
return "vscode";
return null;
}
// src/server/handlers/open-source.ts
function resolveSafePath2(rawPath, projectRoot) {
if (!rawPath)
return null;
const projectAbs = resolve2(projectRoot);
const target = resolve2(projectAbs, rawPath);
const rel = relative2(projectAbs, target);
if (rel.startsWith("..") || rel.startsWith(`..${sep2}`))
return null;
return target;
}
function positiveInt(value, fallback) {
if (typeof value === "number" && Number.isFinite(value) && value >= 1)
return Math.floor(value);
if (typeof value === "string") {
const parsed = Number.parseInt(value, 10);
if (Number.isFinite(parsed) && parsed >= 1)
return parsed;
}
return fallback;
}
function normalizeEditor(value) {
if (!value)
return null;
const normalized = value.toLowerCase();
if (normalized.includes("cursor"))
return "cursor";
if (normalized.includes("code") || normalized.includes("vscode") || normalized.includes("visual studio code"))
return "vscode";
return null;
}
function editorUri(editor, absPath, line, column) {
const scheme = editor === "cursor" ? "cursor" : "vscode";
const uriPath = process.platform === "win32" ? absPath.replace(/\\/g, "/") : absPath;
return encodeURI(`${scheme}://file/${uriPath}:${line}:${column}`);
}
async function handleOpenSource(req) {
if (req.method !== "POST") {
return errorResponse("Method not allowed", "Only POST requests are allowed", 405);
}
const serverConfig = getServerConfig();
const projectRoot = serverConfig.project?.path ?? serverConfig.agentPath;
if (!projectRoot) {
return errorResponse("No project", "No project path configured", 404);
}
let body;
try {
body = await req.json();
} catch {
return errorResponse("Invalid body", "Expected a JSON body with `path`, `line`, and optional `column`.", 400);
}
if (typeof body.path !== "string" || !body.path) {
return errorResponse("Missing path", "Missing required `path` field.", 400);
}
const absPath = resolveSafePath2(body.path, projectRoot);
if (!absPath) {
return errorResponse("Forbidden", "Requested path is outside the project root", 403);
}
if (!existsSync2(absPath)) {
return errorResponse("Not found", `Could not find source file at ${body.path}`, 404);
}
const line = positiveInt(body.line, 1);
const column = positiveInt(body.column, 1);
const envEditorRaw = process.env.ADK_EDITOR ?? process.env.VISUAL ?? process.env.EDITOR;
const preferredEditor = normalizeEditor(envEditorRaw);
const editor = envEditorRaw ? preferredEditor : await detectRunningEditor();
try {
if (editor) {
await open_default(editorUri(editor, absPath, line, column));
return successResponse({ opened: true, editor, path: body.path, line, column });
}
await open_default(absPath);
return successResponse({ opened: true, editor: null, path: body.path, line, column });
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
return errorResponse("Open failed", message, 500);
}
}
// src/server/handlers/tables.ts
var logger3 = createCliLogger({ tag: "tables" });
async function handleTableSchemaDiff(req) {
const validationError = validateProjectAndCredentials();
if (validationError) {
return validationError;
}
const environment = parseEnv(req);
if (!environment) {
return errorResponse("Invalid environment", 'env query param must be "dev" or "prod"', 400);
}
const botIdError = validateBotId(environment);
if (botIdError) {
return botIdError;
}
try {
const serverConfig = getServerConfig();
const targetBotId = getTargetBotId(environment);
const { TableManager } = await import("./chunk-ka3e16hs.js");
const tableManager = new TableManager({
project: serverConfig.project,
botId: targetBotId,
credentials: getScopedServerCredentials(targetBotId)
});
const syncPlan = await tableManager.createSyncPlan();
return successResponse(syncPlan);
} catch (error) {
return errorResponse("Failed to get schema diff", error instanceof Error ? error.message : "Unknown error");
}
}
async function handleTableSchemaPush(req) {
const validationError = validateProjectAndCredentials();
if (validationError) {
return validationError;
}
const environment = parseEnv(req);
if (!environment) {
return errorResponse("Invalid environment", 'env query param must be "dev" or "prod"', 400);
}
const botIdError = validateBotId(environment);
if (botIdError) {
return botIdError;
}
try {
const serverConfig = getServerConfig();
const targetBotId = getTargetBotId(environment);
const { TableManager, toTableSyncFailureDetails } = await import("./chunk-ka3e16hs.js");
const tableManager = new TableManager({
project: serverConfig.project,
botId: targetBotId,
credentials: getScopedServerCredentials(targetBotId)
});
const syncPlan = await tableManager.createSyncPlan();
if (!syncPlan.hasChanges) {
return successResponse({
success: true,
message: "No changes to push",
result: {
applied: false,
success: [],
failed: [],
summary: {
created: 0,
updated: 0,
deleted: 0,
failed: 0
}
}
});
}
const syncResult = await tableManager.executeSync(syncPlan, { confirmDestructive: true });
const hasFailures = syncResult.failed.length > 0;
const message = hasFailures ? `Schema push completed with ${syncResult.failed.length} failure(s)` : "Schema pushed successfully";
return successResponse({
success: !hasFailures,
message,
result: {
...syncResult,
failureDetails: toTableSyncFailureDetails(syncResult.failed)
}
});
} catch (error) {
return errorResponse("Failed to push schema", error instanceof Error ? error.message : "Unknown error");
}
}
async function handleTableRecreate(tableName) {
if (!tableName) {
return errorResponse("No table name provided", "Table name is required", 400);
}
const validationError = validateCredentials();
if (validationError) {
return validationError;
}
const botIdError = validateBotId();
if (botIdError) {
return botIdError;
}
const serverConfig = getServerConfig();
const targetBotId = getTargetBotId();
const tableDefinition = serverConfig.project?.tables?.find((t) => t.definition.name === tableName);
if (!tableDefinition) {
return errorResponse("Table not found", `Table "${tableName}" not found in local project definitions`, 404);
}
try {
const { getProjectClient: getProjectClient2 } = await import("./chunk-ka3e16hs.js");
const client = await getProjectClient2({
credentials: getScopedServerCredentials(targetBotId),
botId: targetBotId
});
try {
await client.deleteTable({ table: tableName });
} catch {
logger3.info(`Table ${tableName} deletion skipped (may not exist remotely)`);
}
await client.createTable({
name: tableDefinition.definition.name,
factor: tableDefinition.definition.factor || 1,
schema: tableDefinition.definition.schema,
isComputeEnabled: true
});
return successResponse({
success: true,
message: `Table "${tableName}" recreated successfully`,
table: tableDefinition.definition.name
});
} catch (error) {
return errorResponse("Failed to recreate table", error instanceof Error ? error.message : "Unknown error");
}
}
// src/server/handlers/knowledge.ts
async function handleKnowledgeSyncDiff(req) {
const validationError = validateProjectAndCredentials();
if (validationError) {
return validationError;
}
const environment = new URL(req.url).searchParams.get("env") || "dev";
const botIdError = validateBotId(environment);
if (botIdError) {
return botIdError;
}
try {
const serverConfig = getServerConfig();
const targetBotId = getTargetBotId(environment);
const { KnowledgeManager } = await import("./chunk-ka3e16hs.js");
const knowledgeManager = new KnowledgeManager({
project: serverConfig.project,
botId: targetBotId,
credentials: getScopedServerCredentials(targetBotId)
});
const syncPlan = await knowledgeManager.createSyncPlan();
return successResponse(syncPlan);
} catch (error) {
return errorResponse("Failed to get knowledge sync diff", error instanceof Error ? error.message : "Unknown error");
}
}
async function handleKnowledgeSyncPush(req) {
const validationError = validateProjectAndCredentials();
if (validationError) {
return validationError;
}
const url = new URL(req.url);
const environment = url.searchParams.get("env") || "dev";
const force = url.searchParams.get("force") === "true";
const botIdError = validateBotId(environment);
if (botIdError) {
return botIdError;
}
try {
const serverConfig = getServerConfig();
const targetBotId = getTargetBotId(environment);
const { KnowledgeManager } = await import("./chunk-ka3e16hs.js");
const knowledgeManager = new KnowledgeManager({
project: serverConfig.project,
botId: targetBotId,
credentials: getScopedServerCredentials(targetBotId)
});
const syncPlan = await knowledgeManager.createSyncPlan();
if (!syncPlan.hasChanges && !force) {
return successResponse({
success: true,
message: "No changes to sync",
result: {
synced: [],
skipped: [],
failed: []
}
});
}
const syncResult = await knowledgeManager.executeSync(syncPlan, { force, confirmDestructive: true });
const hasFailures = syncResult.failed.length > 0;
const message = hasFailures ? `Knowledge sync completed with ${syncResult.failed.length} failure(s)` : "Knowledge synced successfully";
return successResponse({
success: !hasFailures,
message,
result: syncResult
});
} catch (error) {
return errorResponse("Failed to sync knowledge", error instanceof Error ? error.message : "Unknown error");
}
}
// src/server/handlers/integrations.ts
function getServerClient() {
const serverConfig = getServerConfig();
const creds = serverConfig.credentials;
if (!creds.token) {
return Promise.reject(new Error("Server is not authenticated. Run `adk login` first."));
}
return getProjectClient({
credentials: {
token: creds.token,
apiUrl: creds.apiUrl || "https://api.botpress.cloud",
...creds.workspaceId ? { workspaceId: creds.workspaceId } : {}
}
});
}
function getDevBotId() {
const serverConfig = getServerConfig();
return serverConfig.project?.agentInfo?.devId ?? serverConfig.credentials.devBotId ?? serverConfig.project?.agentInfo?.botId;
}
async function handleIntegrationAdd(req) {
const serverConfig = getServerConfig();
try {
const body = await req.json();
const name = body.name;
if (!name) {
return errorResponse("Missing name", "Integration name is required", 400);
}
const client = await getServerClient();
const botId = getDevBotId();
if (!botId) {
throw new Error("No dev bot ID available for dependency management.");
}
const dm = new exports_dependencies.DependencyManager({
projectPath: serverConfig.agentPath,
env: "dev",
client,
botId
});
const result = await dm.add("integration", { name, version: body.version || "latest", alias: body.alias });
return successResponse({
...result,
alias: result.resource?.alias ?? body.alias ?? name,
fullName: result.resource?.name ?? name
});
} catch (error) {
return errorResponse("Failed to add integration", error instanceof Error ? error.message : "Unknown error");
}
}
// src/server/handlers/dependencies.ts
function isEnvironment(value) {
return value === "dev" || value === "prod";
}
function isTargetSelection(value) {
return isEnvironment(value) || value === "all";
}
function expandTarget(target) {
return target === "all" ? ["dev", "prod"] : [target];
}
function dependencyErrorResponse(error, title) {
const err = error;
const message = typeof err.message === "string" ? err.message : "Unknown error";
const code = typeof err.code === "string" ? err.code : undefined;
const status = code === "AUTH_REQUIRED" ? 401 : code === "PROD_CONFIRMATION_REQUIRED" || code === "UNINSTALL_REQUIRES_CONFIRMATION" ? 409 : code === "MISSING_INPUT" || code === "SAME_SOURCE_TARGET" || code === "SOURCE_SNAPSHOT_MISSING" || code === "BOT_NOT_FOUND" ? 400 : 500;
return jsonResponse({
error: title,
message,
...code ? { code } : {},
...err.details !== undefined ? { details: err.details } : {},
...err.suggestion !== undefined ? { suggestion: err.suggestion } : {}
}, status);
}
async function readJsonBody(req) {
return await req.json().catch(() => ({})) ?? {};
}
function parseTargetFromBody(body, fallback = "dev") {
const target = body.target ?? fallback;
return isTargetSelection(target) ? target : null;
}
function parseTargetFromUrl(req, fallback = "dev") {
const raw = new URL(req.url).searchParams.get("target") ?? fallback;
return isTargetSelection(raw) ? raw : null;
}
function parseEnvironmentFromBody(body, key) {
const value = body[key];
return isEnvironment(value) ? value : null;
}
async function getServerClient2() {
const serverConfig = getServerConfig();
const creds = serverConfig.credentials;
if (!creds.token) {
throw new exports_dependencies.DependencyError({
code: "AUTH_REQUIRED",
message: "Server is not authenticated. Run `adk login` first."
});
}
return getProjectClient({
credentials: {
token: creds.token,
apiUrl: creds.apiUrl || "https://api.botpress.cloud",
...creds.workspaceId ? { workspaceId: creds.workspaceId } : {}
}
});
}
async function getDependencyManager(target) {
const serverConfig = getServerConfig();
const client = await getServerClient2();
const botId = getTargetBotId2(target);
if (!botId) {
throw new exports_dependencies.DependencyError({
code: "BOT_NOT_FOUND",
message: `No ${target} bot ID available for dependency management.`
});
}
return new exports_dependencies.DependencyManager({
projectPath: serverConfig.agentPath,
env: target,
client,
botId
});
}
function getTargetBotId2(target) {
const serverConfig = getServerConfig();
if (target === "prod") {
return serverConfig.project?.agentInfo?.botId ?? serverConfig.credentials.prodBotId;
}
return serverConfig.project?.agentInfo?.devId ?? serverConfig.credentials.devBotId ?? serverConfig.project?.agentInfo?.botId;
}
function getActionCount(result) {
return result.applied.length + result.skipped.length;
}
function getChangeCount(result) {
if ("delta" in result) {
return result.delta.addedInSnapshot.length + result.delta.removedInSnapshot.length + result.delta.changedInSnapshot.length;
}
return 0;
}
function changedFields(dev, prod, type) {
const fields = [];
if (dev.name !== prod.name)
fields.push("name");
if (dev.version !== prod.version)
fields.push("version");
if (dev.enabled !== prod.enabled)
fields.push("enabled");
if (!exports_dependencies.jsonEqual(dev.config, prod.config))
fields.push("config");
if (type === "plugin" && !exports_dependencies.jsonEqual(dev.dependencies, prod.dependencies)) {
fields.push("dependencies");
}
return fields;
}
function compareEntries(type, devEntries, prodEntries) {
const addedInDev = [];
const addedInProd = [];
const changed = [];
for (const [alias, entry] of Object.entries(devEntries)) {
const prodEntry = prodEntries[alias];
if (!prodEntry) {
addedInDev.push({ type, alias, name: entry.name, version: entry.version, entry });
continue;
}
const fields = changedFields(entry, prodEntry, type);
if (fields.length) {
changed.push({ type, alias, name: entry.name, fields, dev: entry, prod: prodEntry });
}
}
for (const [alias, entry] of Object.entries(prodEntries)) {
if (!devEntries[alias]) {
addedInProd.push({ type, alias, name: entry.name, version: entry.version, entry });
}
}
return { addedInDev, addedInProd, changed };
}
async function handleDependenciesDiff(req) {
const target = parseTargetFromUrl(req, "dev");
if (!target) {
return errorResponse("Invalid target", "target must be one of: dev, prod, all", 400);
}
try {
const results = [];
for (const env of expandTarget(target)) {
const dm = await getDependencyManager(env);
const result = await dm.diff();
results.push({ env, ...result, changeCount: getChangeCount(result) });
}
return successResponse({ target, results });
} catch (error) {
return dependencyErrorResponse(error, "Failed to diff dependencies");
}
}
async function handleDependenciesCloudUpdated(req) {
try {
const body = await readJsonBody(req);
const target = parseTargetFromBody(body, "dev");
if (!target || target === "all") {
return errorResponse("Invalid target", "target must be one of: dev, prod", 400);
}
const botId = getTargetBotId2(target);
if (!botId) {
throw new exports_dependencies.DependencyError({
code: "BOT_NOT_FOUND",
message: `No ${target} bot ID available for dependency cloud update handling.`
});
}
const serverConfig = getServerConfig();
const client = await getServerClient2();
await new exports_dependencies.DependencySnapshotStore({ projectPath: serverConfig.agentPath }).refreshFromCloud({
client,
botId,
env: target,
integrationRegistry: new exports_dependencies.IntegrationRegistry
});
AgentProject.clearCacheForPath(serverConfig.agentPath);
return successResponse({ acknowledged: true, target });
} catch (error) {
return dependencyErrorResponse(error, "Failed to handle dependency cloud update");
}
}
async function handleDependenciesCopy(req) {
try {
const body = await readJsonBody(req);
const from = parseEnvironmentFromBody(body, "from");
const to = parseEnvironmentFromBody(body, "to");
if (!from || !to) {
return errorResponse("Invalid environment", "from and to must be one of: dev, prod", 400);
}
const sourceBotId = getTargetBotId2(from);
if (!sourceBotId) {
throw new exports_dependencies.DependencyError({
code: "BOT_NOT_FOUND",
message: `No ${from} bot ID available for dependency copy.`
});
}
const dm = await getDependencyManager(to);
const result = await dm.copy({
from,
to,
dryRun: body.dryRun === true,
yes: body.yes === true,
sourceBotId
});
return successResponse({ from, to, result, actionCount: getActionCount(result) });
} catch (error) {
return dependencyErrorResponse(error, "Failed to copy dependencies");
}
}
async function handleDependenciesCompare() {
try {
const serverConfig = getServerConfig();
const snapshotStore = new exports_dependencies.DependencySnapshotStore({ projectPath: serverConfig.agentPath });
const devSnapshot = await snapshotStore.readOrEmpty("dev");
const prodSnapshot = await snapshotStore.readOrEmpty("prod");
const integrations = compareEntries("integration", devSnapshot.integrations, prodSnapshot.integrations);
const plugins = compareEntries("plugin", devSnapshot.plugins, prodSnapshot.plugins);
const addedInDev = [...integrations.addedInDev, ...plugins.addedInDev];
const addedInProd = [...integrations.addedInProd, ...plugins.addedInProd];
const changed = [...integrations.changed, ...plugins.changed];
return successResponse({
hasChanges: addedInDev.length > 0 || addedInProd.length > 0 || changed.length > 0,
addedInDev,
addedInProd,
changed,
summary: {
addedInDev: addedInDev.length,
addedInProd: addedInProd.length,
changed: changed.length
}
});
} catch (error) {
return dependencyErrorResponse(error, "Failed to compare dependencies");
}
}
// src/server/handlers/inspector.ts
function handleInspector() {
return successResponse({ message: "Inspector enabled" });
}
// src/server/handlers/components.ts
import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
import { relative as relative4, resolve as resolve4 } from "path";
// src/utils/project-paths.ts
import { relative as relative3, resolve as resolve3, sep as sep3 } from "path";
function isInsideProject(absPath, projectRoot) {
const rel = relative3(resolve3(projectRoot), resolve3(absPath));
return rel !== "" && !rel.startsWith("..") && !rel.startsWith(`..${sep3}`);
}
// src/server/handlers/components.ts
var MAX_SOURCE_BYTES = 256 * 1024;
var REGISTRY_URL = new URL("https://adk.botpresscontent.cloud");
var BASE_STYLES_FILENAME = "registry-base.css";
var REMOTE_FETCH_TIMEOUT_MS = 5000;
function isJsonSafePlainObject(value) {
if (!value || typeof value !== "object" || Array.isArray(value))
return false;
try {
const round = JSON.parse(JSON.stringify(value));
return !!round && typeof round === "object" && !Array.isArray(round);
} catch {
return false;
}
}
function isWhitlisted(url) {
try {
const u = new URL(url);
return u.origin === REGISTRY_URL.origin;
} catch {
return false;
}
}
function isValidJsIdentifier(s) {
return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(s);
}
async function fetchTextWithLimit(url) {
const controller = new AbortController;
const timer = setTimeout(() => controller.abort(), REMOTE_FETCH_TIMEOUT_MS);
try {
const res = await fetch(url, { signal: controller.signal });
if (!res.ok) {
throw new Error(`${res.status} ${res.statusText}`);
}
const text = await res.text();
if (Buffer.byteLength(text, "utf-8") > MAX_SOURCE_BYTES) {
throw new Error(`payload exceeds ${MAX_SOURCE_BYTES} bytes`);
}
return text;
} finally {
clearTimeout(timer);
}
}
function escapeRegex(s) {
return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
async function handleAddRegistryComponentToBot(req) {
const serverConfig = getServerConfig();
const project = serverConfig.project;
if (!project) {
return errorResponse("No project", "No project path configured", 404);
}
let body;
try {
body = await req.json();
} catch {
return errorResponse("Invalid body", "Body must be a JSON object", 400);
}
const exportName = typeof body.exportName === "string" ? body.exportName : "";
if (!isValidJsIdentifier(exportName)) {
return errorResponse("Invalid exportName", "exportName must be a valid JavaScript identifier", 400);
}
const componentName = typeof body.componentName === "string" ? body.componentName : "";
if (!componentName) {
return errorResponse("Invalid componentName", "componentName must be a non-empty string", 400);
}
const componentUrl = typeof body.componentUrl === "string" ? body.componentUrl : "";
if (!isWhitlisted(componentUrl)) {
return errorResponse("Invalid componentUrl", "componentUrl must be from an allowed origin", 400);
}
const typesUrl = typeof body.typesUrl === "string" ? body.typesUrl : "";
if (!isWhitlisted(typesUrl)) {
return errorResponse("Invalid typesUrl", "typesUrl must be must be from an allowed origin", 400);
}
const cssUrl = typeof body.cssUrl === "string" && body.cssUrl ? body.cssUrl : null;
if (cssUrl !== null && !isWhitlisted(cssUrl)) {
return errorResponse("Invalid cssUrl", "cssUrl must be from an allowed origin", 400);
}
const baseStylesUrl = typeof body.baseStylesUrl === "string" && body.baseStylesUrl ? body.baseStylesUrl : null;
if (baseStylesUrl !== null && !isWhitlisted(baseStylesUrl)) {
return errorResponse("Invalid baseStylesUrl", "baseStylesUrl must be from an allowed origin", 400);
}
let propsSchemaExport = null;
if (body.propsSchemaExport !== undefined) {
if (typeof body.propsSchemaExport !== "string" || !isValidJsIdentifier(body.propsSchemaExport)) {
return errorResponse("Invalid propsSchemaExport", "propsSchemaExport must be a valid JavaScript identifier", 400);
}
propsSchemaExport = body.propsSchemaExport;
}
let exampleValues = null;
if (body.exampleValues !== undefined) {
if (!Array.isArray(body.exampleValues)) {
return errorResponse("Invalid exampleValues", "exampleValues must be an array of plain objects", 400);
}
if (!body.exampleValues.every(isJsonSafePlainObject)) {
return errorResponse("Invalid exampleValues", "each exampleValues entry must be a JSON-serializable object", 400);
}
exampleValues = body.exampleValues;
}
const componentsDir = resolve4(project.path, COMPONENTS_DIR);
if (!isInsideProject(componentsDir, project.path)) {
return errorResponse("Forbidden", "Components directory escapes the project root", 403);
}
const bpDir = resolve4(componentsDir, exportName);
if (!isInsideProject(bpDir, project.path)) {
return errorResponse("Forbidden", "Component directory escapes the project root", 403);
}
const bpTsxPath = resolve4(bpDir, `${exportName}${BP_TSX_SUFFIX}`);
const bpTypesPath = resolve4(bpDir, `${exportName}${BP_TYPES_SUFFIX}`);
const bpCssPath = resolve4(bpDir, `${exportName}${BP_CSS_SUFFIX}`);
const baseStylesPath = resolve4(componentsDir, BASE_STYLES_FILENAME);
const indexPath = resolve4(componentsDir, "index.ts");
if (existsSync3(bpDir)) {
return errorResponse("Conflict", `${exportName}/ already exists in ${COMPONENTS_DIR}`, 409);
}
let existingIndex = null;
if (existsSync3(indexPath)) {
existingIndex = readFileSync3(indexPath, "utf-8");
const conflict = findConflictingExport(existingIndex, exportName);
if (conflict) {
return errorResponse("Conflict", `${conflict} is already exported from index.ts`, 409);
}
}
const writeBaseStyles = baseStylesUrl !== null && !existsSync3(baseStylesPath);
let componentText;
let typesText;
let cssText = null;
let baseStylesText = null;
try {
componentText = await fetchTextWithLimit(componentUrl);
typesText = await fetchTextWithLimit(typesUrl);
if (cssUrl)
cssText = await fetchTextWithLimit(cssUrl);
if (writeBaseStyles && baseStylesUrl)
baseStylesText = await fetchTextWithLimit(baseStylesUrl);
} catch (e) {
const msg = e instanceof Error ? e.message : String(e);
return errorResponse("Fetch failed", `Could not fetch a registry asset: ${msg}`, 502);
}
const typesImportRe = new RegExp(`(from\\s+['"])\\./${escapeRegex(componentName)}\\.types(['"])`);
const rewrittenComponent = componentText.replace(typesImportRe, `$1./${exportName}.bp.types$2`);
if (rewrittenComponent === componentText) {
return errorResponse("Invalid source", `component source did not import its types module ('./${componentName}.types')`, 400);
}
const prependedImports = [];
if (writeBaseStyles || baseStylesUrl)
prependedImports.push(`import '../${BASE_STYLES_FILENAME}'`);
if (cssUrl)
prependedImports.push(`import './${exportName}${BP_CSS_SUFFIX}'`);
const sourceWithImports = prependedImports.length > 0 ? `${prependedImports.join(`
`)}
${rewrittenComponent}` : rewrittenComponent;
mkdirSync(bpDir, { recursive: true });
writeFileSync(bpTsxPath, sourceWithImports, "utf-8");
writeFileSync(bpTypesPath, typesText, "utf-8");
if (cssUrl && cssText !== null)
writeFileSync(bpCssPath, cssText, "utf-8");
if (writeBaseStyles && baseStylesText !== null)
writeFileSync(baseStylesPath, baseStylesText, "utf-8");
const llm = propsSchemaExport && exampleValues && exampleValues.length > 0 ? { description: `TODO: describe ${exportName}`, propsSchemaExport, exampleValues } : null;
const nextIndex = buildIndexUpdate({
existing: existingIndex,
exportName,
llm
});
writeFileSync(indexPath, nextIndex, "utf-8");
return successResponse({
ok: true,
bpTsxPath: relative4(project.path, bpTsxPath),
typesPath: relative4(project.path, bpTypesPath),
cssPath: cssUrl ? relative4(project.path, bpCssPath) : null,
baseStylesWritten: writeBaseStyles,
indexPath: relative4(project.path, indexPath),
dependencies: body.dependencies && typeof body.dependencies === "object" && !Array.isArray(body.dependencies) ? body.dependencies : {}
});
}
// src/server/handlers/installed-components.ts
import { relative as relative5 } from "path";
function readComponentMetadata(instance) {
return instance?.metadata ?? instance?.llmMetadata;
}
function unwrapPropSchema(value) {
let current = value;
while (current._def.typeName === "ZodOptional" || current._def.typeName === "ZodDefault" || current._def.typeName === "ZodNullable") {
current = current._def.innerType;
}
return current;
}
function readZuiPropsMetadata(instance) {
const props = readComponentMetadata(instance)?.props;
const callbackProps = [];
if (!props)
return { propsSchema: null, callbackProps };
const omit = {};
try {
for (const [key, value] of Object.entries(props.shape)) {
if (unwrapPropSchema(value)._def.typeName === "ZodFunction") {
omit[key] = true;
callbackProps.push(key);
}
}
} catch {
return { propsSchema: null, callbackProps };
}
try {
const result = props.omit(omit).toJSONSchema();
const propsSchema = typeof result === "object" && result !== null ? result : null;
return { propsSchema, callbackProps };
} catch {
return { propsSchema: null, callbackProps };
}
}
function readExampleValues(instance) {
const ev = readComponentMetadata(instance)?.exampleValues;
return Array.isArray(ev) ? ev : [];
}
function readDescription(instance) {
const d = readComponentMetadata(instance)?.description;
return typeof d === "string" ? d : undefined;
}
async function handleListInstalledComponents() {
const serverConfig = getServerConfig();
const project = serverConfig.project;
if (!project) {
return errorResponse("No project", "No project path configured", 404);
}
const items = [];
for (const ref of project.customComponents) {
const instance = ref.instance;
const propsMetadata = readZuiPropsMetadata(instance);
items.push({
name: ref.definition.name,
sourcePath: ref.source ? toBotRelative(project.path, ref.source) : ref.path,
description: readDescription(instance),
propsSchema: propsMetadata.propsSchema,
exampleValues: readExampleValues(instance),
callbackProps: propsMetadata.callbackProps
});
}
return successResponse({ components: items });
}
function toBotRelative(projectRoot, absolutePath) {
const rel = relative5(projectRoot, absolutePath);
return rel.split(/[\\/]+/).join("/");
}
// src/server/handlers/component-bundle.ts
import { existsSync as existsSync4 } from "fs";
import { resolve as resolve5 } from "path";
// src/utils/component-builder.ts
async function buildComponentForLocal(entryPoint) {
const cssParts = [];
const result = await Bun.build({
entrypoints: [entryPoint],
format: "esm",
external: ["react", "react-dom"],
plugins: [
style({
collect: (text) => {
cssParts.push(text);
}
}),
globalReactPlugin()
]
});
if (!result.success) {
const errors = result.logs.filter((l) => l.level === "error" || l.level === "warning").map((l) => l.message);
if (!errors.length)
errors.push("Build failed with no diagnostic output");
return { success: false, code: null, css: null, errors };
}
const output = result.outputs[0];
if (!output) {
return { success: false, code: null, css: null, errors: ["Build produced no output"] };
}
const code = await output.text();
const css = cssParts.length > 0 ? cssParts.join(`
`) : null;
return { success: true, code, css, errors: [] };
}
// src/server/handlers/component-bundle.ts
var TEXT = { "Content-Type": "text/plain; charset=utf-8" };
var COMPONENTS_PREFIX = `${COMPONENTS_DIR}/`;
function resolveSource(req) {
const project = getServerConfig().project;
if (!project)
return { error: "No project configured", status: 404 };
const raw = new URL(req.url).searchParams.get("source");
if (!raw)
return { error: "Missing `source` query parameter", status: 400 };
const posix = decodeURIComponent(raw).split(/[\\/]+/).join("/");
if (!posix.startsWith(COMPONENTS_PREFIX) || !posix.endsWith(BP_TSX_SUFFIX)) {
return { error: "`source` must be a .bp.tsx under src/components/", status: 400 };
}
const abs = resolve5(project.path, posix);
if (!isInsideProject(abs, project.path)) {
return { error: "`source` escapes the project root", status: 400 };
}
if (!existsSync4(abs))
return { error: `Source file missing: ${posix}`, status: 404 };
return { abs };
}
async function build(abs) {
const result = await buildComponentForLocal(abs);
if (!result.success) {
return { result: null, status: 502, error: result.errors.join(`
`) };
}
return { result, status: 200 };
}
async function handleComponentBundle(req) {
const resolved = resolveSource(req);
if ("error" in resolved)
return errorResponse("Bad request", resolved.error, resolved.status);
const { result, status, error } = await build(resolved.abs);
if (status !== 200 || !result) {
return new Response(error ?? "Build failed", { status, headers: TEXT });
}
return new Response(result.code, {
status: 200,
headers: {
"Content-Type": "application/javascript; charset=utf-8",
"Cache-Control": "no-cache"
}
});
}
async function handleComponentBundleCss(req) {
const resolved = resolveSource(req);
if ("error" in resolved)
return errorResponse("Bad request", resolved.error, resolved.status);
const { result, status, error } = await build(resolved.abs);
if (status !== 200 || !result) {
return new Response(error ?? "Build failed", { status, headers: TEXT });
}
if (!result.css) {
return new Response(null, { status: 204 });
}
return new Response(result.css, {
status: 200,
headers: {
"Content-Type": "text/css; charset=utf-8",
"Cache-Control": "no-cache"
}
});
}
// src/server/handlers/memory.ts
import { mkdirSync as mkdirSync2 } from "fs";
import { tmpdir } from "os";
import { join as join2 } from "path";
import v8 from "v8";
var jsc = null;
try {
jsc = await import("bun:jsc");
} catch {}
async function handleMemoryDebug() {
const usage = process.memoryUsage();
let bunStats = {};
if (jsc) {
try {
const heapStats = jsc.heapStats();
bunStats = {
jsc: {
heapSize: `${Math.round(heapStats.heapSize / 1024 / 1024)}MB`,
heapCapacity: `${Math.round(heapStats.heapCapacity / 1024 / 1024)}MB`,
extraMemorySize: `${Math.round(heapStats.extraMemorySize / 1024 / 1024)}MB`,
objectCount: heapStats.objectCount,
protectedObjectCount: heapStats.protectedObjectCount,
globalObjectCount: heapStats.globalObjectCount,
protectedGlobalObjectCount: heapStats.protectedGlobalObjectCount,
objectTypeCounts: heapStats.objectTypeCounts
}
};
} catch (e) {
bunStats = { jscError: String(e) };
}
}
return successResponse({
heapUsed: `${Math.round(usage.heapUsed / 1024 / 1024)}MB`,
heapTotal: `${Math.round(usage.heapTotal / 1024 / 1024)}MB`,
external: `${Math.round(usage.external / 1024 / 1024)}MB`,
rss: `${Math.round(usage.rss / 1024 / 1024)}MB`,
raw: {
heapUsed: usage.heapUsed,
heapTotal: usage.heapTotal,
external: usage.external,
rss: usage.rss,
arrayBuffers: usage.arrayBuffers
},
...bunStats
});
}
async function handleMemoryGC() {
if (typeof Bun !== "undefined" && Bun.gc) {
Bun.gc(true);
}
const usage = process.memoryUsage();
return successResponse({
message: "GC triggered",
heapUsed: `${Math.round(usage.heapUsed / 1024 / 1024)}MB`,
heapTotal: `${Math.round(usage.heapTotal / 1024 / 1024)}MB`,
rss: `${Math.round(usage.rss / 1024 / 1024)}MB`
});
}
async function handleMemorySnapshot() {
if (typeof Bun === "undefined" || !Bun.generateHeapSnapshot) {
return errorResponse("Heap snapshots unavailable", "Heap snapshots only available in Bun runtime", 501);
}
const tempDir = tmpdir();
mkdirSync2(tempDir, { recursive: true });
const filename = join2(tempDir, `heap-${Date.now()}.json`);
try {
const snapshot = Bun.generateHeapSnapshot();
await Bun.write(filename, JSON.stringify(snapshot));
if (Bun.gc) {
Bun.gc(true);
}
return successResponse({
message: "Heap snapshot written (Bun/JSC format)",
path: filename,
hint: "Open in Safari DevTools (Timeline > JavaScript Allocations > Import)"
});
} catch (error) {
const details = error instanceof Error ? error.message : String(error);
return errorResponse("Failed to write heap snapshot", details, 500);
}
}
async function handleMemorySnapshotV8() {
const tempDir = tmpdir();
mkdirSync2(tempDir, { recursive: true });
const filename = join2(tempDir, `heap-v8-${Date.now()}.heapsnapshot`);
try {
const snapshotPath = v8.writeHeapSnapshot(filename);
if (typeof Bun !== "undefined" && Bun.gc) {
Bun.gc(true);
}
return successResponse({
message: "V8 heap snapshot written",
path: snapshotPath || filename,
hint: "Open in Chrome DevTools (Memory tab > Load) or analyze with: npx memlab analyze object-size --snapshot <path>"
});
} catch (error) {
const details = error instanceof Error ? error.message : String(error);
return errorResponse("Failed to write V8 heap snapshot", details, 500);
}
}
// src/server/handlers/secrets.ts
function getSecretsContext() {
const serverConfig = getServerConfig();
const projectPath = serverConfig.agentPath;
if (!projectPath)
return null;
const project = serverConfig.project;
const declaredSecrets = project?.config?.secrets ?? {};
return { projectPath, declaredSecrets };
}
function buildFields(declared, stored) {
return Object.entries(declared).map(([key, def]) => ({
key,
description: def.description,
optional: def.optional ?? false,
isSet: key in stored
}));
}
async function handleGetSecrets(req) {
const env = parseEnv(req);
if (!env) {
return errorResponse("Invalid environment", 'env query param must be "dev" or "prod"', 400);
}
const ctx = getSecretsContext();
if (!ctx) {
return successResponse({ fields: [], missingRequired: [], missingOptional: [] });
}
const manager = new SecretsManager(ctx.projectPath);
const stored = await manager.getAll(env, ctx.declaredSecrets);
const fields = buildFields(ctx.declaredSecrets, stored);
const missing = manager.getMissing(ctx.declaredSecrets, stored);
return successResponse({
fields,
missingRequired: missing.required,
missingOptional: missing.optional
});
}
async function handlePutSecrets(req) {
const env = parseEnv(req);
if (!env) {
return errorResponse("Invalid environment", 'env query param must be "dev" or "prod"', 400);
}
const ctx = getSecretsContext();
if (!ctx) {
return errorResponse("No agent loaded", "Agent path not configured", 400);
}
let body;
try {
body = await req.json();
} catch {
return errorResponse("Invalid JSON", "Request body must be valid JSON", 400);
}
const manager = new SecretsManager(ctx.projectPath);
const results = {};
for (const [key, rawValue] of Object.entries(body)) {
const nameValidation = validateSecretName(key);
if (!nameValidation.valid) {
results[key] = { success: false, error: nameValidation.error };
continue;
}
if (!(key in ctx.declaredSecrets)) {
results[key] = {
success: false,
error: `Secret "${key}" is not declared in agent.config.ts`
};
continue;
}
if (typeof rawValue !== "string") {
results[key] = { success: false, error: "Value must be a string" };
continue;
}
const trimmed = rawValue.trim();
if (trimmed.length === 0) {
results[key] = { success: false, error: "Value cannot be empty" };
continue;
}
try {
await manager.set(key, trimmed, env);
results[key] = { success: true };
} catch (error) {
results[key] = {
success: false,
error: error instanceof Error ? error.message : "Failed to store secret"
};
}
}
const anySuccess = Object.values(results).some((r) => r.success);
if (anySuccess && env === "dev") {
emitSecretsValuesChanged();
}
return successResponse({ results });
}
async function handleDeleteSecret(req) {
const env = parseEnv(req);
if (!env) {
return errorResponse("Invalid environment", 'env query param must be "dev" or "prod"', 400);
}
const ctx = getSecretsContext();
if (!ctx) {
return errorResponse("No agent loaded", "Agent path not configured", 400);
}
const url = new URL(req.url);
const key = url.searchParams.get("key");
if (!key) {
return errorResponse("Missing key", "key query param is required", 400);
}
const nameValidation = validateSecretName(key);
if (!nameValidation.valid) {
return errorResponse("Invalid key", nameValidation.error ?? "Invalid secret name", 400);
}
if (!(key in ctx.declaredSecrets)) {
return errorResponse("Unknown key", `Secret "${key}" is not declared in agent.config.ts`, 400);
}
try {
const manager = new SecretsManager(ctx.projectPath);
await manager.delete(key, env);
return successResponse({ success: true });
} catch (error) {
return errorResponse("Delete failed", error instanceof Error ? error.message : "Unknown error", 500);
}
}
async function handlePatchSecretsSchema(req) {
const serverConfig = getServerConfig();
if (!serverConfig.agentPath) {
return errorResponse("No agent path", "Agent path not configured", 400);
}
let updates;
try {
updates = await req.json();
} catch {
return errorResponse("Invalid JSON", "Request body must be valid JSON array", 400);
}
if (!Array.isArray(updates)) {
return errorResponse("Invalid body", "Request body must be an array", 400);
}
for (const update of updates) {
if (update.action === "add") {
const nameValidation = validateSecretName(update.field);
if (!nameValidation.valid) {
return errorResponse("Invalid secret name", nameValidation.error ?? "Invalid secret name", 400);
}
}
}
try {
const configWriter = new ConfigWriter(serverConfig.agentPath);
await configWriter.updateSecrets(updates);
return successResponse({ success: true });
} catch (error) {
return errorResponse("Update failed", error instanceof Error ? error.message : "Unknown error", 500);
}
}
// src/server/handlers/config-models.ts
function isDefaultModelSelection(value) {
return typeof value === "string" && value.length > 0 || Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string" && entry.length > 0);
}
async function handleGetConfigModels() {
const serverConfig = getServerConfig();
if (!serverConfig.project) {
return errorResponse("Project not configured", "Project configuration is not available yet", 400);
}
const defaultModels = serverConfig.project.config?.defaultModels ?? {};
return successResponse({ defaultModels });
}
async function handlePatchConfigModels(req) {
const serverConfig = getServerConfig();
if (!serverConfig.project) {
return errorResponse("Project not configured", "Project configuration is not available yet", 400);
}
if (!serverConfig.agentPath) {
return errorResponse("No agent path", "Agent path not configured", 400);
}
let body;
try {
body = await req.json();
} catch {
return errorResponse("Invalid JSON", "Request body must be valid JSON", 400);
}
if (!body || typeof body !== "object" || Array.isArray(body)) {
return errorResponse("Invalid body", "Request body must be an object", 400);
}
const candidate = body;
const updates = {};
for (const key of ["autonomous", "zai"]) {
const value = candidate[key];
if (value === undefined) {
continue;
}
if (!isDefaultModelSelection(value)) {
return errorResponse("Invalid body", `defaultModels.${key} must be a non-empty string or array of strings`, 400);
}
updates[key] = value;
}
if (!updates.autonomous && !updates.zai) {
return errorResponse("Invalid body", "Request body must include autonomous and/or zai", 400);
}
try {
const configWriter = new ConfigWriter(serverConfig.agentPath);
await configWriter.updateDefaultModels(updates);
const merged = {
...serverConfig.project.config?.defaultModels,
...updates
};
if (serverConfig.project.config) {
serverConfig.project.config.defaultModels = merged;
}
return successResponse({ defaultModels: merged });
} catch (error) {
return errorResponse("Update failed", error instanceof Error ? error.message : "Unknown error", 500);
}
}
// src/server/handlers/agent0-screenshot.ts
var pendingRequests = new Map;
var primaryTab = null;
function getScreenshotSubscriberCount() {
return primaryTab ? 1 : 0;
}
var REQUEST_TIMEOUT_MS = 15000;
function requestScreenshotFromUI() {
const tab = primaryTab;
if (!tab) {
return Promise.reject(new Error("Dev console UI is not connected. The developer must have the ADK Dev Console open in a browser tab for screenshots to work."));
}
const requestId = crypto.randomUUID();
return new Promise((resolve6, reject) => {
const timer = setTimeout(() => {
pendingRequests.delete(requestId);
reject(new Error("Screenshot request timed out"));
}, REQUEST_TIMEOUT_MS);
pendingRequests.set(requestId, { resolve: resolve6, reject, timer });
if (!tab.send("take_screenshot", { requestId })) {
pendingRequests.delete(requestId);
clearTimeout(timer);
reject(new Error("Dev console UI disconnected before it could receive the screenshot request"));
}
});
}
function handleAgent0ScreenshotEventsSSE(req) {
return createSSEStream(req, {
onConnect(client) {
const previous = primaryTab;
primaryTab = client;
previous?.close();
client.send("connected", {});
return () => {
if (primaryTab === client)
primaryTab = null;
};
}
});
}
async function handleAgent0ScreenshotResult(req) {
const corsHeaders = getCorsHeaders(req);
try {
const body = await req.json();
if (!body.requestId) {
return new Response(JSON.stringify({ ok: false, error: "requestId is required" }), {
status: 400,
headers: { "Content-Type": "application/json", ...corsHeaders }
});
}
const pending = pendingRequests.get(body.requestId);
if (!pending) {
return new Response(JSON.stringify({ ok: false, error: "Unknown or expired requestId" }), {
status: 404,
headers: { "Content-Type": "application/json", ...corsHeaders }
});
}
pendingRequests.delete(body.requestId);
clearTimeout(pending.timer);
if (body.error) {
pending.reject(new Error(body.error));
} else if (body.dataUrl) {
pending.resolve({ dataUrl: body.dataUrl, mimeType: body.mimeType ?? "image/png" });
} else {
pending.reject(new Error("Screenshot result missing both dataUrl and error"));
}
return new Response(JSON.stringify({ ok: true }), {
status: 200,
headers: { "Content-Type": "application/json", ...corsHeaders }
});
} catch (e) {
return new Response(JSON.stringify({ ok: false, error: e instanceof Error ? e.message : "Bad request" }), {
status: 400,
headers: { "Content-Type": "application/json", ...corsHeaders }
});
}
}
// src/server/handlers/environment.ts
function handleGetEnvironment() {
return successResponse({ environment: getActiveEnvironment() });
}
async function handleSetEnvironment(req) {
let body;
try {
body = await req.json();
} catch {
return errorResponse("Invalid JSON", "Request body must be valid JSON", 400);
}
const candidate = body?.environment;
if (candidate !== "dev" && candidate !== "prod") {
return errorResponse("Invalid environment", "environment must be one of: dev, prod", 400);
}
setActiveEnvironment(candidate);
return successResponse({ environment: getActiveEnvironment() });
}
// src/server/handlers/models.ts
async function handleModels() {
const serverConfig = getServerConfig();
const credentials = serverConfig.credentials;
const devBotId = serverConfig.project?.agentInfo?.devId ?? credentials?.devBotId;
if (!credentials?.token || !devBotId) {
return errorResponse("Not configured", "Bot credentials are not available yet. Ensure `adk dev` is running and the bot is deployed.", 404);
}
try {
const client = await getProjectClient({
credentials: {
token: credentials.token,
apiUrl: credentials.apiUrl || "https://api.botpress.cloud",
...credentials.workspaceId ? { workspaceId: credentials.workspaceId } : {},
botId: devBotId
},
botId: devBotId
});
const cognitive = new Cognitive({ client, __experimental_beta: true });
const models = await cognitive.fetchRemoteModels();
if (!models || typeof models.values !== "function") {
return successResponse([]);
}
const seen = new Set;
const list = Array.from(models.values()).reduce((acc, m) => {
if (!seen.has(m.ref)) {
seen.add(m.ref);
acc.push({
ref: m.ref,
name: m.name,
description: m.description,
integration: m.integration,
tags: m.tags,
input: m.input,
output: m.output
});
}
return acc;
}, []);
const aliases = [
{
ref: "fast",
name: "Fast",
description: "Fastest available model \u2014 resolved at runtime",
integration: "aliases",
tags: ["alias"],
input: undefined,
output: undefined
},
{
ref: "best",
name: "Best",
description: "Most capable available model \u2014 resolved at runtime",
integration: "aliases",
tags: ["alias"],
input: undefined,
output: undefined
}
];
return successResponse([...aliases, ...list]);
} catch (error) {
return errorResponse("Failed to fetch models", error instanceof Error ? error.message : "Unknown error");
}
}
// src/server/handlers/cognitive-proxy.ts
var logger4 = createCliLogger({ tag: "cognitive-proxy" });
var DEFAULT_API_URL = "https://api.botpress.cloud";
var DEFAULT_COGNITIVE_STREAM_STALL_TIMEOUT_MS = 30000;
var DEFAULT_COGNITIVE_FIRST_TOKEN_TIMEOUT_MS = 120000;
function resolveTimeoutMs(raw, fallback) {
if (!raw)
return fallback;
const parsed = Number(raw);
return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
}
function resolveStallTimeoutMs() {
return resolveTimeoutMs(process.env.ADK_COGNITIVE_STALL_TIMEOUT_MS, DEFAULT_COGNITIVE_STREAM_STALL_TIMEOUT_MS);
}
function resolveFirstTokenTimeoutMs() {
return resolveTimeoutMs(process.env.ADK_COGNITIVE_FIRST_TOKEN_TIMEOUT_MS, DEFAULT_COGNITIVE_FIRST_TOKEN_TIMEOUT_MS);
}
var cognitiveSubpathSchema = ne.string().regex(/^\/[a-zA-Z0-9/_-]+$/, "Cognitive proxy path contains unsupported characters").refine((subpath) => !subpath.includes("//"), "Cognitive proxy path must not contain empty segments").refine((subpath) => !subpath.split("/").includes(".."), "Cognitive proxy path must not contain parent segments");
var messageSchema = ne.object({ role: ne.string() }).passthrough();
var chatRequestSchema = ne.object({ model: ne.string(), messages: ne.array(messageSchema).optional() }).passthrough();
var UPSTREAM_REQUEST_HEADERS = ["accept", "content-type"];
var streamChoiceSchema = ne.object({
index: ne.number().optional(),
delta: ne.object({ tool_calls: ne.array(ne.unknown()).optional() }).passthrough().optional(),
finish_reason: ne.string().nullable().optional()
}).passthrough();
var chatCompletionStreamChunkSchema = ne.object({ choices: ne.array(streamChoiceSchema) }).passthrough();
function hasToolCallDelta(choice) {
return (choice.delta?.tool_calls?.length ?? 0) > 0;
}
function rewriteToolCallFinishReasons(data, choicesWithToolCalls) {
if (data === "[DONE]")
return data;
let parsed;
try {
parsed = JSON.parse(data);
} catch {
return data;
}
const streamChunk = chatCompletionStreamChunkSchema.safeParse(parsed);
if (!streamChunk.success)
return data;
let changed = false;
streamChunk.data.choices.forEach((choice, fallbackIndex) => {
const index = choice.index ?? fallbackIndex;
if (hasToolCallDelta(choice))
choicesWithToolCalls.add(index);
if (choice.finish_reason === "stop" && choicesWithToolCalls.has(index)) {
choice.finish_reason = "tool_calls";
changed = true;
}
});
return changed ? JSON.stringify(streamChunk.data) : data;
}
function rewriteSSEEvent(event, choicesWithToolCalls) {
const lineEnding = event.includes(`\r
`) ? `\r
` : `
`;
const lines = event.split(/\r?\n/);
const dataLineIndexes = lines.map((line2, index) => ({ line: line2, index })).filter(({ line: line2 }) => line2.startsWith("data:")).map(({ index }) => index);
if (dataLineIndexes.length !== 1)
return event;
const dataLineIndex = dataLineIndexes[0];
const line = lines[dataLineIndex];
const separator = line.startsWith("data: ") ? "data: " : "data:";
const data = line.slice(separator.length);
const rewritten = rewriteToolCallFinishReasons(data, choicesWithToolCalls);
if (rewritten === data)
return event;
lines[dataLineIndex] = `${separator}${rewritten}`;
return lines.join(lineEnding);
}
function findSSEEventDelimiter(buffer) {
const lf = buffer.indexOf(`
`);
const crlf = buffer.indexOf(`\r
\r
`);
if (lf === -1 && crlf === -1)
return;
if (lf === -1)
return { index: crlf, delimiter: `\r
\r
` };
if (crlf === -1)
return { index: lf, delimiter: `
` };
return crlf <= lf ? { index: crlf, delimiter: `\r
\r
` } : { index: lf, delimiter: `
` };
}
function formatSSEErrorEvents(message, type) {
return `data: ${JSON.stringify({ error: { message, type } })}
data: [DONE]
`;
}
var MODEL_OUTPUT_PATTERN = /"(?:content|reasoning_content)":"[^"]|"tool_calls":\[/;
function withStallGuard(body, options) {
const reader = body.getReader();
const encoder = new TextEncoder;
const detectionDecoder = new TextDecoder;
const modelSuffix = options.model ? ` (model=${options.model})` : "";
let receivedAny = false;
let sawModelOutput = false;
let firstTokenDeadline = 0;
let cancelledByDownstream = false;
const failStream = (controller, message, type) => {
controller.enqueue(encoder.encode(formatSSEErrorEvents(message, type)));
controller.close();
reader.cancel(new Error(message)).catch(() => {});
};
return new ReadableStream({
async pull(controller) {
if (firstTokenDeadline === 0 && options.firstTokenTimeoutMs > 0) {
firstTokenDeadline = Date.now() + options.firstTokenTimeoutMs;
}
const timeoutMs = sawModelOutput ? options.stallTimeoutMs : options.firstTokenTimeoutMs > 0 ? Math.max(1, firstTokenDeadline - Date.now()) : options.stallTimeoutMs;
let timer;
const stalled = new Promise((resolve6) => {
timer = setTimeout(() => resolve6("stall"), timeoutMs);
});
try {
const result = await Promise.race([reader.read(), stalled]);
if (cancelledByDownstream) {
return;
}
if (result === "stall") {
const budgetMs = sawModelOutput || options.firstTokenTimeoutMs <= 0 ? options.stallTimeoutMs : options.firstTokenTimeoutMs;
const seconds = Math.round(budgetMs / 1000);
const message = sawModelOutput ? `Cognitive upstream stalled mid-stream${modelSuffix}: no bytes received for ${seconds}s. The model provider may be degraded \u2014 retry, or switch to a different model.` : `Cognitive upstream produced no model output within ${seconds}s of accepting the request${modelSuffix}. The provider may be degraded or a large prompt may be prefilling slowly \u2014 retry, or switch to a different model.`;
logger4.warn(message, {
event: "cognitive-stream-stall",
model: options.model,
receivedAny,
sawModelOutput
});
failStream(controller, message, "upstream_stall");
return;
}
if (result.done) {
controller.close();
return;
}
receivedAny = true;
if (!sawModelOutput && MODEL_OUTPUT_PATTERN.test(detectionDecoder.decode(result.value, { stream: true }))) {
sawModelOutput = true;
}
controller.enqueue(result.value);
} catch (err) {
if (cancelledByDownstream) {
return;
}
const detail = err instanceof Error ? err.message : String(err);
const message = `Cognitive upstream stream failed${modelSuffix}: ${detail}`;
logger4.warn(message, { event: "cognitive-stream-error", model: options.model, receivedAny });
failStream(controller, message, "upstream_error");
} finally {
clearTimeout(timer);
}
},
cancel(reason) {
cancelledByDownstream = true;
return reader.cancel(reason);
}
});
}
function rewriteChatCompletionSSE(body) {
const decoder = new TextDecoder;
const encoder = new TextEncoder;
const choicesWithToolCalls = new Set;
let buffer = "";
return body.pipeThrough(new TransformStream({
transform(chunk, controller) {
buffer += decoder.decode(chunk, { stream: true });
let delimiter = findSSEEventDelimiter(buffer);
while (delimiter) {
const event = buffer.slice(0, delimiter.index);
buffer = buffer.slice(delimiter.index + delimiter.delimiter.length);
controller.enqueue(encoder.encode(`${rewriteSSEEvent(event, choicesWithToolCalls)}${delimiter.delimiter}`));
delimiter = findSSEEventDelimiter(buffer);
}
},
flush(controller) {
buffer += decoder.decode();
if (buffer) {
controller.enqueue(encoder.encode(rewriteSSEEvent(buffer, choicesWithToolCalls)));
}
}
}));
}
function buildUpstreamHeaders(req, token, devBotId) {
const headers = new Headers;
for (const header of UPSTREAM_REQUEST_HEADERS) {
const value = req.headers.get(header);
if (value)
headers.set(header, value);
}
headers.set("Authorization", `Bearer ${token}`);
headers.set("X-Bot-Id", devBotId);
return headers;
}
async function handleCognitiveProxy(req, subpath, options = {}) {
const config = getServerConfig();
const { credentials } = config;
const devBotId = config.project?.agentInfo?.devId ?? credentials?.devBotId;
if (!credentials?.token || !devBotId) {
logger4.info(`${req.method} ${subpath} -> 401 (missing creds: token=${!!credentials?.token} devBotId=${!!devBotId})`);
return new Response(JSON.stringify({ error: { message: "Botpress credentials not available", type: "auth_error" } }), {
status: 401,
headers: { "Content-Type": "application/json" }
});
}
const parsedSubpath = cognitiveSubpathSchema.safeParse(subpath);
if (!parsedSubpath.success) {
logger4.info(`${req.method} ${subpath} -> 400 (invalid path)`);
return new Response(JSON.stringify({ error: { message: "Invalid Cognitive proxy path", type: "invalid_request_error" } }), {
status: 400,
headers: { "Content-Type": "application/json" }
});
}
const apiUrl = credentials.apiUrl || DEFAULT_API_URL;
const targetUrl = `${apiUrl}/v2/cognitive/v1${parsedSubpath.data}`;
const headers = buildUpstreamHeaders(req, credentials.token, devBotId);
let loggedModel;
let body = req.body;
if (req.method === "POST" && parsedSubpath.data === "/chat/completions") {
const parsed = chatRequestSchema.parse(await req.json());
parsed.model = parsed.model.replace("--", ":");
loggedModel = parsed.model;
headers.set("content-type", "application/json");
if (parsed.messages) {
for (const msg of parsed.messages) {
if (msg.role === "developer")
msg.role = "system";
}
}
body = JSON.stringify(parsed);
}
logger4.info(`${req.method} ${parsedSubpath.data}${loggedModel ? ` model=${loggedModel}` : ""} -> ${targetUrl}`);
let upstream;
try {
upstream = await fetch(targetUrl, {
method: req.method,
headers,
body,
duplex: "half"
});
} catch (err) {
logger4.info(`fetch threw: ${err instanceof Error ? err.message : String(err)}`);
throw err;
}
logger4.info(`upstream ${upstream.status} content-type=${upstream.headers.get("content-type") ?? "none"}`);
const responseHeaders = new Headers(upstream.headers);
responseHeaders.delete("content-encoding");
responseHeaders.delete("content-length");
responseHeaders.delete("transfer-encoding");
const contentType = responseHeaders.get("content-type");
const stallTimeoutMs = options.stallTimeoutMs ?? resolveStallTimeoutMs();
const firstTokenTimeoutMs = options.firstTokenTimeoutMs ?? resolveFirstTokenTimeoutMs();
const responseBody = upstream.body && parsedSubpath.data === "/chat/completions" && contentType?.includes("text/event-stream") ? rewriteChatCompletionSSE(stallTimeoutMs > 0 ? withStallGuard(upstream.body, {
stallTimeoutMs,
firstTokenTimeoutMs,
model: loggedModel
}) : upstream.body) : upstream.body;
return new Response(responseBody, {
status: upstream.status,
headers: responseHeaders
});
}
// src/server/handlers/deploy.ts
var session = {
status: "idle",
plan: null,
planSummary: null,
context: null,
stages: {},
done: false,
result: null,
evalManifestPlan: null
};
var sessionGeneration = 0;
function resetSession() {
sessionGeneration++;
session = {
status: "idle",
plan: null,
planSummary: null,
context: null,
stages: {},
done: false,
result: null,
evalManifestPlan: null
};
}
function setStage(stage, state) {
session.stages = { ...session.stages, [stage]: state };
}
async function handleDeployPlan(_req) {
if (session.status !== "idle") {
return errorResponse("Deploy in progress", "A deploy operation is already in progress", 409);
}
session.status = "planning";
const gen = sessionGeneration;
try {
const serverConfig = getServerConfig();
if (!serverConfig.project) {
resetSession();
return errorResponse("No project loaded", "Agent project not available", 500);
}
if (!serverConfig.credentials?.token) {
resetSession();
return errorResponse("Not authenticated", "Bot credentials are required. Run `adk login` first.", 401);
}
const agentRoot = await findAgentRootOrFail(process.cwd());
let project = await AgentProject.load(agentRoot, { adkCommand: "adk-deploy" });
const botId = project.agentInfo?.botId;
if (!botId) {
resetSession();
return errorResponse("No bot ID", "No botId found in agent.json. Run `adk link` to link your agent to a bot.", 400);
}
const serverCredentials = serverConfig.credentials;
const workspaceId = project.agentInfo?.workspaceId ?? serverCredentials.workspaceId;
const token = serverCredentials.token;
if (!workspaceId || !token) {
resetSession();
return errorResponse("Missing credentials", "Workspace ID and token are required. Run `adk login` first.", 401);
}
const apiUrl = project.agentInfo?.apiUrl ?? serverCredentials.apiUrl ?? "https://api.botpress.cloud";
const credentials = { token, apiUrl, workspaceId, botId };
const client = await getProjectClient({
project,
credentials,
botId
});
await refreshDependencySnapshotOnce({
projectPath: agentRoot,
env: "prod",
botId,
client,
required: true
});
await refreshDependencySnapshotOnce({
projectPath: agentRoot,
env: "dev",
botId: project.agentInfo?.devId ?? serverConfig.credentials.devBotId,
client,
required: false
});
project = await AgentProject.load(agentRoot, { adkCommand: "adk-deploy" });
await adkBuild({
silent: true,
adkCommand: "adk-deploy",
beforeGenerate: project.customComponents.length > 0 ? async () => {
await buildAndUploadComponents({
agentRoot,
project,
client,
log: () => {}
});
} : undefined
});
if (gen !== sessionGeneration)
return successResponse({ cancelled: true });
let configValid = true;
let configErrors = [];
try {
const configResult = await validateAndPromptConfig({
projectPath: agentRoot,
isProd: true,
interactive: false,
botId,
project,
credentials
});
configValid = configResult.valid;
configErrors = configResult.errors;
} catch (error) {
if (!(isAdkError(error) && error.code === "INVALID_CONFIG_SCHEMA")) {
configValid = false;
configErrors = [error instanceof Error ? error.message : String(error)];
}
}
if (gen !== sessionGeneration)
return successResponse({ cancelled: true });
const checker = new PreflightChecker(agentRoot, { credentials });
const plan = await checker.computeDeployPlan(botId);
const evalManifestPlan = await computeEvalManifestPlan(agentRoot);
const declaredSecrets = project.config?.secrets ?? {};
const secretsManager = new SecretsManager(project.path);
const prodSecrets = await secretsManager.getAll("prod", declaredSecrets);
const missingSecrets = Object.entries(declaredSecrets).filter(([name]) => !(name in prodSecrets)).map(([name, def]) => ({
name,
optional: def.optional ?? false,
description: def.description
}));
const missingRequired = missingSecrets.filter((s) => !s.optional).map((s) => s.name);
if (gen !== sessionGeneration)
return successResponse({ cancelled: true });
session.plan = plan;
session.context = {
agentRoot,
project,
botId,
workspaceId,
credentials: { token, apiUrl },
prodSecrets,
declaredSecrets
};
const hasAnyChanges = plan.preflight.result.hasChanges || plan.tablePlan?.hasChanges || plan.kbPlan?.hasChanges || plan.orphanedKBs.length > 0 || plan.assetPlan?.hasChanges;
const summary = {
botId,
workspaceId,
botName: project.config?.name ?? "Unknown",
preflight: {
hasChanges: plan.preflight.result.hasChanges,
agentConfig: plan.preflight.result.agentConfig,
secretWarnings: plan.preflight.result.secretWarnings
},
tables: plan.tablePlan ? {
hasChanges: plan.tablePlan.hasChanges,
totalCreate: plan.tablePlan.totalCreate,
totalUpdate: plan.tablePlan.totalUpdate,
totalDelete: plan.tablePlan.totalDelete
} : null,
knowledgeBases: plan.kbPlan ? {
hasChanges: plan.kbPlan.hasChanges,
toSync: plan.kbPlan.toSync,
toSkip: plan.kbPlan.toSkip,
orphanedSourcesToDelete: plan.kbPlan.orphanedSourcesToDelete,
orphanedKBs: plan.orphanedKBs.map((kb) => ({ name: kb.name }))
} : null,
assets: plan.assetPlan ? {
hasChanges: plan.assetPlan.hasChanges,
totalCreate: plan.assetPlan.totalCreate,
totalUpdate: plan.assetPlan.totalUpdate,
totalDelete: plan.assetPlan.totalDelete
} : null,
secrets: { missing: missingSecrets, missingRequired },
configValid,
configErrors,
dependencies: {
blocking: summarizeBlockingDependencies(plan.dependencyPlan.blocking),
integrationVersionMismatches: plan.dependencyPlan.integrationVersionMismatches
},
evalManifest: { evalCount: evalManifestPlan.evalCount },
hasDestructiveStorageChanges: plan.hasDestructiveStorageChanges,
hasAnyChanges
};
session.planSummary = summary;
session.evalManifestPlan = evalManifestPlan;
session.status = "planned";
return successResponse(summary);
} catch (error) {
resetSession();
return errorResponse("Deploy plan failed", error instanceof Error ? error.message : String(error));
}
}
async function handleDeployExecute(req) {
const plan = session.plan;
const context = session.context;
if (session.status !== "planned" || !plan || !context) {
return errorResponse("No deploy plan", "Run POST /api/deploy/plan first", 409);
}
try {
const body = await req.json();
try {
assertNoBlockingDependencies(plan, { allowUnconfigured: body.allowUnconfigured });
} catch (error) {
if (isAdkError(error) && error.code === "UNCONFIGURED_DEPENDENCIES") {
return errorResponse("Unconfigured dependencies", `${error.message}. Configure them, then redeploy \u2014 or deploy with "allow unconfigured" to ship them inert.`, 422);
}
throw error;
}
session.status = "executing";
session.stages = {};
session.done = false;
session.result = null;
runDeployPipeline(plan, context, body);
return successResponse({ ok: true });
} catch (error) {
return errorResponse("Invalid request", error instanceof Error ? error.message : String(error), 400);
}
}
function handleDeployStatus() {
return successResponse({
status: session.status,
stages: session.stages,
done: session.done,
result: session.result,
planSummary: session.planSummary
});
}
async function runDeployPipeline(plan, ctx, params) {
const gen = sessionGeneration;
let currentStage = "secrets";
const confirmStorage = params.confirmStorageChanges ?? false;
const evalManifestPlan = session.evalManifestPlan ?? undefined;
const isStale = () => gen !== sessionGeneration;
try {
if (params.secrets && Object.keys(params.secrets).length > 0) {
currentStage = "secrets";
setStage("secrets", { status: "running" });
const manager = new SecretsManager(ctx.project.path);
for (const [key, value] of Object.entries(params.secrets)) {
await manager.set(key, value, "prod");
}
if (isStale())
return;
Object.assign(ctx.prodSecrets, params.secrets);
setStage("secrets", { status: "complete" });
}
const result = await runProdDeployPipeline({
agentRoot: ctx.agentRoot,
project: ctx.project,
plan,
botId: ctx.botId,
workspaceId: ctx.workspaceId,
credentials: ctx.credentials,
secrets: Object.keys(ctx.prodSecrets).length > 0 ? ctx.prodSecrets : undefined,
getClient: () => getProjectClient({
project: ctx.project,
credentials: { ...ctx.credentials, workspaceId: ctx.workspaceId, botId: ctx.botId },
botId: ctx.botId
}),
confirmStorageChanges: confirmStorage,
applyPlanUpdates: true,
evalManifestPlan,
callbacks: {
onStageStart: (stage) => {
if (isStale())
return;
currentStage = stage;
setStage(stage, { status: "running" });
},
onStageComplete: (stage, detail) => {
if (isStale())
return;
setStage(stage, { status: "complete", ...detail ? { detail } : {} });
},
onStageError: (stage, error, event) => {
if (isStale())
return;
const detail = {
message: error instanceof Error ? error.message : String(error),
...event?.nonFatal ? { nonFatal: true } : {},
...event?.detail ?? {}
};
setStage(stage, { status: "error", detail });
}
}
});
if (isStale())
return;
session.done = true;
session.status = "done";
session.result = {
success: result.success,
botId: ctx.botId,
error: result.failures.length > 0 ? `Post-deploy steps failed: ${result.failures.join(", ")}` : undefined
};
} catch (error) {
if (isStale())
return;
setStage(currentStage, {
status: "error",
detail: { message: error instanceof Error ? error.message : String(error) }
});
session.done = true;
session.status = "done";
session.result = {
success: false,
botId: ctx.botId,
error: error instanceof Error ? error.message : String(error)
};
}
}
function handleDeployCancel() {
resetSession();
return successResponse({ ok: true });
}
// src/server/handlers/agent0-status.ts
async function handleAgent0Status() {
const config = getServerConfig();
const runtime = getAgent0RuntimeClient();
if (!runtime) {
return successResponse({
state: "stopped",
projectPath: config.agentPath,
warnings: []
});
}
try {
return successResponse(toRunningStatus(await runtime.getStatus()));
} catch {
return successResponse({
state: "unavailable",
projectPath: config.agentPath,
warnings: [
{
code: "RUNTIME_UNAVAILABLE",
message: "Agent(0) runtime is unavailable."
}
]
});
}
}
function toRunningStatus(status) {
return {
state: "running",
projectPath: status.projectPath,
worktreePath: status.worktreePath,
...status.renderedOpenCodeConfigHash === undefined ? {} : { renderedOpenCodeConfigHash: status.renderedOpenCodeConfigHash },
warnings: []
};
}
// ../adk/dist/agent0/index.js
import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync4, statSync } from "fs";
import { basename, dirname, extname, join as join3 } from "path";
import { fileURLToPath } from "url";
import { createHash } from "crypto";
import { existsSync as existsSync22, realpathSync } from "fs";
import { chmod, mkdir } from "fs/promises";
import { homedir } from "os";
import { join as join22, resolve as resolve6 } from "path";
import { readFile, rename, writeFile, chmod as chmod2 } from "fs/promises";
import { dirname as dirname2 } from "path";
import { execFileSync, spawn } from "child_process";
import { randomUUID } from "crypto";
import { chmodSync, copyFileSync, createWriteStream, existsSync as existsSync32, mkdirSync as mkdirSync3, renameSync, rmSync } from "fs";
import { createRequire as createRequire2 } from "module";
import { arch, homedir as homedir2, platform as platform2, tmpdir as tmpdir2 } from "os";
import { delimiter, dirname as dirname3, join as join4, resolve as resolve22 } from "path";
import { pipeline } from "stream/promises";
import { createHash as createHash2 } from "crypto";
import { chmod as chmod3, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
import { platform } from "os";
import { join as join32 } from "path";
var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
var AdkError;
var init_errors = __esm(() => {
AdkError = class AdkError2 extends Error {
static __IS_ADK_BASE_ERROR = true;
code;
expected;
details;
suggestion;
constructor(opts) {
super(opts.message, opts.cause !== undefined ? { cause: opts.cause } : undefined);
this.name = this.constructor.name;
this.code = opts.code;
this.expected = opts.expected ?? false;
if (opts.details !== undefined) {
this.details = opts.details;
}
if (opts.suggestion !== undefined) {
this.suggestion = opts.suggestion;
}
}
};
});
var init_src = __esm(() => {
init_errors();
});
var AGENT0_CONFIG_SCHEMA_VERSION = 1;
var AGENT0_DEFAULT_PROMPT = `You are agent(0) \u2014 an expert assistant embedded in the Botpress Agent Development Kit control panel.
## Who you help
A developer building an AI agent with the ADK. They're running \`adk dev\` and have the control panel open alongside you. They can see traces, logs, integrations, workflows, and tables in the UI.
## What you know
The ADK is a high-level framework built on Botpress. An agent project has:
- /actions \u2014 strongly-typed callable functions (Action from @botpress/runtime)
- /tools \u2014 LLM-callable interfaces with natural language descriptions (Autonomous.Tool from @botpress/runtime)
- /workflows \u2014 step-based, resumable long-running processes (Workflow from @botpress/runtime)
- /conversations \u2014 channel-specific interaction handlers (Conversation from @botpress/runtime)
- /tables \u2014 schema-validated data storage with semantic search (Table from @botpress/runtime)
- /triggers \u2014 event subscription system (Trigger from @botpress/runtime)
- /knowledge \u2014 RAG knowledge base documents
- agent.config.ts \u2014 agent metadata, integrations, model configuration, variables
The ADK compiles these high-level primitives down to Botpress SDK primitives. Default to ADK terms. Only drop to Botpress SDK concepts when the problem requires it (SDK-level errors, compilation issues, or when the developer explicitly asks).
Schemas use \`z\` from @botpress/sdk (a Zod fork) \u2014 never import Zod directly.
Standalone tools use \`Autonomous.Tool\`: \`import { Autonomous, z } from '@botpress/runtime'\`, then
\`new Autonomous.Tool({...})\`. There is no top-level \`Tool\` export from \`@botpress/runtime\`.
## How you work
**Working directory.** Your shell is already set to the agent project root \u2014 an existing ADK project you build into; never scaffold a new or nested project (no \`adk init\`). Run all commands directly \u2014 never prepend \`cd\` to change into the project directory.
**CLI-first.** Use the \`adk\` CLI with \`--format json\` for everything you can \u2014 status, logs, traces, integrations, workflows, chat, evals. The only MCP tool you have is \`adk_take_screenshot\` (see below), because it requires direct browser access the CLI can't provide.
**Do not run dev subcommands.** Never run commands that start, restart, or watch a development server from this embedded assistant, including \`adk dev\`, \`bun dev\`, \`bun run dev\`, \`npm run dev\`, \`pnpm dev\`, \`yarn dev\`, \`vite dev\`, or framework-specific \`dev\` subcommands. The ADK dev server hosts you; starting or restarting it from inside agent(0) can terminate your own session. If the dev server is missing or unhealthy, ask the developer to start or restart it in their own terminal, then continue with non-dev CLI commands.
**Skills.** The \`adk\` skill is preloaded for every conversation \u2014 treat it as your authoritative reference for ADK primitives, conventions, and CLI usage. Don't try to re-load it. Other packaged skills you can load on demand for deeper topics: \`adk-debugger\` (systematic debugging, traces, common failures), \`adk-evals\` (writing and running evals), \`adk-dev-console\` (Dev Console UI context), and \`adk-docs\` (creating and maintaining ADK docs).
**Page context is auto-attached.** Every developer message begins with a hidden \`<dev_console_context>\` block describing what they're currently viewing in the dev console \u2014 page, URL, selected entity (trace ID, workflow name, action name, etc.), and any active filters. Use it to skip "what page are you on?" questions and answer in terms of what the developer can already see. The block is internal: never echo it back, never quote it verbatim. If it's missing or stale, fall back to asking.
**Look at the screen when it matters.** Use \`adk_take_screenshot\` to capture what the developer currently sees (page + sidebar + your own panel) when they reference something visual \u2014 "I don't see X", "where is this?", "what's that button?", "this looks wrong", "show you what I'm looking at". Don't guess from the URL or invent UI elements that may have moved or been renamed; look first, then answer. Skip the screenshot for non-visual questions (debugging traces, writing code, conceptual questions).
**Orient on first interaction.** If you haven't yet, run \`adk status --format json\` to learn the project's structure, primitives, and integrations before answering.
**Conceptual vs. project questions.** Conceptual questions about ADK, Botpress, or TypeScript \u2014 answer from knowledge immediately. Questions about their project (why something fails, what a file does, how to change behavior) \u2014 inspect first. If in doubt, answer what you can immediately and inspect in parallel.
**Read freely, write carefully.** Inspecting files, querying traces and logs via CLI, and reading documentation are always safe \u2014 do them without asking. But actions that modify the project (adding third-party integrations, editing files, executing workflows, sending messages) should be confirmed first unless the developer explicitly asked you to do it. Installing a chat channel to test your own bot is part of testing \u2014 see below \u2014 not a change that needs confirmation.
**Debug by matching the approach to the problem:**
- Developer gives you an error message \u2192 start from the error, don't begin at "step 1"
- Build or type error \u2192 run \`adk check --format json\` for offline validation AND \`tsc --noEmit\` for type errors (\`adk check\` does NOT typecheck); run \`tsc --noEmit\` before considering any task done. Then check the file and generated types. Traces won't help.
- Runtime behavior is wrong ("it responds wrong") \u2192 reproduce with \`adk chat --single "<relevant message>" --format json\`, then inspect traces with \`adk traces --format json\`
- Nothing happens \u2192 check \`adk logs error --format json\` for silent failures, then check if the handler is registered
- When in doubt \u2192 start with \`adk check --format json\`, then \`adk logs error --format json\`, then traces
**Integrations.** First check if the integration already exists with \`adk integrations list\`. Only search the hub (\`adk integrations search <query>\`) when adding a new integration. Get details with \`adk integrations info <name>\` to understand actions, events, channels, and config requirements. Add it with \`adk integrations add <name>\` after the developer confirms.
**Test iteratively.** To send messages, use \`adk chat --single "<message>" --format json\`. Pass the \`conversationId\` (--conversation-id "<id>") from the previous response to continue. Only test against the local dev bot. Sends need a channel: if none is installed, run \`adk integrations add chat\` first and don't wait for confirmation \u2014 installing the test channel is part of testing. Don't treat conversational changes as done until \`adk chat --single\` actually replies.
**Workflows.** Use \`adk workflows list --format json\` to discover available workflows. Use \`adk workflows inspect <name> --format json\` to get the input schema. Use \`adk workflows run <name> '{"key": "value"}' --format json\` to execute. For workflows with no required input, pass \`'{}'\` as the payload.
**Handle failures.** If a command or tool returns an error, tell the developer what happened and suggest a concrete next step (e.g., "Dev server isn't running \u2014 start it in your terminal with \`adk dev\`, then ask me to continue"). Don't silently retry or ignore errors.
**Edit with precision.** When modifying code, change only what's needed to solve the problem. Don't refactor surrounding code, add features, or "improve" things that weren't asked about. When writing ADK primitives, match ADK conventions. For utility code, match the patterns already in the project.
## How you communicate
**Lead with the answer.** First sentence is the diagnosis, the solution, or the action you took. Context and explanation come after, if needed.
**Show, don't describe.** Instead of "you should add error handling," show the code change. Instead of "the trace shows a failure," show the relevant span data and what it means.
**Match the developer's energy.** Short question \u2192 short answer. Detailed question \u2192 detailed response. "Why is this broken?" \u2192 diagnosis + fix. "How do workflows work?" \u2192 teach.
**Hypothesize while verifying.** If you have a likely diagnosis, say so while you check. "This usually means X \u2014 checking your trace now" is better than silence followed by an answer.
**When you fix something, explain what you changed and why.** Don't apply changes silently \u2014 the developer needs to understand the fix to trust it and learn from it.
**When you don't know, say so plainly.** "I don't have enough context \u2014 can you share the error message?" is fine.
**Skip the filler.** No "Great question!", no "Let me help you with that." Just do it.
**Never read or display the contents of .env files or credentials.** If you need to verify a configuration value, ask the developer to confirm it.`;
var GUIDED_SETUP_PROMPT = `You are agent(0) \u2014 a friendly setup guide for the Botpress Agent Development Kit (ADK).
## Mission
A developer chose "Guided Setup with Agent(0)" from the ADK launcher. A blank ADK project was scaffolded for them and they are in a dedicated guided setup view alongside you. Your job is to understand what they want, infer the right ADK shape, build it with sensible defaults, and validate the agent end-to-end. The whole point is that they don't have to spell everything out \u2014 they should watch you build.
This is an onboarding experience. The developer should feel guided, not interrogated. Ask about outcomes and product behavior; you decide the ADK primitives.
## Conversation Loop
The default mode is **infer and build**, not **ask and wait**. Every question is a tax on the developer; every assumption you make and state clearly is a free invitation for them to correct you. Bias hard toward the latter.
1. **Open with one plain-language question.** Ask what they want to build, in their own words. Do not start with a checklist.
2. **Build an internal intent brief \u2014 silently, with defaults filled in.** For each slot below, fill in the most reasonable assumption given what the developer said. These are working assumptions to state in your plan, not unknowns to interrogate the developer about.
- goal: what useful outcome the agent provides
- trigger: what starts it, and from where
- audience: who talks to it or benefits from it
- behavior: what it reads, decides, writes, or sends
- autonomy: conversational, event-driven, scheduled, callable, or mixed
- data: tables/state, knowledge/RAG, files, seed/demo data
- integrations: Slack, Linear, CRM, calendar, internal API, etc.
- success test: one realistic message, event, or workflow run that should prove it works
- constraints: permissions, human approval, config values, unknown credentials
3. **Default to inferring, not asking.** Use the question tool only when a wrong assumption would force real rework \u2014 the product shape would have to change, or an integration would have to be reconfigured. For everything else (data contents, names, shapes), use clearly-labeled placeholders. See "Defaults Over Questions" below.
4. **State the plan and start building.** Once intent is clear, summarize in 2-3 sentences what you're about to build and name the assumptions you're making, then start. Do not wait for a green-light reply to start writing code. The exception is credential-consuming or irreversible actions: confirm before adding an integration that will prompt for secrets, before deploying, or before destroying existing files.
5. **Build, validate, and hand off.** Build the agent end-to-end \u2014 primitives, config, placeholder data, the works. Run validation, fix failures, then summarize what's now working and how to try it. If the developer's reply at any point is ambiguous but clearly meant to advance ("yep", "sure", "go ahead", typos that read as affirmative), take the charitable interpretation and keep moving rather than re-asking.
## Defaults Over Questions
Use clearly-labeled placeholders rather than ask the developer to author content. Specifically, infer and placeholder these without asking:
- routing rosters, lookup tables, assignment maps
- table rows, seed/demo data
- schema fields, return shapes, retry policies
- channel, workflow, action, and table names
- confidence thresholds, fallback values
- column names
Reserve the question tool for product forks where the default would noticeably reshape the agent or require rework:
- destination shape (post in-channel vs DM vs create ticket vs human-in-the-loop approval) when not implied
- conversational vs event-driven trigger when both are plausible from the description
- which integration to use when several would fit (Slack vs Teams, Linear vs Jira)
- whether the agent should write back or stay read-only when both are plausible
Avoid asking the developer to choose ADK internals at any point: schemas, return types, table columns, workflow names, retry policies, or which primitive to use. Infer those and state your assumption in the plan.
## ADK Architecture Map
Map intent onto the smallest useful set of ADK building blocks:
- \`agent.config.ts\` \u2014 agent metadata, integrations, model/config/state schemas
- \`src/conversations/\` \u2014 channel-specific message handlers for chat-style interaction
- \`src/triggers/\` \u2014 event subscriptions like "when a Slack message/event arrives"
- \`src/workflows/\` \u2014 multi-step, resumable, stateful, scheduled, or human-in-the-loop processes
- \`src/actions/\` \u2014 strongly typed reusable business logic, callable by workflows/conversations/other code
- \`src/tools/\` \u2014 LLM-callable capabilities selected during autonomous reasoning
- \`src/tables/\` \u2014 durable schema-validated records, routing rules, memory, queues, assignments
- \`src/knowledge/\` \u2014 RAG over documents, websites, directories, or table-backed sources
- \`evals/\` \u2014 behavior checks for important user journeys
Default to the simplest design that works. A Slack triage agent may need a Slack conversation or trigger, one workflow, one classification action, and a routing table. It does not need every primitive.
## Prefer AI Over Deterministic Code
The ADK is built for LLM-native patterns. Default to AI for anything resembling reasoning, classification, summarization, or generation. Reserve deterministic code for mechanical work (data transforms, API calls, plain control flow).
- For conversations and workflows, use **\`execute()\`** to let the LLM drive \u2014 provide instructions, hook up tools and knowledge bases, let the model decide. This is the default for chat-style interaction and autonomous workflows. See \`conversations.md\` and \`workflows.md\`.
- For one-shot LLM operations inside actions, workflows, or scripts, use **\`adk.zai.*\`** (imported from \`@botpress/runtime\`):
- \`zai.extract(input, schema)\` \u2014 pull structured data out of free text
- \`zai.check(input, condition)\` \u2014 yes/no classification with reasoning
- \`zai.summarize(input, options)\` \u2014 distill long content
- \`zai.label(input, labels)\` \u2014 multi-class classification against a fixed set
- \`zai.filter(items, condition)\` \u2014 keep items matching a natural-language predicate
- See \`zai-agent-reference.md\` and \`zai-complete-guide.md\`.
- Use hand-rolled logic only when the developer asks for deterministic behavior, the task is mechanical (string formatting, arithmetic, shape transforms), or the operation is genuinely trivial.
When building a triage, routing, classification, extraction, or Q&A agent, the right primitive is almost always \`execute()\` or zai \u2014 not a hand-rolled regex or rule table.
## ADK Knowledge Sources
The \`adk\` skill is preloaded as \`.agent0/capabilities/skills/adk/SKILL.md\`. Treat it as the index, not the whole manual. Before authoring a primitive, read the relevant reference file under \`.agent0/capabilities/skills/adk/references/\`:
- \`agent-config.md\` before changing \`agent.config.ts\`
- \`conversations.md\` before writing or modifying conversations
- \`triggers.md\` before event-driven behavior
- \`workflows.md\` before multi-step or resumable flows
- \`actions.md\` before reusable typed logic
- \`tools.md\` before autonomous LLM tools
- \`zai-agent-reference.md\` and \`zai-complete-guide.md\` before using \`adk.zai.*\` (extract / check / summarize / label / filter)
- \`tables.md\` before durable data
- \`knowledge-bases.md\` before RAG
- \`integration-actions.md\` and \`integrations.md\` before using integration actions
- \`patterns-mistakes.md\` when writing code, especially for imports, workflow steps, and table schemas
- \`cli.md\` when choosing an ADK command
If a signature is still unclear, inspect existing project files, generated types in \`.adk/*.d.ts\`, or \`node_modules/@botpress/runtime\`. Do not guess primitive APIs.
Use ADK imports from \`@botpress/runtime\` for generated agent code. Use Botpress's \`z\` export from the ADK runtime import when following project/template style; never import from \`zod\` directly.
## Command Playbooks
Agent(0) command playbooks are available in \`.agent0/capabilities/playbooks/\`. Use them as workflow guidance:
- \`adk-build.md\` for decomposing a feature into primitives and building it
- \`adk-validate.md\` for static validation of a primitive or feature
- \`adk-test.md\` for invoking the built behavior
- \`adk-eval.md\` for adding regression coverage
You do not need to tell the developer to run these slash commands during guided setup. Follow the playbooks yourself when they apply.
## Visual Context
The guided setup view provides page context automatically. Screenshot capture is not available in guided setup, so rely on that context, project files, and CLI/status output when orienting yourself.
## Working Directory
Your shell is already set to the agent project root. Run all commands directly \u2014 never prepend \`cd\` to change into the project directory.
## Project Inspection
Before planning or writing, inspect enough local context:
- Run \`adk status --format json\` if available to learn project state.
- Read \`agent.config.ts\`.
- Run \`adk integrations list --format json\` before deciding integrations.
- Glob \`src/\` and skim existing primitives if the project is not empty.
- For conversation changes, read every \`src/conversations/*.ts\` file and check channel overlap. Extend an existing overlapping handler; only create a new conversation file when channels are disjoint or the developer explicitly asks.
Never read or display \`.env\` files or credentials. If a secret/config value is needed, ask the developer to confirm or configure it.
## Building Rules
- Use \`adk integrations info <integration> --format json\` before adding an integration when possible. Pin the version when you know it.
- Write files in dependency order: tables/knowledge first, actions/tools next, workflows next, conversations/triggers last.
- Add seed/demo data only when useful and clearly placeholder.
- Use static imports. Avoid dynamic imports except for documented ADK-safe cases.
- Keep names clear and project-local. Do not invent unrelated abstractions.
- Add comments only where they teach a real ADK concept or clarify non-obvious behavior.
## Validation Rules
Validate as you go:
- Run \`adk check --format json\` after meaningful additions.
- Use \`adk build\` when generated types or production bundle behavior need confirmation.
- For conversational agents, use \`adk chat --single "<message>" --format json\` when the chat/webchat integration is present and the dev server can handle it.
- For workflow-first agents, use \`adk workflows inspect <name> --format json\` and \`adk workflows run <name> '<payload>' --format json\` when available.
- If validation fails, fix it before moving on. If a command needs the dev server and it is unavailable, ask the developer to start/restart \`adk dev\`; do not start or restart dev/watch servers from inside agent(0).
Do not run commands that start, restart, or watch a development server from inside guided setup, including \`adk dev\`, \`bun dev\`, \`bun run dev\`, \`npm run dev\`, \`pnpm dev\`, \`yarn dev\`, \`vite dev\`, or framework-specific dev commands.
## Communication Style
Warm, direct, and efficient. No filler. Bias to action over questions; when you must ask, one short batch at a time.`;
var AGENT0_DEFAULT_AGENT = "default";
var AGENT0_DEFAULT_PRIMARY_AGENT_STEPS = 64;
var AGENT0_PRIMARY_AGENT_STEPS_ENV = "ADK_AGENT0_MAX_STEPS";
function resolveAgent0PrimaryAgentSteps(env = process.env) {
const raw = env[AGENT0_PRIMARY_AGENT_STEPS_ENV];
if (raw === undefined || raw.trim() === "")
return AGENT0_DEFAULT_PRIMARY_AGENT_STEPS;
const parsed = Number(raw);
if (Number.isInteger(parsed) && parsed > 0)
return parsed;
process.stderr.write(`[adk] Ignoring invalid ${AGENT0_PRIMARY_AGENT_STEPS_ENV}=${JSON.stringify(raw)}: ` + `expected a positive integer of agentic steps. Falling back to ${AGENT0_DEFAULT_PRIMARY_AGENT_STEPS}.
`);
return AGENT0_DEFAULT_PRIMARY_AGENT_STEPS;
}
var AGENT0_PROJECT_DIR = ".agent0";
var AGENT0_PROJECT_CAPABILITIES_DIR = "capabilities";
var AGENT0_PROJECT_SKILLS_DIR = "skills";
var AGENT0_PROJECT_PLAYBOOKS_DIR = "playbooks";
var AGENT0_SCREENSHOT_MCP_TOOL_PERMISSION = "adk_adk_take_screenshot";
var AGENT0_SCREENSHOT_RAW_TOOL_PERMISSION = "adk_take_screenshot";
function buildAgent0BuiltInCapabilities(options) {
const skillsRoot = resolveAgent0ProjectSkillsRoot(options.agentPath);
const commandsRoot = resolveAgent0ProjectPlaybooksRoot(options.agentPath);
const primaryAgentSteps = resolveAgent0PrimaryAgentSteps();
return {
mcp: {
adk: {
type: "remote",
url: `http://localhost:${options.adkDevConsolePort}/mcp?agent=${encodeURIComponent(options.agentPath)}`,
oauth: false
}
},
skills: {
paths: skillsRoot ? resolveAgent0BuiltInSkillPaths(skillsRoot) : [],
urls: []
},
instructions: skillsRoot ? resolveAgent0BuiltInInstructionFiles(skillsRoot) : [],
command: commandsRoot ? loadAgent0BuiltInCommandConfig(commandsRoot) : {},
agent: {
default: {
description: "Agent(0) - helps build and debug Botpress ADK agents",
prompt: AGENT0_DEFAULT_PROMPT,
mode: "primary",
steps: primaryAgentSteps
},
guided: {
description: "ADK guided setup - interviews the developer and scaffolds a new agent",
prompt: GUIDED_SETUP_PROMPT,
mode: "primary",
steps: primaryAgentSteps,
permission: {
[AGENT0_SCREENSHOT_MCP_TOOL_PERMISSION]: "deny",
[AGENT0_SCREENSHOT_RAW_TOOL_PERMISSION]: "deny"
}
},
build: {
mode: "primary",
steps: primaryAgentSteps
},
plan: {
mode: "primary",
steps: primaryAgentSteps
}
},
defaultAgent: AGENT0_DEFAULT_AGENT
};
}
function getAgent0ProjectCapabilitiesRoot(projectPath) {
return join3(projectPath, AGENT0_PROJECT_DIR, AGENT0_PROJECT_CAPABILITIES_DIR);
}
function resolveAgent0ProjectSkillsRoot(projectPath) {
return firstExistingDirectory([join3(getAgent0ProjectCapabilitiesRoot(projectPath), AGENT0_PROJECT_SKILLS_DIR)]);
}
function resolveAgent0ProjectPlaybooksRoot(projectPath) {
return firstExistingDirectory([join3(getAgent0ProjectCapabilitiesRoot(projectPath), AGENT0_PROJECT_PLAYBOOKS_DIR)]);
}
function resolveAgent0BuiltInSkillsRoot() {
return firstExistingDirectory(resolveAgent0BuiltInSkillsRootCandidates(moduleDir()));
}
function resolveAgent0BuiltInCommandsRoot() {
return firstExistingDirectory(resolveAgent0BuiltInCommandsRootCandidates(moduleDir()));
}
function resolveAgent0BuiltInSkillPaths(skillsRoot = resolveAgent0BuiltInSkillsRoot()) {
if (!skillsRoot)
return [];
return readdirSync(skillsRoot).toSorted().flatMap((entry) => {
const dir = join3(skillsRoot, entry);
if (!statSync(dir).isDirectory())
return [];
if (!existsSync5(join3(dir, "SKILL.md")))
return [];
return [dir];
});
}
function resolveAgent0BuiltInInstructionFiles(skillsRoot = resolveAgent0BuiltInSkillsRoot()) {
const files = skillsRoot ? [join3(skillsRoot, "adk", "SKILL.md")] : [];
return files.filter((file) => existsSync5(file) && statSync(file).isFile());
}
function loadAgent0BuiltInCommandConfig(commandsRoot = resolveAgent0BuiltInCommandsRoot()) {
if (!commandsRoot)
return {};
const commands = {};
for (const file of readdirSync(commandsRoot).toSorted()) {
if (extname(file) !== ".md")
continue;
const filepath = join3(commandsRoot, file);
if (!statSync(filepath).isFile())
continue;
const parsed = parseFrontmatterMarkdown(readFileSync4(filepath, "utf8"));
const name = parsed.frontmatter.name || basename(file, ".md");
if (!name)
continue;
commands[name] = {
template: parsed.body.trim(),
...parsed.frontmatter.description ? { description: parsed.frontmatter.description } : {},
...parsed.frontmatter.agent ? { agent: parsed.frontmatter.agent } : {},
...parsed.frontmatter.model ? { model: parsed.frontmatter.model } : {},
...parsed.frontmatter.subtask === "true" ? { subtask: true } : parsed.frontmatter.subtask === "false" ? { subtask: false } : {}
};
}
return commands;
}
function parseFrontmatterMarkdown(text) {
const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
if (!match)
return { frontmatter: {}, body: text };
const frontmatter = {};
for (const line of match[1].split(/\r?\n/)) {
const index = line.indexOf(":");
if (index === -1)
continue;
const key = line.slice(0, index).trim();
const value = line.slice(index + 1).trim();
if (!key || !value)
continue;
frontmatter[key] = unquote(value);
}
return { frontmatter, body: match[2] ?? "" };
}
function unquote(value) {
const quote = value[0];
return quote && quote === value[value.length - 1] && (quote === '"' || quote === "'") ? value.slice(1, -1) : value;
}
function firstExistingDirectory(paths) {
return paths.find((dir) => existsSync5(dir) && statSync(dir).isDirectory());
}
function resolveAgent0BuiltInSkillsRootCandidates(baseDir) {
return [join3(baseDir, "capabilities", "skills"), join3(baseDir, "agent0-assets", "skills"), join3(baseDir, "skills")];
}
function resolveAgent0BuiltInCommandsRootCandidates(baseDir) {
return [
join3(baseDir, "capabilities", "commands"),
join3(baseDir, "agent0-assets", "playbooks"),
join3(baseDir, "commands")
];
}
function moduleDir() {
return dirname(fileURLToPath(import.meta.url));
}
var PROJECT_HASH_LENGTH = 32;
var OWNER_ONLY_DIR_MODE = 448;
function getAgent0HomeDir(options = {}) {
return join22(options.homeDir ?? process.env.HOME ?? homedir(), ".adk", "agent0");
}
function getAgent0ConfigPath(options = {}) {
return join22(getAgent0HomeDir(options), "config.json");
}
async function ensureAgent0Directory(dirPath) {
await mkdir(dirPath, { recursive: true, mode: OWNER_ONLY_DIR_MODE });
await chmod(dirPath, OWNER_ONLY_DIR_MODE);
}
function canonicalizeAgent0ProjectPath(projectPath) {
const resolved = resolve6(projectPath);
return existsSync22(resolved) ? realpathSync(resolved) : resolved;
}
function getAgent0ProjectHash(projectPath) {
return createHash("sha256").update(canonicalizeAgent0ProjectPath(projectPath)).digest("hex").slice(0, PROJECT_HASH_LENGTH);
}
function getAgent0ProjectPaths(projectPath, options = {}) {
const canonicalProjectPath = canonicalizeAgent0ProjectPath(projectPath);
const projectHash = getAgent0ProjectHash(canonicalProjectPath);
const rootDir = join22(getAgent0HomeDir(options), "projects", projectHash);
const xdgConfigHome = join22(rootDir, "xdg", "config");
const xdgDataHome = join22(rootDir, "xdg", "data");
const xdgCacheHome = join22(rootDir, "xdg", "cache");
const xdgStateHome = join22(rootDir, "xdg", "state");
const fakeHomeDir = join22(rootDir, "home");
return {
projectHash,
canonicalProjectPath,
rootDir,
xdgConfigHome,
xdgDataHome,
xdgCacheHome,
xdgStateHome,
fakeHomeDir,
engineBinDir: join22(rootDir, "bin"),
engineConfigDir: join22(xdgConfigHome, "opencode"),
engineDataDir: join22(xdgDataHome, "opencode"),
sessionsDir: join22(xdgStateHome, "sessions")
};
}
async function ensureAgent0ProjectDirs(projectPath, options = {}) {
const paths = getAgent0ProjectPaths(projectPath, options);
await Promise.all([
ensureAgent0Directory(paths.rootDir),
ensureAgent0Directory(join22(paths.rootDir, "xdg")),
ensureAgent0Directory(paths.xdgConfigHome),
ensureAgent0Directory(paths.xdgDataHome),
ensureAgent0Directory(paths.xdgCacheHome),
ensureAgent0Directory(paths.xdgStateHome),
ensureAgent0Directory(paths.fakeHomeDir),
ensureAgent0Directory(paths.engineBinDir),
ensureAgent0Directory(paths.engineConfigDir),
ensureAgent0Directory(paths.engineDataDir),
ensureAgent0Directory(paths.sessionsDir)
]);
return paths;
}
init_src();
var agent0ProviderAuthSchema = ne.object({
type: ne.literal("api_key"),
apiKey: ne.string().trim().min(1),
baseURL: ne.string().trim().url().optional()
}).strict();
var agent0ProviderConnectionSchema = ne.object({
providerId: ne.string().min(1),
enabled: ne.boolean(),
auth: agent0ProviderAuthSchema.optional(),
createdAt: ne.string().datetime(),
updatedAt: ne.string().datetime()
}).strict();
var agent0ConfigPreferencesSchema = ne.object({
defaultModel: ne.string().min(1).optional(),
showThinking: ne.boolean(),
showUsage: ne.boolean()
}).strict();
var agent0ConfigSchema = ne.object({
schemaVersion: ne.literal(AGENT0_CONFIG_SCHEMA_VERSION),
enabled: ne.boolean(),
providers: ne.record(agent0ProviderConnectionSchema),
preferences: agent0ConfigPreferencesSchema,
createdAt: ne.string().datetime(),
updatedAt: ne.string().datetime()
}).strict();
var DEFAULT_AGENT0_PREFERENCES = {
showThinking: true,
showUsage: false
};
function createDefaultAgent0Config(now = new Date) {
const timestamp = now.toISOString();
return {
schemaVersion: AGENT0_CONFIG_SCHEMA_VERSION,
enabled: true,
providers: {},
preferences: { ...DEFAULT_AGENT0_PREFERENCES },
createdAt: timestamp,
updatedAt: timestamp
};
}
function parseAgent0Config(value) {
const config = agent0ConfigSchema.parse(value);
for (const [key, connection] of Object.entries(config.providers)) {
if (key !== connection.providerId) {
throw new AdkError({
code: "AGENT0_CONFIG_KEY_MISMATCH",
message: `Provider connection key "${key}" does not match providerId "${connection.providerId}"`,
expected: false
});
}
}
return config;
}
function redactProviderAuth(auth2) {
if (!auth2)
return;
return {
type: auth2.type,
configured: Boolean(auth2.apiKey),
...auth2.baseURL ? { baseURL: auth2.baseURL } : {}
};
}
function redactProviderConnection(connection) {
return {
...connection,
auth: redactProviderAuth(connection.auth)
};
}
function redactAgent0Config(config) {
return {
...config,
providers: Object.fromEntries(Object.entries(config.providers).map(([providerId, connection]) => [
providerId,
redactProviderConnection(connection)
]))
};
}
function hasAgent0ProviderAuth(connection) {
return Boolean(connection?.auth?.apiKey);
}
init_src();
class Agent0ConfigError extends AdkError {
constructor(message, cause, code = "AGENT0_CONFIG_INVALID") {
super({ code, message, expected: true, cause });
}
}
class Agent0ConfigStore {
configPath;
now;
writeLock = Promise.resolve();
constructor(options = {}) {
this.configPath = options.configPath ?? getAgent0ConfigPath(options);
this.now = options.now ?? (() => new Date);
}
async read() {
let content;
try {
content = await readFile(this.configPath, "utf-8");
} catch (error) {
if (isFileNotFoundError(error))
return createDefaultAgent0Config(this.now());
throw new Agent0ConfigError(`Failed to read Agent(0) config at ${this.configPath}`, error, "AGENT0_CONFIG_READ_FAILED");
}
try {
return parseAgent0Config(JSON.parse(content));
} catch (error) {
throw new Agent0ConfigError(`Invalid Agent(0) config at ${this.configPath}`, error);
}
}
async write(config) {
const parsed = parseAgent0Config(config);
await writeOwnerOnlyJson(this.configPath, parsed);
}
async reset() {
const config = createDefaultAgent0Config(this.now());
await this.write(config);
return config;
}
async update(updater) {
const result = this.writeLock.then(async () => {
const current = await this.read();
const draft = structuredClone(current);
const updated = updater(draft) ?? draft;
const next = parseAgent0Config({
...updated,
updatedAt: this.now().toISOString()
});
await this.write(next);
return next;
});
this.writeLock = result.then(() => {}, () => {});
return result;
}
}
async function writeOwnerOnlyJson(filePath, value) {
await ensureAgent0Directory(dirname2(filePath));
const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
await writeFile(tmpPath, JSON.stringify(value, null, 2) + `
`, { encoding: "utf-8", mode: 384 });
await chmod2(tmpPath, 384);
await rename(tmpPath, filePath);
await chmod2(filePath, 384);
}
function isFileNotFoundError(error) {
return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
}
init_src();
var apiKey = (apiKeyLabel = "API key", baseURL) => ({
type: "api_key",
apiKeyLabel,
...baseURL ? {
baseURL: {
label: baseURL.label ?? "Base URL",
placeholder: baseURL.placeholder,
defaultValue: baseURL.defaultValue,
required: baseURL.required ?? false
}
} : {}
});
var planned = (reason) => ({ type: "planned", reason });
var modelsDev = (providerId) => ({
type: "models.dev",
...providerId === undefined ? {} : { providerId }
});
var botpressCognitive = () => ({
type: "cognitive"
});
var AGENT0_PROVIDER_CATALOG = [
{
id: "cognitive",
name: "Botpress Cognitive",
description: "First-party Botpress model access through the active ADK dev bot.",
firstParty: true,
status: "available",
enabledByDefault: true,
auth: { type: "none" },
modelSource: botpressCognitive()
},
{
id: "openai",
name: "OpenAI",
description: "Direct OpenAI API access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("OpenAI API key"),
modelSource: modelsDev()
},
{
id: "anthropic",
name: "Anthropic",
description: "Direct Anthropic API access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Anthropic API key"),
modelSource: modelsDev()
},
{
id: "google",
name: "Google Gemini",
description: "Google Gemini API access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Gemini API key"),
modelSource: modelsDev()
},
{
id: "github-copilot",
name: "GitHub Copilot",
description: "GitHub Copilot model access.",
firstParty: false,
status: "planned",
enabledByDefault: false,
auth: planned("GitHub Copilot requires an OAuth/device-code flow, which is outside the first simple API-key pass."),
modelSource: modelsDev()
},
{
id: "openrouter",
name: "OpenRouter",
description: "Aggregator access to many hosted models.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("OpenRouter API key"),
modelSource: modelsDev()
},
{
id: "moonshotai",
name: "Moonshot AI / Kimi",
description: "Direct Moonshot AI access to Kimi models.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Moonshot API key"),
modelSource: modelsDev()
},
{
id: "mistral",
name: "Mistral",
description: "Direct Mistral API access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Mistral API key"),
modelSource: modelsDev()
},
{
id: "groq",
name: "Groq",
description: "Groq-hosted low-latency model access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Groq API key"),
modelSource: modelsDev()
},
{
id: "xai",
name: "xAI",
description: "Direct xAI API access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("xAI API key"),
modelSource: modelsDev()
},
{
id: "deepseek",
name: "DeepSeek",
description: "Direct DeepSeek API access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("DeepSeek API key"),
modelSource: modelsDev()
},
{
id: "cerebras",
name: "Cerebras",
description: "Cerebras-hosted model access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Cerebras API key"),
modelSource: modelsDev()
},
{
id: "fireworks-ai",
name: "Fireworks",
description: "Fireworks-hosted model access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Fireworks API key"),
modelSource: modelsDev()
},
{
id: "togetherai",
name: "Together AI",
description: "Together AI hosted model access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Together API key"),
modelSource: modelsDev()
},
{
id: "cohere",
name: "Cohere",
description: "Direct Cohere API access.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Cohere API key"),
modelSource: modelsDev()
},
{
id: "perplexity",
name: "Perplexity",
description: "Perplexity API access for answer and research-oriented models.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Perplexity API key"),
modelSource: modelsDev()
},
{
id: "azure",
name: "Azure OpenAI",
description: "Azure-hosted OpenAI-compatible deployments.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("Azure OpenAI API key", {
label: "Azure OpenAI endpoint",
placeholder: "https://<resource>.openai.azure.com/openai/deployments/<deployment>",
required: true
}),
modelSource: modelsDev()
},
{
id: "amazon-bedrock",
name: "AWS Bedrock",
description: "AWS Bedrock model access.",
firstParty: false,
status: "planned",
enabledByDefault: false,
auth: planned("AWS Bedrock needs AWS credential and region configuration, not a single API key."),
modelSource: modelsDev()
},
{
id: "google-vertex",
name: "Vertex AI",
description: "Google Cloud Vertex AI model access.",
firstParty: false,
status: "planned",
enabledByDefault: false,
auth: planned("Vertex AI needs Google Cloud project, location, and service account credentials."),
modelSource: modelsDev()
},
{
id: "alibaba",
name: "Alibaba / Qwen / DashScope",
description: "Alibaba DashScope access to Qwen models.",
firstParty: false,
status: "available",
enabledByDefault: false,
auth: apiKey("DashScope API key"),
modelSource: modelsDev()
}
];
var CATALOG_BY_ID = new Map(AGENT0_PROVIDER_CATALOG.map((entry) => [entry.id, entry]));
function listAgent0ProviderCatalog() {
return [...AGENT0_PROVIDER_CATALOG];
}
function getAgent0ProviderCatalogEntry(providerId) {
return CATALOG_BY_ID.get(providerId);
}
function requireAgent0ProviderCatalogEntry(providerId) {
const entry = getAgent0ProviderCatalogEntry(providerId);
if (!entry)
throw new AdkError({
code: "AGENT0_PROVIDER_UNKNOWN",
message: `Unknown Agent(0) provider: ${providerId}`,
expected: false
});
return entry;
}
function toAgent0AvailableModel(entry, model) {
if (model.providerId !== entry.id) {
throw new AdkError({
code: "AGENT0_MODEL_MISMATCH",
message: `Agent(0) model ${model.modelId} belongs to ${model.providerId}, not ${entry.id}`,
expected: false
});
}
return {
id: `${entry.id}/${model.modelId}`,
providerId: entry.id,
providerName: entry.name,
modelId: model.modelId,
name: model.name,
contextWindow: model.contextWindow,
outputLimit: model.outputLimit,
inputCostPer1MTokens: model.inputCostPer1MTokens,
outputCostPer1MTokens: model.outputCostPer1MTokens,
tags: model.tags ? [...model.tags] : undefined
};
}
init_src();
init_src();
var DEFAULT_BOTPRESS_API_URL = "https://api.botpress.cloud";
var DEFAULT_FETCH_TIMEOUT_MS = 5000;
var cognitiveModelsResponseSchema = ne.object({
models: ne.array(ne.object({
id: ne.string(),
name: ne.string(),
tags: ne.array(ne.string()).optional(),
input: ne.object({
maxTokens: ne.number(),
costPer1MTokens: ne.number()
}).optional(),
output: ne.object({
maxTokens: ne.number(),
costPer1MTokens: ne.number()
}).optional()
}))
});
async function fetchBotpressCognitiveModels(options) {
try {
const apiUrl = options.apiUrl || DEFAULT_BOTPRESS_API_URL;
const fetchImpl = options.fetch ?? fetch;
const res = await fetchImpl(`${apiUrl}/v2/cognitive/models`, {
headers: {
Authorization: `Bearer ${options.token}`,
"X-Bot-Id": options.botId
},
...options.timeoutMs === 0 ? {} : { signal: AbortSignal.timeout(options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS) }
});
if (!res.ok)
return;
const { models } = cognitiveModelsResponseSchema.parse(await res.json());
const filtered = models.filter((model) => !model.tags?.includes("speech-to-text") && !model.tags?.includes("deprecated") && !model.tags?.includes("discontinued"));
const nameCounts = new Map;
for (const model of filtered)
nameCounts.set(model.name, (nameCounts.get(model.name) ?? 0) + 1);
return filtered.map((model) => {
if (nameCounts.get(model.name) > 1) {
const provider = model.id.split(":")[0] ?? "";
return { ...model, name: `${model.name} (${provider})` };
}
return model;
});
} catch {
return;
}
}
function toCognitiveModelKey(id) {
return id.replace(":", "--");
}
var DEFAULT_MODELS_DEV_API_URL = "https://models.dev/api.json";
var DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000;
var DEFAULT_MODELS_DEV_FETCH_TIMEOUT_MS = 1e4;
class Agent0ProviderCatalogSourceError extends AdkError {
constructor(message, cause) {
super({ code: "AGENT0_PROVIDER_CATALOG_UNAVAILABLE", message, expected: true, cause });
}
}
class Agent0CompositeProviderCatalogSource {
id = "agent0-composite";
sources;
constructor(options) {
this.sources = options.sources;
}
async listProviders() {
return listAgent0ProviderCatalog();
}
async listModels(options = {}) {
return (await this.listModelsWithStatus(options)).models;
}
async listModelsWithStatus(options = {}) {
const results = await Promise.all(this.sources.map((source) => listSourceModelsWithStatus(source, options)));
return {
models: results.flatMap((result) => result.models),
warnings: results.flatMap((result) => result.warnings)
};
}
async refresh() {
await this.listModels({ refresh: true });
}
}
class Agent0CognitiveCatalogSource {
id = "cognitive";
auth;
resolveAuth;
fetchImpl;
now;
cacheTtlMs;
timeoutMs;
cache;
constructor(options = {}) {
this.auth = options.auth;
this.resolveAuth = options.resolveAuth;
this.fetchImpl = options.fetch;
this.now = options.now ?? (() => Date.now());
this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
this.timeoutMs = options.timeoutMs;
}
async listProviders() {
return listAgent0ProviderCatalog();
}
async listModels(options = {}) {
return (await this.listModelsWithStatus(options)).models;
}
async listModelsWithStatus(options = {}) {
const auth2 = await this.getAuth();
if (!auth2?.token || !auth2.botId) {
return { models: [], warnings: [] };
}
const cognitiveAuth = { ...auth2, token: auth2.token, botId: auth2.botId };
const authKey = getCognitiveAuthCacheKey(cognitiveAuth);
if (!options.refresh && this.cache?.authKey === authKey && this.cache.expiresAt > this.now()) {
return { models: cloneModels(this.cache.models), warnings: [] };
}
const models = await fetchBotpressCognitiveModels({
token: cognitiveAuth.token,
botId: cognitiveAuth.botId,
apiUrl: cognitiveAuth.apiUrl,
fetch: this.fetchImpl,
timeoutMs: this.timeoutMs
});
if (!models) {
return {
models: [],
warnings: [
{
code: "CATALOG_SOURCE_UNAVAILABLE",
source: this.id,
message: "Botpress Cognitive model catalog is unavailable"
}
]
};
}
const mapped = models.map((model) => ({
providerId: "cognitive",
modelId: toCognitiveModelKey(model.id),
name: model.name,
contextWindow: model.input?.maxTokens,
outputLimit: model.output?.maxTokens,
inputCostPer1MTokens: model.input?.costPer1MTokens,
outputCostPer1MTokens: model.output?.costPer1MTokens,
tags: model.tags ? [...model.tags] : undefined
}));
this.cache = {
authKey,
expiresAt: this.now() + this.cacheTtlMs,
models: mapped
};
return {
models: cloneModels(mapped),
warnings: []
};
}
async refresh() {
await this.listModels({ refresh: true });
}
async getAuth() {
try {
return this.auth ?? await this.resolveAuth?.();
} catch {
return;
}
}
}
class Agent0ModelsDevCatalogSource {
id = "models.dev";
url;
fetchImpl;
now;
cacheTtlMs;
timeoutMs;
userAgent;
cache;
constructor(options = {}) {
this.url = options.url ?? DEFAULT_MODELS_DEV_API_URL;
this.fetchImpl = options.fetch ?? ((url, init) => fetch(url, init));
this.now = options.now ?? (() => Date.now());
this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
this.timeoutMs = options.timeoutMs ?? DEFAULT_MODELS_DEV_FETCH_TIMEOUT_MS;
this.userAgent = options.userAgent ?? "@botpress/adk-agent0";
}
async listProviders() {
return listAgent0ProviderCatalog();
}
async listModels(options = {}) {
if (!options.refresh && this.cache && this.cache.expiresAt > this.now()) {
return cloneModels(this.cache.models);
}
const data = await this.fetchModelsDevCatalog();
const models = mapModelsDevCatalog(data, await this.listProviders());
this.cache = {
expiresAt: this.now() + this.cacheTtlMs,
models
};
return cloneModels(models);
}
async refresh() {
await this.listModels({ refresh: true });
}
async fetchModelsDevCatalog() {
let text;
try {
const init = {
headers: {
Accept: "application/json",
"User-Agent": this.userAgent
}
};
if (this.timeoutMs > 0)
init.signal = AbortSignal.timeout(this.timeoutMs);
const response = await this.fetchImpl(this.url, init);
if (!response.ok) {
throw new Error(`models.dev responded with HTTP ${response.status}`);
}
text = await response.text();
} catch (error) {
throw new Agent0ProviderCatalogSourceError("Failed to fetch Agent(0) provider models", error);
}
try {
return JSON.parse(text);
} catch (error) {
throw new Agent0ProviderCatalogSourceError("Failed to parse Agent(0) provider models", error);
}
}
}
function mapModelsDevCatalog(data, providers = listAgent0ProviderCatalog()) {
if (!isRecord(data)) {
throw new Agent0ProviderCatalogSourceError("models.dev catalog must be an object");
}
const models = [];
for (const provider of providers) {
if (provider.modelSource?.type !== "models.dev")
continue;
const source = data[provider.modelSource.providerId ?? provider.id];
if (!isRecord(source))
continue;
const sourceModels = source.models;
if (!isRecord(sourceModels))
continue;
for (const [key, value] of Object.entries(sourceModels)) {
if (!isRecord(value))
continue;
if (value.status === "deprecated")
continue;
const modelId = nonEmptyString(value.id) ?? key;
const limit = isRecord(value.limit) ? value.limit : undefined;
const cost = isRecord(value.cost) ? value.cost : undefined;
const tags = value.reasoning === true ? ["reasoning"] : undefined;
models.push({
providerId: provider.id,
modelId,
name: nonEmptyString(value.name) ?? modelId,
contextWindow: finiteNumber(limit?.context),
outputLimit: finiteNumber(limit?.output),
inputCostPer1MTokens: finiteNumber(cost?.input),
outputCostPer1MTokens: finiteNumber(cost?.output),
tags
});
}
}
return models;
}
function cloneModels(models) {
return models.map((model) => ({
...model,
tags: model.tags ? [...model.tags] : undefined
}));
}
function isRecord(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function nonEmptyString(value) {
return typeof value === "string" && value.trim() ? value : undefined;
}
function finiteNumber(value) {
return typeof value === "number" && Number.isFinite(value) ? value : undefined;
}
async function listSourceModelsWithStatus(source, options) {
try {
if (source.listModelsWithStatus)
return await source.listModelsWithStatus(options);
return {
models: await source.listModels(options),
warnings: []
};
} catch (error) {
return {
models: [],
warnings: [toSourceUnavailableWarning(source, error)]
};
}
}
function getCognitiveAuthCacheKey(auth2) {
return JSON.stringify({
apiUrl: auth2.apiUrl ?? "",
botId: auth2.botId,
token: auth2.token
});
}
function toSourceUnavailableWarning(source, error) {
return {
code: "CATALOG_SOURCE_UNAVAILABLE",
source: source.id ?? "unknown",
message: error instanceof Error ? error.message : "Provider model catalog source is unavailable"
};
}
function createAgent0DefaultProviderCatalogSource(options = {}) {
return new Agent0CompositeProviderCatalogSource({
sources: [new Agent0CognitiveCatalogSource(options.cognitive), new Agent0ModelsDevCatalogSource(options.modelsDev)]
});
}
class Agent0ProviderRegistry {
store;
catalogSource;
now;
constructor(options = {}) {
this.store = options.store ?? new Agent0ConfigStore;
this.catalogSource = options.catalogSource ?? createAgent0DefaultProviderCatalogSource(options.catalogSourceOptions);
this.now = options.now ?? (() => new Date);
}
async listProviders() {
return (await this.listProvidersWithStatus()).providers;
}
async listProvidersWithStatus() {
const [configResult, catalog, modelResult] = await Promise.all([
this.readConfigWithStatus(),
this.listCatalogProviders(),
this.listCatalogModelsWithStatus()
]);
const { config } = configResult;
const redacted = redactAgent0Config(config);
const modelCounts = countModelsByProvider(modelResult.models);
const providers = catalog.map((entry) => {
const connection = redacted.providers[entry.id];
const stored = config.providers[entry.id];
const connected = entry.auth.type === "none" || hasAgent0ProviderAuth(stored);
const enabled = connection?.enabled ?? entry.enabledByDefault;
return {
id: entry.id,
name: entry.name,
displayName: entry.displayName,
description: entry.description,
firstParty: entry.firstParty,
status: entry.status,
enabled,
connected,
auth: entry.auth,
connection,
modelCount: modelCounts.get(entry.id) ?? 0
};
});
return { providers, warnings: [...configResult.warnings, ...modelResult.warnings] };
}
async listModels() {
return (await this.listModelsWithStatus()).models;
}
async listModelsWithStatus() {
const [configResult, catalog, catalogModelResult] = await Promise.all([
this.readConfigWithStatus(),
this.listCatalogProviders(),
this.listCatalogModelsWithStatus()
]);
const { config } = configResult;
const entries = new Map(catalog.map((entry) => [entry.id, entry]));
const models = [];
for (const model of catalogModelResult.models) {
const entry = entries.get(model.providerId);
if (!entry)
continue;
if (!this.isProviderUsable(entry, config.providers[entry.id]))
continue;
models.push(toAgent0AvailableModel(entry, model));
}
return { models, warnings: [...configResult.warnings, ...catalogModelResult.warnings] };
}
async putProviderAuth(providerId, input) {
const entry = requireAgent0ProviderCatalogEntry(providerId);
if (entry.auth.type !== "api_key") {
throw new AdkError({
code: "AGENT0_PROVIDER_KEY_UNSUPPORTED",
message: `Agent(0) provider ${providerId} does not support API-key authentication`,
expected: true
});
}
const now = this.now().toISOString();
const config = await this.store.update((draft) => {
const existing = draft.providers[providerId];
draft.providers[providerId] = {
providerId,
enabled: input.enabled ?? existing?.enabled ?? true,
auth: compactAuth({
type: "api_key",
apiKey: input.apiKey,
baseURL: input.baseURL
}),
createdAt: existing?.createdAt ?? now,
updatedAt: now
};
});
return redactAgent0Config(config).providers[providerId];
}
async removeProviderAuth(providerId) {
requireAgent0ProviderCatalogEntry(providerId);
const now = this.now().toISOString();
const config = await this.store.update((draft) => {
const existing = draft.providers[providerId];
if (!existing)
return;
draft.providers[providerId] = {
...existing,
auth: undefined,
updatedAt: now
};
});
return redactAgent0Config(config).providers[providerId];
}
async setProviderEnabled(providerId, enabled) {
const entry = requireAgent0ProviderCatalogEntry(providerId);
if (enabled && entry.status !== "available") {
throw new AdkError({
code: "AGENT0_PROVIDER_UNAVAILABLE",
message: `Agent(0) provider ${providerId} is not available yet`,
expected: true
});
}
const current = await this.store.read();
if (enabled && entry.auth.type === "api_key" && !hasAgent0ProviderAuth(current.providers[providerId])) {
throw new AdkError({
code: "AGENT0_PROVIDER_NOT_CONNECTED",
message: `Agent(0) provider ${providerId} must be connected before it can be enabled`,
expected: true,
suggestion: `Connect the ${providerId} provider before enabling it.`
});
}
const now = this.now().toISOString();
const config = await this.store.update((draft) => {
const existing = draft.providers[providerId];
draft.providers[providerId] = {
providerId,
enabled,
auth: existing?.auth,
createdAt: existing?.createdAt ?? now,
updatedAt: now
};
});
return redactAgent0Config(config).providers[providerId];
}
isProviderUsable(entry, connection) {
if (entry.status !== "available")
return false;
const enabled = connection?.enabled ?? entry.enabledByDefault;
if (!enabled)
return false;
if (entry.auth.type === "none")
return true;
return hasAgent0ProviderAuth(connection);
}
async listCatalogProviders() {
try {
return await this.catalogSource.listProviders();
} catch {
return listAgent0ProviderCatalog();
}
}
async readConfigWithStatus() {
try {
return { config: await this.store.read(), warnings: [] };
} catch (error) {
if (!(error instanceof Agent0ConfigError))
throw error;
return {
config: createDefaultAgent0Config(this.now()),
warnings: [
{
code: "CONFIG_UNAVAILABLE",
source: "agent0-config",
message: "Saved Agent(0) provider settings are unavailable."
}
]
};
}
}
async listCatalogModelsWithStatus() {
try {
if (this.catalogSource.listModelsWithStatus) {
return await this.catalogSource.listModelsWithStatus();
}
return { models: await this.catalogSource.listModels(), warnings: [] };
} catch (error) {
return {
models: [],
warnings: [
{
code: "CATALOG_SOURCE_UNAVAILABLE",
source: this.catalogSource.id ?? "unknown",
message: error instanceof Error ? error.message : "Provider model catalog source is unavailable"
}
]
};
}
}
}
function compactAuth(auth2) {
const baseURL = auth2.baseURL?.trim();
return {
type: auth2.type,
apiKey: auth2.apiKey,
...baseURL ? { baseURL } : {}
};
}
function countModelsByProvider(models) {
const counts = new Map;
for (const model of models) {
counts.set(model.providerId, (counts.get(model.providerId) ?? 0) + 1);
}
return counts;
}
init_src();
init_src();
init_src();
var AGENT0_BUILT_IN_MCP_PERMISSION = "adk_*";
var AGENT0_HIDDEN_OPENCODE_SKILL = "customize-opencode";
var AGENT0_OPEN_CODE_PERMISSION_POLICY = Object.freeze({
question: "allow",
read: "allow",
list: "allow",
glob: "allow",
grep: "allow",
edit: "allow",
bash: "allow",
todowrite: "allow",
task: "allow",
webfetch: "allow",
websearch: "allow",
skill: {
"*": "allow",
[AGENT0_HIDDEN_OPENCODE_SKILL]: "deny"
},
lsp: "allow",
external_directory: "deny",
repo_clone: "deny",
repo_overview: "allow",
[AGENT0_BUILT_IN_MCP_PERMISSION]: "allow"
});
function buildAgent0OpenCodePermissionConfig() {
return Object.fromEntries(Object.entries(AGENT0_OPEN_CODE_PERMISSION_POLICY).map(([key, value]) => [
key,
typeof value === "string" ? value : { ...value }
]));
}
var AGENT0_PROJECT_ID_CACHE_GUARD_ENV = "OPENCODE_AGENT0_DISABLE_PROJECT_ID_CACHE";
var GIT_SHIM_MODE = 448;
var POSIX_GIT_SHIM = `#!/bin/sh
if [ "\${OPENCODE_AGENT0_DISABLE_PROJECT_ID_CACHE:-}" = "1" ] \\
&& [ "$#" -eq 3 ] \\
&& [ "$1" = "rev-list" ] \\
&& [ "$2" = "--max-parents=0" ] \\
&& [ "$3" = "HEAD" ]; then
parent_comm=$(ps -p "$PPID" -o comm= 2>/dev/null || true)
parent_base=\${parent_comm##*/}
case "$parent_base" in
sh|bash|zsh|fish|dash|ksh|tcsh|csh|pwsh|powershell|powershell.exe|cmd|cmd.exe)
;;
*)
exit 1
;;
esac
fi
if [ -n "\${AGENT0_REAL_GIT:-}" ]; then
exec "$AGENT0_REAL_GIT" "$@"
fi
real_git=
self_dir=$(CDPATH= cd "$(dirname "$0")" 2>/dev/null && pwd -P)
old_ifs=$IFS
IFS=:
for dir in \${PATH:-}; do
[ -n "$dir" ] || dir=.
resolved=$(CDPATH= cd "$dir" 2>/dev/null && pwd -P || true)
[ "$resolved" = "$self_dir" ] && continue
candidate=$dir/git
if [ -x "$candidate" ]; then
real_git=$candidate
break
fi
done
IFS=$old_ifs
if [ -z "$real_git" ]; then
echo "Agent(0) git shim could not locate the real git executable" >&2
exit 127
fi
exec "$real_git" "$@"
`;
var WINDOWS_GIT_SHIM = `@echo off
setlocal EnableExtensions DisableDelayedExpansion
if "%OPENCODE_AGENT0_DISABLE_PROJECT_ID_CACHE%"=="1" (
if "%~1"=="rev-list" if "%~2"=="--max-parents=0" if "%~3"=="HEAD" if "%~4"=="" (
exit /b 1
)
)
if not "%AGENT0_REAL_GIT%"=="" (
"%AGENT0_REAL_GIT%" %*
exit /b %ERRORLEVEL%
)
for /f "delims=" %%G in ('where.exe git 2^>nul') do (
if /I not "%%~fG"=="%~f0" (
"%%~fG" %*
exit /b %ERRORLEVEL%
)
)
echo Agent(0) git shim could not locate the real git executable 1>&2
exit /b 127
`;
function getAgent0ProjectDiscoveryGitShimFilename(targetPlatform = platform()) {
return targetPlatform === "win32" ? "git.cmd" : "git";
}
async function ensureAgent0ProjectDiscoveryGitShim(paths2) {
const targetPlatform = platform();
const shimPath = join32(paths2.engineBinDir, getAgent0ProjectDiscoveryGitShimFilename(targetPlatform));
const shimContent = targetPlatform === "win32" ? WINDOWS_GIT_SHIM : POSIX_GIT_SHIM;
await mkdir2(paths2.engineBinDir, { recursive: true, mode: GIT_SHIM_MODE });
await chmod3(paths2.engineBinDir, GIT_SHIM_MODE);
await writeFile2(shimPath, shimContent, { mode: GIT_SHIM_MODE });
await chmod3(shimPath, GIT_SHIM_MODE);
return shimPath;
}
function buildAgent0OpenCodeAuthContent(config) {
return Object.fromEntries(getAgent0OpenCodeAuthenticatedProviders(config).map(([providerId, connection]) => [
providerId,
{ type: "api", key: connection.auth.apiKey }
]));
}
function buildAgent0OpenCodeConfig(options) {
const builtIns = buildAgent0BuiltInCapabilities({
adkDevConsolePort: options.adkDevConsolePort,
agentPath: options.agentPath
});
const authenticatedProviders = options.agent0Config ? getAgent0OpenCodeAuthenticatedProviders(options.agent0Config) : [];
const externalProviderConfig = Object.fromEntries(authenticatedProviders.flatMap(([providerId, connection]) => connection.auth.baseURL ? [[providerId, { options: { baseURL: connection.auth.baseURL } }]] : []));
const provider = {
...externalProviderConfig,
...options.cognitiveModels === undefined ? {} : { cognitive: buildAgent0CognitiveProvider(options) }
};
const enabledProviders = [
...options.cognitiveModels === undefined ? [] : ["cognitive"],
...authenticatedProviders.map(([providerId]) => providerId)
];
return {
...options.openCodePort ? {
server: {
port: options.openCodePort,
...options.corsOrigins?.length ? { cors: [...options.corsOrigins] } : {}
}
} : {},
...options.agent0Config || options.cognitiveModels !== undefined ? { enabled_providers: enabledProviders } : {},
...Object.keys(provider).length ? { provider } : {},
mcp: builtIns.mcp,
permission: buildAgent0OpenCodePermissionConfig(),
default_agent: builtIns.defaultAgent,
agent: builtIns.agent,
...Object.keys(builtIns.command).length ? { command: builtIns.command } : {},
plugin: [],
skills: builtIns.skills,
instructions: builtIns.instructions,
share: "disabled",
autoupdate: false
};
}
function buildAgent0CognitiveProvider(options) {
const baseURL = `http://localhost:${options.adkDevConsolePort}/api/agent-proxy/${encodeURIComponent(options.agentPath)}/api/cognitive/v1`;
const models = Object.fromEntries((options.cognitiveModels ?? []).filter((model) => model.providerId === "cognitive").map((model) => [
model.modelId,
{
id: model.modelId,
name: model.name,
...renderCognitiveModelCostAndLimits(model),
...renderCognitiveModelModalities(model)
}
]));
return {
api: "openai-completions",
name: "Botpress Cognitive",
options: { apiKey: "cognitive", baseURL },
models
};
}
function buildAgent0OpenCodeEnv(paths2, configOrContent, authContent = {}) {
const configContent = typeof configOrContent === "string" ? configOrContent : JSON.stringify(configOrContent);
return {
XDG_CONFIG_HOME: paths2.xdgConfigHome,
XDG_DATA_HOME: paths2.xdgDataHome,
XDG_CACHE_HOME: paths2.xdgCacheHome,
XDG_STATE_HOME: paths2.xdgStateHome,
OPENCODE_CONFIG_DIR: paths2.engineConfigDir,
OPENCODE_CONFIG_CONTENT: configContent,
OPENCODE_AUTH_CONTENT: JSON.stringify(authContent),
OPENCODE_TEST_HOME: paths2.fakeHomeDir,
OPENCODE_PURE: "1",
OPENCODE_DISABLE_PROJECT_CONFIG: "1",
OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
OPENCODE_DISABLE_DEFAULT_PLUGINS: "1",
OPENCODE_DISABLE_CLAUDE_CODE: "1",
OPENCODE_DISABLE_CLAUDE_CODE_SKILLS: "1",
OPENCODE_DISABLE_AUTOUPDATE: "1",
OPENCODE_DISABLE_SHARE: "1",
[AGENT0_PROJECT_ID_CACHE_GUARD_ENV]: "1",
PATH: ""
};
}
function renderAgent0OpenCodeRuntime(options) {
const config = buildAgent0OpenCodeConfig(options);
const configContent = JSON.stringify(config);
const authContent = options.agent0Config ? buildAgent0OpenCodeAuthContent(options.agent0Config) : {};
return {
config,
authContent,
renderedOpenCodeConfigHash: sha256(configContent),
env: buildAgent0OpenCodeEnv(options.paths, configContent, authContent)
};
}
async function prepareAgent0OpenCodeRuntime(options) {
await ensureAgent0ProjectDiscoveryGitShim(options.paths);
return renderAgent0OpenCodeRuntime(options);
}
function getAgent0OpenCodeAuthenticatedProviders(config) {
return Object.entries(config.providers).sort(([left], [right]) => left.localeCompare(right)).flatMap(([, connection]) => {
if (!connection.enabled || connection.auth?.type !== "api_key")
return [];
const entry = getAgent0ProviderCatalogEntry(connection.providerId);
if (!entry)
throw new AdkError({
code: "AGENT0_PROVIDER_UNKNOWN",
message: `Unknown Agent(0) provider: ${connection.providerId}`,
expected: false
});
if (entry.firstParty || entry.auth.type !== "api_key")
return [];
const providerId = entry.modelSource?.type === "models.dev" ? entry.modelSource.providerId ?? entry.id : undefined;
if (!providerId)
throw new AdkError({
code: "AGENT0_PROVIDER_SOURCE_MISSING",
message: `Agent(0) provider ${connection.providerId} has no OpenCode provider source`,
expected: false
});
return [[providerId, { ...connection, auth: connection.auth }]];
});
}
function renderCognitiveModelCostAndLimits(model) {
if (model.inputCostPer1MTokens === undefined && model.outputCostPer1MTokens === undefined && model.contextWindow === undefined && model.outputLimit === undefined) {
return {};
}
return {
cost: {
input: model.inputCostPer1MTokens ?? 0,
output: model.outputCostPer1MTokens ?? 0
},
limit: {
context: model.contextWindow ?? 0,
output: model.outputLimit ?? 0
}
};
}
function sha256(content) {
return createHash2("sha256").update(content).digest("hex");
}
function renderCognitiveModelModalities(model) {
if (!model.tags?.includes("vision"))
return {};
return {
attachment: true,
modalities: {
input: ["text", "image"],
output: ["text"]
}
};
}
var DEFAULT_STARTUP_TIMEOUT_MS = 15000;
var AGENT0_OPENCODE_HOSTNAME = "127.0.0.1";
var DEFAULT_SERVER_USERNAME = "agent0";
var OPENCODE_VERSION = "1.15.10";
var PROVIDER_AUTH_ENV_KEYS = new Set([
"AICORE_SERVICE_KEY",
"ANTHROPIC_API_KEY",
"AWS_ACCESS_KEY_ID",
"AWS_BEARER_TOKEN_BEDROCK",
"AWS_SECRET_ACCESS_KEY",
"AWS_SESSION_TOKEN",
"AZURE_OPENAI_API_KEY",
"CEREBRAS_API_KEY",
"CF_AIG_TOKEN",
"CLOUDFLARE_API_KEY",
"CLOUDFLARE_API_TOKEN",
"COHERE_API_KEY",
"DASHSCOPE_API_KEY",
"DEEPSEEK_API_KEY",
"FIREWORKS_API_KEY",
"GEMINI_API_KEY",
"GROQ_API_KEY",
"MISTRAL_API_KEY",
"MOONSHOT_API_KEY",
"OPENAI_API_KEY",
"OPENROUTER_API_KEY",
"PERPLEXITY_API_KEY",
"QWEN_API_KEY",
"TOGETHER_API_KEY",
"TOGETHERAI_API_KEY",
"XAI_API_KEY"
]);
class Agent0OpenCodeStartupTimeoutError extends AdkError {
timeoutMs;
startupOutput;
constructor(timeoutMs, options = {}) {
super({
code: "AGENT0_OPENCODE_STARTUP_TIMEOUT",
message: `Agent(0) private OpenCode runtime did not start within ${timeoutMs}ms` + (options.startupOutput ? `
${options.startupOutput}` : ""),
expected: true,
details: { timeoutMs },
cause: options.cause
});
this.timeoutMs = timeoutMs;
if (options.startupOutput !== undefined) {
this.startupOutput = options.startupOutput;
}
}
}
function sanitizeAgent0OpenCodeBaseEnv(env) {
return Object.fromEntries(Object.entries(env).filter(([key]) => !shouldStripEnv(key)));
}
function buildAgent0OpenCodeProcessEnv(options) {
return {
...sanitizeAgent0OpenCodeBaseEnv(options.baseEnv),
...options.runtimeEnv,
OPENCODE_SERVER_USERNAME: options.serverAuth.username,
OPENCODE_SERVER_PASSWORD: options.serverAuth.password
};
}
function buildAgent0OpenCodeAuthHeaders(auth2) {
return {
Authorization: `Basic ${Buffer.from(`${auth2.username}:${auth2.password}`).toString("base64")}`
};
}
async function resolveAgent0OpenCodeBinary(options = {}) {
const local = (options.findNodeModulesBinary ?? findAgent0OpenCodeBinaryInNodeModules)();
if (local)
return local;
const cached = getCachedAgent0OpenCodeBinary(options);
if (cached)
return cached;
return downloadAgent0OpenCodeBinary(options);
}
function findAgent0OpenCodeBinaryInNodeModules() {
const require2 = createRequire2(import.meta.url);
try {
const packageJsonPath = require2.resolve("opencode-ai/package.json");
const packageDir = dirname3(packageJsonPath);
const candidates = [resolve22(packageDir, "bin", "opencode.exe"), resolve22(packageDir, "bin", "opencode")];
return candidates.find((candidate) => existsSync32(candidate)) ?? null;
} catch {
return null;
}
}
function getCachedAgent0OpenCodeBinary(options) {
const binary = join4(getAgent0OpenCodeCacheDir(options), getAgent0OpenCodeBinaryName());
return existsSync32(binary) ? binary : null;
}
async function downloadAgent0OpenCodeBinary(options) {
const version = options.version ?? OPENCODE_VERSION;
if (version === "0.0.0") {
throw new AdkError({
code: "AGENT0_OPENCODE_VERSION_UNRESOLVED",
message: "Unable to resolve pinned opencode-ai version",
expected: false
});
}
const { name, binary } = getAgent0OpenCodePlatformPackage();
const tarballUrl = `https://registry.npmjs.org/${name}/-/${name}-${version}.tgz`;
const fetchImpl = options.fetch ?? fetch;
const cacheDir = getAgent0OpenCodeCacheDir(options);
const tmpDirPath = join4(tmpdir2(), `agent0-opencode-download-${Date.now()}`);
options.onLog?.(`Downloading opencode v${version} (${name})...`);
mkdirSync3(cacheDir, { recursive: true });
mkdirSync3(tmpDirPath, { recursive: true });
try {
const tarPath = join4(tmpDirPath, "opencode.tgz");
const response = await fetchImpl(tarballUrl);
if (!response.ok || !response.body) {
throw new AdkError({
code: "AGENT0_OPENCODE_DOWNLOAD_FAILED",
message: `Failed to download ${tarballUrl}: ${response.status} ${response.statusText}`,
expected: true
});
}
await pipeline(response.body, createWriteStream(tarPath));
const extractDir = join4(tmpDirPath, "extracted");
mkdirSync3(extractDir, { recursive: true });
execFileSync("tar", ["xzf", tarPath, "-C", extractDir, `package/bin/${binary}`]);
const extractedBinary = join4(extractDir, "package", "bin", binary);
if (!existsSync32(extractedBinary)) {
throw new AdkError({
code: "AGENT0_OPENCODE_DOWNLOAD_FAILED",
message: `Binary not found at expected path package/bin/${binary} in ${name}@${version} tarball`,
expected: true
});
}
const destBinary = join4(cacheDir, binary);
const tmpBinary = `${destBinary}.tmp`;
copyFileSync(extractedBinary, tmpBinary);
if (platform2() !== "win32")
chmodSync(tmpBinary, 493);
renameSync(tmpBinary, destBinary);
options.onLog?.(`Opencode v${version} cached at ${cacheDir}`);
return destBinary;
} finally {
try {
rmSync(tmpDirPath, { recursive: true, force: true });
} catch {}
}
}
function getAgent0OpenCodeCacheDir(options) {
return join4(options.homeDir ?? homedir2(), ".adk", "opencode", options.version ?? OPENCODE_VERSION);
}
function getAgent0OpenCodeBinaryName() {
return platform2() === "win32" ? "opencode.exe" : "opencode";
}
function getAgent0OpenCodePlatformPackage() {
const plat = platform2() === "win32" ? "windows" : platform2();
const packageArch = arch() === "arm64" ? "arm64" : "x64";
return {
name: `opencode-${plat}-${packageArch}`,
binary: getAgent0OpenCodeBinaryName()
};
}
async function startAgent0OpenCodeProcess(options) {
const runtime = await prepareAgent0OpenCodeRuntime(options);
const baseEnv = options.env ?? process.env;
const serverAuth = {
username: options.serverUsername ?? DEFAULT_SERVER_USERNAME,
password: options.serverPassword ?? randomUUID()
};
const child = spawn(options.binaryPath ?? await resolveAgent0OpenCodeBinary({ onLog: options.onLog }), ["serve", "--hostname", AGENT0_OPENCODE_HOSTNAME, "--port", "0", "--pure"], {
cwd: options.cwd ?? options.paths.canonicalProjectPath,
env: buildAgent0OpenCodeProcessEnv({
baseEnv,
runtimeEnv: {
...runtime.env,
PATH: prependPath(options.paths.engineBinDir, baseEnv.PATH ?? baseEnv.Path)
},
serverAuth
}),
stdio: ["ignore", "pipe", "pipe"]
});
try {
const baseURL = await waitForOpenCodeServer(child, {
timeoutMs: options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
signal: options.signal,
onLog: options.onLog
});
return {
baseURL,
authHeaders: buildAgent0OpenCodeAuthHeaders(serverAuth),
renderedOpenCodeConfigHash: runtime.renderedOpenCodeConfigHash,
pid: child.pid,
stop: () => stopAgent0OpenCodeProcess(child)
};
} catch (error) {
await stopAgent0OpenCodeProcess(child);
throw error;
}
}
async function stopAgent0OpenCodeProcess(child) {
if (child.exitCode !== null || child.signalCode !== null)
return;
await new Promise((resolveStop) => {
const timeout = setTimeout(() => {
child.kill("SIGKILL");
resolveStop();
}, 1000);
child.once("exit", () => {
clearTimeout(timeout);
resolveStop();
});
child.kill("SIGTERM");
});
}
function shouldStripEnv(key) {
const normalized = key.toUpperCase();
return normalized.startsWith("OPENCODE_") || normalized.startsWith("XDG_") || normalized.startsWith("AGENT0_") || PROVIDER_AUTH_ENV_KEYS.has(normalized);
}
async function waitForOpenCodeServer(child, options) {
const chunks = [];
return new Promise((resolveReady, rejectReady) => {
let settled = false;
const timeout = setTimeout(() => {
finish(new Agent0OpenCodeStartupTimeoutError(options.timeoutMs));
}, options.timeoutMs);
const finish = (error, url) => {
if (settled)
return;
settled = true;
clearTimeout(timeout);
child.stdout.off("data", onData);
child.stderr.off("data", onData);
child.off("error", onError);
child.off("exit", onExit);
options.signal?.removeEventListener("abort", onAbort);
if (error)
rejectReady(appendStartupOutput(error, chunks));
else
resolveReady(url);
};
const onData = (data) => {
const text = data.toString("utf8");
chunks.push(text);
options.onLog?.(text);
const match = /opencode server listening on (http:\/\/[^\s]+)/.exec(chunks.join(""));
if (match)
finish(undefined, match[1]);
};
const onExit = (code, signal) => {
finish(new Error(`Agent(0) private OpenCode runtime exited before startup: code=${code} signal=${signal}`));
};
const onError = (error) => {
finish(error);
};
const onAbort = () => {
child.kill("SIGTERM");
finish(new Error("Agent(0) private OpenCode runtime startup aborted"));
};
child.stdout.on("data", onData);
child.stderr.on("data", onData);
child.on("error", onError);
child.on("exit", onExit);
options.signal?.addEventListener("abort", onAbort, { once: true });
if (options.signal?.aborted)
onAbort();
});
}
function appendStartupOutput(error, chunks) {
const output = chunks.join("").trim();
if (!output)
return error;
if (error instanceof Agent0OpenCodeStartupTimeoutError) {
return new Agent0OpenCodeStartupTimeoutError(error.timeoutMs, {
cause: error.cause,
startupOutput: output
});
}
const wrapped = new Error(`${error.message}
${output}`);
wrapped.cause = error;
return wrapped;
}
function prependPath(dir, currentPath) {
return currentPath ? `${dir}${delimiter}${currentPath}` : dir;
}
class Agent0RuntimeClientError extends AdkError {
status;
constructor(code, message, options = {}) {
super({
code,
message,
expected: code === "ENGINE_UNAVAILABLE",
cause: options.cause,
details: options.status !== undefined ? { status: options.status } : undefined
});
this.status = options.status;
}
}
async function startAgent0RuntimeClient(options) {
const { fetch: fetchImpl, ...processOptions } = options;
const engine = await startAgent0OpenCodeProcess(processOptions);
return createAgent0RuntimeClient({
engine,
projectPath: options.paths.canonicalProjectPath,
fetch: fetchImpl
});
}
function createAgent0RuntimeClient(options) {
const fetchImpl = options.fetch ?? ((url, init) => fetch(url, init));
return {
async getStatus() {
const pathInfo = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: "/path",
searchParams: { directory: options.projectPath }
});
return normalizeAgent0RuntimeStatus(pathInfo, options.projectPath, options.engine.renderedOpenCodeConfigHash);
},
async listSessions() {
const sessions = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: "/session",
searchParams: { directory: options.projectPath, roots: "true" }
});
if (!Array.isArray(sessions)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid session list response");
}
return {
sessions: sessions.map((session2) => normalizeAgent0Session(session2, options.projectPath)),
warnings: []
};
},
async createSession(input = {}) {
const session2 = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: "/session",
method: "POST",
searchParams: { directory: options.projectPath },
body: toOpenCodeCreateSessionInput(input)
});
return normalizeAgent0Session(session2, options.projectPath);
},
async listMessages(sessionId) {
const messages = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: `/session/${encodeURIComponent(sessionId)}/message`,
searchParams: { directory: options.projectPath }
});
if (!Array.isArray(messages)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid message list response");
}
return {
messages: messages.map(normalizeAgent0Message),
warnings: []
};
},
async sendMessage(sessionId, input) {
const send = async () => {
const message2 = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: `/session/${encodeURIComponent(sessionId)}/message`,
method: "POST",
searchParams: { directory: options.projectPath },
body: toOpenCodePromptInput(input)
});
return normalizeAgent0Message(message2);
};
let message = await send();
for (let retry = 0;retry < EMPTY_COMPLETION_MAX_RETRIES && input.generateReply !== false && isEmptyCompletion(message); retry++) {
await new Promise((resolve32) => setTimeout(resolve32, EMPTY_COMPLETION_RETRY_DELAY_MS));
message = await send();
}
return message;
},
async abortSession(sessionId) {
const result = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: `/session/${encodeURIComponent(sessionId)}/abort`,
method: "POST",
searchParams: { directory: options.projectPath }
});
if (typeof result !== "boolean") {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid abort response");
}
return { aborted: result, warnings: [] };
},
async listQuestions(sessionId) {
const questions = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: "/question",
searchParams: { directory: options.projectPath }
});
if (!Array.isArray(questions)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid question list response");
}
const normalized = questions.map(normalizeAgent0QuestionRequest);
return {
questions: sessionId ? normalized.filter((question) => question.sessionId === sessionId) : normalized,
warnings: []
};
},
async replyQuestion(sessionId, questionId, input) {
await ensureAgent0QuestionBelongsToSession({
engine: options.engine,
fetch: fetchImpl,
projectPath: options.projectPath,
sessionId,
questionId
});
const result = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: `/question/${encodeURIComponent(questionId)}/reply`,
method: "POST",
searchParams: { directory: options.projectPath },
body: { answers: input.answers }
});
if (typeof result !== "boolean") {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid question reply response");
}
return { answered: result, warnings: [] };
},
async rejectQuestion(sessionId, questionId) {
await ensureAgent0QuestionBelongsToSession({
engine: options.engine,
fetch: fetchImpl,
projectPath: options.projectPath,
sessionId,
questionId
});
const result = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: `/question/${encodeURIComponent(questionId)}/reject`,
method: "POST",
searchParams: { directory: options.projectPath }
});
if (typeof result !== "boolean") {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid question reject response");
}
return { rejected: result, warnings: [] };
},
async listCommands() {
return {
commands: listAgent0BuiltInCommands(options.projectPath),
warnings: []
};
},
async runCommand(sessionId, input) {
const command = getAgent0BuiltInCommand(options.projectPath, input.command);
if (!command) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", `Unknown Agent(0) command: ${input.command}`);
}
const message = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: fetchImpl,
path: `/session/${encodeURIComponent(sessionId)}/message`,
method: "POST",
searchParams: { directory: options.projectPath },
body: toOpenCodePromptInput({
parts: [{ type: "text", text: renderAgent0CommandTemplate(command.template, input.arguments) }],
mode: input.mode,
model: input.model,
generateReply: true
})
});
return normalizeAgent0Message(message);
},
streamEvents(input = {}) {
return streamAgent0OpenCodeEvents({
engine: options.engine,
fetch: fetchImpl,
projectPath: options.projectPath,
sessionId: input.sessionId,
signal: input.signal
});
},
stop() {
return options.engine.stop();
}
};
}
async function ensureAgent0QuestionBelongsToSession(options) {
const questions = await fetchAgent0OpenCodeJson({
engine: options.engine,
fetch: options.fetch,
path: "/question",
searchParams: { directory: options.projectPath }
});
if (!Array.isArray(questions)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid question list response");
}
const belongsToSession = questions.map(normalizeAgent0QuestionRequest).some((question) => question.id === options.questionId && question.sessionId === options.sessionId);
if (!belongsToSession) {
throw new Agent0RuntimeClientError("ENGINE_HTTP_ERROR", "Agent(0) private runtime question request was not found", {
status: 404
});
}
}
async function fetchAgent0OpenCodeJson(options) {
const url = new URL(options.path, options.engine.baseURL);
for (const [key, value] of Object.entries(options.searchParams ?? {})) {
url.searchParams.set(key, value);
}
let response;
try {
response = await options.fetch(url, {
method: options.method ?? "GET",
headers: {
...options.engine.authHeaders,
...options.body === undefined ? {} : { "Content-Type": "application/json" }
},
...options.body === undefined ? {} : { body: JSON.stringify(options.body) }
});
} catch (error) {
throw new Agent0RuntimeClientError("ENGINE_UNAVAILABLE", "Agent(0) private runtime is unavailable", {
cause: error
});
}
if (!response.ok) {
let detail = "";
try {
const body = await response.text();
if (body)
detail = `: ${body.slice(0, 500)}`;
} catch {}
throw new Agent0RuntimeClientError("ENGINE_HTTP_ERROR", `Agent(0) private runtime responded with HTTP ${response.status}${detail}`, { status: response.status });
}
try {
return await response.json();
} catch (error) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned invalid JSON", {
cause: error
});
}
}
async function* streamAgent0OpenCodeEvents(options) {
const url = new URL("/event", options.engine.baseURL);
url.searchParams.set("directory", options.projectPath);
let response;
try {
response = await options.fetch(url, {
headers: options.engine.authHeaders,
signal: options.signal
});
} catch (error) {
throw new Agent0RuntimeClientError("ENGINE_UNAVAILABLE", "Agent(0) private runtime event stream is unavailable", {
cause: error
});
}
if (!response.ok) {
throw new Agent0RuntimeClientError("ENGINE_HTTP_ERROR", `Agent(0) private runtime event stream responded with HTTP ${response.status}`, { status: response.status });
}
if (!response.body) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an empty event stream");
}
const reader = response.body.getReader();
const decoder = new TextDecoder;
let buffer = "";
try {
while (true) {
const chunk = await reader.read();
if (chunk.done)
break;
buffer += decoder.decode(chunk.value, { stream: true }).replace(/\r\n?/g, `
`);
let separatorIndex;
while ((separatorIndex = buffer.indexOf(`
`)) !== -1) {
const record = buffer.slice(0, separatorIndex);
buffer = buffer.slice(separatorIndex + 2);
const event = normalizeOpenCodeSSERecord(record);
if (!event || !matchesAgent0RuntimeEventSession(event, options.sessionId))
continue;
yield event;
}
}
buffer += decoder.decode();
if (buffer.trim().length > 0) {
const event = normalizeOpenCodeSSERecord(buffer);
if (event && matchesAgent0RuntimeEventSession(event, options.sessionId))
yield event;
}
} finally {
await reader.cancel().catch(() => {});
}
}
function normalizeOpenCodeSSERecord(record) {
const dataLines = [];
for (const line of record.split(`
`)) {
if (line.length === 0 || line.startsWith(":"))
continue;
const colon = line.indexOf(":");
const field = colon === -1 ? line : line.slice(0, colon);
const value2 = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
if (field === "data")
dataLines.push(value2);
}
if (dataLines.length === 0)
return;
let value;
try {
value = JSON.parse(dataLines.join(`
`));
} catch {
return;
}
try {
return normalizeOpenCodeEvent(value);
} catch {
return;
}
}
function normalizeOpenCodeEvent(value) {
if (!isRecord2(value) || typeof value.type !== "string") {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid event envelope");
}
const id = typeof value.id === "string" ? value.id : undefined;
const properties = isRecord2(value.properties) ? value.properties : {};
switch (value.type) {
case "server.connected":
return { ...id ? { id } : {}, type: "runtime.connected" };
case "server.heartbeat":
return { ...id ? { id } : {}, type: "runtime.heartbeat" };
case "message.updated": {
if (!isRecord2(properties.info))
return invalidOpenCodeEvent("message.updated");
return { ...id ? { id } : {}, type: "message.updated", message: normalizeAgent0MessageInfo(properties.info) };
}
case "message.removed": {
if (typeof properties.sessionID !== "string" || typeof properties.messageID !== "string") {
return invalidOpenCodeEvent("message.removed");
}
return {
...id ? { id } : {},
type: "message.removed",
sessionId: properties.sessionID,
messageId: properties.messageID
};
}
case "message.part.updated": {
if (!isRecord2(properties.part) || typeof properties.sessionID !== "string") {
return invalidOpenCodeEvent("message.part.updated");
}
const messageId = typeof properties.part.messageID === "string" ? properties.part.messageID : typeof properties.messageID === "string" ? properties.messageID : undefined;
if (!messageId)
return invalidOpenCodeEvent("message.part.updated");
const [part] = normalizeAgent0MessagePart(properties.part);
if (!part)
return;
return {
...id ? { id } : {},
type: "message.part.updated",
sessionId: properties.sessionID,
messageId,
part,
...typeof properties.time === "number" ? { updatedAt: normalizeTimestamp(properties.time) } : {}
};
}
case "message.part.delta": {
if (typeof properties.sessionID !== "string" || typeof properties.messageID !== "string" || typeof properties.partID !== "string" || typeof properties.field !== "string" || typeof properties.delta !== "string") {
return invalidOpenCodeEvent("message.part.delta");
}
return {
...id ? { id } : {},
type: "message.part.delta",
sessionId: properties.sessionID,
messageId: properties.messageID,
partId: properties.partID,
field: properties.field,
delta: properties.delta
};
}
case "message.part.removed": {
if (typeof properties.sessionID !== "string" || typeof properties.messageID !== "string" || typeof properties.partID !== "string") {
return invalidOpenCodeEvent("message.part.removed");
}
return {
...id ? { id } : {},
type: "message.part.removed",
sessionId: properties.sessionID,
messageId: properties.messageID,
partId: properties.partID
};
}
case "session.status": {
if (typeof properties.sessionID !== "string")
return invalidOpenCodeEvent("session.status");
const status = normalizeAgent0SessionStatus(properties.status);
if (!status)
return invalidOpenCodeEvent("session.status");
return {
...id ? { id } : {},
type: "session.status",
sessionId: properties.sessionID,
status
};
}
case "session.error": {
if (!isRecord2(properties.error))
return invalidOpenCodeEvent("session.error");
return {
...id ? { id } : {},
type: "session.error",
...typeof properties.sessionID === "string" ? { sessionId: properties.sessionID } : {},
error: normalizeAgent0Error(properties.error)
};
}
case "question.asked": {
return { ...id ? { id } : {}, type: "question.asked", question: normalizeAgent0QuestionRequest(properties) };
}
case "question.replied": {
if (typeof properties.sessionID !== "string" || typeof properties.requestID !== "string" || !Array.isArray(properties.answers)) {
return invalidOpenCodeEvent("question.replied");
}
return {
...id ? { id } : {},
type: "question.replied",
sessionId: properties.sessionID,
questionId: properties.requestID,
answers: normalizeQuestionAnswers(properties.answers)
};
}
case "question.rejected": {
if (typeof properties.sessionID !== "string" || typeof properties.requestID !== "string") {
return invalidOpenCodeEvent("question.rejected");
}
return {
...id ? { id } : {},
type: "question.rejected",
sessionId: properties.sessionID,
questionId: properties.requestID
};
}
default:
return;
}
}
function invalidOpenCodeEvent(type) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", `Agent(0) private runtime returned an invalid ${type} event`);
}
function matchesAgent0RuntimeEventSession(event, sessionId) {
if (!sessionId)
return true;
switch (event.type) {
case "runtime.connected":
case "runtime.heartbeat":
return true;
case "message.updated":
return event.message.sessionId === sessionId;
case "question.asked":
return event.question.sessionId === sessionId;
case "session.error":
return event.sessionId === undefined || event.sessionId === sessionId;
default:
return event.sessionId === sessionId;
}
}
function normalizeAgent0QuestionRequest(value) {
if (!isRecord2(value) || typeof value.id !== "string" || typeof value.sessionID !== "string") {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid question request");
}
if (!Array.isArray(value.questions)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned a question request without questions");
}
return {
id: value.id,
sessionId: value.sessionID,
questions: value.questions.map(normalizeAgent0QuestionInfo),
...isRecord2(value.tool) && typeof value.tool.messageID === "string" && typeof value.tool.callID === "string" ? { tool: { messageId: value.tool.messageID, callId: value.tool.callID } } : {}
};
}
function normalizeAgent0QuestionInfo(value) {
if (!isRecord2(value) || typeof value.question !== "string" || typeof value.header !== "string" || !Array.isArray(value.options)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid question");
}
return {
question: value.question,
header: value.header,
options: value.options.flatMap((option) => {
if (!isRecord2(option) || typeof option.label !== "string")
return [];
return [
{
label: option.label,
...typeof option.description === "string" ? { description: option.description } : {}
}
];
}),
...typeof value.multiple === "boolean" ? { multiple: value.multiple } : {},
...typeof value.custom === "boolean" ? { custom: value.custom } : {}
};
}
function normalizeQuestionAnswers(value) {
return value.map((answer) => {
if (!Array.isArray(answer) || answer.some((item) => typeof item !== "string")) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned invalid question answers");
}
return [...answer];
});
}
function listAgent0BuiltInCommands(projectPath) {
const commandsRoot = resolveAgent0ProjectPlaybooksRoot(projectPath);
if (!commandsRoot)
return [];
return Object.entries(loadAgent0BuiltInCommandConfig(commandsRoot)).map(([name, command]) => ({
name,
...command.description ? { description: command.description } : {},
hints: extractAgent0CommandHints(command.template),
...typeof command.subtask === "boolean" ? { subtask: command.subtask } : {}
})).toSorted((left, right) => left.name.localeCompare(right.name));
}
function getAgent0BuiltInCommand(projectPath, name) {
const commandsRoot = resolveAgent0ProjectPlaybooksRoot(projectPath);
if (!commandsRoot)
return;
return loadAgent0BuiltInCommandConfig(commandsRoot)[name];
}
function extractAgent0CommandHints(template) {
const hints = new Set;
for (const match of template.matchAll(/\$\d+/g)) {
hints.add(match[0]);
}
if (template.includes("$ARGUMENTS")) {
hints.add("$ARGUMENTS");
}
return [...hints].sort();
}
function renderAgent0CommandTemplate(template, args) {
return template.replaceAll("$ARGUMENTS", args?.trim() ?? "");
}
function normalizeAgent0Session(value, projectPath) {
if (!isRecord2(value) || typeof value.id !== "string" || typeof value.title !== "string") {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid session response");
}
if (!isRecord2(value.time)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned a session without valid timestamps");
}
const mode = normalizeAgent0SessionMode(value.agent);
return {
id: value.id,
title: value.title,
projectPath,
...typeof value.path === "string" ? { path: value.path } : {},
...typeof value.parentID === "string" ? { parentId: value.parentID } : {},
...mode ? { mode } : {},
...isRecord2(value.model) ? { model: normalizeAgent0SessionModel(value.model) } : {},
createdAt: normalizeTimestamp(value.time.created),
updatedAt: normalizeTimestamp(value.time.updated),
...value.time.archived === undefined || value.time.archived === null ? {} : { archivedAt: normalizeTimestamp(value.time.archived) }
};
}
function normalizeAgent0SessionModel(value) {
if (typeof value.providerID !== "string" || typeof value.id !== "string") {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid session model reference");
}
return {
providerId: value.providerID,
modelId: value.id,
...typeof value.variant === "string" ? { variant: value.variant } : {}
};
}
function normalizeAgent0MessageInfo(info) {
if (typeof info.id !== "string" || typeof info.sessionID !== "string" || info.role !== "user" && info.role !== "assistant" || !isRecord2(info.time)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid message info response");
}
const model = info.role === "user" ? isRecord2(info.model) ? normalizeAgent0MessageModel(info.model) : undefined : normalizeAgent0AssistantMessageModel(info);
const usage = normalizeAgent0MessageUsage(info);
const mode = normalizeAgent0SessionMode(info.agent);
return {
id: info.id,
sessionId: info.sessionID,
role: info.role,
createdAt: normalizeTimestamp(info.time.created),
completed: info.role === "user" || typeof info.time.completed === "number" || isRecord2(info.error),
...typeof info.time.completed === "number" ? { completedAt: normalizeTimestamp(info.time.completed) } : {},
...typeof info.parentID === "string" ? { parentId: info.parentID } : {},
...mode ? { mode } : {},
...model ? { model } : {},
...usage ? { usage } : {},
...isRecord2(info.error) ? { error: normalizeAgent0Error(info.error) } : {}
};
}
var EMPTY_COMPLETION_MAX_RETRIES = 1;
var EMPTY_COMPLETION_RETRY_DELAY_MS = 500;
function isEmptyCompletion(message) {
return message.role === "assistant" && message.completed && message.error === undefined && message.parts.length === 0 && (message.usage?.outputTokens ?? 0) === 0;
}
function normalizeAgent0Message(value) {
if (!isRecord2(value) || !isRecord2(value.info) || !Array.isArray(value.parts)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid message response");
}
const info = normalizeAgent0MessageInfo(value.info);
const parts = value.parts.flatMap(normalizeAgent0MessagePart);
return {
...info,
parts
};
}
function normalizeAgent0MessageModel(value) {
if (typeof value.providerID !== "string" || typeof value.modelID !== "string") {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid message model reference");
}
return {
providerId: value.providerID,
modelId: value.modelID,
...typeof value.variant === "string" ? { variant: value.variant } : {}
};
}
function normalizeAgent0AssistantMessageModel(value) {
if (typeof value.providerID !== "string" || typeof value.modelID !== "string")
return;
return {
providerId: value.providerID,
modelId: value.modelID,
...typeof value.variant === "string" ? { variant: value.variant } : {}
};
}
function normalizeAgent0SessionMode(value) {
return value === "default" || value === "guided" ? value : undefined;
}
function normalizeAgent0SessionStatus(value) {
if (!isRecord2(value))
return;
if (value.type === "idle" || value.type === "busy")
return { type: value.type };
if (value.type !== "retry" || typeof value.attempt !== "number" || !Number.isFinite(value.attempt) || typeof value.message !== "string" || typeof value.next !== "number" || !Number.isFinite(value.next)) {
return;
}
return {
type: "retry",
attempt: value.attempt,
message: value.message,
next: value.next,
...isRecord2(value.action) && typeof value.action.reason === "string" && typeof value.action.provider === "string" && typeof value.action.title === "string" && typeof value.action.message === "string" && typeof value.action.label === "string" ? {
action: {
reason: value.action.reason,
provider: value.action.provider,
title: value.action.title,
message: value.action.message,
label: value.action.label,
...typeof value.action.link === "string" ? { link: value.action.link } : {}
}
} : {}
};
}
function normalizeAgent0MessagePart(part) {
if (!isRecord2(part) || typeof part.id !== "string" || typeof part.type !== "string")
return [];
switch (part.type) {
case "text":
return [
{
id: part.id,
type: "text",
...typeof part.text === "string" ? { text: part.text } : {},
...part.synthetic === true ? { synthetic: true } : {},
...part.ignored === true ? { ignored: true } : {},
...isRecord2(part.metadata) ? { metadata: part.metadata } : {},
...normalizeAgent0PartTime(part.time) ? { time: normalizeAgent0PartTime(part.time) } : {}
}
];
case "agent":
return [
{
id: part.id,
type: "agent",
title: typeof part.name === "string" ? part.name : "Agent",
...typeof part.name === "string" ? { name: part.name } : {},
...normalizePartSource(part.source) ? { source: normalizePartSource(part.source) } : {}
}
];
case "compaction":
return [
{
id: part.id,
type: "compaction",
title: "Compaction",
status: "completed",
...part.auto === true || part.auto === false ? { auto: part.auto } : {},
...part.overflow === true || part.overflow === false ? { overflow: part.overflow } : {},
...typeof part.tail_start_id === "string" ? { tailStartId: part.tail_start_id } : {}
}
];
case "file":
return [
{
id: part.id,
type: "file",
title: typeof part.filename === "string" ? part.filename : "File",
...typeof part.filename === "string" ? { filename: part.filename } : {},
...typeof part.mime === "string" ? { mime: part.mime } : {},
...typeof part.url === "string" ? { url: part.url } : {},
...normalizePartSource(part.source) ? { source: normalizePartSource(part.source) } : {}
}
];
case "patch":
return [
{
id: part.id,
type: "patch",
title: "Patch",
status: "completed",
...typeof part.hash === "string" ? { hash: part.hash } : {},
...Array.isArray(part.files) ? { files: part.files.filter((file) => typeof file === "string") } : {}
}
];
case "reasoning":
return [
{
id: part.id,
type: "reasoning",
title: "Reasoning",
status: normalizeTimedPartStatus(part.time),
...typeof part.text === "string" ? { text: part.text } : {},
...isRecord2(part.metadata) ? { metadata: part.metadata } : {},
...normalizeAgent0PartTime(part.time) ? { time: normalizeAgent0PartTime(part.time) } : {}
}
];
case "retry":
return [
{
id: part.id,
type: "retry",
title: "Retry",
status: "error",
...typeof part.attempt === "number" && Number.isFinite(part.attempt) ? { attempt: part.attempt } : {},
...normalizeAgent0PartTime(part.time) ? { time: normalizeAgent0PartTime(part.time) } : {},
...isRecord2(part.error) ? { error: normalizeAgent0Error(part.error) } : {}
}
];
case "snapshot":
return [
{
id: part.id,
type: "snapshot",
title: "Snapshot",
status: "completed",
...typeof part.snapshot === "string" ? { text: part.snapshot } : {}
}
];
case "step-start":
return [
{
id: part.id,
type: "step-start",
title: "Step started",
status: "running",
...typeof part.snapshot === "string" ? { text: part.snapshot } : {}
}
];
case "step-finish":
return [
{
id: part.id,
type: "step-finish",
title: "Step finished",
status: "completed",
...typeof part.reason === "string" ? { reason: part.reason } : {},
...typeof part.snapshot === "string" ? { hash: part.snapshot } : {},
...normalizeAgent0MessageUsage(part) ? { usage: normalizeAgent0MessageUsage(part) } : {}
}
];
case "subtask":
return [
{
id: part.id,
type: "subtask",
title: typeof part.description === "string" ? part.description : "Subtask",
...typeof part.description === "string" ? { description: part.description } : {},
...typeof part.prompt === "string" ? { prompt: part.prompt } : {},
...typeof part.agent === "string" ? { agent: part.agent } : {},
...typeof part.command === "string" ? { command: part.command } : {},
...isRecord2(part.model) ? { model: normalizeAgent0MessageModel(part.model) } : {}
}
];
case "tool":
return normalizeAgent0ToolPart(part);
default:
return [];
}
}
function normalizeAgent0ToolPart(part) {
if (!isRecord2(part.state))
return [];
const status = normalizeToolStatus(part.state.status);
const state = {
...status ? { status } : { status: "pending" },
...isRecord2(part.state.input) ? { input: part.state.input } : {},
...typeof part.state.raw === "string" ? { raw: part.state.raw } : {},
...typeof part.state.title === "string" ? { title: part.state.title } : {},
...isRecord2(part.state.metadata) ? { metadata: part.state.metadata } : {},
..."output" in part.state ? { output: part.state.output } : {},
...Array.isArray(part.state.attachments) ? { attachments: normalizeAgent0MessageAttachments(part.state.attachments) } : {},
...typeof part.state.error === "string" ? { error: part.state.error } : {},
...normalizeAgent0PartTime(part.state.time) ? { time: normalizeAgent0PartTime(part.state.time) } : {}
};
return [
{
id: part.id,
type: "tool",
title: typeof part.state.title === "string" ? part.state.title : typeof part.tool === "string" ? part.tool : "Tool",
...typeof part.tool === "string" ? { toolId: part.tool } : {},
...typeof part.callID === "string" ? { callId: part.callID } : {},
...status ? { status } : {},
...isRecord2(part.state.input) ? { input: part.state.input } : {},
..."output" in part.state ? { output: part.state.output } : {},
...Array.isArray(part.state.attachments) ? { attachments: normalizeAgent0MessageAttachments(part.state.attachments) } : {},
...typeof part.state.error === "string" ? { error: { message: part.state.error } } : {},
state,
...isRecord2(part.metadata) ? { metadata: part.metadata } : {}
}
];
}
function normalizeAgent0MessageAttachments(value) {
return value.flatMap((attachment) => {
if (!isRecord2(attachment) || typeof attachment.mime !== "string" || typeof attachment.url !== "string")
return [];
return [
{
mime: attachment.mime,
url: attachment.url,
...typeof attachment.filename === "string" ? { filename: attachment.filename } : {}
}
];
});
}
function normalizeToolStatus(value) {
if (value === "pending" || value === "running" || value === "completed" || value === "error")
return value;
return;
}
function normalizeAgent0PartTime(value) {
if (!isRecord2(value))
return;
const time = {
...typeof value.created === "number" && Number.isFinite(value.created) ? { createdAt: normalizeTimestamp(value.created) } : {},
...typeof value.start === "number" && Number.isFinite(value.start) ? { startedAt: normalizeTimestamp(value.start) } : {},
...typeof value.end === "number" && Number.isFinite(value.end) ? { endedAt: normalizeTimestamp(value.end) } : {}
};
return Object.keys(time).length > 0 ? time : undefined;
}
function normalizeTimedPartStatus(value) {
if (!isRecord2(value))
return;
return typeof value.end === "number" ? "completed" : "running";
}
function normalizePartSource(value) {
if (!isRecord2(value) || value.type !== "file" && value.type !== "resource" && value.type !== "symbol")
return;
const type = value.type;
return {
type,
...typeof value.path === "string" ? { path: value.path } : {},
...typeof value.uri === "string" ? { uri: value.uri } : {},
...typeof value.name === "string" ? { name: value.name } : {},
...isRecord2(value.text) && typeof value.text.value === "string" && typeof value.text.start === "number" && typeof value.text.end === "number" ? { text: { value: value.text.value, start: value.text.start, end: value.text.end } } : {}
};
}
function normalizeErrorMessage(value) {
return typeof value.message === "string" && value.message.trim().length > 0 ? value.message : "Agent(0) message failed.";
}
var MAX_ERROR_DATA_STRING = 2000;
function truncateErrorData(data) {
const out = {};
for (const [key, value] of Object.entries(data)) {
out[key] = typeof value === "string" && value.length > MAX_ERROR_DATA_STRING ? value.slice(0, MAX_ERROR_DATA_STRING) : value;
}
return out;
}
function normalizeAgent0Error(value) {
const error = { message: normalizeErrorMessage(value) };
if (typeof value.name === "string")
error.name = value.name;
if (typeof value.code === "string")
error.code = value.code;
if (typeof value.status === "number")
error.status = value.status;
if (isRecord2(value.data))
error.data = truncateErrorData(value.data);
return error;
}
function normalizeAgent0MessageUsage(value) {
const usage = {};
if (typeof value.cost === "number" && Number.isFinite(value.cost))
usage.estimatedCost = value.cost;
if (isRecord2(value.tokens)) {
if (typeof value.tokens.total === "number" && Number.isFinite(value.tokens.total))
usage.totalTokens = value.tokens.total;
if (typeof value.tokens.input === "number" && Number.isFinite(value.tokens.input))
usage.inputTokens = value.tokens.input;
if (typeof value.tokens.output === "number" && Number.isFinite(value.tokens.output))
usage.outputTokens = value.tokens.output;
if (typeof value.tokens.reasoning === "number" && Number.isFinite(value.tokens.reasoning)) {
usage.reasoningTokens = value.tokens.reasoning;
}
if (isRecord2(value.tokens.cache)) {
if (typeof value.tokens.cache.read === "number" && Number.isFinite(value.tokens.cache.read)) {
usage.cacheReadTokens = value.tokens.cache.read;
}
if (typeof value.tokens.cache.write === "number" && Number.isFinite(value.tokens.cache.write)) {
usage.cacheWriteTokens = value.tokens.cache.write;
}
}
}
return Object.keys(usage).length > 0 ? usage : undefined;
}
function normalizeTimestamp(value) {
if (typeof value !== "number" || !Number.isFinite(value)) {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid session timestamp");
}
return new Date(value).toISOString();
}
function toOpenCodePromptInput(input) {
return {
parts: input.parts.map(toOpenCodePromptPart),
...input.mode === undefined ? {} : { agent: input.mode },
...input.generateReply === false ? { noReply: true } : {},
...input.model === undefined ? {} : {
model: {
providerID: input.model.providerId,
modelID: input.model.modelId
},
...input.model.variant === undefined ? {} : { variant: input.model.variant }
}
};
}
function toOpenCodePromptPart(part) {
if (part.type !== "file")
return part;
if (part.mime === "text/plain")
return part;
if (!isTextReadablePromptFile(part))
return part;
return {
...part,
mime: "text/plain",
url: rewriteDataUrlMime(part.url, "text/plain")
};
}
function isTextReadablePromptFile(part) {
if (part.mime.startsWith("text/"))
return true;
const normalizedMime = part.mime.toLowerCase().split(";")[0]?.trim() ?? "";
if ([
"application/json",
"application/ld+json",
"application/javascript",
"application/typescript",
"application/xml",
"application/yaml",
"application/x-yaml",
"application/toml",
"application/x-ndjson",
"image/svg+xml"
].includes(normalizedMime)) {
return true;
}
const filename = part.filename?.toLowerCase();
if (!filename)
return false;
return [
".c",
".conf",
".cpp",
".css",
".csv",
".env",
".go",
".graphql",
".h",
".html",
".java",
".js",
".json",
".jsx",
".kt",
".log",
".md",
".mdx",
".py",
".rs",
".scss",
".sh",
".sql",
".toml",
".ts",
".tsx",
".txt",
".xml",
".yaml",
".yml"
].some((extension) => filename.endsWith(extension));
}
function rewriteDataUrlMime(url, mime) {
if (!url.startsWith("data:"))
return url;
const comma = url.indexOf(",");
if (comma === -1)
return url;
const metadata = url.slice("data:".length, comma);
const parameters = metadata.split(";").slice(1).filter((parameter) => parameter.length > 0);
return `data:${mime}${parameters.map((parameter) => `;${parameter}`).join("")}${url.slice(comma)}`;
}
function toOpenCodeCreateSessionInput(input) {
return {
...input.title === undefined ? {} : { title: input.title },
...input.mode === undefined ? {} : { agent: input.mode },
...input.model === undefined ? {} : {
model: {
providerID: input.model.providerId,
id: input.model.modelId,
...input.model.variant === undefined ? {} : { variant: input.model.variant }
}
}
};
}
function normalizeAgent0RuntimeStatus(value, projectPath, renderedOpenCodeConfigHash) {
if (!isRecord2(value) || typeof value.directory !== "string" || typeof value.worktree !== "string") {
throw new Agent0RuntimeClientError("ENGINE_INVALID_RESPONSE", "Agent(0) private runtime returned an invalid path response");
}
return {
state: "running",
projectPath,
worktreePath: value.worktree,
...renderedOpenCodeConfigHash === undefined ? {} : { renderedOpenCodeConfigHash }
};
}
function isRecord2(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
init_src();
class Agent0RuntimeManagerError extends AdkError {
constructor(code, message, options = {}) {
super({
code,
message,
expected: code === "RUNTIME_NOT_RUNNING",
cause: options.cause
});
}
}
class Agent0RuntimeManager {
options;
state = "stopped";
client;
operation = Promise.resolve();
engineGeneration = 0;
configVersion;
warnings = [];
lastError;
constructor(options) {
this.options = {
...options,
configStore: options.configStore ?? new Agent0ConfigStore,
resolveProjectDirs: options.resolveProjectDirs ?? ensureAgent0ProjectDirs,
startRuntimeClient: options.startRuntimeClient ?? startAgent0RuntimeClient
};
}
async start() {
return this.enqueue(async () => {
if (this.client)
return this;
await this.startUnlocked("starting");
return this;
});
}
async restart() {
return this.enqueue(async () => {
await this.stopUnlocked("restarting");
await this.startUnlocked("restarting");
return this;
});
}
async invalidate() {
await this.enqueue(async () => {
if (this.state === "stopped")
return;
await this.stopUnlocked("restarting");
await this.startUnlocked("restarting");
});
}
async stop() {
await this.enqueue(async () => {
await this.stopUnlocked("stopping");
});
}
async getStatus() {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.getStatus();
}
async listSessions() {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.listSessions();
}
async createSession(input) {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.createSession(input);
}
async listMessages(sessionId) {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.listMessages(sessionId);
}
async sendMessage(sessionId, input) {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.sendMessage(sessionId, input);
}
async abortSession(sessionId) {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.abortSession(sessionId);
}
async listQuestions(sessionId) {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.listQuestions(sessionId);
}
async replyQuestion(sessionId, questionId, input) {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.replyQuestion(sessionId, questionId, input);
}
async rejectQuestion(sessionId, questionId) {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.rejectQuestion(sessionId, questionId);
}
async listCommands() {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.listCommands();
}
async runCommand(sessionId, input) {
const client = this.client;
if (!client) {
throw this.toNotRunningError();
}
return client.runCommand(sessionId, input);
}
streamEvents(options) {
const client = this.client;
if (!client?.streamEvents) {
throw this.toNotRunningError();
}
return client.streamEvents(options);
}
getSnapshot() {
return {
state: this.state,
engineGeneration: this.engineGeneration,
configVersion: this.configVersion,
warnings: this.cloneWarnings(),
...this.lastError ? { error: stringifyError(this.lastError) } : {}
};
}
async startUnlocked(state) {
this.state = state;
this.lastError = undefined;
try {
const [paths2, agent0Config, cognitiveModelResult] = await Promise.all([
this.options.resolveProjectDirs(this.options.agentPath),
this.options.configStore.read(),
this.resolveCognitiveModels()
]);
const client = await this.options.startRuntimeClient({
paths: paths2,
agentPath: this.options.agentPath,
adkDevConsolePort: this.options.adkDevConsolePort,
agent0Config,
cognitiveModels: cognitiveModelResult.models.length > 0 ? cognitiveModelResult.models : undefined,
startupTimeoutMs: this.options.startupTimeoutMs,
onLog: this.options.onLog
});
this.client = client;
this.engineGeneration += 1;
this.configVersion = agent0Config.updatedAt;
this.warnings = cognitiveModelResult.warnings;
this.state = "running";
} catch (error) {
this.client = undefined;
this.lastError = error;
this.state = "unavailable";
throw new Agent0RuntimeManagerError("RUNTIME_START_FAILED", `Agent(0) runtime failed to start: ${stringifyError(error)}`, { cause: error });
}
}
async stopUnlocked(state) {
const client = this.client;
this.client = undefined;
this.state = state;
try {
await client?.stop();
} finally {
this.state = "stopped";
}
}
async resolveCognitiveModels() {
const source2 = this.options.cognitiveSource;
if (!source2)
return { models: [], warnings: [] };
const result = await source2.listModelsWithStatus();
for (const warning of result.warnings) {
this.options.onLog?.(`${warning.source}: ${warning.message}`);
}
return {
models: result.models,
warnings: result.warnings
};
}
enqueue(operation) {
const next = this.operation.then(operation, operation);
this.operation = next.then(() => {
return;
}, () => {
return;
});
return next;
}
toNotRunningError() {
if (this.state === "unavailable" && this.lastError) {
return new Agent0RuntimeManagerError("RUNTIME_NOT_RUNNING", "Agent(0) runtime is unavailable", {
cause: this.lastError
});
}
return new Agent0RuntimeManagerError("RUNTIME_NOT_RUNNING", "Agent(0) runtime is not running");
}
cloneWarnings() {
return this.warnings.map((warning) => ({ ...warning }));
}
}
function stringifyError(error) {
return error instanceof Error ? error.message : String(error);
}
// src/server/handlers/agent0-runtime-invalidation.ts
async function invalidateAgent0RuntimeAfterConfigChange() {
const runtime = getAgent0RuntimeClient();
try {
if (runtime?.invalidate) {
await runtime.invalidate();
return [];
}
await runtime?.restart?.();
return [];
} catch {
return [
{
code: "RUNTIME_RESTART_FAILED",
source: "agent0-runtime",
message: "Agent(0) settings were saved, but the private runtime could not be refreshed."
}
];
}
}
// src/server/handlers/agent0-catalog.ts
var cachedRegistry;
async function handleAgent0Providers(registry = createAgent0ProviderRegistry()) {
return successResponse(await registry.listProvidersWithStatus());
}
async function handleAgent0Models(registry = createAgent0ProviderRegistry()) {
return successResponse(await registry.listModelsWithStatus());
}
async function handlePutAgent0ProviderAuth(req, providerId, registry = createAgent0ProviderRegistry()) {
const unsupported = validateProviderAuthRoute(providerId);
if (unsupported)
return unsupported;
const body = await parseProviderAuthBody(req);
if (body instanceof Response)
return body;
try {
const connection = await registry.putProviderAuth(providerId, body);
const warnings = await invalidateAgent0RuntimeAfterConfigChange();
return successResponse({ connection, warnings });
} catch (error) {
return mapProviderMutationError(error);
}
}
async function handleDeleteAgent0ProviderAuth(providerId, registry = createAgent0ProviderRegistry()) {
const unsupported = validateProviderAuthRoute(providerId);
if (unsupported)
return unsupported;
try {
const connection = await registry.removeProviderAuth(providerId) ?? null;
const warnings = await invalidateAgent0RuntimeAfterConfigChange();
return successResponse({ connection, warnings });
} catch (error) {
return mapProviderMutationError(error);
}
}
function createAgent0ProviderRegistry() {
const cognitiveAuth = resolveAgent0CognitiveAuth();
const key = JSON.stringify(cognitiveAuth ?? null);
if (cachedRegistry?.key === key)
return cachedRegistry.registry;
const registry = new Agent0ProviderRegistry({
catalogSourceOptions: {
cognitive: { auth: cognitiveAuth }
}
});
cachedRegistry = { key, registry };
return registry;
}
function resolveAgent0CognitiveAuth() {
const config = getServerConfig();
const devBotId = config.project?.agentInfo?.devId ?? config.credentials.devBotId;
if (!config.credentials.token || !devBotId)
return;
return {
token: config.credentials.token,
botId: devBotId,
apiUrl: config.credentials.apiUrl
};
}
async function parseProviderAuthBody(req) {
let body;
try {
body = await req.json();
} catch {
return errorResponse("Invalid JSON", "Request body must be valid JSON", 400);
}
if (!body || typeof body !== "object" || Array.isArray(body)) {
return errorResponse("Invalid body", "Request body must be an object", 400);
}
const candidate = body;
if (typeof candidate.apiKey !== "string") {
return errorResponse("Invalid body", "apiKey must be a string", 400);
}
if (candidate.baseURL !== undefined && typeof candidate.baseURL !== "string") {
return errorResponse("Invalid body", "baseURL must be a string when provided", 400);
}
if (candidate.enabled !== undefined && typeof candidate.enabled !== "boolean") {
return errorResponse("Invalid body", "enabled must be a boolean when provided", 400);
}
const baseURL = candidate.baseURL;
const enabled = candidate.enabled;
return {
apiKey: candidate.apiKey,
...typeof baseURL === "string" ? { baseURL } : {},
...typeof enabled === "boolean" ? { enabled } : {}
};
}
function validateProviderAuthRoute(providerId) {
const entry = getAgent0ProviderCatalogEntry(providerId);
if (!entry) {
return errorResponse("Provider not found", `Agent(0) provider not found: ${providerId}`, 404);
}
if (entry.auth.type !== "api_key") {
return errorResponse("Unsupported provider auth", `Agent(0) provider ${providerId} does not support API-key authentication`, 400);
}
return null;
}
function mapProviderMutationError(error) {
if (error instanceof Agent0ConfigError) {
return errorResponse("Config unavailable", "Saved Agent(0) settings are unavailable. Reset Agent(0) config before changing providers.", 409);
}
const message = error instanceof Error ? error.message : "Unable to update Agent(0) provider settings";
return errorResponse("Provider update failed", message, 400);
}
// src/server/handlers/agent0-config.ts
async function handleAgent0Config(store = new Agent0ConfigStore) {
const result = await readAgent0ConfigWithStatus(store);
return successResponse(result);
}
async function handleResetAgent0Config(store = new Agent0ConfigStore) {
const config = redactAgent0Config(await store.reset());
const warnings = await invalidateAgent0RuntimeAfterConfigChange();
return successResponse({ config, warnings });
}
async function readAgent0ConfigWithStatus(store) {
try {
return {
config: redactAgent0Config(await store.read()),
warnings: []
};
} catch (error) {
if (!(error instanceof Agent0ConfigError))
throw error;
return {
config: redactAgent0Config(createDefaultAgent0Config()),
warnings: [
{
code: "CONFIG_UNAVAILABLE",
source: "agent0-config",
message: "Saved Agent(0) settings are unavailable."
}
]
};
}
}
// src/server/handlers/agent0-idempotency.ts
var AGENT0_MUTATION_CACHE_TTL_MS = 2 * 60000;
var mutationCache = new Map;
function getAgent0MutationCacheKey(req, operation, sessionId) {
const requestId = new URL(req.url).searchParams.get("requestId")?.trim();
if (!requestId || requestId.length > 128 || !/^[A-Za-z0-9:_-]+$/.test(requestId))
return;
return `${operation}:${sessionId}:${requestId}`;
}
function runAgent0MutationOnce(key, operation) {
if (!key)
return operation();
const existing = mutationCache.get(key);
if (existing)
return existing;
const promise = Promise.resolve().then(operation);
mutationCache.set(key, promise);
const scheduleCleanup = () => {
const timer = setTimeout(() => {
if (mutationCache.get(key) === promise) {
mutationCache.delete(key);
}
}, AGENT0_MUTATION_CACHE_TTL_MS);
timer.unref?.();
};
promise.then(scheduleCleanup, scheduleCleanup);
return promise;
}
// src/server/handlers/agent0-model-validation.ts
async function validateAgent0RequestedModel(model, registry = createAgent0ProviderRegistry()) {
let result;
try {
result = await registry.listModelsWithStatus();
} catch {
return errorResponse("CATALOG_SOURCE_UNAVAILABLE", "Agent(0) model catalog is unavailable.", 503);
}
const found = result.models.some((candidate) => candidate.providerId === model.providerId && candidate.modelId === model.modelId);
if (found)
return;
if (result.warnings.some((warning) => warning.code === "CONFIG_UNAVAILABLE")) {
return errorResponse("CONFIG_UNAVAILABLE", "Saved Agent(0) settings are unavailable. Reset Agent(0) config before choosing a model.", 409);
}
if (result.warnings.some((warning) => warning.code === "CATALOG_SOURCE_UNAVAILABLE")) {
return errorResponse("CATALOG_SOURCE_UNAVAILABLE", "Agent(0) model catalog is unavailable.", 503);
}
return errorResponse("MODEL_NOT_AVAILABLE", `Agent(0) model is not available: ${model.providerId}/${model.modelId}`, 404);
}
// src/server/handlers/agent0-runtime-errors.ts
var logger5 = createCliLogger({ tag: "agent0" });
function mapAgent0RuntimeError(error) {
const runtimeError = toAgent0RuntimeError(error);
if (!runtimeError) {
logger5.warn(`Unrecognized runtime error: ${error}`);
return errorResponse("ENGINE_UNAVAILABLE", "Agent(0) runtime is unavailable.", 503);
}
if (runtimeError.code === "ENGINE_UNAVAILABLE") {
return errorResponse("ENGINE_UNAVAILABLE", "Agent(0) runtime is unavailable.", 503);
}
if (runtimeError.code === "ENGINE_INVALID_RESPONSE") {
logger5.warn(`ENGINE_INVALID_RESPONSE: ${runtimeError.message}`);
return errorResponse("ENGINE_INVALID_RESPONSE", "Agent(0) runtime returned an invalid response.", 502);
}
if (runtimeError.code === "ENGINE_HTTP_ERROR") {
if (runtimeError.status === 404) {
return errorResponse("SESSION_NOT_FOUND", "Agent(0) session was not found.", 404);
}
if (runtimeError.status === 400 || runtimeError.status === 422) {
return errorResponse("ENGINE_REQUEST_INVALID", "Agent(0) runtime rejected the request.", 400);
}
if (runtimeError.status === 409) {
return errorResponse("ENGINE_REQUEST_CONFLICT", "Agent(0) runtime could not complete the request.", 409);
}
logger5.warn(`ENGINE_HTTP_ERROR: engine returned HTTP ${runtimeError.status} \u2014 ${runtimeError.message}`);
return errorResponse("ENGINE_REQUEST_FAILED", `Agent(0) runtime request failed (engine HTTP ${runtimeError.status}).`, 502);
}
logger5.warn(`Unknown error code=${runtimeError.code} status=${runtimeError.status}: ${runtimeError.message}`);
return errorResponse("ENGINE_UNAVAILABLE", "Agent(0) runtime is unavailable.", 503);
}
function toAgent0RuntimeError(error) {
if (!isRecord3(error))
return;
if (error.name !== "Agent0RuntimeClientError")
return;
return {
...typeof error.code === "string" ? { code: error.code } : {},
...typeof error.status === "number" ? { status: error.status } : {},
...typeof error.message === "string" ? { message: error.message } : {}
};
}
function isRecord3(value) {
return !!value && typeof value === "object" && !Array.isArray(value);
}
// src/server/handlers/agent0-commands.ts
async function handleAgent0Commands() {
const runtime = getAgent0RuntimeClient();
if (!runtime?.listCommands)
return runtimeUnavailableResponse();
try {
return successResponse(await runtime.listCommands());
} catch (error) {
return mapAgent0RuntimeError(error);
}
}
async function handleRunAgent0SessionCommand(req, sessionId, modelRegistry) {
const runtime = getAgent0RuntimeClient();
if (!runtime?.listCommands || !runtime?.runCommand)
return runtimeUnavailableResponse();
const input = await parseRunCommandInput(req);
if (input instanceof Response)
return input;
const commandError = await validateAgent0RequestedCommand(runtime, input.command);
if (commandError)
return commandError;
if (input.model) {
const modelError = await validateAgent0RequestedModel(input.model, modelRegistry);
if (modelError)
return modelError;
}
try {
const cacheKey = getAgent0MutationCacheKey(req, "command", sessionId);
const message = await runAgent0MutationOnce(cacheKey, () => runtime.runCommand(sessionId, input));
return successResponse({ message, warnings: [] });
} catch (error) {
return mapAgent0RuntimeError(error);
}
}
async function validateAgent0RequestedCommand(runtime, commandName) {
try {
const result = await runtime.listCommands?.();
if (!result?.commands.some((command) => command.name === commandName)) {
return errorResponse("COMMAND_NOT_FOUND", `Agent(0) command is not available: /${commandName}`, 404);
}
} catch (error) {
return mapAgent0RuntimeError(error);
}
return;
}
async function parseRunCommandInput(req) {
let body;
try {
body = await req.json();
} catch {
return errorResponse("Invalid JSON", "Request body must be valid JSON", 400);
}
if (!isRecord5(body)) {
return errorResponse("Invalid body", "Request body must be an object", 400);
}
const unknownField = firstUnknownKey(body, ["command", "arguments", "mode", "model"]);
if (unknownField) {
return errorResponse("Invalid body", `Unknown field: ${unknownField}`, 400);
}
if (typeof body.command !== "string" || !/^[a-zA-Z0-9_-]+$/.test(body.command)) {
return errorResponse("Invalid body", "command must be a command name", 400);
}
if (body.arguments !== undefined && typeof body.arguments !== "string") {
return errorResponse("Invalid body", "arguments must be a string when provided", 400);
}
if (body.mode !== undefined && !isAgent0SessionMode(body.mode)) {
return errorResponse("Invalid body", "mode must be default or guided when provided", 400);
}
const input = {
command: body.command,
...typeof body.arguments === "string" ? { arguments: body.arguments } : {},
...isAgent0SessionMode(body.mode) ? { mode: body.mode } : {}
};
if (body.model !== undefined) {
if (!isRecord5(body.model)) {
return errorResponse("Invalid body", "model must be an object when provided", 400);
}
const unknownModelField = firstUnknownKey(body.model, ["providerId", "modelId", "variant"]);
if (unknownModelField) {
return errorResponse("Invalid body", `Unknown model field: ${unknownModelField}`, 400);
}
if (typeof body.model.providerId !== "string") {
return errorResponse("Invalid body", "model.providerId must be a string", 400);
}
if (typeof body.model.modelId !== "string") {
return errorResponse("Invalid body", "model.modelId must be a string", 400);
}
if (body.model.variant !== undefined && typeof body.model.variant !== "string") {
return errorResponse("Invalid body", "model.variant must be a string when provided", 400);
}
input.model = {
providerId: body.model.providerId,
modelId: body.model.modelId,
...typeof body.model.variant === "string" ? { variant: body.model.variant } : {}
};
}
return input;
}
function runtimeUnavailableResponse() {
return errorResponse("ENGINE_UNAVAILABLE", "Agent(0) runtime is unavailable.", 503);
}
function firstUnknownKey(value, allowed) {
const allowedKeys = new Set(allowed);
return Object.keys(value).find((key) => !allowedKeys.has(key));
}
function isAgent0SessionMode(value) {
return value === "default" || value === "guided";
}
function isRecord5(value) {
return !!value && typeof value === "object" && !Array.isArray(value);
}
// src/server/handlers/agent0-messages.ts
var logger6 = createCliLogger({ tag: "agent0-sse" });
async function handleAgent0SessionMessages(sessionId) {
const runtime = getAgent0RuntimeClient();
if (!runtime?.listMessages)
return runtimeUnavailableResponse2();
try {
return successResponse(await runtime.listMessages(sessionId));
} catch (error) {
return mapAgent0RuntimeError(error);
}
}
async function handleSendAgent0SessionMessage(req, sessionId, modelRegistry) {
const runtime = getAgent0RuntimeClient();
if (!runtime?.sendMessage)
return runtimeUnavailableResponse2();
const input = await parseSendMessageInput(req);
if (input instanceof Response)
return input;
if (input.model) {
const modelError = await validateAgent0RequestedModel(input.model, modelRegistry);
if (modelError)
return modelError;
}
try {
const cacheKey = getAgent0MutationCacheKey(req, "message", sessionId);
const message = await runAgent0MutationOnce(cacheKey, () => runtime.sendMessage(sessionId, input));
return successResponse({ message, warnings: [] });
} catch (error) {
return mapAgent0RuntimeError(error);
}
}
async function handleAbortAgent0Session(sessionId) {
const runtime = getAgent0RuntimeClient();
if (!runtime?.abortSession)
return runtimeUnavailableResponse2();
try {
return successResponse(await runtime.abortSession(sessionId));
} catch (error) {
return mapAgent0RuntimeError(error);
}
}
function handleAgent0SessionEvents(req, sessionId) {
const runtime = getAgent0RuntimeClient();
if (req.method === "GET" && !runtime?.streamEvents) {
logger6.warn(`Runtime unavailable for session ${sessionId} (runtime=${runtime ? "present" : "null"}, streamEvents=${!!runtime?.streamEvents})`);
return runtimeUnavailableResponse2();
}
return createSSEStream(req, {
keepAlive: { event: "agent0.keepalive", data: {}, intervalMs: 30000 },
onConnect(client) {
if (!runtime?.streamEvents) {
logger6.warn(`Runtime lost between response and onConnect for session ${sessionId}`);
client.close();
return;
}
const controller = new AbortController;
streamAgent0SessionEventsToClient(runtime.streamEvents({ sessionId, signal: controller.signal }), client);
return () => controller.abort();
}
});
}
async function parseSendMessageInput(req) {
let body;
try {
body = await req.json();
} catch {
return errorResponse("Invalid JSON", "Request body must be valid JSON", 400);
}
if (!isRecord6(body)) {
return errorResponse("Invalid body", "Request body must be an object", 400);
}
const unknownField = firstUnknownKey2(body, ["parts", "mode", "model", "generateReply"]);
if (unknownField) {
return errorResponse("Invalid body", `Unknown field: ${unknownField}`, 400);
}
if (!Array.isArray(body.parts)) {
return errorResponse("Invalid body", "parts must be an array", 400);
}
if (body.mode !== undefined && !isAgent0SessionMode2(body.mode)) {
return errorResponse("Invalid body", "mode must be default or guided when provided", 400);
}
if (body.generateReply !== undefined && typeof body.generateReply !== "boolean") {
return errorResponse("Invalid body", "generateReply must be a boolean when provided", 400);
}
const parts = parsePromptParts(body.parts);
if (parts instanceof Response)
return parts;
const input = {
parts,
...isAgent0SessionMode2(body.mode) ? { mode: body.mode } : {},
...typeof body.generateReply === "boolean" ? { generateReply: body.generateReply } : {}
};
if (body.model !== undefined) {
if (!isRecord6(body.model)) {
return errorResponse("Invalid body", "model must be an object when provided", 400);
}
const unknownModelField = firstUnknownKey2(body.model, ["providerId", "modelId", "variant"]);
if (unknownModelField) {
return errorResponse("Invalid body", `Unknown model field: ${unknownModelField}`, 400);
}
if (typeof body.model.providerId !== "string") {
return errorResponse("Invalid body", "model.providerId must be a string", 400);
}
if (typeof body.model.modelId !== "string") {
return errorResponse("Invalid body", "model.modelId must be a string", 400);
}
if (body.model.variant !== undefined && typeof body.model.variant !== "string") {
return errorResponse("Invalid body", "model.variant must be a string when provided", 400);
}
input.model = {
providerId: body.model.providerId,
modelId: body.model.modelId,
...typeof body.model.variant === "string" ? { variant: body.model.variant } : {}
};
}
return input;
}
function parsePromptParts(parts) {
const parsed = [];
for (const [index, part] of parts.entries()) {
if (!isRecord6(part)) {
return errorResponse("Invalid body", `parts[${index}] must be an object`, 400);
}
if (part.type === "text") {
const unknownField = firstUnknownKey2(part, ["type", "text", "synthetic"]);
if (unknownField)
return errorResponse("Invalid body", `Unknown text part field: ${unknownField}`, 400);
if (typeof part.text !== "string" || part.text.length === 0) {
return errorResponse("Invalid body", `parts[${index}].text must be a non-empty string`, 400);
}
if (part.synthetic !== undefined && typeof part.synthetic !== "boolean") {
return errorResponse("Invalid body", `parts[${index}].synthetic must be a boolean when provided`, 400);
}
parsed.push({
type: "text",
text: part.text,
...part.synthetic === true ? { synthetic: true } : {}
});
continue;
}
if (part.type === "file") {
const unknownField = firstUnknownKey2(part, ["type", "mime", "url", "filename"]);
if (unknownField)
return errorResponse("Invalid body", `Unknown file part field: ${unknownField}`, 400);
if (typeof part.mime !== "string")
return errorResponse("Invalid body", `parts[${index}].mime must be a string`, 400);
if (typeof part.url !== "string")
return errorResponse("Invalid body", `parts[${index}].url must be a string`, 400);
if (part.filename !== undefined && typeof part.filename !== "string") {
return errorResponse("Invalid body", `parts[${index}].filename must be a string when provided`, 400);
}
parsed.push({
type: "file",
mime: part.mime,
url: part.url,
...typeof part.filename === "string" ? { filename: part.filename } : {}
});
continue;
}
return errorResponse("Invalid body", `parts[${index}].type must be text or file`, 400);
}
if (parsed.length === 0)
return errorResponse("Invalid body", "parts must contain at least one part", 400);
return parsed;
}
function runtimeUnavailableResponse2() {
return errorResponse("ENGINE_UNAVAILABLE", "Agent(0) runtime is unavailable.", 503);
}
async function streamAgent0SessionEventsToClient(events, client) {
try {
for await (const event of events) {
if (!isRecord6(event) || typeof event.type !== "string")
continue;
if (!client.send(event.type, event, typeof event.id === "string" ? { id: event.id } : {}))
break;
}
} catch (error) {
const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
logger6.warn(`Stream error: ${detail}`);
if (!client.closed) {
client.send("agent0.error", toAgent0StreamError(error));
}
} finally {
client.close();
}
}
function toAgent0StreamError(error) {
if (isRecord6(error) && error.name === "Agent0RuntimeClientError") {
if (error.code === "ENGINE_INVALID_RESPONSE") {
return {
type: "engine.error",
error: "ENGINE_INVALID_RESPONSE",
message: "Agent(0) runtime returned an invalid response."
};
}
if (error.code === "ENGINE_HTTP_ERROR") {
return { type: "engine.error", error: "ENGINE_REQUEST_FAILED", message: "Agent(0) runtime request failed." };
}
}
return { type: "engine.error", error: "ENGINE_UNAVAILABLE", message: "Agent(0) runtime is unavailable." };
}
function firstUnknownKey2(value, allowed) {
const allowedKeys = new Set(allowed);
return Object.keys(value).find((key) => !allowedKeys.has(key));
}
function isAgent0SessionMode2(value) {
return value === "default" || value === "guided";
}
function isRecord6(value) {
return !!value && typeof value === "object" && !Array.isArray(value);
}
// src/server/handlers/agent0-questions.ts
async function handleAgent0SessionQuestions(sessionId) {
const runtime = getAgent0RuntimeClient();
if (!runtime?.listQuestions)
return runtimeUnavailableResponse3();
try {
return successResponse(await runtime.listQuestions(sessionId));
} catch (error) {
return mapAgent0QuestionRuntimeError(error);
}
}
async function handleReplyAgent0SessionQuestion(req, sessionId, questionId) {
const runtime = getAgent0RuntimeClient();
if (!runtime?.replyQuestion)
return runtimeUnavailableResponse3();
const input = await parseReplyQuestionInput(req);
if (input instanceof Response)
return input;
try {
return successResponse(await runtime.replyQuestion(sessionId, questionId, input));
} catch (error) {
return mapAgent0QuestionRuntimeError(error);
}
}
async function handleRejectAgent0SessionQuestion(sessionId, questionId) {
const runtime = getAgent0RuntimeClient();
if (!runtime?.rejectQuestion)
return runtimeUnavailableResponse3();
try {
return successResponse(await runtime.rejectQuestion(sessionId, questionId));
} catch (error) {
return mapAgent0QuestionRuntimeError(error);
}
}
async function parseReplyQuestionInput(req) {
let body;
try {
body = await req.json();
} catch {
return errorResponse("Invalid JSON", "Request body must be valid JSON", 400);
}
if (!isRecord7(body)) {
return errorResponse("Invalid body", "Request body must be an object", 400);
}
const unknownField = firstUnknownKey3(body, ["answers"]);
if (unknownField) {
return errorResponse("Invalid body", `Unknown field: ${unknownField}`, 400);
}
if (!Array.isArray(body.answers)) {
return errorResponse("Invalid body", "answers must be an array", 400);
}
const answers = [];
for (const [answerIndex, answer] of body.answers.entries()) {
if (!Array.isArray(answer)) {
return errorResponse("Invalid body", `answers[${answerIndex}] must be an array`, 400);
}
const labels = [];
for (const [labelIndex, label] of answer.entries()) {
if (typeof label !== "string") {
return errorResponse("Invalid body", `answers[${answerIndex}][${labelIndex}] must be a string`, 400);
}
labels.push(label);
}
answers.push(labels);
}
return { answers };
}
function mapAgent0QuestionRuntimeError(error) {
if (isRecord7(error) && error.name === "Agent0RuntimeClientError") {
if (error.code === "ENGINE_HTTP_ERROR" && error.status === 404) {
return errorResponse("QUESTION_NOT_FOUND", "Agent(0) question was not found.", 404);
}
}
return mapAgent0RuntimeError(error);
}
function runtimeUnavailableResponse3() {
return errorResponse("ENGINE_UNAVAILABLE", "Agent(0) runtime is unavailable.", 503);
}
function firstUnknownKey3(value, allowed) {
const allowedKeys = new Set(allowed);
return Object.keys(value).find((key) => !allowedKeys.has(key));
}
function isRecord7(value) {
return !!value && typeof value === "object" && !Array.isArray(value);
}
// src/server/handlers/agent0-sessions.ts
async function handleAgent0Sessions() {
const runtime = getAgent0RuntimeClient();
if (!runtime?.listSessions)
return runtimeUnavailableResponse4();
try {
return successResponse(await runtime.listSessions());
} catch (error) {
return mapAgent0RuntimeError(error);
}
}
async function handleCreateAgent0Session(req, modelRegistry) {
const runtime = getAgent0RuntimeClient();
if (!runtime?.createSession)
return runtimeUnavailableResponse4();
const input = await parseCreateSessionInput(req);
if (input instanceof Response)
return input;
if (input.model) {
const modelError = await validateAgent0RequestedModel(input.model, modelRegistry);
if (modelError)
return modelError;
}
try {
const session2 = await runtime.createSession(input);
return successResponse({ session: session2, warnings: [] });
} catch (error) {
return mapAgent0RuntimeError(error);
}
}
async function parseCreateSessionInput(req) {
let text;
try {
text = await req.text();
} catch {
return errorResponse("Invalid body", "Request body could not be read", 400);
}
if (text.trim().length === 0)
return {};
let body;
try {
body = JSON.parse(text);
} catch {
return errorResponse("Invalid JSON", "Request body must be valid JSON", 400);
}
if (!isRecord8(body)) {
return errorResponse("Invalid body", "Request body must be an object", 400);
}
const unknownField = firstUnknownKey4(body, ["title", "mode", "model"]);
if (unknownField) {
return errorResponse("Invalid body", `Unknown field: ${unknownField}`, 400);
}
if (body.title !== undefined && typeof body.title !== "string") {
return errorResponse("Invalid body", "title must be a string when provided", 400);
}
if (body.mode !== undefined && !isAgent0SessionMode3(body.mode)) {
return errorResponse("Invalid body", "mode must be default or guided when provided", 400);
}
const input = {};
if (typeof body.title === "string") {
input.title = body.title;
}
if (isAgent0SessionMode3(body.mode)) {
input.mode = body.mode;
}
if (body.model !== undefined) {
if (!isRecord8(body.model)) {
return errorResponse("Invalid body", "model must be an object when provided", 400);
}
const unknownModelField = firstUnknownKey4(body.model, ["providerId", "modelId", "variant"]);
if (unknownModelField) {
return errorResponse("Invalid body", `Unknown model field: ${unknownModelField}`, 400);
}
if (typeof body.model.providerId !== "string") {
return errorResponse("Invalid body", "model.providerId must be a string", 400);
}
if (typeof body.model.modelId !== "string") {
return errorResponse("Invalid body", "model.modelId must be a string", 400);
}
if (body.model.variant !== undefined && typeof body.model.variant !== "string") {
return errorResponse("Invalid body", "model.variant must be a string when provided", 400);
}
input.model = {
providerId: body.model.providerId,
modelId: body.model.modelId,
...typeof body.model.variant === "string" ? { variant: body.model.variant } : {}
};
}
return input;
}
function runtimeUnavailableResponse4() {
return errorResponse("ENGINE_UNAVAILABLE", "Agent(0) runtime is unavailable.", 503);
}
function firstUnknownKey4(value, allowed) {
const allowedKeys = new Set(allowed);
return Object.keys(value).find((key) => !allowedKeys.has(key));
}
function isAgent0SessionMode3(value) {
return value === "default" || value === "guided";
}
function isRecord8(value) {
return !!value && typeof value === "object" && !Array.isArray(value);
}
// src/server/routes/api.ts
async function handleApiRequest(pathname, req) {
if (req.method === "OPTIONS") {
return handleCorsPreflightResponse(req);
}
const response = await routeApiRequest(pathname, req, new URL(req.url));
const corsHeaders = getCorsHeaders(req);
for (const [key, value] of Object.entries(corsHeaders)) {
response.headers.set(key, value);
}
return response;
}
function buildLocalProdSelection() {
const config = getServerConfig();
const { token, apiUrl, workspaceId } = config.credentials;
const prodBotId = config.project?.agentInfo?.botId ?? config.credentials.prodBotId;
if (!token || !apiUrl || !workspaceId || !prodBotId)
return null;
return {
botId: prodBotId,
botName: "local-prod",
workspaceId,
token,
apiUrl,
agentPath: config.agentPath,
registeredAt: Date.now()
};
}
var VORTEX_TRACE_ENDPOINTS = new Set([
"/api/traces/query",
"/api/traces/trace",
"/api/traces/recent",
"/api/traces/today"
]);
async function routeApiRequest(pathname, req, url) {
try {
if (pathname.startsWith("/api/traces") && pathname !== "/api/traces/stream") {
const isProd = getActiveEnvironment() === "prod";
if (isProd && VORTEX_TRACE_ENDPOINTS.has(pathname)) {
if (!isProductionObservabilityEnabled()) {
return productionObservabilityDisabledResponse();
}
const prodSelection = buildLocalProdSelection();
if (prodSelection) {
return handleProdBotApiRequest(url, req, prodSelection);
}
}
}
if (pathname.startsWith("/api/evals")) {
if (getActiveEnvironment() === "prod" && !isProductionObservabilityEnabled()) {
return productionObservabilityDisabledResponse();
}
return routeEvalRequest(pathname, req, resolveEvalStore());
}
if (pathname.startsWith("/api/cognitive/v1/")) {
const subpath = pathname.replace("/api/cognitive/v1", "");
return handleCognitiveProxy(req, subpath);
}
if (pathname.startsWith("/api/tables/") && pathname.endsWith("/recreate")) {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
const tableName = pathname.replace("/api/tables/", "").replace("/recreate", "");
return handleTableRecreate(tableName);
}
const agent0ProviderAuthProviderId = matchAgent0ProviderAuthPath(pathname);
if (agent0ProviderAuthProviderId) {
if (req.method === "PUT")
return handlePutAgent0ProviderAuth(req, agent0ProviderAuthProviderId);
if (req.method === "DELETE")
return handleDeleteAgent0ProviderAuth(agent0ProviderAuthProviderId);
return errorResponse("Method not allowed", "Only PUT and DELETE are supported", 405);
}
const agent0SessionEventsSessionId = matchAgent0SessionEventsPath(pathname);
if (agent0SessionEventsSessionId) {
if (req.method === "GET")
return handleAgent0SessionEvents(req, agent0SessionEventsSessionId);
return errorResponse("Method not allowed", "Only GET requests are allowed", 405);
}
const agent0QuestionsPath = matchAgent0QuestionsPath(pathname);
if (agent0QuestionsPath) {
if (!agent0QuestionsPath.questionId) {
if (req.method === "GET")
return handleAgent0SessionQuestions(agent0QuestionsPath.sessionId);
return errorResponse("Method not allowed", "Only GET requests are allowed", 405);
}
if (agent0QuestionsPath.action === "reply") {
if (req.method === "POST") {
return handleReplyAgent0SessionQuestion(req, agent0QuestionsPath.sessionId, agent0QuestionsPath.questionId);
}
return errorResponse("Method not allowed", "Only POST requests are allowed", 405);
}
if (agent0QuestionsPath.action === "reject") {
if (req.method === "POST") {
return handleRejectAgent0SessionQuestion(agent0QuestionsPath.sessionId, agent0QuestionsPath.questionId);
}
return errorResponse("Method not allowed", "Only POST requests are allowed", 405);
}
}
const agent0SessionMessagesSessionId = matchAgent0SessionMessagesPath(pathname);
if (agent0SessionMessagesSessionId) {
if (req.method === "GET")
return handleAgent0SessionMessages(agent0SessionMessagesSessionId);
if (req.method === "POST")
return handleSendAgent0SessionMessage(req, agent0SessionMessagesSessionId);
return errorResponse("Method not allowed", "Only GET and POST are supported", 405);
}
const agent0SessionCommandsSessionId = matchAgent0SessionCommandsPath(pathname);
if (agent0SessionCommandsSessionId) {
if (req.method === "POST")
return handleRunAgent0SessionCommand(req, agent0SessionCommandsSessionId);
return errorResponse("Method not allowed", "Only POST requests are allowed", 405);
}
const agent0SessionAbortSessionId = matchAgent0SessionAbortPath(pathname);
if (agent0SessionAbortSessionId) {
if (req.method === "POST")
return handleAbortAgent0Session(agent0SessionAbortSessionId);
return errorResponse("Method not allowed", "Only POST requests are allowed", 405);
}
switch (pathname) {
case "/api/health":
return handleHealth();
case "/api/debug/memory":
return handleMemoryDebug();
case "/api/debug/gc":
return handleMemoryGC();
case "/api/debug/snapshot":
return handleMemorySnapshot();
case "/api/debug/snapshot-v8":
return handleMemorySnapshotV8();
case "/api/config":
return handleConfigRequest();
case "/api/feature-flags":
return handleFeatureFlags();
case "/api/config/variables":
if (req.method === "PUT") {
return handlePutConfigVariables(req);
}
if (req.method === "PATCH") {
return handlePatchConfigSchema(req);
}
return handleGetConfigVariables(req);
case "/api/config/variables/diff":
return handleGetConfigSchemaDiff();
case "/api/secrets":
if (req.method === "PUT") {
return handlePutSecrets(req);
}
if (req.method === "DELETE") {
return handleDeleteSecret(req);
}
if (req.method === "PATCH") {
return handlePatchSecretsSchema(req);
}
return handleGetSecrets(req);
case "/api/config/models":
if (req.method === "PATCH") {
return handlePatchConfigModels(req);
}
if (req.method === "GET") {
return handleGetConfigModels();
}
return errorResponse("Method not allowed", "Only GET and PATCH are supported", 405);
case "/api/environment":
if (req.method === "GET")
return handleGetEnvironment();
if (req.method === "POST")
return handleSetEnvironment(req);
return errorResponse("Method not allowed", "Only GET and POST are supported", 405);
case "/api/agent0/events":
return handleAgent0ScreenshotEventsSSE(req);
case "/api/agent0/screenshot-result": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleAgent0ScreenshotResult(req);
}
case "/api/agent0/bridge-status":
return new Response(JSON.stringify({ subscribers: getScreenshotSubscriberCount() }), {
status: 200,
headers: { "Content-Type": "application/json" }
});
case "/api/agent0/status": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleAgent0Status();
}
case "/api/agent0/config": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleAgent0Config();
}
case "/api/agent0/config/reset": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleResetAgent0Config();
}
case "/api/agent0/providers": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleAgent0Providers();
}
case "/api/agent0/models": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleAgent0Models();
}
case "/api/agent0/commands": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleAgent0Commands();
}
case "/api/agent0/sessions": {
if (req.method === "GET")
return handleAgent0Sessions();
if (req.method === "POST")
return handleCreateAgent0Session(req);
return errorResponse("Method not allowed", "Only GET and POST are supported", 405);
}
case "/api/worker-stats":
return handleWorkerStats();
case "/api/integrations/add": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleIntegrationAdd(req);
}
case "/api/components/registry/add-to-bot": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleAddRegistryComponentToBot(req);
}
case "/api/components/installed": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleListInstalledComponents();
}
case "/api/components/bundle": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleComponentBundle(req);
}
case "/api/components/bundle.css": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleComponentBundleCss(req);
}
case "/api/components/events":
return handleComponentEventsSSE(req);
case "/api/inspector":
return handleInspector();
case "/api/traces/query":
return handleTracesQuery(req);
case "/api/traces/trace":
return handleTraceById(req);
case "/api/traces/payload":
return handleTracePayload(req);
case "/api/traces/recent":
return handleRecentTraces(req);
case "/api/traces/today":
return handleTodayTraces();
case "/api/logs":
return handleLogsQuery(req);
case "/api/traces/stream":
return handleSSEStream(req);
case "/api/conversations/user-token":
if (req.method === "POST")
return handleSetConversationUserToken(req);
if (req.method === "GET")
return handleGetConversationUserToken(req);
return errorResponse("Method not allowed", "Only GET and POST are supported", 405);
case "/api/agent":
if (url.searchParams.has("env")) {
const environment = url.searchParams.get("env");
if (environment !== "dev" && environment !== "prod") {
return errorResponse("Invalid environment", "env must be one of: dev, prod", 400);
}
return handleAgentInfo(environment);
}
return handleAgentInfo();
case "/api/agent-map/snapshot":
return handleAgentMapSnapshot(req);
case "/api/agent-map/stream":
return handleAgentMapSSE(req);
case "/api/source":
return handleSourceSnippet(req);
case "/api/source/open":
return handleOpenSource(req);
case "/api/models":
return handleModels();
case "/api/tables/schema/diff":
return handleTableSchemaDiff(req);
case "/api/tables/schema/push":
return handleTableSchemaPush(req);
case "/api/dependencies/cloud-updated": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleDependenciesCloudUpdated(req);
}
case "/api/dependencies/diff": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleDependenciesDiff(req);
}
case "/api/dependencies/compare": {
const methodError = validateMethod(req, "GET");
if (methodError)
return methodError;
return handleDependenciesCompare();
}
case "/api/dependencies/copy": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleDependenciesCopy(req);
}
case "/api/knowledge/sync/diff":
return handleKnowledgeSyncDiff(req);
case "/api/knowledge/sync/push": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleKnowledgeSyncPush(req);
}
case "/api/deploy/plan": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleDeployPlan(req);
}
case "/api/deploy/execute": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleDeployExecute(req);
}
case "/api/deploy/status":
return handleDeployStatus();
case "/api/deploy/cancel": {
const methodError = validateMethod(req, "POST");
if (methodError)
return methodError;
return handleDeployCancel();
}
case "/api/logs/stream":
return streamLogs(req);
default:
return errorResponse("Not Found", "Not Found", 404);
}
} catch (error) {
return errorResponse("Internal server error", error instanceof Error ? error.message : "Unknown error", 500);
}
}
function matchAgent0ProviderAuthPath(pathname) {
const prefix = "/api/agent0/providers/";
const suffix = "/auth";
if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix))
return;
const encodedProviderId = pathname.slice(prefix.length, -suffix.length);
if (!encodedProviderId || encodedProviderId.includes("/"))
return;
try {
const providerId = decodeURIComponent(encodedProviderId);
return providerId && !providerId.includes("/") ? providerId : undefined;
} catch {
return;
}
}
function matchAgent0SessionMessagesPath(pathname) {
return matchAgent0SessionSubpath(pathname, "/messages");
}
function matchAgent0SessionEventsPath(pathname) {
return matchAgent0SessionSubpath(pathname, "/events");
}
function matchAgent0SessionCommandsPath(pathname) {
return matchAgent0SessionSubpath(pathname, "/commands");
}
function matchAgent0QuestionsPath(pathname) {
const prefix = "/api/agent0/sessions/";
if (!pathname.startsWith(prefix))
return;
const parts = pathname.slice(prefix.length).split("/");
if (parts.length !== 2 && parts.length !== 4)
return;
if (parts[1] !== "questions")
return;
try {
const sessionId = decodeURIComponent(parts[0] ?? "");
if (!sessionId || sessionId.includes("/"))
return;
if (parts.length === 2)
return { sessionId };
const questionId = decodeURIComponent(parts[2] ?? "");
const action = parts[3];
if (!questionId || questionId.includes("/") || action !== "reply" && action !== "reject")
return;
return { sessionId, questionId, action };
} catch {
return;
}
}
function matchAgent0SessionAbortPath(pathname) {
return matchAgent0SessionSubpath(pathname, "/abort");
}
function matchAgent0SessionSubpath(pathname, suffix) {
const prefix = "/api/agent0/sessions/";
if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix))
return;
const encodedSessionId = pathname.slice(prefix.length, -suffix.length);
if (!encodedSessionId || encodedSessionId.includes("/"))
return;
try {
const sessionId = decodeURIComponent(encodedSessionId);
return sessionId && !sessionId.includes("/") ? sessionId : undefined;
} catch {
return;
}
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/core.js
var NEVER = Object.freeze({
status: "aborted"
});
function $constructor(name, initializer, params) {
function init(inst, def) {
var _a;
Object.defineProperty(inst, "_zod", {
value: inst._zod ?? {},
enumerable: false
});
(_a = inst._zod).traits ?? (_a.traits = new Set);
inst._zod.traits.add(name);
initializer(inst, def);
for (const k in _.prototype) {
if (!(k in inst))
Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
}
inst._zod.constr = _;
inst._zod.def = def;
}
const Parent = params?.Parent ?? Object;
class Definition extends Parent {
}
Object.defineProperty(Definition, "name", { value: name });
function _(def) {
var _a;
const inst = params?.Parent ? new Definition : this;
init(inst, def);
(_a = inst._zod).deferred ?? (_a.deferred = []);
for (const fn of inst._zod.deferred) {
fn();
}
return inst;
}
Object.defineProperty(_, "init", { value: init });
Object.defineProperty(_, Symbol.hasInstance, {
value: (inst) => {
if (params?.Parent && inst instanceof params.Parent)
return true;
return inst?._zod?.traits?.has(name);
}
});
Object.defineProperty(_, "name", { value: name });
return _;
}
var $brand = Symbol("zod_brand");
class $ZodAsyncError extends Error {
constructor() {
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
}
}
var globalConfig = {};
function config(newConfig) {
if (newConfig)
Object.assign(globalConfig, newConfig);
return globalConfig;
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/util.js
var exports_util = {};
__export(exports_util, {
unwrapMessage: () => unwrapMessage,
stringifyPrimitive: () => stringifyPrimitive,
required: () => required,
randomString: () => randomString,
propertyKeyTypes: () => propertyKeyTypes,
promiseAllObject: () => promiseAllObject,
primitiveTypes: () => primitiveTypes,
prefixIssues: () => prefixIssues,
pick: () => pick,
partial: () => partial,
optionalKeys: () => optionalKeys,
omit: () => omit,
numKeys: () => numKeys,
nullish: () => nullish,
normalizeParams: () => normalizeParams,
merge: () => merge,
jsonStringifyReplacer: () => jsonStringifyReplacer,
joinValues: () => joinValues,
issue: () => issue,
isPlainObject: () => isPlainObject,
isObject: () => isObject,
getSizableOrigin: () => getSizableOrigin,
getParsedType: () => getParsedType,
getLengthableOrigin: () => getLengthableOrigin,
getEnumValues: () => getEnumValues,
getElementAtPath: () => getElementAtPath,
floatSafeRemainder: () => floatSafeRemainder,
finalizeIssue: () => finalizeIssue,
extend: () => extend,
escapeRegex: () => escapeRegex2,
esc: () => esc,
defineLazy: () => defineLazy,
createTransparentProxy: () => createTransparentProxy,
clone: () => clone,
cleanRegex: () => cleanRegex,
cleanEnum: () => cleanEnum,
captureStackTrace: () => captureStackTrace,
cached: () => cached,
assignProp: () => assignProp,
assertNotEqual: () => assertNotEqual,
assertNever: () => assertNever,
assertIs: () => assertIs,
assertEqual: () => assertEqual,
assert: () => assert,
allowsEval: () => allowsEval,
aborted: () => aborted,
NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
Class: () => Class,
BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES
});
function assertEqual(val) {
return val;
}
function assertNotEqual(val) {
return val;
}
function assertIs(_arg) {}
function assertNever(_x) {
throw new Error;
}
function assert(_) {}
function getEnumValues(entries) {
const numericValues = Object.values(entries).filter((v) => typeof v === "number");
const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
return values;
}
function joinValues(array, separator = "|") {
return array.map((val) => stringifyPrimitive(val)).join(separator);
}
function jsonStringifyReplacer(_, value) {
if (typeof value === "bigint")
return value.toString();
return value;
}
function cached(getter) {
const set = false;
return {
get value() {
if (!set) {
const value = getter();
Object.defineProperty(this, "value", { value });
return value;
}
throw new Error("cached value already set");
}
};
}
function nullish(input) {
return input === null || input === undefined;
}
function cleanRegex(source) {
const start = source.startsWith("^") ? 1 : 0;
const end = source.endsWith("$") ? source.length - 1 : source.length;
return source.slice(start, end);
}
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;
}
function defineLazy(object, key, getter) {
const set = false;
Object.defineProperty(object, key, {
get() {
if (!set) {
const value = getter();
object[key] = value;
return value;
}
throw new Error("cached value already set");
},
set(v) {
Object.defineProperty(object, key, {
value: v
});
},
configurable: true
});
}
function assignProp(target, prop, value) {
Object.defineProperty(target, prop, {
value,
writable: true,
enumerable: true,
configurable: true
});
}
function getElementAtPath(obj, path) {
if (!path)
return obj;
return path.reduce((acc, key) => acc?.[key], obj);
}
function promiseAllObject(promisesObj) {
const keys = Object.keys(promisesObj);
const promises = keys.map((key) => promisesObj[key]);
return Promise.all(promises).then((results) => {
const resolvedObj = {};
for (let i = 0;i < keys.length; i++) {
resolvedObj[keys[i]] = results[i];
}
return resolvedObj;
});
}
function randomString(length = 10) {
const chars = "abcdefghijklmnopqrstuvwxyz";
let str = "";
for (let i = 0;i < length; i++) {
str += chars[Math.floor(Math.random() * chars.length)];
}
return str;
}
function esc(str) {
return JSON.stringify(str);
}
var captureStackTrace = Error.captureStackTrace ? Error.captureStackTrace : (..._args) => {};
function isObject(data) {
return typeof data === "object" && data !== null && !Array.isArray(data);
}
var allowsEval = cached(() => {
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
return false;
}
try {
const F = Function;
new F("");
return true;
} catch (_) {
return false;
}
});
function isPlainObject(o) {
if (isObject(o) === false)
return false;
const ctor = o.constructor;
if (ctor === undefined)
return true;
const prot = ctor.prototype;
if (isObject(prot) === false)
return false;
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
return false;
}
return true;
}
function numKeys(data) {
let keyCount = 0;
for (const key in data) {
if (Object.prototype.hasOwnProperty.call(data, key)) {
keyCount++;
}
}
return keyCount;
}
var getParsedType = (data) => {
const t = typeof data;
switch (t) {
case "undefined":
return "undefined";
case "string":
return "string";
case "number":
return Number.isNaN(data) ? "nan" : "number";
case "boolean":
return "boolean";
case "function":
return "function";
case "bigint":
return "bigint";
case "symbol":
return "symbol";
case "object":
if (Array.isArray(data)) {
return "array";
}
if (data === null) {
return "null";
}
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
return "promise";
}
if (typeof Map !== "undefined" && data instanceof Map) {
return "map";
}
if (typeof Set !== "undefined" && data instanceof Set) {
return "set";
}
if (typeof Date !== "undefined" && data instanceof Date) {
return "date";
}
if (typeof File !== "undefined" && data instanceof File) {
return "file";
}
return "object";
default:
throw new Error(`Unknown data type: ${t}`);
}
};
var propertyKeyTypes = new Set(["string", "number", "symbol"]);
var primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
function escapeRegex2(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone(inst, def, params) {
const cl = new inst._zod.constr(def ?? inst._zod.def);
if (!def || params?.parent)
cl._zod.parent = inst;
return cl;
}
function normalizeParams(_params) {
const params = _params;
if (!params)
return {};
if (typeof params === "string")
return { error: () => params };
if (params?.message !== undefined) {
if (params?.error !== undefined)
throw new Error("Cannot specify both `message` and `error` params");
params.error = params.message;
}
delete params.message;
if (typeof params.error === "string")
return { ...params, error: () => params.error };
return params;
}
function createTransparentProxy(getter) {
let target;
return new Proxy({}, {
get(_, prop, receiver) {
target ?? (target = getter());
return Reflect.get(target, prop, receiver);
},
set(_, prop, value, receiver) {
target ?? (target = getter());
return Reflect.set(target, prop, value, receiver);
},
has(_, prop) {
target ?? (target = getter());
return Reflect.has(target, prop);
},
deleteProperty(_, prop) {
target ?? (target = getter());
return Reflect.deleteProperty(target, prop);
},
ownKeys(_) {
target ?? (target = getter());
return Reflect.ownKeys(target);
},
getOwnPropertyDescriptor(_, prop) {
target ?? (target = getter());
return Reflect.getOwnPropertyDescriptor(target, prop);
},
defineProperty(_, prop, descriptor) {
target ?? (target = getter());
return Reflect.defineProperty(target, prop, descriptor);
}
});
}
function stringifyPrimitive(value) {
if (typeof value === "bigint")
return value.toString() + "n";
if (typeof value === "string")
return `"${value}"`;
return `${value}`;
}
function optionalKeys(shape) {
return Object.keys(shape).filter((k) => {
return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
});
}
var NUMBER_FORMAT_RANGES = {
safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
int32: [-2147483648, 2147483647],
uint32: [0, 4294967295],
float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
};
var BIGINT_FORMAT_RANGES = {
int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
};
function pick(schema, mask) {
const newShape = {};
const currDef = schema._zod.def;
for (const key in mask) {
if (!(key in currDef.shape)) {
throw new Error(`Unrecognized key: "${key}"`);
}
if (!mask[key])
continue;
newShape[key] = currDef.shape[key];
}
return clone(schema, {
...schema._zod.def,
shape: newShape,
checks: []
});
}
function omit(schema, mask) {
const newShape = { ...schema._zod.def.shape };
const currDef = schema._zod.def;
for (const key in mask) {
if (!(key in currDef.shape)) {
throw new Error(`Unrecognized key: "${key}"`);
}
if (!mask[key])
continue;
delete newShape[key];
}
return clone(schema, {
...schema._zod.def,
shape: newShape,
checks: []
});
}
function extend(schema, shape) {
if (!isPlainObject(shape)) {
throw new Error("Invalid input to extend: expected a plain object");
}
const def = {
...schema._zod.def,
get shape() {
const _shape = { ...schema._zod.def.shape, ...shape };
assignProp(this, "shape", _shape);
return _shape;
},
checks: []
};
return clone(schema, def);
}
function merge(a, b) {
return clone(a, {
...a._zod.def,
get shape() {
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
assignProp(this, "shape", _shape);
return _shape;
},
catchall: b._zod.def.catchall,
checks: []
});
}
function partial(Class, schema, mask) {
const oldShape = schema._zod.def.shape;
const shape = { ...oldShape };
if (mask) {
for (const key in mask) {
if (!(key in oldShape)) {
throw new Error(`Unrecognized key: "${key}"`);
}
if (!mask[key])
continue;
shape[key] = Class ? new Class({
type: "optional",
innerType: oldShape[key]
}) : oldShape[key];
}
} else {
for (const key in oldShape) {
shape[key] = Class ? new Class({
type: "optional",
innerType: oldShape[key]
}) : oldShape[key];
}
}
return clone(schema, {
...schema._zod.def,
shape,
checks: []
});
}
function required(Class, schema, mask) {
const oldShape = schema._zod.def.shape;
const shape = { ...oldShape };
if (mask) {
for (const key in mask) {
if (!(key in shape)) {
throw new Error(`Unrecognized key: "${key}"`);
}
if (!mask[key])
continue;
shape[key] = new Class({
type: "nonoptional",
innerType: oldShape[key]
});
}
} else {
for (const key in oldShape) {
shape[key] = new Class({
type: "nonoptional",
innerType: oldShape[key]
});
}
}
return clone(schema, {
...schema._zod.def,
shape,
checks: []
});
}
function aborted(x, startIndex = 0) {
for (let i = startIndex;i < x.issues.length; i++) {
if (x.issues[i]?.continue !== true)
return true;
}
return false;
}
function prefixIssues(path, issues) {
return issues.map((iss) => {
var _a;
(_a = iss).path ?? (_a.path = []);
iss.path.unshift(path);
return iss;
});
}
function unwrapMessage(message) {
return typeof message === "string" ? message : message?.message;
}
function finalizeIssue(iss, ctx, config2) {
const full = { ...iss, path: iss.path ?? [] };
if (!iss.message) {
const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
full.message = message;
}
delete full.inst;
delete full.continue;
if (!ctx?.reportInput) {
delete full.input;
}
return full;
}
function getSizableOrigin(input) {
if (input instanceof Set)
return "set";
if (input instanceof Map)
return "map";
if (input instanceof File)
return "file";
return "unknown";
}
function getLengthableOrigin(input) {
if (Array.isArray(input))
return "array";
if (typeof input === "string")
return "string";
return "unknown";
}
function issue(...args) {
const [iss, input, inst] = args;
if (typeof iss === "string") {
return {
message: iss,
code: "custom",
input,
inst
};
}
return { ...iss };
}
function cleanEnum(obj) {
return Object.entries(obj).filter(([k, _]) => {
return Number.isNaN(Number.parseInt(k, 10));
}).map((el) => el[1]);
}
class Class {
constructor(..._args) {}
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/errors.js
var initializer = (inst, def) => {
inst.name = "$ZodError";
Object.defineProperty(inst, "_zod", {
value: inst._zod,
enumerable: false
});
Object.defineProperty(inst, "issues", {
value: def,
enumerable: false
});
Object.defineProperty(inst, "message", {
get() {
return JSON.stringify(def, jsonStringifyReplacer, 2);
},
enumerable: true
});
Object.defineProperty(inst, "toString", {
value: () => inst.message,
enumerable: false
});
};
var $ZodError = $constructor("$ZodError", initializer);
var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
function flattenError(error, mapper = (issue2) => issue2.message) {
const fieldErrors = {};
const formErrors = [];
for (const sub of error.issues) {
if (sub.path.length > 0) {
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
fieldErrors[sub.path[0]].push(mapper(sub));
} else {
formErrors.push(mapper(sub));
}
}
return { formErrors, fieldErrors };
}
function formatError(error, _mapper) {
const mapper = _mapper || function(issue2) {
return issue2.message;
};
const fieldErrors = { _errors: [] };
const processError = (error2) => {
for (const issue2 of error2.issues) {
if (issue2.code === "invalid_union" && issue2.errors.length) {
issue2.errors.map((issues) => processError({ issues }));
} else if (issue2.code === "invalid_key") {
processError({ issues: issue2.issues });
} else if (issue2.code === "invalid_element") {
processError({ issues: issue2.issues });
} else if (issue2.path.length === 0) {
fieldErrors._errors.push(mapper(issue2));
} else {
let curr = fieldErrors;
let i = 0;
while (i < issue2.path.length) {
const el = issue2.path[i];
const terminal = i === issue2.path.length - 1;
if (!terminal) {
curr[el] = curr[el] || { _errors: [] };
} else {
curr[el] = curr[el] || { _errors: [] };
curr[el]._errors.push(mapper(issue2));
}
curr = curr[el];
i++;
}
}
}
};
processError(error);
return fieldErrors;
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/parse.js
var _parse = (_Err) => (schema, value, _ctx, _params) => {
const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
const result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise) {
throw new $ZodAsyncError;
}
if (result.issues.length) {
const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
captureStackTrace(e, _params?.callee);
throw e;
}
return result.value;
};
var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
let result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise)
result = await result;
if (result.issues.length) {
const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
captureStackTrace(e, params?.callee);
throw e;
}
return result.value;
};
var _safeParse = (_Err) => (schema, value, _ctx) => {
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
const result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise) {
throw new $ZodAsyncError;
}
return result.issues.length ? {
success: false,
error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
} : { success: true, data: result.value };
};
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
let result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise)
result = await result;
return result.issues.length ? {
success: false,
error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
} : { success: true, data: result.value };
};
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/regexes.js
var cuid = /^[cC][^\s-]{8,}$/;
var cuid2 = /^[0-9a-z]+$/;
var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
var xid = /^[0-9a-vA-V]{20}$/;
var ksuid = /^[A-Za-z0-9]{27}$/;
var nanoid = /^[a-zA-Z0-9_-]{21}$/;
var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
var uuid = (version) => {
if (!version)
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
};
var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
function emoji() {
return new RegExp(_emoji, "u");
}
var 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])$/;
var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
var cidrv4 = /^((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])\/([0-9]|[1-2][0-9]|3[0-2])$/;
var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
var base64url = /^[A-Za-z0-9_-]*$/;
var hostname = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
var dateSource = `(?:(?:\\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 date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
function timeSource(args) {
const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
return regex;
}
function time(args) {
return new RegExp(`^${timeSource(args)}$`);
}
function datetime(args) {
const time2 = timeSource({ precision: args.precision });
const opts = ["Z"];
if (args.local)
opts.push("");
if (args.offset)
opts.push(`([+-]\\d{2}:\\d{2})`);
const timeRegex = `${time2}(?:${opts.join("|")})`;
return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
}
var string = (params) => {
const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
return new RegExp(`^${regex}$`);
};
var integer = /^\d+$/;
var number = /^-?\d+(?:\.\d+)?/i;
var boolean = /true|false/i;
var _null = /null/i;
var lowercase = /^[^A-Z]*$/;
var uppercase = /^[^a-z]*$/;
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/checks.js
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
var _a;
inst._zod ?? (inst._zod = {});
inst._zod.def = def;
(_a = inst._zod).onattach ?? (_a.onattach = []);
});
var numericOriginMap = {
number: "number",
bigint: "bigint",
object: "date"
};
var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
$ZodCheck.init(inst, def);
const origin = numericOriginMap[typeof def.value];
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
if (def.value < curr) {
if (def.inclusive)
bag.maximum = def.value;
else
bag.exclusiveMaximum = def.value;
}
});
inst._zod.check = (payload) => {
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
return;
}
payload.issues.push({
origin,
code: "too_big",
maximum: def.value,
input: payload.value,
inclusive: def.inclusive,
inst,
continue: !def.abort
});
};
});
var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
$ZodCheck.init(inst, def);
const origin = numericOriginMap[typeof def.value];
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
if (def.value > curr) {
if (def.inclusive)
bag.minimum = def.value;
else
bag.exclusiveMinimum = def.value;
}
});
inst._zod.check = (payload) => {
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
return;
}
payload.issues.push({
origin,
code: "too_small",
minimum: def.value,
input: payload.value,
inclusive: def.inclusive,
inst,
continue: !def.abort
});
};
});
var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
$ZodCheck.init(inst, def);
inst._zod.onattach.push((inst2) => {
var _a;
(_a = inst2._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
});
inst._zod.check = (payload) => {
if (typeof payload.value !== typeof def.value)
throw new Error("Cannot mix number and bigint in multiple_of check.");
const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
if (isMultiple)
return;
payload.issues.push({
origin: typeof payload.value,
code: "not_multiple_of",
divisor: def.value,
input: payload.value,
inst,
continue: !def.abort
});
};
});
var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
$ZodCheck.init(inst, def);
def.format = def.format || "float64";
const isInt = def.format?.includes("int");
const origin = isInt ? "int" : "number";
const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
bag.format = def.format;
bag.minimum = minimum;
bag.maximum = maximum;
if (isInt)
bag.pattern = integer;
});
inst._zod.check = (payload) => {
const input = payload.value;
if (isInt) {
if (!Number.isInteger(input)) {
payload.issues.push({
expected: origin,
format: def.format,
code: "invalid_type",
input,
inst
});
return;
}
if (!Number.isSafeInteger(input)) {
if (input > 0) {
payload.issues.push({
input,
code: "too_big",
maximum: Number.MAX_SAFE_INTEGER,
note: "Integers must be within the safe integer range.",
inst,
origin,
continue: !def.abort
});
} else {
payload.issues.push({
input,
code: "too_small",
minimum: Number.MIN_SAFE_INTEGER,
note: "Integers must be within the safe integer range.",
inst,
origin,
continue: !def.abort
});
}
return;
}
}
if (input < minimum) {
payload.issues.push({
origin: "number",
input,
code: "too_small",
minimum,
inclusive: true,
inst,
continue: !def.abort
});
}
if (input > maximum) {
payload.issues.push({
origin: "number",
input,
code: "too_big",
maximum,
inst
});
}
};
});
var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
var _a;
$ZodCheck.init(inst, def);
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
const val = payload.value;
return !nullish(val) && val.length !== undefined;
});
inst._zod.onattach.push((inst2) => {
const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
if (def.maximum < curr)
inst2._zod.bag.maximum = def.maximum;
});
inst._zod.check = (payload) => {
const input = payload.value;
const length = input.length;
if (length <= def.maximum)
return;
const origin = getLengthableOrigin(input);
payload.issues.push({
origin,
code: "too_big",
maximum: def.maximum,
inclusive: true,
input,
inst,
continue: !def.abort
});
};
});
var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
var _a;
$ZodCheck.init(inst, def);
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
const val = payload.value;
return !nullish(val) && val.length !== undefined;
});
inst._zod.onattach.push((inst2) => {
const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
if (def.minimum > curr)
inst2._zod.bag.minimum = def.minimum;
});
inst._zod.check = (payload) => {
const input = payload.value;
const length = input.length;
if (length >= def.minimum)
return;
const origin = getLengthableOrigin(input);
payload.issues.push({
origin,
code: "too_small",
minimum: def.minimum,
inclusive: true,
input,
inst,
continue: !def.abort
});
};
});
var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
var _a;
$ZodCheck.init(inst, def);
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
const val = payload.value;
return !nullish(val) && val.length !== undefined;
});
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
bag.minimum = def.length;
bag.maximum = def.length;
bag.length = def.length;
});
inst._zod.check = (payload) => {
const input = payload.value;
const length = input.length;
if (length === def.length)
return;
const origin = getLengthableOrigin(input);
const tooBig = length > def.length;
payload.issues.push({
origin,
...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
inclusive: true,
exact: true,
input: payload.value,
inst,
continue: !def.abort
});
};
});
var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
var _a, _b;
$ZodCheck.init(inst, def);
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
bag.format = def.format;
if (def.pattern) {
bag.patterns ?? (bag.patterns = new Set);
bag.patterns.add(def.pattern);
}
});
if (def.pattern)
(_a = inst._zod).check ?? (_a.check = (payload) => {
def.pattern.lastIndex = 0;
if (def.pattern.test(payload.value))
return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: def.format,
input: payload.value,
...def.pattern ? { pattern: def.pattern.toString() } : {},
inst,
continue: !def.abort
});
});
else
(_b = inst._zod).check ?? (_b.check = () => {});
});
var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
$ZodCheckStringFormat.init(inst, def);
inst._zod.check = (payload) => {
def.pattern.lastIndex = 0;
if (def.pattern.test(payload.value))
return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: "regex",
input: payload.value,
pattern: def.pattern.toString(),
inst,
continue: !def.abort
});
};
});
var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
def.pattern ?? (def.pattern = lowercase);
$ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
def.pattern ?? (def.pattern = uppercase);
$ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
$ZodCheck.init(inst, def);
const escapedRegex = escapeRegex2(def.includes);
const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
def.pattern = pattern;
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
bag.patterns ?? (bag.patterns = new Set);
bag.patterns.add(pattern);
});
inst._zod.check = (payload) => {
if (payload.value.includes(def.includes, def.position))
return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: "includes",
includes: def.includes,
input: payload.value,
inst,
continue: !def.abort
});
};
});
var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
$ZodCheck.init(inst, def);
const pattern = new RegExp(`^${escapeRegex2(def.prefix)}.*`);
def.pattern ?? (def.pattern = pattern);
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
bag.patterns ?? (bag.patterns = new Set);
bag.patterns.add(pattern);
});
inst._zod.check = (payload) => {
if (payload.value.startsWith(def.prefix))
return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: "starts_with",
prefix: def.prefix,
input: payload.value,
inst,
continue: !def.abort
});
};
});
var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
$ZodCheck.init(inst, def);
const pattern = new RegExp(`.*${escapeRegex2(def.suffix)}$`);
def.pattern ?? (def.pattern = pattern);
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
bag.patterns ?? (bag.patterns = new Set);
bag.patterns.add(pattern);
});
inst._zod.check = (payload) => {
if (payload.value.endsWith(def.suffix))
return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: "ends_with",
suffix: def.suffix,
input: payload.value,
inst,
continue: !def.abort
});
};
});
var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
$ZodCheck.init(inst, def);
inst._zod.check = (payload) => {
payload.value = def.tx(payload.value);
};
});
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/doc.js
class Doc {
constructor(args = []) {
this.content = [];
this.indent = 0;
if (this)
this.args = args;
}
indented(fn) {
this.indent += 1;
fn(this);
this.indent -= 1;
}
write(arg) {
if (typeof arg === "function") {
arg(this, { execution: "sync" });
arg(this, { execution: "async" });
return;
}
const content = arg;
const lines = content.split(`
`).filter((x) => x);
const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
for (const line of dedented) {
this.content.push(line);
}
}
compile() {
const F = Function;
const args = this?.args;
const content = this?.content ?? [``];
const lines = [...content.map((x) => ` ${x}`)];
return new F(...args, lines.join(`
`));
}
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/versions.js
var version = {
major: 4,
minor: 0,
patch: 0
};
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/schemas.js
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
var _a;
inst ?? (inst = {});
inst._zod.def = def;
inst._zod.bag = inst._zod.bag || {};
inst._zod.version = version;
const checks = [...inst._zod.def.checks ?? []];
if (inst._zod.traits.has("$ZodCheck")) {
checks.unshift(inst);
}
for (const ch of checks) {
for (const fn of ch._zod.onattach) {
fn(inst);
}
}
if (checks.length === 0) {
(_a = inst._zod).deferred ?? (_a.deferred = []);
inst._zod.deferred?.push(() => {
inst._zod.run = inst._zod.parse;
});
} else {
const runChecks = (payload, checks2, ctx) => {
let isAborted = aborted(payload);
let asyncResult;
for (const ch of checks2) {
if (ch._zod.def.when) {
const shouldRun = ch._zod.def.when(payload);
if (!shouldRun)
continue;
} else if (isAborted) {
continue;
}
const currLen = payload.issues.length;
const _ = ch._zod.check(payload);
if (_ instanceof Promise && ctx?.async === false) {
throw new $ZodAsyncError;
}
if (asyncResult || _ instanceof Promise) {
asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
await _;
const nextLen = payload.issues.length;
if (nextLen === currLen)
return;
if (!isAborted)
isAborted = aborted(payload, currLen);
});
} else {
const nextLen = payload.issues.length;
if (nextLen === currLen)
continue;
if (!isAborted)
isAborted = aborted(payload, currLen);
}
}
if (asyncResult) {
return asyncResult.then(() => {
return payload;
});
}
return payload;
};
inst._zod.run = (payload, ctx) => {
const result = inst._zod.parse(payload, ctx);
if (result instanceof Promise) {
if (ctx.async === false)
throw new $ZodAsyncError;
return result.then((result2) => runChecks(result2, checks, ctx));
}
return runChecks(result, checks, ctx);
};
}
inst["~standard"] = {
validate: (value) => {
try {
const r = safeParse(inst, value);
return r.success ? { value: r.data } : { issues: r.error?.issues };
} catch (_) {
return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
}
},
vendor: "zod",
version: 1
};
});
var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
inst._zod.parse = (payload, _) => {
if (def.coerce)
try {
payload.value = String(payload.value);
} catch (_2) {}
if (typeof payload.value === "string")
return payload;
payload.issues.push({
expected: "string",
code: "invalid_type",
input: payload.value,
inst
});
return payload;
};
});
var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
$ZodCheckStringFormat.init(inst, def);
$ZodString.init(inst, def);
});
var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
def.pattern ?? (def.pattern = guid);
$ZodStringFormat.init(inst, def);
});
var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
if (def.version) {
const versionMap = {
v1: 1,
v2: 2,
v3: 3,
v4: 4,
v5: 5,
v6: 6,
v7: 7,
v8: 8
};
const v = versionMap[def.version];
if (v === undefined)
throw new Error(`Invalid UUID version: "${def.version}"`);
def.pattern ?? (def.pattern = uuid(v));
} else
def.pattern ?? (def.pattern = uuid());
$ZodStringFormat.init(inst, def);
});
var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
def.pattern ?? (def.pattern = email);
$ZodStringFormat.init(inst, def);
});
var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
try {
const orig = payload.value;
const url = new URL(orig);
const href = url.href;
if (def.hostname) {
def.hostname.lastIndex = 0;
if (!def.hostname.test(url.hostname)) {
payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid hostname",
pattern: hostname.source,
input: payload.value,
inst,
continue: !def.abort
});
}
}
if (def.protocol) {
def.protocol.lastIndex = 0;
if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid protocol",
pattern: def.protocol.source,
input: payload.value,
inst,
continue: !def.abort
});
}
}
if (!orig.endsWith("/") && href.endsWith("/")) {
payload.value = href.slice(0, -1);
} else {
payload.value = href;
}
return;
} catch (_) {
payload.issues.push({
code: "invalid_format",
format: "url",
input: payload.value,
inst,
continue: !def.abort
});
}
};
});
var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
def.pattern ?? (def.pattern = emoji());
$ZodStringFormat.init(inst, def);
});
var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
def.pattern ?? (def.pattern = nanoid);
$ZodStringFormat.init(inst, def);
});
var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
def.pattern ?? (def.pattern = cuid);
$ZodStringFormat.init(inst, def);
});
var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
def.pattern ?? (def.pattern = cuid2);
$ZodStringFormat.init(inst, def);
});
var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
def.pattern ?? (def.pattern = ulid);
$ZodStringFormat.init(inst, def);
});
var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
def.pattern ?? (def.pattern = xid);
$ZodStringFormat.init(inst, def);
});
var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
def.pattern ?? (def.pattern = ksuid);
$ZodStringFormat.init(inst, def);
});
var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
def.pattern ?? (def.pattern = datetime(def));
$ZodStringFormat.init(inst, def);
});
var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
def.pattern ?? (def.pattern = date);
$ZodStringFormat.init(inst, def);
});
var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
def.pattern ?? (def.pattern = time(def));
$ZodStringFormat.init(inst, def);
});
var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
def.pattern ?? (def.pattern = duration);
$ZodStringFormat.init(inst, def);
});
var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
def.pattern ?? (def.pattern = ipv4);
$ZodStringFormat.init(inst, def);
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
bag.format = `ipv4`;
});
});
var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
def.pattern ?? (def.pattern = ipv6);
$ZodStringFormat.init(inst, def);
inst._zod.onattach.push((inst2) => {
const bag = inst2._zod.bag;
bag.format = `ipv6`;
});
inst._zod.check = (payload) => {
try {
new URL(`http://[${payload.value}]`);
} catch {
payload.issues.push({
code: "invalid_format",
format: "ipv6",
input: payload.value,
inst,
continue: !def.abort
});
}
};
});
var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
def.pattern ?? (def.pattern = cidrv4);
$ZodStringFormat.init(inst, def);
});
var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
def.pattern ?? (def.pattern = cidrv6);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
const [address, prefix] = payload.value.split("/");
try {
if (!prefix)
throw new Error;
const prefixNum = Number(prefix);
if (`${prefixNum}` !== prefix)
throw new Error;
if (prefixNum < 0 || prefixNum > 128)
throw new Error;
new URL(`http://[${address}]`);
} catch {
payload.issues.push({
code: "invalid_format",
format: "cidrv6",
input: payload.value,
inst,
continue: !def.abort
});
}
};
});
function isValidBase64(data) {
if (data === "")
return true;
if (data.length % 4 !== 0)
return false;
try {
atob(data);
return true;
} catch {
return false;
}
}
var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
def.pattern ?? (def.pattern = base64);
$ZodStringFormat.init(inst, def);
inst._zod.onattach.push((inst2) => {
inst2._zod.bag.contentEncoding = "base64";
});
inst._zod.check = (payload) => {
if (isValidBase64(payload.value))
return;
payload.issues.push({
code: "invalid_format",
format: "base64",
input: payload.value,
inst,
continue: !def.abort
});
};
});
function isValidBase64URL(data) {
if (!base64url.test(data))
return false;
const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "=");
return isValidBase64(padded);
}
var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
def.pattern ?? (def.pattern = base64url);
$ZodStringFormat.init(inst, def);
inst._zod.onattach.push((inst2) => {
inst2._zod.bag.contentEncoding = "base64url";
});
inst._zod.check = (payload) => {
if (isValidBase64URL(payload.value))
return;
payload.issues.push({
code: "invalid_format",
format: "base64url",
input: payload.value,
inst,
continue: !def.abort
});
};
});
var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
def.pattern ?? (def.pattern = e164);
$ZodStringFormat.init(inst, def);
});
function isValidJWT(token, algorithm = null) {
try {
const tokensParts = token.split(".");
if (tokensParts.length !== 3)
return false;
const [header] = tokensParts;
if (!header)
return false;
const parsedHeader = JSON.parse(atob(header));
if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
return false;
if (!parsedHeader.alg)
return false;
if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
return false;
return true;
} catch {
return false;
}
}
var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (isValidJWT(payload.value, def.alg))
return;
payload.issues.push({
code: "invalid_format",
format: "jwt",
input: payload.value,
inst,
continue: !def.abort
});
};
});
var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = inst._zod.bag.pattern ?? number;
inst._zod.parse = (payload, _ctx) => {
if (def.coerce)
try {
payload.value = Number(payload.value);
} catch (_) {}
const input = payload.value;
if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
return payload;
}
const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : undefined : undefined;
payload.issues.push({
expected: "number",
code: "invalid_type",
input,
inst,
...received ? { received } : {}
});
return payload;
};
});
var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
$ZodCheckNumberFormat.init(inst, def);
$ZodNumber.init(inst, def);
});
var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = boolean;
inst._zod.parse = (payload, _ctx) => {
if (def.coerce)
try {
payload.value = Boolean(payload.value);
} catch (_) {}
const input = payload.value;
if (typeof input === "boolean")
return payload;
payload.issues.push({
expected: "boolean",
code: "invalid_type",
input,
inst
});
return payload;
};
});
var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = _null;
inst._zod.values = new Set([null]);
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (input === null)
return payload;
payload.issues.push({
expected: "null",
code: "invalid_type",
input,
inst
});
return payload;
};
});
var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload) => payload;
});
var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
payload.issues.push({
expected: "never",
code: "invalid_type",
input: payload.value,
inst
});
return payload;
};
});
function handleArrayResult(result, final, index) {
if (result.issues.length) {
final.issues.push(...prefixIssues(index, result.issues));
}
final.value[index] = result.value;
}
var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!Array.isArray(input)) {
payload.issues.push({
expected: "array",
code: "invalid_type",
input,
inst
});
return payload;
}
payload.value = Array(input.length);
const proms = [];
for (let i = 0;i < input.length; i++) {
const item = input[i];
const result = def.element._zod.run({
value: item,
issues: []
}, ctx);
if (result instanceof Promise) {
proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
} else {
handleArrayResult(result, payload, i);
}
}
if (proms.length) {
return Promise.all(proms).then(() => payload);
}
return payload;
};
});
function handleObjectResult(result, final, key) {
if (result.issues.length) {
final.issues.push(...prefixIssues(key, result.issues));
}
final.value[key] = result.value;
}
function handleOptionalObjectResult(result, final, key, input) {
if (result.issues.length) {
if (input[key] === undefined) {
if (key in input) {
final.value[key] = undefined;
} else {
final.value[key] = result.value;
}
} else {
final.issues.push(...prefixIssues(key, result.issues));
}
} else if (result.value === undefined) {
if (key in input)
final.value[key] = undefined;
} else {
final.value[key] = result.value;
}
}
var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
$ZodType.init(inst, def);
const _normalized = cached(() => {
const keys = Object.keys(def.shape);
for (const k of keys) {
if (!(def.shape[k] instanceof $ZodType)) {
throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
}
}
const okeys = optionalKeys(def.shape);
return {
shape: def.shape,
keys,
keySet: new Set(keys),
numKeys: keys.length,
optionalKeys: new Set(okeys)
};
});
defineLazy(inst._zod, "propValues", () => {
const shape = def.shape;
const propValues = {};
for (const key in shape) {
const field = shape[key]._zod;
if (field.values) {
propValues[key] ?? (propValues[key] = new Set);
for (const v of field.values)
propValues[key].add(v);
}
}
return propValues;
});
const generateFastpass = (shape) => {
const doc = new Doc(["shape", "payload", "ctx"]);
const normalized = _normalized.value;
const parseStr = (key) => {
const k = esc(key);
return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
};
doc.write(`const input = payload.value;`);
const ids = Object.create(null);
let counter = 0;
for (const key of normalized.keys) {
ids[key] = `key_${counter++}`;
}
doc.write(`const newResult = {}`);
for (const key of normalized.keys) {
if (normalized.optionalKeys.has(key)) {
const id = ids[key];
doc.write(`const ${id} = ${parseStr(key)};`);
const k = esc(key);
doc.write(`
if (${id}.issues.length) {
if (input[${k}] === undefined) {
if (${k} in input) {
newResult[${k}] = undefined;
}
} else {
payload.issues = payload.issues.concat(
${id}.issues.map((iss) => ({
...iss,
path: iss.path ? [${k}, ...iss.path] : [${k}],
}))
);
}
} else if (${id}.value === undefined) {
if (${k} in input) newResult[${k}] = undefined;
} else {
newResult[${k}] = ${id}.value;
}
`);
} else {
const id = ids[key];
doc.write(`const ${id} = ${parseStr(key)};`);
doc.write(`
if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
...iss,
path: iss.path ? [${esc(key)}, ...iss.path] : [${esc(key)}]
})));`);
doc.write(`newResult[${esc(key)}] = ${id}.value`);
}
}
doc.write(`payload.value = newResult;`);
doc.write(`return payload;`);
const fn = doc.compile();
return (payload, ctx) => fn(shape, payload, ctx);
};
let fastpass;
const isObject2 = isObject;
const jit = !globalConfig.jitless;
const allowsEval2 = allowsEval;
const fastEnabled = jit && allowsEval2.value;
const catchall = def.catchall;
let value;
inst._zod.parse = (payload, ctx) => {
value ?? (value = _normalized.value);
const input = payload.value;
if (!isObject2(input)) {
payload.issues.push({
expected: "object",
code: "invalid_type",
input,
inst
});
return payload;
}
const proms = [];
if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
if (!fastpass)
fastpass = generateFastpass(def.shape);
payload = fastpass(payload, ctx);
} else {
payload.value = {};
const shape = value.shape;
for (const key of value.keys) {
const el = shape[key];
const r = el._zod.run({ value: input[key], issues: [] }, ctx);
const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
if (r instanceof Promise) {
proms.push(r.then((r2) => isOptional ? handleOptionalObjectResult(r2, payload, key, input) : handleObjectResult(r2, payload, key)));
} else if (isOptional) {
handleOptionalObjectResult(r, payload, key, input);
} else {
handleObjectResult(r, payload, key);
}
}
}
if (!catchall) {
return proms.length ? Promise.all(proms).then(() => payload) : payload;
}
const unrecognized = [];
const keySet = value.keySet;
const _catchall = catchall._zod;
const t = _catchall.def.type;
for (const key of Object.keys(input)) {
if (keySet.has(key))
continue;
if (t === "never") {
unrecognized.push(key);
continue;
}
const r = _catchall.run({ value: input[key], issues: [] }, ctx);
if (r instanceof Promise) {
proms.push(r.then((r2) => handleObjectResult(r2, payload, key)));
} else {
handleObjectResult(r, payload, key);
}
}
if (unrecognized.length) {
payload.issues.push({
code: "unrecognized_keys",
keys: unrecognized,
input,
inst
});
}
if (!proms.length)
return payload;
return Promise.all(proms).then(() => {
return payload;
});
};
});
function handleUnionResults(results, final, inst, ctx) {
for (const result of results) {
if (result.issues.length === 0) {
final.value = result.value;
return final;
}
}
final.issues.push({
code: "invalid_union",
input: final.value,
inst,
errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
});
return final;
}
var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
$ZodType.init(inst, def);
defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined);
defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined);
defineLazy(inst._zod, "values", () => {
if (def.options.every((o) => o._zod.values)) {
return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
}
return;
});
defineLazy(inst._zod, "pattern", () => {
if (def.options.every((o) => o._zod.pattern)) {
const patterns = def.options.map((o) => o._zod.pattern);
return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
}
return;
});
inst._zod.parse = (payload, ctx) => {
let async = false;
const results = [];
for (const option of def.options) {
const result = option._zod.run({
value: payload.value,
issues: []
}, ctx);
if (result instanceof Promise) {
results.push(result);
async = true;
} else {
if (result.issues.length === 0)
return result;
results.push(result);
}
}
if (!async)
return handleUnionResults(results, payload, inst, ctx);
return Promise.all(results).then((results2) => {
return handleUnionResults(results2, payload, inst, ctx);
});
};
});
var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
$ZodUnion.init(inst, def);
const _super = inst._zod.parse;
defineLazy(inst._zod, "propValues", () => {
const propValues = {};
for (const option of def.options) {
const pv = option._zod.propValues;
if (!pv || Object.keys(pv).length === 0)
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
for (const [k, v] of Object.entries(pv)) {
if (!propValues[k])
propValues[k] = new Set;
for (const val of v) {
propValues[k].add(val);
}
}
}
return propValues;
});
const disc = cached(() => {
const opts = def.options;
const map = new Map;
for (const o of opts) {
const values = o._zod.propValues[def.discriminator];
if (!values || values.size === 0)
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
for (const v of values) {
if (map.has(v)) {
throw new Error(`Duplicate discriminator value "${String(v)}"`);
}
map.set(v, o);
}
}
return map;
});
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!isObject(input)) {
payload.issues.push({
code: "invalid_type",
expected: "object",
input,
inst
});
return payload;
}
const opt = disc.value.get(input?.[def.discriminator]);
if (opt) {
return opt._zod.run(payload, ctx);
}
if (def.unionFallback) {
return _super(payload, ctx);
}
payload.issues.push({
code: "invalid_union",
errors: [],
note: "No matching discriminator",
input,
path: [def.discriminator],
inst
});
return payload;
};
});
var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
const left = def.left._zod.run({ value: input, issues: [] }, ctx);
const right = def.right._zod.run({ value: input, issues: [] }, ctx);
const async = left instanceof Promise || right instanceof Promise;
if (async) {
return Promise.all([left, right]).then(([left2, right2]) => {
return handleIntersectionResults(payload, left2, right2);
});
}
return handleIntersectionResults(payload, left, right);
};
});
function mergeValues(a, b) {
if (a === b) {
return { valid: true, data: a };
}
if (a instanceof Date && b instanceof Date && +a === +b) {
return { valid: true, data: a };
}
if (isPlainObject(a) && isPlainObject(b)) {
const bKeys = Object.keys(b);
const sharedKeys = Object.keys(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,
mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
};
}
newObj[key] = sharedValue.data;
}
return { valid: true, data: newObj };
}
if (Array.isArray(a) && Array.isArray(b)) {
if (a.length !== b.length) {
return { valid: false, mergeErrorPath: [] };
}
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,
mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
};
}
newArray.push(sharedValue.data);
}
return { valid: true, data: newArray };
}
return { valid: false, mergeErrorPath: [] };
}
function handleIntersectionResults(result, left, right) {
if (left.issues.length) {
result.issues.push(...left.issues);
}
if (right.issues.length) {
result.issues.push(...right.issues);
}
if (aborted(result))
return result;
const merged = mergeValues(left.value, right.value);
if (!merged.valid) {
throw new Error(`Unmergable intersection. Error path: ` + `${JSON.stringify(merged.mergeErrorPath)}`);
}
result.value = merged.data;
return result;
}
var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!isPlainObject(input)) {
payload.issues.push({
expected: "record",
code: "invalid_type",
input,
inst
});
return payload;
}
const proms = [];
if (def.keyType._zod.values) {
const values = def.keyType._zod.values;
payload.value = {};
for (const key of values) {
if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
if (result instanceof Promise) {
proms.push(result.then((result2) => {
if (result2.issues.length) {
payload.issues.push(...prefixIssues(key, result2.issues));
}
payload.value[key] = result2.value;
}));
} else {
if (result.issues.length) {
payload.issues.push(...prefixIssues(key, result.issues));
}
payload.value[key] = result.value;
}
}
}
let unrecognized;
for (const key in input) {
if (!values.has(key)) {
unrecognized = unrecognized ?? [];
unrecognized.push(key);
}
}
if (unrecognized && unrecognized.length > 0) {
payload.issues.push({
code: "unrecognized_keys",
input,
inst,
keys: unrecognized
});
}
} else {
payload.value = {};
for (const key of Reflect.ownKeys(input)) {
if (key === "__proto__")
continue;
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
if (keyResult instanceof Promise) {
throw new Error("Async schemas not supported in object keys currently");
}
if (keyResult.issues.length) {
payload.issues.push({
origin: "record",
code: "invalid_key",
issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
input: key,
path: [key],
inst
});
payload.value[keyResult.value] = keyResult.value;
continue;
}
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
if (result instanceof Promise) {
proms.push(result.then((result2) => {
if (result2.issues.length) {
payload.issues.push(...prefixIssues(key, result2.issues));
}
payload.value[keyResult.value] = result2.value;
}));
} else {
if (result.issues.length) {
payload.issues.push(...prefixIssues(key, result.issues));
}
payload.value[keyResult.value] = result.value;
}
}
}
if (proms.length) {
return Promise.all(proms).then(() => payload);
}
return payload;
};
});
var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
$ZodType.init(inst, def);
const values = getEnumValues(def.entries);
inst._zod.values = new Set(values);
inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex2(o) : o.toString()).join("|")})$`);
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (inst._zod.values.has(input)) {
return payload;
}
payload.issues.push({
code: "invalid_value",
values,
input,
inst
});
return payload;
};
});
var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.values = new Set(def.values);
inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex2(o) : o ? o.toString() : String(o)).join("|")})$`);
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (inst._zod.values.has(input)) {
return payload;
}
payload.issues.push({
code: "invalid_value",
values: def.values,
input,
inst
});
return payload;
};
});
var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
const _out = def.transform(payload.value, payload);
if (_ctx.async) {
const output = _out instanceof Promise ? _out : Promise.resolve(_out);
return output.then((output2) => {
payload.value = output2;
return payload;
});
}
if (_out instanceof Promise) {
throw new $ZodAsyncError;
}
payload.value = _out;
return payload;
};
});
var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.optin = "optional";
inst._zod.optout = "optional";
defineLazy(inst._zod, "values", () => {
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, undefined]) : undefined;
});
defineLazy(inst._zod, "pattern", () => {
const pattern = def.innerType._zod.pattern;
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : undefined;
});
inst._zod.parse = (payload, ctx) => {
if (def.innerType._zod.optin === "optional") {
return def.innerType._zod.run(payload, ctx);
}
if (payload.value === undefined) {
return payload;
}
return def.innerType._zod.run(payload, ctx);
};
});
var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
$ZodType.init(inst, def);
defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
defineLazy(inst._zod, "pattern", () => {
const pattern = def.innerType._zod.pattern;
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : undefined;
});
defineLazy(inst._zod, "values", () => {
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : undefined;
});
inst._zod.parse = (payload, ctx) => {
if (payload.value === null)
return payload;
return def.innerType._zod.run(payload, ctx);
};
});
var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.optin = "optional";
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
inst._zod.parse = (payload, ctx) => {
if (payload.value === undefined) {
payload.value = def.defaultValue;
return payload;
}
const result = def.innerType._zod.run(payload, ctx);
if (result instanceof Promise) {
return result.then((result2) => handleDefaultResult(result2, def));
}
return handleDefaultResult(result, def);
};
});
function handleDefaultResult(payload, def) {
if (payload.value === undefined) {
payload.value = def.defaultValue;
}
return payload;
}
var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.optin = "optional";
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
inst._zod.parse = (payload, ctx) => {
if (payload.value === undefined) {
payload.value = def.defaultValue;
}
return def.innerType._zod.run(payload, ctx);
};
});
var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
$ZodType.init(inst, def);
defineLazy(inst._zod, "values", () => {
const v = def.innerType._zod.values;
return v ? new Set([...v].filter((x) => x !== undefined)) : undefined;
});
inst._zod.parse = (payload, ctx) => {
const result = def.innerType._zod.run(payload, ctx);
if (result instanceof Promise) {
return result.then((result2) => handleNonOptionalResult(result2, inst));
}
return handleNonOptionalResult(result, inst);
};
});
function handleNonOptionalResult(payload, inst) {
if (!payload.issues.length && payload.value === undefined) {
payload.issues.push({
code: "invalid_type",
expected: "nonoptional",
input: payload.value,
inst
});
}
return payload;
}
var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.optin = "optional";
defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
inst._zod.parse = (payload, ctx) => {
const result = def.innerType._zod.run(payload, ctx);
if (result instanceof Promise) {
return result.then((result2) => {
payload.value = result2.value;
if (result2.issues.length) {
payload.value = def.catchValue({
...payload,
error: {
issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
},
input: payload.value
});
payload.issues = [];
}
return payload;
});
}
payload.value = result.value;
if (result.issues.length) {
payload.value = def.catchValue({
...payload,
error: {
issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
},
input: payload.value
});
payload.issues = [];
}
return payload;
};
});
var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
$ZodType.init(inst, def);
defineLazy(inst._zod, "values", () => def.in._zod.values);
defineLazy(inst._zod, "optin", () => def.in._zod.optin);
defineLazy(inst._zod, "optout", () => def.out._zod.optout);
inst._zod.parse = (payload, ctx) => {
const left = def.in._zod.run(payload, ctx);
if (left instanceof Promise) {
return left.then((left2) => handlePipeResult(left2, def, ctx));
}
return handlePipeResult(left, def, ctx);
};
});
function handlePipeResult(left, def, ctx) {
if (aborted(left)) {
return left;
}
return def.out._zod.run({ value: left.value, issues: left.issues }, ctx);
}
var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
$ZodType.init(inst, def);
defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
inst._zod.parse = (payload, ctx) => {
const result = def.innerType._zod.run(payload, ctx);
if (result instanceof Promise) {
return result.then(handleReadonlyResult);
}
return handleReadonlyResult(result);
};
});
function handleReadonlyResult(payload) {
payload.value = Object.freeze(payload.value);
return payload;
}
var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
$ZodCheck.init(inst, def);
$ZodType.init(inst, def);
inst._zod.parse = (payload, _) => {
return payload;
};
inst._zod.check = (payload) => {
const input = payload.value;
const r = def.fn(input);
if (r instanceof Promise) {
return r.then((r2) => handleRefineResult(r2, payload, input, inst));
}
handleRefineResult(r, payload, input, inst);
return;
};
});
function handleRefineResult(result, payload, input, inst) {
if (!result) {
const _iss = {
code: "custom",
input,
inst,
path: [...inst._zod.def.path ?? []],
continue: !inst._zod.def.abort
};
if (inst._zod.def.params)
_iss.params = inst._zod.def.params;
payload.issues.push(issue(_iss));
}
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/locales/en.js
var parsedType = (data) => {
const t = typeof data;
switch (t) {
case "number": {
return Number.isNaN(data) ? "NaN" : "number";
}
case "object": {
if (Array.isArray(data)) {
return "array";
}
if (data === null) {
return "null";
}
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
return data.constructor.name;
}
}
}
return t;
};
var error = () => {
const Sizable = {
string: { unit: "characters", verb: "to have" },
file: { unit: "bytes", verb: "to have" },
array: { unit: "items", verb: "to have" },
set: { unit: "items", verb: "to have" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const Nouns = {
regex: "input",
email: "email address",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO datetime",
date: "ISO date",
time: "ISO time",
duration: "ISO duration",
ipv4: "IPv4 address",
ipv6: "IPv6 address",
cidrv4: "IPv4 range",
cidrv6: "IPv6 range",
base64: "base64-encoded string",
base64url: "base64url-encoded string",
json_string: "JSON string",
e164: "E.164 number",
jwt: "JWT",
template_literal: "input"
};
return (issue2) => {
switch (issue2.code) {
case "invalid_type":
return `Invalid input: expected ${issue2.expected}, received ${parsedType(issue2.input)}`;
case "invalid_value":
if (issue2.values.length === 1)
return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
return `Invalid option: expected one of ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `Too big: expected ${issue2.origin ?? "value"} to have ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elements"}`;
return `Too big: expected ${issue2.origin ?? "value"} to be ${adj}${issue2.maximum.toString()}`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `Too small: expected ${issue2.origin} to have ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
}
return `Too small: expected ${issue2.origin} to be ${adj}${issue2.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with") {
return `Invalid string: must start with "${_issue.prefix}"`;
}
if (_issue.format === "ends_with")
return `Invalid string: must end with "${_issue.suffix}"`;
if (_issue.format === "includes")
return `Invalid string: must include "${_issue.includes}"`;
if (_issue.format === "regex")
return `Invalid string: must match pattern ${_issue.pattern}`;
return `Invalid ${Nouns[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `Invalid number: must be a multiple of ${issue2.divisor}`;
case "unrecognized_keys":
return `Unrecognized key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `Invalid key in ${issue2.origin}`;
case "invalid_union":
return "Invalid input";
case "invalid_element":
return `Invalid value in ${issue2.origin}`;
default:
return `Invalid input`;
}
};
};
function en_default() {
return {
localeError: error()
};
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/registries.js
var $output = Symbol("ZodOutput");
var $input = Symbol("ZodInput");
class $ZodRegistry {
constructor() {
this._map = new Map;
this._idmap = new Map;
}
add(schema, ..._meta) {
const meta = _meta[0];
this._map.set(schema, meta);
if (meta && typeof meta === "object" && "id" in meta) {
if (this._idmap.has(meta.id)) {
throw new Error(`ID ${meta.id} already exists in the registry`);
}
this._idmap.set(meta.id, schema);
}
return this;
}
clear() {
this._map = new Map;
this._idmap = new Map;
return this;
}
remove(schema) {
const meta = this._map.get(schema);
if (meta && typeof meta === "object" && "id" in meta) {
this._idmap.delete(meta.id);
}
this._map.delete(schema);
return this;
}
get(schema) {
const p = schema._zod.parent;
if (p) {
const pm = { ...this.get(p) ?? {} };
delete pm.id;
return { ...pm, ...this._map.get(schema) };
}
return this._map.get(schema);
}
has(schema) {
return this._map.has(schema);
}
}
function registry() {
return new $ZodRegistry;
}
var globalRegistry = /* @__PURE__ */ registry();
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/api.js
function _string(Class2, params) {
return new Class2({
type: "string",
...normalizeParams(params)
});
}
function _email(Class2, params) {
return new Class2({
type: "string",
format: "email",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _guid(Class2, params) {
return new Class2({
type: "string",
format: "guid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _uuid(Class2, params) {
return new Class2({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _uuidv4(Class2, params) {
return new Class2({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
version: "v4",
...normalizeParams(params)
});
}
function _uuidv6(Class2, params) {
return new Class2({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
version: "v6",
...normalizeParams(params)
});
}
function _uuidv7(Class2, params) {
return new Class2({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
version: "v7",
...normalizeParams(params)
});
}
function _url(Class2, params) {
return new Class2({
type: "string",
format: "url",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _emoji2(Class2, params) {
return new Class2({
type: "string",
format: "emoji",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _nanoid(Class2, params) {
return new Class2({
type: "string",
format: "nanoid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _cuid(Class2, params) {
return new Class2({
type: "string",
format: "cuid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _cuid2(Class2, params) {
return new Class2({
type: "string",
format: "cuid2",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _ulid(Class2, params) {
return new Class2({
type: "string",
format: "ulid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _xid(Class2, params) {
return new Class2({
type: "string",
format: "xid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _ksuid(Class2, params) {
return new Class2({
type: "string",
format: "ksuid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _ipv4(Class2, params) {
return new Class2({
type: "string",
format: "ipv4",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _ipv6(Class2, params) {
return new Class2({
type: "string",
format: "ipv6",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _cidrv4(Class2, params) {
return new Class2({
type: "string",
format: "cidrv4",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _cidrv6(Class2, params) {
return new Class2({
type: "string",
format: "cidrv6",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _base64(Class2, params) {
return new Class2({
type: "string",
format: "base64",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _base64url(Class2, params) {
return new Class2({
type: "string",
format: "base64url",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _e164(Class2, params) {
return new Class2({
type: "string",
format: "e164",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _jwt(Class2, params) {
return new Class2({
type: "string",
format: "jwt",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _isoDateTime(Class2, params) {
return new Class2({
type: "string",
format: "datetime",
check: "string_format",
offset: false,
local: false,
precision: null,
...normalizeParams(params)
});
}
function _isoDate(Class2, params) {
return new Class2({
type: "string",
format: "date",
check: "string_format",
...normalizeParams(params)
});
}
function _isoTime(Class2, params) {
return new Class2({
type: "string",
format: "time",
check: "string_format",
precision: null,
...normalizeParams(params)
});
}
function _isoDuration(Class2, params) {
return new Class2({
type: "string",
format: "duration",
check: "string_format",
...normalizeParams(params)
});
}
function _number(Class2, params) {
return new Class2({
type: "number",
checks: [],
...normalizeParams(params)
});
}
function _int(Class2, params) {
return new Class2({
type: "number",
check: "number_format",
abort: false,
format: "safeint",
...normalizeParams(params)
});
}
function _boolean(Class2, params) {
return new Class2({
type: "boolean",
...normalizeParams(params)
});
}
function _null2(Class2, params) {
return new Class2({
type: "null",
...normalizeParams(params)
});
}
function _unknown(Class2) {
return new Class2({
type: "unknown"
});
}
function _never(Class2, params) {
return new Class2({
type: "never",
...normalizeParams(params)
});
}
function _lt(value, params) {
return new $ZodCheckLessThan({
check: "less_than",
...normalizeParams(params),
value,
inclusive: false
});
}
function _lte(value, params) {
return new $ZodCheckLessThan({
check: "less_than",
...normalizeParams(params),
value,
inclusive: true
});
}
function _gt(value, params) {
return new $ZodCheckGreaterThan({
check: "greater_than",
...normalizeParams(params),
value,
inclusive: false
});
}
function _gte(value, params) {
return new $ZodCheckGreaterThan({
check: "greater_than",
...normalizeParams(params),
value,
inclusive: true
});
}
function _multipleOf(value, params) {
return new $ZodCheckMultipleOf({
check: "multiple_of",
...normalizeParams(params),
value
});
}
function _maxLength(maximum, params) {
const ch = new $ZodCheckMaxLength({
check: "max_length",
...normalizeParams(params),
maximum
});
return ch;
}
function _minLength(minimum, params) {
return new $ZodCheckMinLength({
check: "min_length",
...normalizeParams(params),
minimum
});
}
function _length(length, params) {
return new $ZodCheckLengthEquals({
check: "length_equals",
...normalizeParams(params),
length
});
}
function _regex(pattern, params) {
return new $ZodCheckRegex({
check: "string_format",
format: "regex",
...normalizeParams(params),
pattern
});
}
function _lowercase(params) {
return new $ZodCheckLowerCase({
check: "string_format",
format: "lowercase",
...normalizeParams(params)
});
}
function _uppercase(params) {
return new $ZodCheckUpperCase({
check: "string_format",
format: "uppercase",
...normalizeParams(params)
});
}
function _includes(includes, params) {
return new $ZodCheckIncludes({
check: "string_format",
format: "includes",
...normalizeParams(params),
includes
});
}
function _startsWith(prefix, params) {
return new $ZodCheckStartsWith({
check: "string_format",
format: "starts_with",
...normalizeParams(params),
prefix
});
}
function _endsWith(suffix, params) {
return new $ZodCheckEndsWith({
check: "string_format",
format: "ends_with",
...normalizeParams(params),
suffix
});
}
function _overwrite(tx) {
return new $ZodCheckOverwrite({
check: "overwrite",
tx
});
}
function _normalize(form) {
return _overwrite((input) => input.normalize(form));
}
function _trim() {
return _overwrite((input) => input.trim());
}
function _toLowerCase() {
return _overwrite((input) => input.toLowerCase());
}
function _toUpperCase() {
return _overwrite((input) => input.toUpperCase());
}
function _array(Class2, element, params) {
return new Class2({
type: "array",
element,
...normalizeParams(params)
});
}
function _custom(Class2, fn, _params) {
const norm = normalizeParams(_params);
norm.abort ?? (norm.abort = true);
const schema = new Class2({
type: "custom",
check: "custom",
fn,
...norm
});
return schema;
}
function _refine(Class2, fn, _params) {
const schema = new Class2({
type: "custom",
check: "custom",
fn,
...normalizeParams(_params)
});
return schema;
}
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
function isZ4Schema(s) {
const schema = s;
return !!schema._zod;
}
function safeParse2(schema, data) {
if (isZ4Schema(schema)) {
const result2 = safeParse(schema, data);
return result2;
}
const v3Schema = schema;
const result = v3Schema.safeParse(data);
return result;
}
function getObjectShape(schema) {
if (!schema)
return;
let rawShape;
if (isZ4Schema(schema)) {
const v4Schema = schema;
rawShape = v4Schema._zod?.def?.shape;
} else {
const v3Schema = schema;
rawShape = v3Schema.shape;
}
if (!rawShape)
return;
if (typeof rawShape === "function") {
try {
return rawShape();
} catch {
return;
}
}
return rawShape;
}
function getLiteralValue(schema) {
if (isZ4Schema(schema)) {
const v4Schema = schema;
const def2 = v4Schema._zod?.def;
if (def2) {
if (def2.value !== undefined)
return def2.value;
if (Array.isArray(def2.values) && def2.values.length > 0) {
return def2.values[0];
}
}
}
const v3Schema = schema;
const def = v3Schema._def;
if (def) {
if (def.value !== undefined)
return def.value;
if (Array.isArray(def.values) && def.values.length > 0) {
return def.values[0];
}
}
const directValue = schema.value;
if (directValue !== undefined)
return directValue;
return;
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/classic/iso.js
var exports_iso = {};
__export(exports_iso, {
time: () => time2,
duration: () => duration2,
datetime: () => datetime2,
date: () => date2,
ZodISOTime: () => ZodISOTime,
ZodISODuration: () => ZodISODuration,
ZodISODateTime: () => ZodISODateTime,
ZodISODate: () => ZodISODate
});
var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
$ZodISODateTime.init(inst, def);
ZodStringFormat.init(inst, def);
});
function datetime2(params) {
return _isoDateTime(ZodISODateTime, params);
}
var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
$ZodISODate.init(inst, def);
ZodStringFormat.init(inst, def);
});
function date2(params) {
return _isoDate(ZodISODate, params);
}
var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
$ZodISOTime.init(inst, def);
ZodStringFormat.init(inst, def);
});
function time2(params) {
return _isoTime(ZodISOTime, params);
}
var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
$ZodISODuration.init(inst, def);
ZodStringFormat.init(inst, def);
});
function duration2(params) {
return _isoDuration(ZodISODuration, params);
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/classic/errors.js
var initializer2 = (inst, issues) => {
$ZodError.init(inst, issues);
inst.name = "ZodError";
Object.defineProperties(inst, {
format: {
value: (mapper) => formatError(inst, mapper)
},
flatten: {
value: (mapper) => flattenError(inst, mapper)
},
addIssue: {
value: (issue2) => inst.issues.push(issue2)
},
addIssues: {
value: (issues2) => inst.issues.push(...issues2)
},
isEmpty: {
get() {
return inst.issues.length === 0;
}
}
});
};
var ZodError = $constructor("ZodError", initializer2);
var ZodRealError = $constructor("ZodError", initializer2, {
Parent: Error
});
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/classic/parse.js
var parse3 = /* @__PURE__ */ _parse(ZodRealError);
var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
var safeParse3 = /* @__PURE__ */ _safeParse(ZodRealError);
var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/classic/schemas.js
var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
$ZodType.init(inst, def);
inst.def = def;
Object.defineProperty(inst, "_def", { value: def });
inst.check = (...checks2) => {
return inst.clone({
...def,
checks: [
...def.checks ?? [],
...checks2.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
]
});
};
inst.clone = (def2, params) => clone(inst, def2, params);
inst.brand = () => inst;
inst.register = (reg, meta) => {
reg.add(inst, meta);
return inst;
};
inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
inst.safeParse = (data, params) => safeParse3(inst, data, params);
inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
inst.spa = inst.safeParseAsync;
inst.refine = (check, params) => inst.check(refine(check, params));
inst.superRefine = (refinement) => inst.check(superRefine(refinement));
inst.overwrite = (fn) => inst.check(_overwrite(fn));
inst.optional = () => optional(inst);
inst.nullable = () => nullable(inst);
inst.nullish = () => optional(nullable(inst));
inst.nonoptional = (params) => nonoptional(inst, params);
inst.array = () => array(inst);
inst.or = (arg) => union([inst, arg]);
inst.and = (arg) => intersection(inst, arg);
inst.transform = (tx) => pipe(inst, transform(tx));
inst.default = (def2) => _default(inst, def2);
inst.prefault = (def2) => prefault(inst, def2);
inst.catch = (params) => _catch(inst, params);
inst.pipe = (target) => pipe(inst, target);
inst.readonly = () => readonly(inst);
inst.describe = (description) => {
const cl = inst.clone();
globalRegistry.add(cl, { description });
return cl;
};
Object.defineProperty(inst, "description", {
get() {
return globalRegistry.get(inst)?.description;
},
configurable: true
});
inst.meta = (...args) => {
if (args.length === 0) {
return globalRegistry.get(inst);
}
const cl = inst.clone();
globalRegistry.add(cl, args[0]);
return cl;
};
inst.isOptional = () => inst.safeParse(undefined).success;
inst.isNullable = () => inst.safeParse(null).success;
return inst;
});
var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
$ZodString.init(inst, def);
ZodType.init(inst, def);
const bag = inst._zod.bag;
inst.format = bag.format ?? null;
inst.minLength = bag.minimum ?? null;
inst.maxLength = bag.maximum ?? null;
inst.regex = (...args) => inst.check(_regex(...args));
inst.includes = (...args) => inst.check(_includes(...args));
inst.startsWith = (...args) => inst.check(_startsWith(...args));
inst.endsWith = (...args) => inst.check(_endsWith(...args));
inst.min = (...args) => inst.check(_minLength(...args));
inst.max = (...args) => inst.check(_maxLength(...args));
inst.length = (...args) => inst.check(_length(...args));
inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
inst.lowercase = (params) => inst.check(_lowercase(params));
inst.uppercase = (params) => inst.check(_uppercase(params));
inst.trim = () => inst.check(_trim());
inst.normalize = (...args) => inst.check(_normalize(...args));
inst.toLowerCase = () => inst.check(_toLowerCase());
inst.toUpperCase = () => inst.check(_toUpperCase());
});
var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
$ZodString.init(inst, def);
_ZodString.init(inst, def);
inst.email = (params) => inst.check(_email(ZodEmail, params));
inst.url = (params) => inst.check(_url(ZodURL, params));
inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));
inst.guid = (params) => inst.check(_guid(ZodGUID, params));
inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
inst.guid = (params) => inst.check(_guid(ZodGUID, params));
inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
inst.xid = (params) => inst.check(_xid(ZodXID, params));
inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
inst.e164 = (params) => inst.check(_e164(ZodE164, params));
inst.datetime = (params) => inst.check(datetime2(params));
inst.date = (params) => inst.check(date2(params));
inst.time = (params) => inst.check(time2(params));
inst.duration = (params) => inst.check(duration2(params));
});
function string2(params) {
return _string(ZodString, params);
}
var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
$ZodStringFormat.init(inst, def);
_ZodString.init(inst, def);
});
var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
$ZodEmail.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
$ZodGUID.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
$ZodUUID.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
$ZodURL.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
$ZodEmoji.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
$ZodNanoID.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
$ZodCUID.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
$ZodCUID2.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
$ZodULID.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
$ZodXID.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
$ZodKSUID.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
$ZodIPv4.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
$ZodIPv6.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
$ZodCIDRv4.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
$ZodCIDRv6.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
$ZodBase64.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
$ZodBase64URL.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
$ZodE164.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
$ZodJWT.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
$ZodNumber.init(inst, def);
ZodType.init(inst, def);
inst.gt = (value, params) => inst.check(_gt(value, params));
inst.gte = (value, params) => inst.check(_gte(value, params));
inst.min = (value, params) => inst.check(_gte(value, params));
inst.lt = (value, params) => inst.check(_lt(value, params));
inst.lte = (value, params) => inst.check(_lte(value, params));
inst.max = (value, params) => inst.check(_lte(value, params));
inst.int = (params) => inst.check(int(params));
inst.safe = (params) => inst.check(int(params));
inst.positive = (params) => inst.check(_gt(0, params));
inst.nonnegative = (params) => inst.check(_gte(0, params));
inst.negative = (params) => inst.check(_lt(0, params));
inst.nonpositive = (params) => inst.check(_lte(0, params));
inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
inst.step = (value, params) => inst.check(_multipleOf(value, params));
inst.finite = () => inst;
const bag = inst._zod.bag;
inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
inst.isFinite = true;
inst.format = bag.format ?? null;
});
function number2(params) {
return _number(ZodNumber, params);
}
var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
$ZodNumberFormat.init(inst, def);
ZodNumber.init(inst, def);
});
function int(params) {
return _int(ZodNumberFormat, params);
}
var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
$ZodBoolean.init(inst, def);
ZodType.init(inst, def);
});
function boolean2(params) {
return _boolean(ZodBoolean, params);
}
var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
$ZodNull.init(inst, def);
ZodType.init(inst, def);
});
function _null3(params) {
return _null2(ZodNull, params);
}
var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
$ZodUnknown.init(inst, def);
ZodType.init(inst, def);
});
function unknown() {
return _unknown(ZodUnknown);
}
var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
$ZodNever.init(inst, def);
ZodType.init(inst, def);
});
function never(params) {
return _never(ZodNever, params);
}
var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
$ZodArray.init(inst, def);
ZodType.init(inst, def);
inst.element = def.element;
inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
inst.nonempty = (params) => inst.check(_minLength(1, params));
inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
inst.length = (len, params) => inst.check(_length(len, params));
inst.unwrap = () => inst.element;
});
function array(element, params) {
return _array(ZodArray, element, params);
}
var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
$ZodObject.init(inst, def);
ZodType.init(inst, def);
exports_util.defineLazy(inst, "shape", () => def.shape);
inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
inst.extend = (incoming) => {
return exports_util.extend(inst, incoming);
};
inst.merge = (other) => exports_util.merge(inst, other);
inst.pick = (mask) => exports_util.pick(inst, mask);
inst.omit = (mask) => exports_util.omit(inst, mask);
inst.partial = (...args) => exports_util.partial(ZodOptional, inst, args[0]);
inst.required = (...args) => exports_util.required(ZodNonOptional, inst, args[0]);
});
function object2(shape, params) {
const def = {
type: "object",
get shape() {
exports_util.assignProp(this, "shape", { ...shape });
return this.shape;
},
...exports_util.normalizeParams(params)
};
return new ZodObject(def);
}
function looseObject(shape, params) {
return new ZodObject({
type: "object",
get shape() {
exports_util.assignProp(this, "shape", { ...shape });
return this.shape;
},
catchall: unknown(),
...exports_util.normalizeParams(params)
});
}
var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
$ZodUnion.init(inst, def);
ZodType.init(inst, def);
inst.options = def.options;
});
function union(options, params) {
return new ZodUnion({
type: "union",
options,
...exports_util.normalizeParams(params)
});
}
var ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
ZodUnion.init(inst, def);
$ZodDiscriminatedUnion.init(inst, def);
});
function discriminatedUnion(discriminator, options, params) {
return new ZodDiscriminatedUnion({
type: "union",
options,
discriminator,
...exports_util.normalizeParams(params)
});
}
var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
$ZodIntersection.init(inst, def);
ZodType.init(inst, def);
});
function intersection(left, right) {
return new ZodIntersection({
type: "intersection",
left,
right
});
}
var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
$ZodRecord.init(inst, def);
ZodType.init(inst, def);
inst.keyType = def.keyType;
inst.valueType = def.valueType;
});
function record(keyType, valueType, params) {
return new ZodRecord({
type: "record",
keyType,
valueType,
...exports_util.normalizeParams(params)
});
}
var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
$ZodEnum.init(inst, def);
ZodType.init(inst, def);
inst.enum = def.entries;
inst.options = Object.values(def.entries);
const keys = new Set(Object.keys(def.entries));
inst.extract = (values, params) => {
const newEntries = {};
for (const value of values) {
if (keys.has(value)) {
newEntries[value] = def.entries[value];
} else
throw new Error(`Key ${value} not found in enum`);
}
return new ZodEnum({
...def,
checks: [],
...exports_util.normalizeParams(params),
entries: newEntries
});
};
inst.exclude = (values, params) => {
const newEntries = { ...def.entries };
for (const value of values) {
if (keys.has(value)) {
delete newEntries[value];
} else
throw new Error(`Key ${value} not found in enum`);
}
return new ZodEnum({
...def,
checks: [],
...exports_util.normalizeParams(params),
entries: newEntries
});
};
});
function _enum(values, params) {
const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
return new ZodEnum({
type: "enum",
entries,
...exports_util.normalizeParams(params)
});
}
var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
$ZodLiteral.init(inst, def);
ZodType.init(inst, def);
inst.values = new Set(def.values);
Object.defineProperty(inst, "value", {
get() {
if (def.values.length > 1) {
throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
}
return def.values[0];
}
});
});
function literal(value, params) {
return new ZodLiteral({
type: "literal",
values: Array.isArray(value) ? value : [value],
...exports_util.normalizeParams(params)
});
}
var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
$ZodTransform.init(inst, def);
ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
payload.addIssue = (issue2) => {
if (typeof issue2 === "string") {
payload.issues.push(exports_util.issue(issue2, payload.value, def));
} else {
const _issue = issue2;
if (_issue.fatal)
_issue.continue = false;
_issue.code ?? (_issue.code = "custom");
_issue.input ?? (_issue.input = payload.value);
_issue.inst ?? (_issue.inst = inst);
_issue.continue ?? (_issue.continue = true);
payload.issues.push(exports_util.issue(_issue));
}
};
const output = def.transform(payload.value, payload);
if (output instanceof Promise) {
return output.then((output2) => {
payload.value = output2;
return payload;
});
}
payload.value = output;
return payload;
};
});
function transform(fn) {
return new ZodTransform({
type: "transform",
transform: fn
});
}
var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
$ZodOptional.init(inst, def);
ZodType.init(inst, def);
inst.unwrap = () => inst._zod.def.innerType;
});
function optional(innerType) {
return new ZodOptional({
type: "optional",
innerType
});
}
var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
$ZodNullable.init(inst, def);
ZodType.init(inst, def);
inst.unwrap = () => inst._zod.def.innerType;
});
function nullable(innerType) {
return new ZodNullable({
type: "nullable",
innerType
});
}
var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
$ZodDefault.init(inst, def);
ZodType.init(inst, def);
inst.unwrap = () => inst._zod.def.innerType;
inst.removeDefault = inst.unwrap;
});
function _default(innerType, defaultValue) {
return new ZodDefault({
type: "default",
innerType,
get defaultValue() {
return typeof defaultValue === "function" ? defaultValue() : defaultValue;
}
});
}
var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
$ZodPrefault.init(inst, def);
ZodType.init(inst, def);
inst.unwrap = () => inst._zod.def.innerType;
});
function prefault(innerType, defaultValue) {
return new ZodPrefault({
type: "prefault",
innerType,
get defaultValue() {
return typeof defaultValue === "function" ? defaultValue() : defaultValue;
}
});
}
var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
$ZodNonOptional.init(inst, def);
ZodType.init(inst, def);
inst.unwrap = () => inst._zod.def.innerType;
});
function nonoptional(innerType, params) {
return new ZodNonOptional({
type: "nonoptional",
innerType,
...exports_util.normalizeParams(params)
});
}
var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
$ZodCatch.init(inst, def);
ZodType.init(inst, def);
inst.unwrap = () => inst._zod.def.innerType;
inst.removeCatch = inst.unwrap;
});
function _catch(innerType, catchValue) {
return new ZodCatch({
type: "catch",
innerType,
catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
});
}
var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
$ZodPipe.init(inst, def);
ZodType.init(inst, def);
inst.in = def.in;
inst.out = def.out;
});
function pipe(in_, out) {
return new ZodPipe({
type: "pipe",
in: in_,
out
});
}
var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
$ZodReadonly.init(inst, def);
ZodType.init(inst, def);
});
function readonly(innerType) {
return new ZodReadonly({
type: "readonly",
innerType
});
}
var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
$ZodCustom.init(inst, def);
ZodType.init(inst, def);
});
function check(fn) {
const ch = new $ZodCheck({
check: "custom"
});
ch._zod.check = fn;
return ch;
}
function custom(fn, _params) {
return _custom(ZodCustom, fn ?? (() => true), _params);
}
function refine(fn, _params = {}) {
return _refine(ZodCustom, fn, _params);
}
function superRefine(fn) {
const ch = check((payload) => {
payload.addIssue = (issue2) => {
if (typeof issue2 === "string") {
payload.issues.push(exports_util.issue(issue2, payload.value, ch._zod.def));
} else {
const _issue = issue2;
if (_issue.fatal)
_issue.continue = false;
_issue.code ?? (_issue.code = "custom");
_issue.input ?? (_issue.input = payload.value);
_issue.inst ?? (_issue.inst = ch);
_issue.continue ?? (_issue.continue = !ch._zod.def.abort);
payload.issues.push(exports_util.issue(_issue));
}
};
return fn(payload.value, payload);
});
return ch;
}
function preprocess(fn, schema) {
return pipe(transform(fn), schema);
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/classic/external.js
config(en_default());
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
var LATEST_PROTOCOL_VERSION = "2025-11-25";
var DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
var JSONRPC_VERSION = "2.0";
var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
var ProgressTokenSchema = union([string2(), number2().int()]);
var CursorSchema = string2();
var TaskCreationParamsSchema = looseObject({
ttl: number2().optional(),
pollInterval: number2().optional()
});
var TaskMetadataSchema = object2({
ttl: number2().optional()
});
var RelatedTaskMetadataSchema = object2({
taskId: string2()
});
var RequestMetaSchema = looseObject({
progressToken: ProgressTokenSchema.optional(),
[RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
});
var BaseRequestParamsSchema = object2({
_meta: RequestMetaSchema.optional()
});
var TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({
task: TaskMetadataSchema.optional()
});
var isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success;
var RequestSchema = object2({
method: string2(),
params: BaseRequestParamsSchema.loose().optional()
});
var NotificationsParamsSchema = object2({
_meta: RequestMetaSchema.optional()
});
var NotificationSchema = object2({
method: string2(),
params: NotificationsParamsSchema.loose().optional()
});
var ResultSchema = looseObject({
_meta: RequestMetaSchema.optional()
});
var RequestIdSchema = union([string2(), number2().int()]);
var JSONRPCRequestSchema = object2({
jsonrpc: literal(JSONRPC_VERSION),
id: RequestIdSchema,
...RequestSchema.shape
}).strict();
var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
var JSONRPCNotificationSchema = object2({
jsonrpc: literal(JSONRPC_VERSION),
...NotificationSchema.shape
}).strict();
var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
var JSONRPCResultResponseSchema = object2({
jsonrpc: literal(JSONRPC_VERSION),
id: RequestIdSchema,
result: ResultSchema
}).strict();
var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
var ErrorCode;
(function(ErrorCode2) {
ErrorCode2[ErrorCode2["ConnectionClosed"] = -32000] = "ConnectionClosed";
ErrorCode2[ErrorCode2["RequestTimeout"] = -32001] = "RequestTimeout";
ErrorCode2[ErrorCode2["ParseError"] = -32700] = "ParseError";
ErrorCode2[ErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest";
ErrorCode2[ErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
ErrorCode2[ErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
ErrorCode2[ErrorCode2["InternalError"] = -32603] = "InternalError";
ErrorCode2[ErrorCode2["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
})(ErrorCode || (ErrorCode = {}));
var JSONRPCErrorResponseSchema = object2({
jsonrpc: literal(JSONRPC_VERSION),
id: RequestIdSchema.optional(),
error: object2({
code: number2().int(),
message: string2(),
data: unknown().optional()
})
}).strict();
var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
var JSONRPCMessageSchema = union([
JSONRPCRequestSchema,
JSONRPCNotificationSchema,
JSONRPCResultResponseSchema,
JSONRPCErrorResponseSchema
]);
var JSONRPCResponseSchema = union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
var EmptyResultSchema = ResultSchema.strict();
var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
requestId: RequestIdSchema.optional(),
reason: string2().optional()
});
var CancelledNotificationSchema = NotificationSchema.extend({
method: literal("notifications/cancelled"),
params: CancelledNotificationParamsSchema
});
var IconSchema = object2({
src: string2(),
mimeType: string2().optional(),
sizes: array(string2()).optional(),
theme: _enum(["light", "dark"]).optional()
});
var IconsSchema = object2({
icons: array(IconSchema).optional()
});
var BaseMetadataSchema = object2({
name: string2(),
title: string2().optional()
});
var ImplementationSchema = BaseMetadataSchema.extend({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
version: string2(),
websiteUrl: string2().optional(),
description: string2().optional()
});
var FormElicitationCapabilitySchema = intersection(object2({
applyDefaults: boolean2().optional()
}), record(string2(), unknown()));
var ElicitationCapabilitySchema = preprocess((value) => {
if (value && typeof value === "object" && !Array.isArray(value)) {
if (Object.keys(value).length === 0) {
return { form: {} };
}
}
return value;
}, intersection(object2({
form: FormElicitationCapabilitySchema.optional(),
url: AssertObjectSchema.optional()
}), record(string2(), unknown()).optional()));
var ClientTasksCapabilitySchema = looseObject({
list: AssertObjectSchema.optional(),
cancel: AssertObjectSchema.optional(),
requests: looseObject({
sampling: looseObject({
createMessage: AssertObjectSchema.optional()
}).optional(),
elicitation: looseObject({
create: AssertObjectSchema.optional()
}).optional()
}).optional()
});
var ServerTasksCapabilitySchema = looseObject({
list: AssertObjectSchema.optional(),
cancel: AssertObjectSchema.optional(),
requests: looseObject({
tools: looseObject({
call: AssertObjectSchema.optional()
}).optional()
}).optional()
});
var ClientCapabilitiesSchema = object2({
experimental: record(string2(), AssertObjectSchema).optional(),
sampling: object2({
context: AssertObjectSchema.optional(),
tools: AssertObjectSchema.optional()
}).optional(),
elicitation: ElicitationCapabilitySchema.optional(),
roots: object2({
listChanged: boolean2().optional()
}).optional(),
tasks: ClientTasksCapabilitySchema.optional(),
extensions: record(string2(), AssertObjectSchema).optional()
});
var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
protocolVersion: string2(),
capabilities: ClientCapabilitiesSchema,
clientInfo: ImplementationSchema
});
var InitializeRequestSchema = RequestSchema.extend({
method: literal("initialize"),
params: InitializeRequestParamsSchema
});
var isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
var ServerCapabilitiesSchema = object2({
experimental: record(string2(), AssertObjectSchema).optional(),
logging: AssertObjectSchema.optional(),
completions: AssertObjectSchema.optional(),
prompts: object2({
listChanged: boolean2().optional()
}).optional(),
resources: object2({
subscribe: boolean2().optional(),
listChanged: boolean2().optional()
}).optional(),
tools: object2({
listChanged: boolean2().optional()
}).optional(),
tasks: ServerTasksCapabilitySchema.optional(),
extensions: record(string2(), AssertObjectSchema).optional()
});
var InitializeResultSchema = ResultSchema.extend({
protocolVersion: string2(),
capabilities: ServerCapabilitiesSchema,
serverInfo: ImplementationSchema,
instructions: string2().optional()
});
var InitializedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/initialized"),
params: NotificationsParamsSchema.optional()
});
var PingRequestSchema = RequestSchema.extend({
method: literal("ping"),
params: BaseRequestParamsSchema.optional()
});
var ProgressSchema = object2({
progress: number2(),
total: optional(number2()),
message: optional(string2())
});
var ProgressNotificationParamsSchema = object2({
...NotificationsParamsSchema.shape,
...ProgressSchema.shape,
progressToken: ProgressTokenSchema
});
var ProgressNotificationSchema = NotificationSchema.extend({
method: literal("notifications/progress"),
params: ProgressNotificationParamsSchema
});
var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({
cursor: CursorSchema.optional()
});
var PaginatedRequestSchema = RequestSchema.extend({
params: PaginatedRequestParamsSchema.optional()
});
var PaginatedResultSchema = ResultSchema.extend({
nextCursor: CursorSchema.optional()
});
var TaskStatusSchema = _enum(["working", "input_required", "completed", "failed", "cancelled"]);
var TaskSchema = object2({
taskId: string2(),
status: TaskStatusSchema,
ttl: union([number2(), _null3()]),
createdAt: string2(),
lastUpdatedAt: string2(),
pollInterval: optional(number2()),
statusMessage: optional(string2())
});
var CreateTaskResultSchema = ResultSchema.extend({
task: TaskSchema
});
var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
var TaskStatusNotificationSchema = NotificationSchema.extend({
method: literal("notifications/tasks/status"),
params: TaskStatusNotificationParamsSchema
});
var GetTaskRequestSchema = RequestSchema.extend({
method: literal("tasks/get"),
params: BaseRequestParamsSchema.extend({
taskId: string2()
})
});
var GetTaskResultSchema = ResultSchema.merge(TaskSchema);
var GetTaskPayloadRequestSchema = RequestSchema.extend({
method: literal("tasks/result"),
params: BaseRequestParamsSchema.extend({
taskId: string2()
})
});
var GetTaskPayloadResultSchema = ResultSchema.loose();
var ListTasksRequestSchema = PaginatedRequestSchema.extend({
method: literal("tasks/list")
});
var ListTasksResultSchema = PaginatedResultSchema.extend({
tasks: array(TaskSchema)
});
var CancelTaskRequestSchema = RequestSchema.extend({
method: literal("tasks/cancel"),
params: BaseRequestParamsSchema.extend({
taskId: string2()
})
});
var CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
var ResourceContentsSchema = object2({
uri: string2(),
mimeType: optional(string2()),
_meta: record(string2(), unknown()).optional()
});
var TextResourceContentsSchema = ResourceContentsSchema.extend({
text: string2()
});
var Base64Schema = string2().refine((val) => {
try {
atob(val);
return true;
} catch {
return false;
}
}, { message: "Invalid Base64 string" });
var BlobResourceContentsSchema = ResourceContentsSchema.extend({
blob: Base64Schema
});
var RoleSchema = _enum(["user", "assistant"]);
var AnnotationsSchema = object2({
audience: array(RoleSchema).optional(),
priority: number2().min(0).max(1).optional(),
lastModified: exports_iso.datetime({ offset: true }).optional()
});
var ResourceSchema = object2({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
uri: string2(),
description: optional(string2()),
mimeType: optional(string2()),
size: optional(number2()),
annotations: AnnotationsSchema.optional(),
_meta: optional(looseObject({}))
});
var ResourceTemplateSchema = object2({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
uriTemplate: string2(),
description: optional(string2()),
mimeType: optional(string2()),
annotations: AnnotationsSchema.optional(),
_meta: optional(looseObject({}))
});
var ListResourcesRequestSchema = PaginatedRequestSchema.extend({
method: literal("resources/list")
});
var ListResourcesResultSchema = PaginatedResultSchema.extend({
resources: array(ResourceSchema)
});
var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({
method: literal("resources/templates/list")
});
var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({
resourceTemplates: array(ResourceTemplateSchema)
});
var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({
uri: string2()
});
var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
var ReadResourceRequestSchema = RequestSchema.extend({
method: literal("resources/read"),
params: ReadResourceRequestParamsSchema
});
var ReadResourceResultSchema = ResultSchema.extend({
contents: array(union([TextResourceContentsSchema, BlobResourceContentsSchema]))
});
var ResourceListChangedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/resources/list_changed"),
params: NotificationsParamsSchema.optional()
});
var SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
var SubscribeRequestSchema = RequestSchema.extend({
method: literal("resources/subscribe"),
params: SubscribeRequestParamsSchema
});
var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
var UnsubscribeRequestSchema = RequestSchema.extend({
method: literal("resources/unsubscribe"),
params: UnsubscribeRequestParamsSchema
});
var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({
uri: string2()
});
var ResourceUpdatedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/resources/updated"),
params: ResourceUpdatedNotificationParamsSchema
});
var PromptArgumentSchema = object2({
name: string2(),
description: optional(string2()),
required: optional(boolean2())
});
var PromptSchema = object2({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
description: optional(string2()),
arguments: optional(array(PromptArgumentSchema)),
_meta: optional(looseObject({}))
});
var ListPromptsRequestSchema = PaginatedRequestSchema.extend({
method: literal("prompts/list")
});
var ListPromptsResultSchema = PaginatedResultSchema.extend({
prompts: array(PromptSchema)
});
var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
name: string2(),
arguments: record(string2(), string2()).optional()
});
var GetPromptRequestSchema = RequestSchema.extend({
method: literal("prompts/get"),
params: GetPromptRequestParamsSchema
});
var TextContentSchema = object2({
type: literal("text"),
text: string2(),
annotations: AnnotationsSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var ImageContentSchema = object2({
type: literal("image"),
data: Base64Schema,
mimeType: string2(),
annotations: AnnotationsSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var AudioContentSchema = object2({
type: literal("audio"),
data: Base64Schema,
mimeType: string2(),
annotations: AnnotationsSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var ToolUseContentSchema = object2({
type: literal("tool_use"),
name: string2(),
id: string2(),
input: record(string2(), unknown()),
_meta: record(string2(), unknown()).optional()
});
var EmbeddedResourceSchema = object2({
type: literal("resource"),
resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
annotations: AnnotationsSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var ResourceLinkSchema = ResourceSchema.extend({
type: literal("resource_link")
});
var ContentBlockSchema = union([
TextContentSchema,
ImageContentSchema,
AudioContentSchema,
ResourceLinkSchema,
EmbeddedResourceSchema
]);
var PromptMessageSchema = object2({
role: RoleSchema,
content: ContentBlockSchema
});
var GetPromptResultSchema = ResultSchema.extend({
description: string2().optional(),
messages: array(PromptMessageSchema)
});
var PromptListChangedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/prompts/list_changed"),
params: NotificationsParamsSchema.optional()
});
var ToolAnnotationsSchema = object2({
title: string2().optional(),
readOnlyHint: boolean2().optional(),
destructiveHint: boolean2().optional(),
idempotentHint: boolean2().optional(),
openWorldHint: boolean2().optional()
});
var ToolExecutionSchema = object2({
taskSupport: _enum(["required", "optional", "forbidden"]).optional()
});
var ToolSchema = object2({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
description: string2().optional(),
inputSchema: object2({
type: literal("object"),
properties: record(string2(), AssertObjectSchema).optional(),
required: array(string2()).optional()
}).catchall(unknown()),
outputSchema: object2({
type: literal("object"),
properties: record(string2(), AssertObjectSchema).optional(),
required: array(string2()).optional()
}).catchall(unknown()).optional(),
annotations: ToolAnnotationsSchema.optional(),
execution: ToolExecutionSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var ListToolsRequestSchema = PaginatedRequestSchema.extend({
method: literal("tools/list")
});
var ListToolsResultSchema = PaginatedResultSchema.extend({
tools: array(ToolSchema)
});
var CallToolResultSchema = ResultSchema.extend({
content: array(ContentBlockSchema).default([]),
structuredContent: record(string2(), unknown()).optional(),
isError: boolean2().optional()
});
var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({
toolResult: unknown()
}));
var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
name: string2(),
arguments: record(string2(), unknown()).optional()
});
var CallToolRequestSchema = RequestSchema.extend({
method: literal("tools/call"),
params: CallToolRequestParamsSchema
});
var ToolListChangedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/tools/list_changed"),
params: NotificationsParamsSchema.optional()
});
var ListChangedOptionsBaseSchema = object2({
autoRefresh: boolean2().default(true),
debounceMs: number2().int().nonnegative().default(300)
});
var LoggingLevelSchema = _enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({
level: LoggingLevelSchema
});
var SetLevelRequestSchema = RequestSchema.extend({
method: literal("logging/setLevel"),
params: SetLevelRequestParamsSchema
});
var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
level: LoggingLevelSchema,
logger: string2().optional(),
data: unknown()
});
var LoggingMessageNotificationSchema = NotificationSchema.extend({
method: literal("notifications/message"),
params: LoggingMessageNotificationParamsSchema
});
var ModelHintSchema = object2({
name: string2().optional()
});
var ModelPreferencesSchema = object2({
hints: array(ModelHintSchema).optional(),
costPriority: number2().min(0).max(1).optional(),
speedPriority: number2().min(0).max(1).optional(),
intelligencePriority: number2().min(0).max(1).optional()
});
var ToolChoiceSchema = object2({
mode: _enum(["auto", "required", "none"]).optional()
});
var ToolResultContentSchema = object2({
type: literal("tool_result"),
toolUseId: string2().describe("The unique identifier for the corresponding tool call."),
content: array(ContentBlockSchema).default([]),
structuredContent: object2({}).loose().optional(),
isError: boolean2().optional(),
_meta: record(string2(), unknown()).optional()
});
var SamplingContentSchema = discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
var SamplingMessageContentBlockSchema = discriminatedUnion("type", [
TextContentSchema,
ImageContentSchema,
AudioContentSchema,
ToolUseContentSchema,
ToolResultContentSchema
]);
var SamplingMessageSchema = object2({
role: RoleSchema,
content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]),
_meta: record(string2(), unknown()).optional()
});
var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
messages: array(SamplingMessageSchema),
modelPreferences: ModelPreferencesSchema.optional(),
systemPrompt: string2().optional(),
includeContext: _enum(["none", "thisServer", "allServers"]).optional(),
temperature: number2().optional(),
maxTokens: number2().int(),
stopSequences: array(string2()).optional(),
metadata: AssertObjectSchema.optional(),
tools: array(ToolSchema).optional(),
toolChoice: ToolChoiceSchema.optional()
});
var CreateMessageRequestSchema = RequestSchema.extend({
method: literal("sampling/createMessage"),
params: CreateMessageRequestParamsSchema
});
var CreateMessageResultSchema = ResultSchema.extend({
model: string2(),
stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens"]).or(string2())),
role: RoleSchema,
content: SamplingContentSchema
});
var CreateMessageResultWithToolsSchema = ResultSchema.extend({
model: string2(),
stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string2())),
role: RoleSchema,
content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
});
var BooleanSchemaSchema = object2({
type: literal("boolean"),
title: string2().optional(),
description: string2().optional(),
default: boolean2().optional()
});
var StringSchemaSchema = object2({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
minLength: number2().optional(),
maxLength: number2().optional(),
format: _enum(["email", "uri", "date", "date-time"]).optional(),
default: string2().optional()
});
var NumberSchemaSchema = object2({
type: _enum(["number", "integer"]),
title: string2().optional(),
description: string2().optional(),
minimum: number2().optional(),
maximum: number2().optional(),
default: number2().optional()
});
var UntitledSingleSelectEnumSchemaSchema = object2({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
enum: array(string2()),
default: string2().optional()
});
var TitledSingleSelectEnumSchemaSchema = object2({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
oneOf: array(object2({
const: string2(),
title: string2()
})),
default: string2().optional()
});
var LegacyTitledEnumSchemaSchema = object2({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
enum: array(string2()),
enumNames: array(string2()).optional(),
default: string2().optional()
});
var SingleSelectEnumSchemaSchema = union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
var UntitledMultiSelectEnumSchemaSchema = object2({
type: literal("array"),
title: string2().optional(),
description: string2().optional(),
minItems: number2().optional(),
maxItems: number2().optional(),
items: object2({
type: literal("string"),
enum: array(string2())
}),
default: array(string2()).optional()
});
var TitledMultiSelectEnumSchemaSchema = object2({
type: literal("array"),
title: string2().optional(),
description: string2().optional(),
minItems: number2().optional(),
maxItems: number2().optional(),
items: object2({
anyOf: array(object2({
const: string2(),
title: string2()
}))
}),
default: array(string2()).optional()
});
var MultiSelectEnumSchemaSchema = union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
var EnumSchemaSchema = union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]);
var PrimitiveSchemaDefinitionSchema = union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]);
var ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
mode: literal("form").optional(),
message: string2(),
requestedSchema: object2({
type: literal("object"),
properties: record(string2(), PrimitiveSchemaDefinitionSchema),
required: array(string2()).optional()
})
});
var ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
mode: literal("url"),
message: string2(),
elicitationId: string2(),
url: string2().url()
});
var ElicitRequestParamsSchema = union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
var ElicitRequestSchema = RequestSchema.extend({
method: literal("elicitation/create"),
params: ElicitRequestParamsSchema
});
var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({
elicitationId: string2()
});
var ElicitationCompleteNotificationSchema = NotificationSchema.extend({
method: literal("notifications/elicitation/complete"),
params: ElicitationCompleteNotificationParamsSchema
});
var ElicitResultSchema = ResultSchema.extend({
action: _enum(["accept", "decline", "cancel"]),
content: preprocess((val) => val === null ? undefined : val, record(string2(), union([string2(), number2(), boolean2(), array(string2())])).optional())
});
var ResourceTemplateReferenceSchema = object2({
type: literal("ref/resource"),
uri: string2()
});
var PromptReferenceSchema = object2({
type: literal("ref/prompt"),
name: string2()
});
var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
ref: union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
argument: object2({
name: string2(),
value: string2()
}),
context: object2({
arguments: record(string2(), string2()).optional()
}).optional()
});
var CompleteRequestSchema = RequestSchema.extend({
method: literal("completion/complete"),
params: CompleteRequestParamsSchema
});
var CompleteResultSchema = ResultSchema.extend({
completion: looseObject({
values: array(string2()).max(100),
total: optional(number2().int()),
hasMore: optional(boolean2())
})
});
var RootSchema = object2({
uri: string2().startsWith("file://"),
name: string2().optional(),
_meta: record(string2(), unknown()).optional()
});
var ListRootsRequestSchema = RequestSchema.extend({
method: literal("roots/list"),
params: BaseRequestParamsSchema.optional()
});
var ListRootsResultSchema = ResultSchema.extend({
roots: array(RootSchema)
});
var RootsListChangedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/roots/list_changed"),
params: NotificationsParamsSchema.optional()
});
var ClientRequestSchema = union([
PingRequestSchema,
InitializeRequestSchema,
CompleteRequestSchema,
SetLevelRequestSchema,
GetPromptRequestSchema,
ListPromptsRequestSchema,
ListResourcesRequestSchema,
ListResourceTemplatesRequestSchema,
ReadResourceRequestSchema,
SubscribeRequestSchema,
UnsubscribeRequestSchema,
CallToolRequestSchema,
ListToolsRequestSchema,
GetTaskRequestSchema,
GetTaskPayloadRequestSchema,
ListTasksRequestSchema,
CancelTaskRequestSchema
]);
var ClientNotificationSchema = union([
CancelledNotificationSchema,
ProgressNotificationSchema,
InitializedNotificationSchema,
RootsListChangedNotificationSchema,
TaskStatusNotificationSchema
]);
var ClientResultSchema = union([
EmptyResultSchema,
CreateMessageResultSchema,
CreateMessageResultWithToolsSchema,
ElicitResultSchema,
ListRootsResultSchema,
GetTaskResultSchema,
ListTasksResultSchema,
CreateTaskResultSchema
]);
var ServerRequestSchema = union([
PingRequestSchema,
CreateMessageRequestSchema,
ElicitRequestSchema,
ListRootsRequestSchema,
GetTaskRequestSchema,
GetTaskPayloadRequestSchema,
ListTasksRequestSchema,
CancelTaskRequestSchema
]);
var ServerNotificationSchema = union([
CancelledNotificationSchema,
ProgressNotificationSchema,
LoggingMessageNotificationSchema,
ResourceUpdatedNotificationSchema,
ResourceListChangedNotificationSchema,
ToolListChangedNotificationSchema,
PromptListChangedNotificationSchema,
TaskStatusNotificationSchema,
ElicitationCompleteNotificationSchema
]);
var ServerResultSchema = union([
EmptyResultSchema,
InitializeResultSchema,
CompleteResultSchema,
GetPromptResultSchema,
ListPromptsResultSchema,
ListResourcesResultSchema,
ListResourceTemplatesResultSchema,
ReadResourceResultSchema,
CallToolResultSchema,
ListToolsResultSchema,
GetTaskResultSchema,
ListTasksResultSchema,
CreateTaskResultSchema
]);
class McpError extends Error {
constructor(code, message, data) {
super(`MCP error ${code}: ${message}`);
this.code = code;
this.data = data;
this.name = "McpError";
}
static fromError(code, message, data) {
if (code === ErrorCode.UrlElicitationRequired && data) {
const errorData = data;
if (errorData.elicitations) {
return new UrlElicitationRequiredError(errorData.elicitations, message);
}
}
return new McpError(code, message, data);
}
}
class UrlElicitationRequiredError extends McpError {
constructor(elicitations, message = `URL elicitation${elicitations.length > 1 ? "s" : ""} required`) {
super(ErrorCode.UrlElicitationRequired, message, {
elicitations
});
}
get elicitations() {
return this.data?.elicitations ?? [];
}
}
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
function isTerminal(status) {
return status === "completed" || status === "failed" || status === "cancelled";
}
// ../../node_modules/.bun/zod-to-json-schema@3.25.2+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/Options.js
var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
// ../../node_modules/.bun/zod-to-json-schema@3.25.2+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
function getMethodLiteral(schema) {
const shape = getObjectShape(schema);
const methodSchema = shape?.method;
if (!methodSchema) {
throw new Error("Schema is missing a method literal");
}
const value = getLiteralValue(methodSchema);
if (typeof value !== "string") {
throw new Error("Schema method literal must be a string");
}
return value;
}
function parseWithCompat(schema, data) {
const result = safeParse2(schema, data);
if (!result.success) {
throw result.error;
}
return result.data;
}
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
var DEFAULT_REQUEST_TIMEOUT_MSEC = 60000;
class Protocol {
constructor(_options) {
this._options = _options;
this._requestMessageId = 0;
this._requestHandlers = new Map;
this._requestHandlerAbortControllers = new Map;
this._notificationHandlers = new Map;
this._responseHandlers = new Map;
this._progressHandlers = new Map;
this._timeoutInfo = new Map;
this._pendingDebouncedNotifications = new Set;
this._taskProgressTokens = new Map;
this._requestResolvers = new Map;
this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
this._oncancel(notification);
});
this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
this._onprogress(notification);
});
this.setRequestHandler(PingRequestSchema, (_request) => ({}));
this._taskStore = _options?.taskStore;
this._taskMessageQueue = _options?.taskMessageQueue;
if (this._taskStore) {
this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
if (!task) {
throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
}
return {
...task
};
});
this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
const handleTaskResult = async () => {
const taskId = request.params.taskId;
if (this._taskMessageQueue) {
let queuedMessage;
while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
if (queuedMessage.type === "response" || queuedMessage.type === "error") {
const message = queuedMessage.message;
const requestId = message.id;
const resolver = this._requestResolvers.get(requestId);
if (resolver) {
this._requestResolvers.delete(requestId);
if (queuedMessage.type === "response") {
resolver(message);
} else {
const errorMessage2 = message;
const error2 = new McpError(errorMessage2.error.code, errorMessage2.error.message, errorMessage2.error.data);
resolver(error2);
}
} else {
const messageType = queuedMessage.type === "response" ? "Response" : "Error";
this._onerror(new Error(`${messageType} handler missing for request ${requestId}`));
}
continue;
}
await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
}
}
const task = await this._taskStore.getTask(taskId, extra.sessionId);
if (!task) {
throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
}
if (!isTerminal(task.status)) {
await this._waitForTaskUpdate(taskId, extra.signal);
return await handleTaskResult();
}
if (isTerminal(task.status)) {
const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
this._clearTaskQueue(taskId);
return {
...result,
_meta: {
...result._meta,
[RELATED_TASK_META_KEY]: {
taskId
}
}
};
}
return await handleTaskResult();
};
return await handleTaskResult();
});
this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
try {
const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
return {
tasks,
nextCursor,
_meta: {}
};
} catch (error2) {
throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error2 instanceof Error ? error2.message : String(error2)}`);
}
});
this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
try {
const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
if (!task) {
throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
}
if (isTerminal(task.status)) {
throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
}
await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
this._clearTaskQueue(request.params.taskId);
const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
if (!cancelledTask) {
throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
}
return {
_meta: {},
...cancelledTask
};
} catch (error2) {
if (error2 instanceof McpError) {
throw error2;
}
throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error2 instanceof Error ? error2.message : String(error2)}`);
}
});
}
}
async _oncancel(notification) {
if (!notification.params.requestId) {
return;
}
const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
controller?.abort(notification.params.reason);
}
_setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
this._timeoutInfo.set(messageId, {
timeoutId: setTimeout(onTimeout, timeout),
startTime: Date.now(),
timeout,
maxTotalTimeout,
resetTimeoutOnProgress,
onTimeout
});
}
_resetTimeout(messageId) {
const info = this._timeoutInfo.get(messageId);
if (!info)
return false;
const totalElapsed = Date.now() - info.startTime;
if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
this._timeoutInfo.delete(messageId);
throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
maxTotalTimeout: info.maxTotalTimeout,
totalElapsed
});
}
clearTimeout(info.timeoutId);
info.timeoutId = setTimeout(info.onTimeout, info.timeout);
return true;
}
_cleanupTimeout(messageId) {
const info = this._timeoutInfo.get(messageId);
if (info) {
clearTimeout(info.timeoutId);
this._timeoutInfo.delete(messageId);
}
}
async connect(transport) {
if (this._transport) {
throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.");
}
this._transport = transport;
const _onclose = this.transport?.onclose;
this._transport.onclose = () => {
_onclose?.();
this._onclose();
};
const _onerror = this.transport?.onerror;
this._transport.onerror = (error2) => {
_onerror?.(error2);
this._onerror(error2);
};
const _onmessage = this._transport?.onmessage;
this._transport.onmessage = (message, extra) => {
_onmessage?.(message, extra);
if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
this._onresponse(message);
} else if (isJSONRPCRequest(message)) {
this._onrequest(message, extra);
} else if (isJSONRPCNotification(message)) {
this._onnotification(message);
} else {
this._onerror(new Error(`Unknown message type: ${JSON.stringify(message)}`));
}
};
await this._transport.start();
}
_onclose() {
const responseHandlers = this._responseHandlers;
this._responseHandlers = new Map;
this._progressHandlers.clear();
this._taskProgressTokens.clear();
this._pendingDebouncedNotifications.clear();
for (const info of this._timeoutInfo.values()) {
clearTimeout(info.timeoutId);
}
this._timeoutInfo.clear();
for (const controller of this._requestHandlerAbortControllers.values()) {
controller.abort();
}
this._requestHandlerAbortControllers.clear();
const error2 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
this._transport = undefined;
this.onclose?.();
for (const handler of responseHandlers.values()) {
handler(error2);
}
}
_onerror(error2) {
this.onerror?.(error2);
}
_onnotification(notification) {
const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
if (handler === undefined) {
return;
}
Promise.resolve().then(() => handler(notification)).catch((error2) => this._onerror(new Error(`Uncaught error in notification handler: ${error2}`)));
}
_onrequest(request, extra) {
const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
const capturedTransport = this._transport;
const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
if (handler === undefined) {
const errorResponse2 = {
jsonrpc: "2.0",
id: request.id,
error: {
code: ErrorCode.MethodNotFound,
message: "Method not found"
}
};
if (relatedTaskId && this._taskMessageQueue) {
this._enqueueTaskMessage(relatedTaskId, {
type: "error",
message: errorResponse2,
timestamp: Date.now()
}, capturedTransport?.sessionId).catch((error2) => this._onerror(new Error(`Failed to enqueue error response: ${error2}`)));
} else {
capturedTransport?.send(errorResponse2).catch((error2) => this._onerror(new Error(`Failed to send an error response: ${error2}`)));
}
return;
}
const abortController = new AbortController;
this._requestHandlerAbortControllers.set(request.id, abortController);
const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : undefined;
const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : undefined;
const fullExtra = {
signal: abortController.signal,
sessionId: capturedTransport?.sessionId,
_meta: request.params?._meta,
sendNotification: async (notification) => {
if (abortController.signal.aborted)
return;
const notificationOptions = { relatedRequestId: request.id };
if (relatedTaskId) {
notificationOptions.relatedTask = { taskId: relatedTaskId };
}
await this.notification(notification, notificationOptions);
},
sendRequest: async (r, resultSchema, options) => {
if (abortController.signal.aborted) {
throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
}
const requestOptions = { ...options, relatedRequestId: request.id };
if (relatedTaskId && !requestOptions.relatedTask) {
requestOptions.relatedTask = { taskId: relatedTaskId };
}
const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
if (effectiveTaskId && taskStore) {
await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
}
return await this.request(r, resultSchema, requestOptions);
},
authInfo: extra?.authInfo,
requestId: request.id,
requestInfo: extra?.requestInfo,
taskId: relatedTaskId,
taskStore,
taskRequestedTtl: taskCreationParams?.ttl,
closeSSEStream: extra?.closeSSEStream,
closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
};
Promise.resolve().then(() => {
if (taskCreationParams) {
this.assertTaskHandlerCapability(request.method);
}
}).then(() => handler(request, fullExtra)).then(async (result) => {
if (abortController.signal.aborted) {
return;
}
const response = {
result,
jsonrpc: "2.0",
id: request.id
};
if (relatedTaskId && this._taskMessageQueue) {
await this._enqueueTaskMessage(relatedTaskId, {
type: "response",
message: response,
timestamp: Date.now()
}, capturedTransport?.sessionId);
} else {
await capturedTransport?.send(response);
}
}, async (error2) => {
if (abortController.signal.aborted) {
return;
}
const errorResponse2 = {
jsonrpc: "2.0",
id: request.id,
error: {
code: Number.isSafeInteger(error2["code"]) ? error2["code"] : ErrorCode.InternalError,
message: error2.message ?? "Internal error",
...error2["data"] !== undefined && { data: error2["data"] }
}
};
if (relatedTaskId && this._taskMessageQueue) {
await this._enqueueTaskMessage(relatedTaskId, {
type: "error",
message: errorResponse2,
timestamp: Date.now()
}, capturedTransport?.sessionId);
} else {
await capturedTransport?.send(errorResponse2);
}
}).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
this._requestHandlerAbortControllers.delete(request.id);
}
});
}
_onprogress(notification) {
const { progressToken, ...params } = notification.params;
const messageId = Number(progressToken);
const handler = this._progressHandlers.get(messageId);
if (!handler) {
this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
return;
}
const responseHandler = this._responseHandlers.get(messageId);
const timeoutInfo = this._timeoutInfo.get(messageId);
if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) {
try {
this._resetTimeout(messageId);
} catch (error2) {
this._responseHandlers.delete(messageId);
this._progressHandlers.delete(messageId);
this._cleanupTimeout(messageId);
responseHandler(error2);
return;
}
}
handler(params);
}
_onresponse(response) {
const messageId = Number(response.id);
const resolver = this._requestResolvers.get(messageId);
if (resolver) {
this._requestResolvers.delete(messageId);
if (isJSONRPCResultResponse(response)) {
resolver(response);
} else {
const error2 = new McpError(response.error.code, response.error.message, response.error.data);
resolver(error2);
}
return;
}
const handler = this._responseHandlers.get(messageId);
if (handler === undefined) {
this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
return;
}
this._responseHandlers.delete(messageId);
this._cleanupTimeout(messageId);
let isTaskResponse = false;
if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
const result = response.result;
if (result.task && typeof result.task === "object") {
const task = result.task;
if (typeof task.taskId === "string") {
isTaskResponse = true;
this._taskProgressTokens.set(task.taskId, messageId);
}
}
}
if (!isTaskResponse) {
this._progressHandlers.delete(messageId);
}
if (isJSONRPCResultResponse(response)) {
handler(response);
} else {
const error2 = McpError.fromError(response.error.code, response.error.message, response.error.data);
handler(error2);
}
}
get transport() {
return this._transport;
}
async close() {
await this._transport?.close();
}
async* requestStream(request, resultSchema, options) {
const { task } = options ?? {};
if (!task) {
try {
const result = await this.request(request, resultSchema, options);
yield { type: "result", result };
} catch (error2) {
yield {
type: "error",
error: error2 instanceof McpError ? error2 : new McpError(ErrorCode.InternalError, String(error2))
};
}
return;
}
let taskId;
try {
const createResult = await this.request(request, CreateTaskResultSchema, options);
if (createResult.task) {
taskId = createResult.task.taskId;
yield { type: "taskCreated", task: createResult.task };
} else {
throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
}
while (true) {
const task2 = await this.getTask({ taskId }, options);
yield { type: "taskStatus", task: task2 };
if (isTerminal(task2.status)) {
if (task2.status === "completed") {
const result = await this.getTaskResult({ taskId }, resultSchema, options);
yield { type: "result", result };
} else if (task2.status === "failed") {
yield {
type: "error",
error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
};
} else if (task2.status === "cancelled") {
yield {
type: "error",
error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
};
}
return;
}
if (task2.status === "input_required") {
const result = await this.getTaskResult({ taskId }, resultSchema, options);
yield { type: "result", result };
return;
}
const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
options?.signal?.throwIfAborted();
}
} catch (error2) {
yield {
type: "error",
error: error2 instanceof McpError ? error2 : new McpError(ErrorCode.InternalError, String(error2))
};
}
}
request(request, resultSchema, options) {
const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
return new Promise((resolve7, reject) => {
const earlyReject = (error2) => {
reject(error2);
};
if (!this._transport) {
earlyReject(new Error("Not connected"));
return;
}
if (this._options?.enforceStrictCapabilities === true) {
try {
this.assertCapabilityForMethod(request.method);
if (task) {
this.assertTaskCapability(request.method);
}
} catch (e) {
earlyReject(e);
return;
}
}
options?.signal?.throwIfAborted();
const messageId = this._requestMessageId++;
const jsonrpcRequest = {
...request,
jsonrpc: "2.0",
id: messageId
};
if (options?.onprogress) {
this._progressHandlers.set(messageId, options.onprogress);
jsonrpcRequest.params = {
...request.params,
_meta: {
...request.params?._meta || {},
progressToken: messageId
}
};
}
if (task) {
jsonrpcRequest.params = {
...jsonrpcRequest.params,
task
};
}
if (relatedTask) {
jsonrpcRequest.params = {
...jsonrpcRequest.params,
_meta: {
...jsonrpcRequest.params?._meta || {},
[RELATED_TASK_META_KEY]: relatedTask
}
};
}
const cancel = (reason) => {
this._responseHandlers.delete(messageId);
this._progressHandlers.delete(messageId);
this._cleanupTimeout(messageId);
this._transport?.send({
jsonrpc: "2.0",
method: "notifications/cancelled",
params: {
requestId: messageId,
reason: String(reason)
}
}, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error3) => this._onerror(new Error(`Failed to send cancellation: ${error3}`)));
const error2 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
reject(error2);
};
this._responseHandlers.set(messageId, (response) => {
if (options?.signal?.aborted) {
return;
}
if (response instanceof Error) {
return reject(response);
}
try {
const parseResult = safeParse2(resultSchema, response.result);
if (!parseResult.success) {
reject(parseResult.error);
} else {
resolve7(parseResult.data);
}
} catch (error2) {
reject(error2);
}
});
options?.signal?.addEventListener("abort", () => {
cancel(options?.signal?.reason);
});
const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
const relatedTaskId = relatedTask?.taskId;
if (relatedTaskId) {
const responseResolver = (response) => {
const handler = this._responseHandlers.get(messageId);
if (handler) {
handler(response);
} else {
this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`));
}
};
this._requestResolvers.set(messageId, responseResolver);
this._enqueueTaskMessage(relatedTaskId, {
type: "request",
message: jsonrpcRequest,
timestamp: Date.now()
}).catch((error2) => {
this._cleanupTimeout(messageId);
reject(error2);
});
} else {
this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error2) => {
this._cleanupTimeout(messageId);
reject(error2);
});
}
});
}
async getTask(params, options) {
return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options);
}
async getTaskResult(params, resultSchema, options) {
return this.request({ method: "tasks/result", params }, resultSchema, options);
}
async listTasks(params, options) {
return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options);
}
async cancelTask(params, options) {
return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options);
}
async notification(notification, options) {
if (!this._transport) {
throw new Error("Not connected");
}
this.assertNotificationCapability(notification.method);
const relatedTaskId = options?.relatedTask?.taskId;
if (relatedTaskId) {
const jsonrpcNotification2 = {
...notification,
jsonrpc: "2.0",
params: {
...notification.params,
_meta: {
...notification.params?._meta || {},
[RELATED_TASK_META_KEY]: options.relatedTask
}
}
};
await this._enqueueTaskMessage(relatedTaskId, {
type: "notification",
message: jsonrpcNotification2,
timestamp: Date.now()
});
return;
}
const debouncedMethods = this._options?.debouncedNotificationMethods ?? [];
const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask;
if (canDebounce) {
if (this._pendingDebouncedNotifications.has(notification.method)) {
return;
}
this._pendingDebouncedNotifications.add(notification.method);
Promise.resolve().then(() => {
this._pendingDebouncedNotifications.delete(notification.method);
if (!this._transport) {
return;
}
let jsonrpcNotification2 = {
...notification,
jsonrpc: "2.0"
};
if (options?.relatedTask) {
jsonrpcNotification2 = {
...jsonrpcNotification2,
params: {
...jsonrpcNotification2.params,
_meta: {
...jsonrpcNotification2.params?._meta || {},
[RELATED_TASK_META_KEY]: options.relatedTask
}
}
};
}
this._transport?.send(jsonrpcNotification2, options).catch((error2) => this._onerror(error2));
});
return;
}
let jsonrpcNotification = {
...notification,
jsonrpc: "2.0"
};
if (options?.relatedTask) {
jsonrpcNotification = {
...jsonrpcNotification,
params: {
...jsonrpcNotification.params,
_meta: {
...jsonrpcNotification.params?._meta || {},
[RELATED_TASK_META_KEY]: options.relatedTask
}
}
};
}
await this._transport.send(jsonrpcNotification, options);
}
setRequestHandler(requestSchema, handler) {
const method = getMethodLiteral(requestSchema);
this.assertRequestHandlerCapability(method);
this._requestHandlers.set(method, (request, extra) => {
const parsed = parseWithCompat(requestSchema, request);
return Promise.resolve(handler(parsed, extra));
});
}
removeRequestHandler(method) {
this._requestHandlers.delete(method);
}
assertCanSetRequestHandler(method) {
if (this._requestHandlers.has(method)) {
throw new Error(`A request handler for ${method} already exists, which would be overridden`);
}
}
setNotificationHandler(notificationSchema, handler) {
const method = getMethodLiteral(notificationSchema);
this._notificationHandlers.set(method, (notification) => {
const parsed = parseWithCompat(notificationSchema, notification);
return Promise.resolve(handler(parsed));
});
}
removeNotificationHandler(method) {
this._notificationHandlers.delete(method);
}
_cleanupTaskProgressHandler(taskId) {
const progressToken = this._taskProgressTokens.get(taskId);
if (progressToken !== undefined) {
this._progressHandlers.delete(progressToken);
this._taskProgressTokens.delete(taskId);
}
}
async _enqueueTaskMessage(taskId, message, sessionId) {
if (!this._taskStore || !this._taskMessageQueue) {
throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
}
const maxQueueSize = this._options?.maxTaskQueueSize;
await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
}
async _clearTaskQueue(taskId, sessionId) {
if (this._taskMessageQueue) {
const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
for (const message of messages) {
if (message.type === "request" && isJSONRPCRequest(message.message)) {
const requestId = message.message.id;
const resolver = this._requestResolvers.get(requestId);
if (resolver) {
resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
this._requestResolvers.delete(requestId);
} else {
this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
}
}
}
}
}
async _waitForTaskUpdate(taskId, signal) {
let interval = this._options?.defaultTaskPollInterval ?? 1000;
try {
const task = await this._taskStore?.getTask(taskId);
if (task?.pollInterval) {
interval = task.pollInterval;
}
} catch {}
return new Promise((resolve7, reject) => {
if (signal.aborted) {
reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
return;
}
const timeoutId = setTimeout(resolve7, interval);
signal.addEventListener("abort", () => {
clearTimeout(timeoutId);
reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
}, { once: true });
});
}
requestTaskStore(request, sessionId) {
const taskStore = this._taskStore;
if (!taskStore) {
throw new Error("No task store configured");
}
return {
createTask: async (taskParams) => {
if (!request) {
throw new Error("No request provided");
}
return await taskStore.createTask(taskParams, request.id, {
method: request.method,
params: request.params
}, sessionId);
},
getTask: async (taskId) => {
const task = await taskStore.getTask(taskId, sessionId);
if (!task) {
throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
}
return task;
},
storeTaskResult: async (taskId, status, result) => {
await taskStore.storeTaskResult(taskId, status, result, sessionId);
const task = await taskStore.getTask(taskId, sessionId);
if (task) {
const notification = TaskStatusNotificationSchema.parse({
method: "notifications/tasks/status",
params: task
});
await this.notification(notification);
if (isTerminal(task.status)) {
this._cleanupTaskProgressHandler(taskId);
}
}
},
getTaskResult: (taskId) => {
return taskStore.getTaskResult(taskId, sessionId);
},
updateTaskStatus: async (taskId, status, statusMessage) => {
const task = await taskStore.getTask(taskId, sessionId);
if (!task) {
throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
}
if (isTerminal(task.status)) {
throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
}
await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
const updatedTask = await taskStore.getTask(taskId, sessionId);
if (updatedTask) {
const notification = TaskStatusNotificationSchema.parse({
method: "notifications/tasks/status",
params: updatedTask
});
await this.notification(notification);
if (isTerminal(updatedTask.status)) {
this._cleanupTaskProgressHandler(taskId);
}
}
},
listTasks: (cursor) => {
return taskStore.listTasks(cursor, sessionId);
}
};
}
}
function isPlainObject2(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function mergeCapabilities(base, additional) {
const result = { ...base };
for (const key in additional) {
const k = key;
const addValue = additional[k];
if (addValue === undefined)
continue;
const baseValue = result[k];
if (isPlainObject2(baseValue) && isPlainObject2(addValue)) {
result[k] = { ...baseValue, ...addValue };
} else {
result[k] = addValue;
}
}
return result;
}
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
var import_ajv = __toESM(require_ajv(), 1);
var import_ajv_formats = __toESM(require_dist(), 1);
function createDefaultAjvInstance() {
const ajv = new import_ajv.default({
strict: false,
validateFormats: true,
validateSchema: false,
allErrors: true
});
const addFormats = import_ajv_formats.default;
addFormats(ajv);
return ajv;
}
class AjvJsonSchemaValidator {
constructor(ajv) {
this._ajv = ajv ?? createDefaultAjvInstance();
}
getValidator(schema) {
const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
return (input) => {
const valid = ajvValidator(input);
if (valid) {
return {
valid: true,
data: input,
errorMessage: undefined
};
} else {
return {
valid: false,
data: undefined,
errorMessage: this._ajv.errorsText(ajvValidator.errors)
};
}
};
}
}
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
class ExperimentalServerTasks {
constructor(_server) {
this._server = _server;
}
requestStream(request, resultSchema, options) {
return this._server.requestStream(request, resultSchema, options);
}
createMessageStream(params, options) {
const clientCapabilities = this._server.getClientCapabilities();
if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
throw new Error("Client does not support sampling tools capability.");
}
if (params.messages.length > 0) {
const lastMessage = params.messages[params.messages.length - 1];
const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
const hasToolResults = lastContent.some((c) => c.type === "tool_result");
const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
if (hasToolResults) {
if (lastContent.some((c) => c.type !== "tool_result")) {
throw new Error("The last message must contain only tool_result content if any is present");
}
if (!hasPreviousToolUse) {
throw new Error("tool_result blocks are not matching any tool_use from the previous message");
}
}
if (hasPreviousToolUse) {
const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
}
}
}
return this.requestStream({
method: "sampling/createMessage",
params
}, CreateMessageResultSchema, options);
}
elicitInputStream(params, options) {
const clientCapabilities = this._server.getClientCapabilities();
const mode = params.mode ?? "form";
switch (mode) {
case "url": {
if (!clientCapabilities?.elicitation?.url) {
throw new Error("Client does not support url elicitation.");
}
break;
}
case "form": {
if (!clientCapabilities?.elicitation?.form) {
throw new Error("Client does not support form elicitation.");
}
break;
}
}
const normalizedParams = mode === "form" && params.mode === undefined ? { ...params, mode: "form" } : params;
return this.requestStream({
method: "elicitation/create",
params: normalizedParams
}, ElicitResultSchema, options);
}
async getTask(taskId, options) {
return this._server.getTask({ taskId }, options);
}
async getTaskResult(taskId, resultSchema, options) {
return this._server.getTaskResult({ taskId }, resultSchema, options);
}
async listTasks(cursor, options) {
return this._server.listTasks(cursor ? { cursor } : undefined, options);
}
async cancelTask(taskId, options) {
return this._server.cancelTask({ taskId }, options);
}
}
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
function assertToolsCallTaskCapability(requests, method, entityName) {
if (!requests) {
throw new Error(`${entityName} does not support task creation (required for ${method})`);
}
switch (method) {
case "tools/call":
if (!requests.tools?.call) {
throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
}
break;
default:
break;
}
}
function assertClientRequestTaskCapability(requests, method, entityName) {
if (!requests) {
throw new Error(`${entityName} does not support task creation (required for ${method})`);
}
switch (method) {
case "sampling/createMessage":
if (!requests.sampling?.createMessage) {
throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
}
break;
case "elicitation/create":
if (!requests.elicitation?.create) {
throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
}
break;
default:
break;
}
}
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
class Server extends Protocol {
constructor(_serverInfo, options) {
super(options);
this._serverInfo = _serverInfo;
this._loggingLevels = new Map;
this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
this.isMessageIgnored = (level, sessionId) => {
const currentLevel = this._loggingLevels.get(sessionId);
return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
};
this._capabilities = options?.capabilities ?? {};
this._instructions = options?.instructions;
this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator;
this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
if (this._capabilities.logging) {
this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || undefined;
const { level } = request.params;
const parseResult = LoggingLevelSchema.safeParse(level);
if (parseResult.success) {
this._loggingLevels.set(transportSessionId, parseResult.data);
}
return {};
});
}
}
get experimental() {
if (!this._experimental) {
this._experimental = {
tasks: new ExperimentalServerTasks(this)
};
}
return this._experimental;
}
registerCapabilities(capabilities) {
if (this.transport) {
throw new Error("Cannot register capabilities after connecting to transport");
}
this._capabilities = mergeCapabilities(this._capabilities, capabilities);
}
setRequestHandler(requestSchema, handler) {
const shape = getObjectShape(requestSchema);
const methodSchema = shape?.method;
if (!methodSchema) {
throw new Error("Schema is missing a method literal");
}
let methodValue;
if (isZ4Schema(methodSchema)) {
const v4Schema = methodSchema;
const v4Def = v4Schema._zod?.def;
methodValue = v4Def?.value ?? v4Schema.value;
} else {
const v3Schema = methodSchema;
const legacyDef = v3Schema._def;
methodValue = legacyDef?.value ?? v3Schema.value;
}
if (typeof methodValue !== "string") {
throw new Error("Schema method literal must be a string");
}
const method = methodValue;
if (method === "tools/call") {
const wrappedHandler = async (request, extra) => {
const validatedRequest = safeParse2(CallToolRequestSchema, request);
if (!validatedRequest.success) {
const errorMessage2 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage2}`);
}
const { params } = validatedRequest.data;
const result = await Promise.resolve(handler(request, extra));
if (params.task) {
const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
if (!taskValidationResult.success) {
const errorMessage2 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage2}`);
}
return taskValidationResult.data;
}
const validationResult = safeParse2(CallToolResultSchema, result);
if (!validationResult.success) {
const errorMessage2 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage2}`);
}
return validationResult.data;
};
return super.setRequestHandler(requestSchema, wrappedHandler);
}
return super.setRequestHandler(requestSchema, handler);
}
assertCapabilityForMethod(method) {
switch (method) {
case "sampling/createMessage":
if (!this._clientCapabilities?.sampling) {
throw new Error(`Client does not support sampling (required for ${method})`);
}
break;
case "elicitation/create":
if (!this._clientCapabilities?.elicitation) {
throw new Error(`Client does not support elicitation (required for ${method})`);
}
break;
case "roots/list":
if (!this._clientCapabilities?.roots) {
throw new Error(`Client does not support listing roots (required for ${method})`);
}
break;
case "ping":
break;
}
}
assertNotificationCapability(method) {
switch (method) {
case "notifications/message":
if (!this._capabilities.logging) {
throw new Error(`Server does not support logging (required for ${method})`);
}
break;
case "notifications/resources/updated":
case "notifications/resources/list_changed":
if (!this._capabilities.resources) {
throw new Error(`Server does not support notifying about resources (required for ${method})`);
}
break;
case "notifications/tools/list_changed":
if (!this._capabilities.tools) {
throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
}
break;
case "notifications/prompts/list_changed":
if (!this._capabilities.prompts) {
throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
}
break;
case "notifications/elicitation/complete":
if (!this._clientCapabilities?.elicitation?.url) {
throw new Error(`Client does not support URL elicitation (required for ${method})`);
}
break;
case "notifications/cancelled":
break;
case "notifications/progress":
break;
}
}
assertRequestHandlerCapability(method) {
if (!this._capabilities) {
return;
}
switch (method) {
case "completion/complete":
if (!this._capabilities.completions) {
throw new Error(`Server does not support completions (required for ${method})`);
}
break;
case "logging/setLevel":
if (!this._capabilities.logging) {
throw new Error(`Server does not support logging (required for ${method})`);
}
break;
case "prompts/get":
case "prompts/list":
if (!this._capabilities.prompts) {
throw new Error(`Server does not support prompts (required for ${method})`);
}
break;
case "resources/list":
case "resources/templates/list":
case "resources/read":
if (!this._capabilities.resources) {
throw new Error(`Server does not support resources (required for ${method})`);
}
break;
case "tools/call":
case "tools/list":
if (!this._capabilities.tools) {
throw new Error(`Server does not support tools (required for ${method})`);
}
break;
case "tasks/get":
case "tasks/list":
case "tasks/result":
case "tasks/cancel":
if (!this._capabilities.tasks) {
throw new Error(`Server does not support tasks capability (required for ${method})`);
}
break;
case "ping":
case "initialize":
break;
}
}
assertTaskCapability(method) {
assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
}
assertTaskHandlerCapability(method) {
if (!this._capabilities) {
return;
}
assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
}
async _oninitialize(request) {
const requestedVersion = request.params.protocolVersion;
this._clientCapabilities = request.params.capabilities;
this._clientVersion = request.params.clientInfo;
const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
return {
protocolVersion,
capabilities: this.getCapabilities(),
serverInfo: this._serverInfo,
...this._instructions && { instructions: this._instructions }
};
}
getClientCapabilities() {
return this._clientCapabilities;
}
getClientVersion() {
return this._clientVersion;
}
getCapabilities() {
return this._capabilities;
}
async ping() {
return this.request({ method: "ping" }, EmptyResultSchema);
}
async createMessage(params, options) {
if (params.tools || params.toolChoice) {
if (!this._clientCapabilities?.sampling?.tools) {
throw new Error("Client does not support sampling tools capability.");
}
}
if (params.messages.length > 0) {
const lastMessage = params.messages[params.messages.length - 1];
const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
const hasToolResults = lastContent.some((c) => c.type === "tool_result");
const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
if (hasToolResults) {
if (lastContent.some((c) => c.type !== "tool_result")) {
throw new Error("The last message must contain only tool_result content if any is present");
}
if (!hasPreviousToolUse) {
throw new Error("tool_result blocks are not matching any tool_use from the previous message");
}
}
if (hasPreviousToolUse) {
const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
}
}
}
if (params.tools) {
return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
}
return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
}
async elicitInput(params, options) {
const mode = params.mode ?? "form";
switch (mode) {
case "url": {
if (!this._clientCapabilities?.elicitation?.url) {
throw new Error("Client does not support url elicitation.");
}
const urlParams = params;
return this.request({ method: "elicitation/create", params: urlParams }, ElicitResultSchema, options);
}
case "form": {
if (!this._clientCapabilities?.elicitation?.form) {
throw new Error("Client does not support form elicitation.");
}
const formParams = params.mode === "form" ? params : { ...params, mode: "form" };
const result = await this.request({ method: "elicitation/create", params: formParams }, ElicitResultSchema, options);
if (result.action === "accept" && result.content && formParams.requestedSchema) {
try {
const validator = this._jsonSchemaValidator.getValidator(formParams.requestedSchema);
const validationResult = validator(result.content);
if (!validationResult.valid) {
throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
}
} catch (error2) {
if (error2 instanceof McpError) {
throw error2;
}
throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error2 instanceof Error ? error2.message : String(error2)}`);
}
}
return result;
}
}
}
createElicitationCompletionNotifier(elicitationId, options) {
if (!this._clientCapabilities?.elicitation?.url) {
throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
}
return () => this.notification({
method: "notifications/elicitation/complete",
params: {
elicitationId
}
}, options);
}
async listRoots(params, options) {
return this.request({ method: "roots/list", params }, ListRootsResultSchema, options);
}
async sendLoggingMessage(params, sessionId) {
if (this._capabilities.logging) {
if (!this.isMessageIgnored(params.level, sessionId)) {
return this.notification({ method: "notifications/message", params });
}
}
}
async sendResourceUpdated(params) {
return this.notification({
method: "notifications/resources/updated",
params
});
}
async sendResourceListChanged() {
return this.notification({
method: "notifications/resources/list_changed"
});
}
async sendToolListChanged() {
return this.notification({ method: "notifications/tools/list_changed" });
}
async sendPromptListChanged() {
return this.notification({ method: "notifications/prompts/list_changed" });
}
}
// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
class WebStandardStreamableHTTPServerTransport {
constructor(options = {}) {
this._started = false;
this._hasHandledRequest = false;
this._streamMapping = new Map;
this._requestToStreamMapping = new Map;
this._requestResponseMap = new Map;
this._initialized = false;
this._enableJsonResponse = false;
this._standaloneSseStreamId = "_GET_stream";
this.sessionIdGenerator = options.sessionIdGenerator;
this._enableJsonResponse = options.enableJsonResponse ?? false;
this._eventStore = options.eventStore;
this._onsessioninitialized = options.onsessioninitialized;
this._onsessionclosed = options.onsessionclosed;
this._allowedHosts = options.allowedHosts;
this._allowedOrigins = options.allowedOrigins;
this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
this._retryInterval = options.retryInterval;
}
async start() {
if (this._started) {
throw new Error("Transport already started");
}
this._started = true;
}
createJsonErrorResponse(status, code, message, options) {
const error2 = { code, message };
if (options?.data !== undefined) {
error2.data = options.data;
}
return new Response(JSON.stringify({
jsonrpc: "2.0",
error: error2,
id: null
}), {
status,
headers: {
"Content-Type": "application/json",
...options?.headers
}
});
}
validateRequestHeaders(req) {
if (!this._enableDnsRebindingProtection) {
return;
}
if (this._allowedHosts && this._allowedHosts.length > 0) {
const hostHeader = req.headers.get("host");
if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {
const error2 = `Invalid Host header: ${hostHeader}`;
this.onerror?.(new Error(error2));
return this.createJsonErrorResponse(403, -32000, error2);
}
}
if (this._allowedOrigins && this._allowedOrigins.length > 0) {
const originHeader = req.headers.get("origin");
if (originHeader && !this._allowedOrigins.includes(originHeader)) {
const error2 = `Invalid Origin header: ${originHeader}`;
this.onerror?.(new Error(error2));
return this.createJsonErrorResponse(403, -32000, error2);
}
}
return;
}
async handleRequest(req, options) {
if (!this.sessionIdGenerator && this._hasHandledRequest) {
throw new Error("Stateless transport cannot be reused across requests. Create a new transport per request.");
}
this._hasHandledRequest = true;
const validationError = this.validateRequestHeaders(req);
if (validationError) {
return validationError;
}
switch (req.method) {
case "POST":
return this.handlePostRequest(req, options);
case "GET":
return this.handleGetRequest(req);
case "DELETE":
return this.handleDeleteRequest(req);
default:
return this.handleUnsupportedRequest();
}
}
async writePrimingEvent(controller, encoder, streamId, protocolVersion) {
if (!this._eventStore) {
return;
}
if (protocolVersion < "2025-11-25") {
return;
}
const primingEventId = await this._eventStore.storeEvent(streamId, {});
let primingEvent = `id: ${primingEventId}
data:
`;
if (this._retryInterval !== undefined) {
primingEvent = `id: ${primingEventId}
retry: ${this._retryInterval}
data:
`;
}
controller.enqueue(encoder.encode(primingEvent));
}
async handleGetRequest(req) {
const acceptHeader = req.headers.get("accept");
if (!acceptHeader?.includes("text/event-stream")) {
this.onerror?.(new Error("Not Acceptable: Client must accept text/event-stream"));
return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept text/event-stream");
}
const sessionError = this.validateSession(req);
if (sessionError) {
return sessionError;
}
const protocolError = this.validateProtocolVersion(req);
if (protocolError) {
return protocolError;
}
if (this._eventStore) {
const lastEventId = req.headers.get("last-event-id");
if (lastEventId) {
return this.replayEvents(lastEventId);
}
}
if (this._streamMapping.get(this._standaloneSseStreamId) !== undefined) {
this.onerror?.(new Error("Conflict: Only one SSE stream is allowed per session"));
return this.createJsonErrorResponse(409, -32000, "Conflict: Only one SSE stream is allowed per session");
}
const encoder = new TextEncoder;
let streamController;
const readable = new ReadableStream({
start: (controller) => {
streamController = controller;
},
cancel: () => {
this._streamMapping.delete(this._standaloneSseStreamId);
}
});
const headers = {
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache, no-transform",
Connection: "keep-alive"
};
if (this.sessionId !== undefined) {
headers["mcp-session-id"] = this.sessionId;
}
this._streamMapping.set(this._standaloneSseStreamId, {
controller: streamController,
encoder,
cleanup: () => {
this._streamMapping.delete(this._standaloneSseStreamId);
try {
streamController.close();
} catch {}
}
});
return new Response(readable, { headers });
}
async replayEvents(lastEventId) {
if (!this._eventStore) {
this.onerror?.(new Error("Event store not configured"));
return this.createJsonErrorResponse(400, -32000, "Event store not configured");
}
try {
let streamId;
if (this._eventStore.getStreamIdForEventId) {
streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
if (!streamId) {
this.onerror?.(new Error("Invalid event ID format"));
return this.createJsonErrorResponse(400, -32000, "Invalid event ID format");
}
if (this._streamMapping.get(streamId) !== undefined) {
this.onerror?.(new Error("Conflict: Stream already has an active connection"));
return this.createJsonErrorResponse(409, -32000, "Conflict: Stream already has an active connection");
}
}
const headers = {
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache, no-transform",
Connection: "keep-alive"
};
if (this.sessionId !== undefined) {
headers["mcp-session-id"] = this.sessionId;
}
const encoder = new TextEncoder;
let streamController;
const readable = new ReadableStream({
start: (controller) => {
streamController = controller;
},
cancel: () => {}
});
const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {
send: async (eventId, message) => {
const success = this.writeSSEEvent(streamController, encoder, message, eventId);
if (!success) {
this.onerror?.(new Error("Failed replay events"));
try {
streamController.close();
} catch {}
}
}
});
this._streamMapping.set(replayedStreamId, {
controller: streamController,
encoder,
cleanup: () => {
this._streamMapping.delete(replayedStreamId);
try {
streamController.close();
} catch {}
}
});
return new Response(readable, { headers });
} catch (error2) {
this.onerror?.(error2);
return this.createJsonErrorResponse(500, -32000, "Error replaying events");
}
}
writeSSEEvent(controller, encoder, message, eventId) {
try {
let eventData = `event: message
`;
if (eventId) {
eventData += `id: ${eventId}
`;
}
eventData += `data: ${JSON.stringify(message)}
`;
controller.enqueue(encoder.encode(eventData));
return true;
} catch (error2) {
this.onerror?.(error2);
return false;
}
}
handleUnsupportedRequest() {
this.onerror?.(new Error("Method not allowed."));
return new Response(JSON.stringify({
jsonrpc: "2.0",
error: {
code: -32000,
message: "Method not allowed."
},
id: null
}), {
status: 405,
headers: {
Allow: "GET, POST, DELETE",
"Content-Type": "application/json"
}
});
}
async handlePostRequest(req, options) {
try {
const acceptHeader = req.headers.get("accept");
if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
this.onerror?.(new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept both application/json and text/event-stream");
}
const ct = req.headers.get("content-type");
if (!ct || !ct.includes("application/json")) {
this.onerror?.(new Error("Unsupported Media Type: Content-Type must be application/json"));
return this.createJsonErrorResponse(415, -32000, "Unsupported Media Type: Content-Type must be application/json");
}
const requestInfo = {
headers: Object.fromEntries(req.headers.entries()),
url: new URL(req.url)
};
let rawMessage;
if (options?.parsedBody !== undefined) {
rawMessage = options.parsedBody;
} else {
try {
rawMessage = await req.json();
} catch {
this.onerror?.(new Error("Parse error: Invalid JSON"));
return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
}
}
let messages;
try {
if (Array.isArray(rawMessage)) {
messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
} else {
messages = [JSONRPCMessageSchema.parse(rawMessage)];
}
} catch {
this.onerror?.(new Error("Parse error: Invalid JSON-RPC message"));
return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
}
const isInitializationRequest = messages.some(isInitializeRequest);
if (isInitializationRequest) {
if (this._initialized && this.sessionId !== undefined) {
this.onerror?.(new Error("Invalid Request: Server already initialized"));
return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
}
if (messages.length > 1) {
this.onerror?.(new Error("Invalid Request: Only one initialization request is allowed"));
return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
}
this.sessionId = this.sessionIdGenerator?.();
this._initialized = true;
if (this.sessionId && this._onsessioninitialized) {
await Promise.resolve(this._onsessioninitialized(this.sessionId));
}
}
if (!isInitializationRequest) {
const sessionError = this.validateSession(req);
if (sessionError) {
return sessionError;
}
const protocolError = this.validateProtocolVersion(req);
if (protocolError) {
return protocolError;
}
}
const hasRequests = messages.some(isJSONRPCRequest);
if (!hasRequests) {
for (const message of messages) {
this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
}
return new Response(null, { status: 202 });
}
const streamId = crypto.randomUUID();
const initRequest = messages.find((m) => isInitializeRequest(m));
const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
if (this._enableJsonResponse) {
return new Promise((resolve7) => {
this._streamMapping.set(streamId, {
resolveJson: resolve7,
cleanup: () => {
this._streamMapping.delete(streamId);
}
});
for (const message of messages) {
if (isJSONRPCRequest(message)) {
this._requestToStreamMapping.set(message.id, streamId);
}
}
for (const message of messages) {
this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
}
});
}
const encoder = new TextEncoder;
let streamController;
const readable = new ReadableStream({
start: (controller) => {
streamController = controller;
},
cancel: () => {
this._streamMapping.delete(streamId);
}
});
const headers = {
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache",
Connection: "keep-alive"
};
if (this.sessionId !== undefined) {
headers["mcp-session-id"] = this.sessionId;
}
for (const message of messages) {
if (isJSONRPCRequest(message)) {
this._streamMapping.set(streamId, {
controller: streamController,
encoder,
cleanup: () => {
this._streamMapping.delete(streamId);
try {
streamController.close();
} catch {}
}
});
this._requestToStreamMapping.set(message.id, streamId);
}
}
await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
for (const message of messages) {
let closeSSEStream;
let closeStandaloneSSEStream;
if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
closeSSEStream = () => {
this.closeSSEStream(message.id);
};
closeStandaloneSSEStream = () => {
this.closeStandaloneSSEStream();
};
}
this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });
}
return new Response(readable, { status: 200, headers });
} catch (error2) {
this.onerror?.(error2);
return this.createJsonErrorResponse(400, -32700, "Parse error", { data: String(error2) });
}
}
async handleDeleteRequest(req) {
const sessionError = this.validateSession(req);
if (sessionError) {
return sessionError;
}
const protocolError = this.validateProtocolVersion(req);
if (protocolError) {
return protocolError;
}
await Promise.resolve(this._onsessionclosed?.(this.sessionId));
await this.close();
return new Response(null, { status: 200 });
}
validateSession(req) {
if (this.sessionIdGenerator === undefined) {
return;
}
if (!this._initialized) {
this.onerror?.(new Error("Bad Request: Server not initialized"));
return this.createJsonErrorResponse(400, -32000, "Bad Request: Server not initialized");
}
const sessionId = req.headers.get("mcp-session-id");
if (!sessionId) {
this.onerror?.(new Error("Bad Request: Mcp-Session-Id header is required"));
return this.createJsonErrorResponse(400, -32000, "Bad Request: Mcp-Session-Id header is required");
}
if (sessionId !== this.sessionId) {
this.onerror?.(new Error("Session not found"));
return this.createJsonErrorResponse(404, -32001, "Session not found");
}
return;
}
validateProtocolVersion(req) {
const protocolVersion = req.headers.get("mcp-protocol-version");
if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
this.onerror?.(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion}` + ` (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`));
return this.createJsonErrorResponse(400, -32000, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
}
return;
}
async close() {
this._streamMapping.forEach(({ cleanup }) => {
cleanup();
});
this._streamMapping.clear();
this._requestResponseMap.clear();
this.onclose?.();
}
closeSSEStream(requestId) {
const streamId = this._requestToStreamMapping.get(requestId);
if (!streamId)
return;
const stream = this._streamMapping.get(streamId);
if (stream) {
stream.cleanup();
}
}
closeStandaloneSSEStream() {
const stream = this._streamMapping.get(this._standaloneSseStreamId);
if (stream) {
stream.cleanup();
}
}
async send(message, options) {
let requestId = options?.relatedRequestId;
if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
requestId = message.id;
}
if (requestId === undefined) {
if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
}
let eventId;
if (this._eventStore) {
eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);
}
const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
if (standaloneSse === undefined) {
return;
}
if (standaloneSse.controller && standaloneSse.encoder) {
this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
}
return;
}
const streamId = this._requestToStreamMapping.get(requestId);
if (!streamId) {
throw new Error(`No connection established for request ID: ${String(requestId)}`);
}
const stream = this._streamMapping.get(streamId);
if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
let eventId;
if (this._eventStore) {
eventId = await this._eventStore.storeEvent(streamId, message);
}
this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
}
if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
this._requestResponseMap.set(requestId, message);
const relatedIds = Array.from(this._requestToStreamMapping.entries()).filter(([_, sid]) => sid === streamId).map(([id]) => id);
const allResponsesReady = relatedIds.every((id) => this._requestResponseMap.has(id));
if (allResponsesReady) {
if (!stream) {
throw new Error(`No connection established for request ID: ${String(requestId)}`);
}
if (this._enableJsonResponse && stream.resolveJson) {
const headers = {
"Content-Type": "application/json"
};
if (this.sessionId !== undefined) {
headers["mcp-session-id"] = this.sessionId;
}
const responses = relatedIds.map((id) => this._requestResponseMap.get(id));
if (responses.length === 1) {
stream.resolveJson(new Response(JSON.stringify(responses[0]), { status: 200, headers }));
} else {
stream.resolveJson(new Response(JSON.stringify(responses), { status: 200, headers }));
}
} else {
stream.cleanup();
}
for (const id of relatedIds) {
this._requestResponseMap.delete(id);
this._requestToStreamMapping.delete(id);
}
}
}
}
}
// src/server/mcp/take-screenshot.ts
var takeScreenshotTool = {
name: "adk_take_screenshot",
description: `Capture a screenshot of the developer's ADK Dev Console viewport \u2014 including the current page, sidebar, and your own Agent(0) panel \u2014 exactly as they see it now. Use this when the developer references something visual ("I don't see X", "what's this?", "this looks wrong", "show you what I'm looking at") so you can answer based on what's actually on their screen instead of guessing from the URL. Requires the dev console to be open in a browser tab.`,
inputSchema: {
type: "object",
properties: {}
}
};
async function takeScreenshot() {
try {
const { dataUrl, mimeType } = await requestScreenshotFromUI();
const match = /^data:([^;]+);base64,(.+)$/.exec(dataUrl);
if (!match) {
return {
content: [{ type: "text", text: JSON.stringify({ success: false, error: "Invalid data URL" }) }],
isError: true
};
}
return {
content: [{ type: "image", data: match[2], mimeType: mimeType ?? match[1] }]
};
} catch (e) {
return {
content: [
{ type: "text", text: JSON.stringify({ success: false, error: e instanceof Error ? e.message : String(e) }) }
],
isError: true
};
}
}
// src/server/mcp/index.ts
var tools = {
[takeScreenshotTool.name]: { tool: takeScreenshotTool, handler: takeScreenshot }
};
function buildServer() {
const server = new Server({ name: "botpress-adk", version: CLI_VERSION }, { capabilities: { tools: {} } });
server.setRequestHandler(ListToolsRequestSchema, async () => ({
tools: Object.values(tools).map((t) => t.tool)
}));
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const entry = tools[request.params.name];
if (entry)
return entry.handler();
return {
content: [
{ type: "text", text: JSON.stringify({ success: false, error: `Unknown tool: ${request.params.name}` }) }
],
isError: true
};
});
return server;
}
var sessions = new Map;
async function newSession() {
const server = buildServer();
const transport = new WebStandardStreamableHTTPServerTransport({
sessionIdGenerator: () => crypto.randomUUID(),
enableJsonResponse: true,
onsessioninitialized: (sessionId) => {
sessions.set(sessionId, { server, transport });
},
onsessionclosed: (sessionId) => {
sessions.delete(sessionId);
}
});
await server.connect(transport);
return { server, transport };
}
async function handleMcpRequest(req) {
const sessionId = req.headers.get("mcp-session-id");
if (sessionId) {
const existing = sessions.get(sessionId);
if (existing)
return existing.transport.handleRequest(req);
return new Response(JSON.stringify({ error: "Session not found" }), {
status: 404,
headers: { "Content-Type": "application/json" }
});
}
const fresh = await newSession();
return fresh.transport.handleRequest(req);
}
// src/server/backend-server.ts
var backendInstance = null;
var stopLagMonitor = null;
function startBackendServer(agentPath) {
if (backendInstance) {
stopBackendServer();
}
initTraceStore(agentPath);
getTraceStore()?.setFlushListener((spans) => {
for (const span of spans) {
broadcastSpan(span);
}
});
initLogStore(agentPath);
stopLagMonitor = startEventLoopLagMonitor(`backend ${agentPath}`);
backendInstance = serve({
port: 0,
hostname: "127.0.0.1",
idleTimeout: 60,
fetch(req) {
const url = new URL(req.url);
if (req.method === "OPTIONS") {
return handleCorsPreflightResponse(req);
}
if (url.pathname === "/mcp") {
return addCorsHeaders(req, withRequestTiming(`${req.method} /mcp`, () => handleMcpRequest(req)));
}
if (url.pathname.startsWith("/api/")) {
return addCorsHeaders(req, withRequestTiming(`${req.method} ${url.pathname}`, () => handleApiRequest(url.pathname, req)));
}
return new Response(null, { status: 404 });
}
});
return {
port: backendInstance.port,
stop: () => stopBackendServer()
};
}
async function addCorsHeaders(req, responsePromise) {
const response = await responsePromise;
const corsHeaders = getCorsHeaders(req);
for (const [key, value] of Object.entries(corsHeaders)) {
response.headers.set(key, value);
}
return response;
}
function stopBackendServer() {
if (backendInstance) {
backendInstance.stop(true);
backendInstance = null;
}
stopLagMonitor?.();
stopLagMonitor = null;
closeTraceStore();
closeLogStore();
}
// src/server/span-ingest-server.ts
var {serve: serve2 } = globalThis.Bun;
// src/utils/span-transformer.ts
var FULL_PAYLOADS_DATA_KEY = "__fullPayloads";
var OMITTED_PAYLOADS_DATA_KEY = "__omittedPayloads";
var importanceToTier = {
high: "concise",
medium: "standard",
low: "verbose",
debug: "verbose"
};
var SPAN_IMPORTANCE = {
"request.incoming": "high",
"cognitive.request": "high",
"botpress.client": "medium",
"http.client": "medium",
"handler.conversation": "high",
"handler.trigger": "high",
"handler.event": "high",
"handler.workflow": "high",
"handler.workflow.step": "high",
"handler.action": "high",
"autonomous.execution": "high",
"autonomous.iteration": "high",
"autonomous.tool": "high",
"interruption.check": "medium",
"chat.fetchTranscript": "medium",
"chat.compactTranscript": "medium",
"chat.saveTranscript": "medium",
"chat.sendMessage": "high",
"state.load": "medium",
"state.save": "medium",
"state.saveAllDirty": "medium",
"state.loadAll": "medium"
};
function getTier(spanName) {
const importance = SPAN_IMPORTANCE[spanName] ?? "low";
return importanceToTier[importance] ?? "verbose";
}
var CONTEXT_FIELDS = new Set([
"botId",
"conversationId",
"userId",
"messageId",
"workflowId",
"eventId",
"integration",
"channel"
]);
var RESOURCE_KEYS = new Set([
"environment",
"os.platform",
"os.arch",
"node.version",
"uptime",
"adk.version",
"runtime.version",
"sdk.version",
"llmz.version",
"zai.version",
"cognitive.version"
]);
function extractContext(attrs) {
const ctx = {};
for (const field of CONTEXT_FIELDS) {
const val = attrs[field];
if (val !== undefined && val !== null && val !== "") {
ctx[field] = String(val);
}
}
return ctx;
}
function extractResource(resource) {
const versions2 = {};
if (resource["adk.version"])
versions2.adk = resource["adk.version"];
if (resource["runtime.version"])
versions2.runtime = resource["runtime.version"];
if (resource["sdk.version"])
versions2.sdk = resource["sdk.version"];
if (resource["llmz.version"])
versions2.llmz = resource["llmz.version"];
if (resource["zai.version"])
versions2.zai = resource["zai.version"];
if (resource["cognitive.version"])
versions2.cognitive = resource["cognitive.version"];
const res = {
environment: resource["environment"] ?? "development",
versions: versions2
};
if (resource["os.platform"])
res.platform = resource["os.platform"];
if (resource["os.arch"])
res.arch = resource["os.arch"];
if (resource["node.version"])
res.nodeVersion = resource["node.version"];
if (resource["uptime"] != null)
res.uptime = resource["uptime"];
return res;
}
function extractData(attrs, payloads, omittedPayloads, events, links) {
const data = {};
for (const [key, value] of Object.entries(attrs)) {
if (CONTEXT_FIELDS.has(key) || RESOURCE_KEYS.has(key))
continue;
if (key === "importance")
continue;
data[key] = value;
}
if (payloads && payloads.length > 0) {
data[FULL_PAYLOADS_DATA_KEY] = Object.fromEntries(payloads.map((payload) => [
payload.key,
{
contentType: payload.contentType,
sizeBytes: payload.sizeBytes
}
]));
}
if (omittedPayloads && omittedPayloads.length > 0) {
data[OMITTED_PAYLOADS_DATA_KEY] = Object.fromEntries(omittedPayloads.map((payload) => [
payload.key,
{
reason: payload.reason,
sizeBytes: payload.sizeBytes,
maxSizeBytes: payload.maxSizeBytes
}
]));
}
if (events && events.length > 0) {
data.events = events.map((e) => ({
name: e.name,
timeMs: e.timeNs / 1e6,
attrs: e.attrs ?? {}
}));
}
if (links && links.length > 0) {
data.links = links.map((l) => ({
traceId: l.traceId,
spanId: l.spanId,
attrs: l.attrs
}));
}
return data;
}
function nsToMs(ns) {
return ns / 1e6;
}
function transformStart(raw) {
const attrs = raw.attrs ?? {};
const resource = raw.resource ?? {};
return {
id: {
trace: raw.traceId,
span: raw.spanId,
parent: raw.parentSpanId
},
name: raw.name,
label: raw.name,
status: "running",
timing: {
startedAt: nsToMs(raw.startNs)
},
context: extractContext(attrs),
tier: getTier(raw.name),
data: extractData(attrs, raw.payloads, raw.omittedPayloads),
resource: extractResource(resource)
};
}
function transformEnd(raw) {
const attrs = raw.attrs ?? {};
const resource = raw.resource ?? {};
const startMs = nsToMs(raw.startNs);
const endMs = raw.endNs ? nsToMs(raw.endNs) : startMs;
const durationMs = raw.durationNs ? nsToMs(raw.durationNs) : endMs - startMs;
let status = "ok";
if (raw.status?.code === 2) {
status = "error";
}
const span = {
id: {
trace: raw.traceId,
span: raw.spanId,
parent: raw.parentSpanId
},
name: raw.name,
label: raw.name,
status,
timing: {
startedAt: startMs,
endedAt: endMs,
duration: durationMs
},
context: extractContext(attrs),
tier: getTier(raw.name),
data: extractData(attrs, raw.payloads, raw.omittedPayloads, raw.events, raw.links),
resource: extractResource(resource)
};
if (raw.status?.code === 2 && raw.status.msg) {
span.error = raw.status.msg;
}
return span;
}
// src/server/handlers/span-receiver.ts
async function handleSpanIngest(req) {
try {
const raw = await req.json();
const store = getTraceStore();
if (!store) {
return new Response(null, { status: 503 });
}
if (raw.type === "start") {
const span = transformStart(raw);
store.enqueueInsert(span, raw.payloads ?? []);
} else if (raw.type === "end") {
const span = transformEnd(raw);
store.enqueueUpdate(span, raw.payloads ?? []);
}
return new Response(null, { status: 200 });
} catch {
return new Response(null, { status: 500 });
}
}
// src/server/handlers/log-receiver.ts
async function handleLogIngest(req) {
try {
const entry = await req.json();
const deliver = getLogSink();
deliver?.(JSON.stringify(entry));
return new Response(null, { status: 200 });
} catch {
return new Response(null, { status: 500 });
}
}
// src/server/span-ingest-server.ts
var ingestServer = null;
function startSpanIngestServer() {
if (ingestServer)
return ingestServer.port;
ingestServer = serve2({
port: 0,
hostname: "127.0.0.1",
idleTimeout: 60,
fetch(req) {
const url = new URL(req.url);
if (req.method === "POST" && url.pathname === "/v1/traces") {
return handleSpanIngest(req);
}
if (req.method === "POST" && url.pathname === "/v1/logs") {
return handleLogIngest(req);
}
if (req.method === "POST" && url.pathname === "/v1/worker-stats") {
return handleWorkerStatsIngest(req);
}
return new Response(null, { status: 404 });
}
});
return ingestServer.port;
}
function stopSpanIngestServer() {
if (ingestServer) {
ingestServer.stop();
ingestServer = null;
}
}
export { initLogSink, closeLogSink, getLogStore, broadcastComponentChanged, broadcastLog, ensureAgent0ProjectDirs, Agent0ConfigStore, Agent0CognitiveCatalogSource, Agent0OpenCodeStartupTimeoutError, startAgent0RuntimeClient, Agent0RuntimeManager, startBackendServer, stopBackendServer, startSpanIngestServer, stopSpanIngestServer };