@pantheon.ai/agents 0.0.1

package/dist/index.js

@@ -0,0 +1,2029 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { createCommand } from "commander";
+import expandTilde from "expand-tilde";
+import path from "node:path";
+import * as process$1 from "node:process";
+import { multistream, pino, transport } from "pino";
+import * as fs$1 from "node:fs";
+import { Kysely, MysqlDialect } from "kysely";
+import { createPool } from "mysql2";
+import z$1, { z } from "zod";
+
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region schemas/task-list.ts
+const taskItemSchema = z.discriminatedUnion("status", [
+	z.object({
+		status: z.literal("pending"),
+		id: z.string(),
+		task: z.string(),
+		project_id: z.uuid(),
+		base_branch_id: z.uuid(),
+		queued_at: z.coerce.date()
+	}),
+	z.object({
+		status: z.literal("running"),
+		id: z.string(),
+		task: z.string(),
+		project_id: z.uuid(),
+		base_branch_id: z.uuid(),
+		branch_id: z.uuid(),
+		queued_at: z.coerce.date(),
+		started_at: z.coerce.date()
+	}),
+	z.object({
+		status: z.literal("completed"),
+		id: z.string(),
+		task: z.string(),
+		project_id: z.uuid(),
+		base_branch_id: z.uuid(),
+		branch_id: z.uuid(),
+		queued_at: z.coerce.date(),
+		started_at: z.coerce.date(),
+		ended_at: z.coerce.date(),
+		output: z.string()
+	}),
+	z.object({
+		status: z.literal("failed"),
+		id: z.string(),
+		task: z.string(),
+		project_id: z.uuid(),
+		base_branch_id: z.uuid(),
+		branch_id: z.uuid().optional(),
+		queued_at: z.coerce.date(),
+		started_at: z.coerce.date().optional(),
+		ended_at: z.coerce.date().optional(),
+		error: z.string()
+	}),
+	z.object({
+		status: z.literal("cancelled"),
+		id: z.string(),
+		task: z.string(),
+		project_id: z.uuid(),
+		queued_at: z.coerce.date(),
+		cancelled_at: z.coerce.date()
+	})
+]);
+
+//#endregion
+//#region utils/get-error-message.ts
+function getErrorMessage(error) {
+	return String(error?.message ?? error);
+}
+
+//#endregion
+//#region task-list/task-list-provider.ts
+var TaskListProvider = class {
+	logger;
+	agentName;
+	constructor(agentName, logger) {
+		this.agentName = agentName;
+		this.logger = logger;
+	}
+	async createTask(params) {
+		return await this.insertTask({
+			status: "pending",
+			...params,
+			queued_at: /* @__PURE__ */ new Date()
+		});
+	}
+	async startTask({ status, id, ...task }, startTask) {
+		const now = /* @__PURE__ */ new Date();
+		let updatePromise;
+		try {
+			this.logger.info(`Starting task ${id}`);
+			const branchId = await startTask(task);
+			this.logger.info(`Started task ${id} at branch ${branchId}`);
+			updatePromise = this.updateTask({
+				status: "running",
+				id,
+				...task,
+				branch_id: branchId,
+				started_at: now
+			});
+		} catch (e) {
+			this.logger.error("Failed to start task: %s", getErrorMessage(e));
+			updatePromise = this.updateTask({
+				status: "failed",
+				id,
+				...task,
+				started_at: now,
+				ended_at: /* @__PURE__ */ new Date(),
+				error: getErrorMessage(e)
+			}).then(() => Promise.reject(e));
+		}
+		await updatePromise;
+	}
+	async failTask(task, error) {
+		if (task.status !== "running") {
+			this.logger.error(`Can't fail a task that is not running. [task = ${task.id}, status = ${task.status}]`);
+			throw new Error("Can't fail a task that is not running");
+		}
+		await this.updateTask({
+			...task,
+			status: "failed",
+			ended_at: /* @__PURE__ */ new Date(),
+			error
+		});
+	}
+	async completeTask(task, output) {
+		if (task.status !== "running") {
+			this.logger.error(`Can't complete a task that is not running. [task = ${task.id}, status = ${task.status}]`);
+			throw new Error("Can't complete a task that is not running");
+		}
+		await this.updateTask({
+			...task,
+			status: "completed",
+			ended_at: /* @__PURE__ */ new Date(),
+			output
+		});
+	}
+	async cancelTask(task) {
+		if (task.status !== "pending") {
+			this.logger.error(`Can't cancel a task that is not pending. [task = ${task.id}, status = ${task.status}]`);
+			throw new Error("Can't cancel a task that is not pending");
+		}
+		await this.updateTask({
+			...task,
+			status: "cancelled",
+			cancelled_at: /* @__PURE__ */ new Date()
+		});
+	}
+};
+
+//#endregion
+//#region task-list/task-list-tidb-provider.ts
+var TaskListTidbProvider = class extends TaskListProvider {
+	db;
+	constructor(agentName, logger) {
+		super(agentName, logger);
+		this.db = new Kysely({ dialect: new MysqlDialect({ pool: createPool({
+			uri: process.env.DATABASE_URL,
+			supportBigNumbers: true,
+			bigNumberStrings: true
+		}) }) });
+	}
+	async close() {
+		await this.db.destroy();
+	}
+	selectTask() {
+		return this.db.selectFrom("task").selectAll().where("agent", "=", this.agentName);
+	}
+	async getAgentConfig(projectId) {
+		const config = await this.db.selectFrom("agent_project_config").selectAll().where("project_id", "=", projectId).where("agent", "=", this.agentName).executeTakeFirst();
+		if (config == null) return null;
+		return config;
+	}
+	async setAgentConfig(config) {
+		await this.db.insertInto("agent_project_config").values({
+			agent: this.agentName,
+			...config
+		}).execute();
+	}
+	async getTask(taskId) {
+		const taskItem = await this.selectTask().where("id", "=", taskId).executeTakeFirst();
+		if (taskItem == null) return null;
+		return taskItemSchema.parse(taskItem);
+	}
+	async getTasks({ status, order_by, order_direction = "asc" } = {}) {
+		let builder = this.selectTask();
+		if (status && status.length > 0) builder = builder.where("status", "in", status);
+		if (order_by) builder = builder.orderBy(order_by, order_direction);
+		return (await builder.execute()).map((item) => taskItemSchema.parse(item));
+	}
+	async updateTask(taskItem) {
+		const { id, started_at, ended_at, queued_at, ...rest } = taskItem;
+		await this.db.updateTable("task").set({
+			started_at,
+			ended_at,
+			queued_at,
+			...rest
+		}).where("id", "=", id).where("agent", "=", this.agentName).execute();
+	}
+	async insertTask(taskItem) {
+		const { started_at, ended_at, queued_at, ...rest } = taskItem;
+		const { insertId } = await this.db.insertInto("task").values({
+			agent: this.agentName,
+			started_at,
+			ended_at,
+			queued_at,
+			...rest
+		}).executeTakeFirstOrThrow();
+		return {
+			...taskItem,
+			id: String(insertId)
+		};
+	}
+};
+
+//#endregion
+//#region ../sdk/src/lib/stream-parser.ts
+var StreamResponseParser = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async handleResponse(response, context) {
+		this.options.validateResponse?.(response);
+		if (!response.body) throw new Error("Response body is missing");
+		return this.options.pipe(response.body, Object.freeze({
+			...context,
+			response
+		}));
+	}
+};
+
+//#endregion
+//#region ../sdk/src/lib/validator.ts
+const VALIDATOR_SYMBOL = Symbol("validator");
+function isValidator(object) {
+	return typeof object === "object" && object !== null && object[VALIDATOR_SYMBOL] === true && typeof object.parse === "function";
+}
+
+//#endregion
+//#region ../../node_modules/url-template/lib/url-template.js
+function encodeReserved(str) {
+	return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
+		if (!/%[0-9A-Fa-f]/.test(part)) part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
+		return part;
+	}).join("");
+}
+function encodeUnreserved(str) {
+	return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+		return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+	});
+}
+function encodeValue(operator, value, key) {
+	value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
+	if (key) return encodeUnreserved(key) + "=" + value;
+	else return value;
+}
+function isDefined(value) {
+	return value !== void 0 && value !== null;
+}
+function isKeyOperator(operator) {
+	return operator === ";" || operator === "&" || operator === "?";
+}
+function getValues(context, operator, key, modifier) {
+	var value = context[key], result = [];
+	if (isDefined(value) && value !== "") if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+		value = value.toString();
+		if (modifier && modifier !== "*") value = value.substring(0, parseInt(modifier, 10));
+		result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));
+	} else if (modifier === "*") if (Array.isArray(value)) value.filter(isDefined).forEach(function(value) {
+		result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));
+	});
+	else Object.keys(value).forEach(function(k) {
+		if (isDefined(value[k])) result.push(encodeValue(operator, value[k], k));
+	});
+	else {
+		var tmp = [];
+		if (Array.isArray(value)) value.filter(isDefined).forEach(function(value) {
+			tmp.push(encodeValue(operator, value));
+		});
+		else Object.keys(value).forEach(function(k) {
+			if (isDefined(value[k])) {
+				tmp.push(encodeUnreserved(k));
+				tmp.push(encodeValue(operator, value[k].toString()));
+			}
+		});
+		if (isKeyOperator(operator)) result.push(encodeUnreserved(key) + "=" + tmp.join(","));
+		else if (tmp.length !== 0) result.push(tmp.join(","));
+	}
+	else if (operator === ";") {
+		if (isDefined(value)) result.push(encodeUnreserved(key));
+	} else if (value === "" && (operator === "&" || operator === "?")) result.push(encodeUnreserved(key) + "=");
+	else if (value === "") result.push("");
+	return result;
+}
+function parseTemplate(template) {
+	var operators = [
+		"+",
+		"#",
+		".",
+		"/",
+		";",
+		"?",
+		"&"
+	];
+	return { expand: function(context) {
+		return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function(_, expression, literal) {
+			if (expression) {
+				var operator = null, values = [];
+				if (operators.indexOf(expression.charAt(0)) !== -1) {
+					operator = expression.charAt(0);
+					expression = expression.substr(1);
+				}
+				expression.split(/,/g).forEach(function(variable) {
+					var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
+					values.push.apply(values, getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
+				});
+				if (operator && operator !== "+") {
+					var separator = ",";
+					if (operator === "?") separator = "&";
+					else if (operator !== "#") separator = operator;
+					return (values.length !== 0 ? operator : "") + values.join(separator);
+				} else return values.join(",");
+			} else return encodeReserved(literal);
+		});
+	} };
+}
+
+//#endregion
+//#region ../sdk/src/lib/api.ts
+function typeOf() {
+	return null;
+}
+function createUrlTemplate(method) {
+	return function(arr, ...params) {
+		let url = arr[0];
+		let expandedPaths = false;
+		for (let i = 1; i < arr.length; i++) if (params[i - 1] === "path*") {
+			url += "<path*>";
+			expandedPaths = true;
+		} else url += "{" + params[i - 1].replace(/\?$/, "") + "}" + arr[i];
+		const [pathPart, searchPart] = url.split("?");
+		const pathPartTemplate = expandedPaths ? { expand: (context) => {
+			return parseTemplate(pathPart.replace(/<path\*>/, String(context["path*"]).replace(/^\//, ""))).expand(context);
+		} } : parseTemplate(pathPart);
+		const searchParamsBuilders = [];
+		if (searchPart) searchPart.split("&").forEach((entry) => {
+			const [key, value = ""] = entry.split("=").map(decodeURIComponent);
+			if (/^\{[^}]+}$/.test(value)) {
+				const templateValue = value.slice(1, -1);
+				searchParamsBuilders.push((usp, context) => {
+					if (templateValue in context) {
+						const value = context[templateValue];
+						if (value === void 0) return;
+						if (Array.isArray(value)) value.forEach((v) => usp.append(key, String(v)));
+						else usp.append(key, String(value));
+					}
+				});
+			} else if (value !== "") {
+				const template = parseTemplate(value);
+				searchParamsBuilders.push((usp, context) => {
+					usp.append(key, template.expand(context));
+				});
+			} else searchParamsBuilders.push((usp) => {
+				usp.append(key, "");
+			});
+		});
+		return {
+			method,
+			signature: `${method} ${url}`,
+			templateUrl: url,
+			template: { expand: (context) => {
+				const pathPart = pathPartTemplate.expand(context);
+				const usp = new URLSearchParams();
+				searchParamsBuilders.forEach((template) => {
+					template(usp, context);
+				});
+				if (Array.from(usp).length > 0) return pathPart + "?" + usp.toString();
+				else return pathPart;
+			} },
+			__params__: typeOf()
+		};
+	};
+}
+const get = createUrlTemplate("get");
+const post = createUrlTemplate("post");
+const put = createUrlTemplate("put");
+const del = createUrlTemplate("delete");
+const patch = createUrlTemplate("patch");
+function defineApi(urlTemplate, _type, responseSchema) {
+	const method = urlTemplate.method;
+	return {
+		method: urlTemplate.method,
+		signature: urlTemplate.signature,
+		url: ((params) => urlTemplate.template.expand(params ?? {})),
+		requestInit: (body) => {
+			if (method === "get" || method === "delete") return { method };
+			if (body instanceof ReadableStream) return {
+				method,
+				body,
+				duplex: "half"
+			};
+			else if (body instanceof FormData) return {
+				method,
+				body
+			};
+			else return {
+				method,
+				body: JSON.stringify(body),
+				headers: { "Content-Type": "application/json" }
+			};
+		},
+		handleResponse: async (response, context) => {
+			if (responseSchema instanceof StreamResponseParser) return responseSchema.handleResponse(response, context);
+			else if (responseSchema === "text") return await response.text();
+			else if (responseSchema === "raw") return response;
+			else if (isValidator(responseSchema)) return responseSchema.parse(response);
+			else return responseSchema.parse(await response.json());
+		}
+	};
+}
+
+//#endregion
+//#region ../sdk/src/lib/zod.ts
+var ZodStream = class extends TransformStream {
+	constructor({ schema, onParseFailed }) {
+		super({ async transform(chunk, controller) {
+			const result = await schema.safeParseAsync(chunk);
+			if (result.success) controller.enqueue(result.data);
+			else if (onParseFailed) onParseFailed(result.error, chunk, controller);
+			else controller.error(result.error);
+		} });
+	}
+};
+const zodJsonDate = z.coerce.date();
+
+//#endregion
+//#region ../sdk/src/schemas/branch.ts
+const branchManifestArtifactSchema = z.object({
+	type: z.string(),
+	path: z.string(),
+	description: z.string()
+});
+const branchManifestSchema = z.object({
+	summary: z.string().optional(),
+	export: z.object({
+		include_patterns: z.string().array(),
+		exclude_patterns: z.string().array()
+	}).optional(),
+	artifacts: branchManifestArtifactSchema.array().optional()
+});
+const snapSchema = z.object({
+	snap_id: z.string(),
+	snap_status: z.string(),
+	snap_type: z.string(),
+	started_at: zodJsonDate,
+	finished_at: zodJsonDate,
+	exit_code: z.number().nullable(),
+	error: z.string().nullable(),
+	step_index: z.number(),
+	event_stream_id: z.string().nullable(),
+	tool_use_id: z.string().nullable(),
+	manifest_status: z.string().nullable(),
+	manifest_task_id: z.string().nullable(),
+	manifest_snap_id: z.string().nullable()
+});
+const snapDetailsSchema = snapSchema.extend({
+	output: z.string().nullable(),
+	command: z.string().array().nullable().optional()
+});
+const branchStatusSchema = z.enum([
+	"created",
+	"pending",
+	"running",
+	"ready_for_manifest",
+	"manifesting",
+	"succeed",
+	"failed"
+]);
+const branchSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	display_name: z.string(),
+	status: branchStatusSchema,
+	status_text: z.string().nullable(),
+	level: z.number(),
+	project_id: z.string(),
+	parent_id: z.string().nullable(),
+	created_at: zodJsonDate,
+	updated_at: zodJsonDate,
+	latest_snap_id: z.string().nullable(),
+	latest_snap: snapSchema.nullable(),
+	manifest: branchManifestSchema.nullable()
+});
+const branchSnapsSchema = z.object({
+	branch_id: z.string(),
+	branch_name: z.string(),
+	branch_status: branchStatusSchema,
+	branch_status_text: z.string().nullable(),
+	steps: z.array(snapDetailsSchema),
+	steps_total: z.number()
+});
+const branchExecutionResultSchema = z.object({
+	execution_id: z.string(),
+	status: z.string(),
+	status_text: z.string(),
+	branch_id: z.string(),
+	snap_id: z.string(),
+	background_task_id: z.string().nullable(),
+	started_at: zodJsonDate,
+	last_polled_at: zodJsonDate,
+	ended_at: zodJsonDate.nullable(),
+	exit_code: z.number().nullable()
+});
+
+//#endregion
+//#region ../sdk/src/schemas/common.ts
+function paged(schema) {
+	return z.object({
+		items: z.array(schema),
+		total: z.number(),
+		page: z.number(),
+		size: z.number(),
+		pages: z.number()
+	});
+}
+
+//#endregion
+//#region ../sdk/src/schemas/exploration.ts
+const createExplorationResultSchema = z.object({
+	id: z.string(),
+	project_id: z.string(),
+	parent_branch_id: z.string(),
+	baseline_branch_id: z.string().nullable(),
+	background_task_id: z.string().nullable(),
+	status: z.string(),
+	status_text: z.string().nullable(),
+	started_at: zodJsonDate.nullable(),
+	ended_at: zodJsonDate.nullable(),
+	branches: z.object({
+		branch_id: z.string(),
+		branch_name: z.string(),
+		branch_display_name: z.string(),
+		latest_snap_id: z.string(),
+		execution_results: branchExecutionResultSchema.array()
+	}).array()
+});
+const explorationSchema = z.object({
+	id: z.string(),
+	project_id: z.string(),
+	parent_branch_id: z.string(),
+	tdd_baseline_branch_id: z.string().nullable(),
+	background_task_id: z.string().nullable(),
+	num_branches: z.number().int(),
+	shared_prompt_sequence: z.string().array(),
+	status_text: z.string(),
+	call_agent: z.string().nullable(),
+	started_at: zodJsonDate.nullable(),
+	ended_at: zodJsonDate.nullable(),
+	created_at: zodJsonDate,
+	updated_at: zodJsonDate,
+	agent: z.string(),
+	status: z.string()
+});
+const explorationResultSchema = z.object({
+	id: z.string(),
+	project_id: z.string(),
+	parent_branch_id: z.string(),
+	baseline_branch_id: z.string().nullable(),
+	background_task_id: z.string().nullable(),
+	status: z.string(),
+	status_text: z.string(),
+	started_at: zodJsonDate,
+	ended_at: zodJsonDate.nullable(),
+	branches: z.object({
+		branch_id: z.string(),
+		branch_name: z.string(),
+		branch_display_name: z.string(),
+		latest_snap_id: z.string(),
+		execution_results: z.object({
+			execution_id: z.string(),
+			status: z.string(),
+			status_text: z.string(),
+			branch_id: z.string(),
+			snap_id: z.string(),
+			background_task_id: z.string().nullable(),
+			started_at: zodJsonDate,
+			last_polled_at: zodJsonDate,
+			ended_at: zodJsonDate.nullable(),
+			exit_code: z.number().nullable()
+		}).array()
+	}).array()
+});
+
+//#endregion
+//#region ../sdk/src/schemas/fs.ts
+const fsEntrySchema = z.object({
+	name: z.string(),
+	is_dir: z.boolean(),
+	size: z.number(),
+	mode: z.string(),
+	mod_time: zodJsonDate
+});
+const FSResponseValidator = Object.freeze({
+	[VALIDATOR_SYMBOL]: true,
+	__phantom__: typeOf(),
+	async parse(response) {
+		if (response.headers.get("Content-Type") === "application/json+directory") {
+			const data = await response.json();
+			return fsEntrySchema.array().parse(data);
+		} else {
+			const blob = await response.blob();
+			return new File([blob], response.url.split("/").pop(), { type: response.headers.get("content-type") ?? "application/octet-stream" });
+		}
+	}
+});
+
+//#endregion
+//#region ../sdk/src/schemas/ai.ts
+const providerMetadataSchema = z$1.record(z$1.string(), z$1.record(z$1.string(), z$1.any()));
+const messageMetadataSchema = z$1.object().loose();
+const toolsShapeMap = { fake: {
+	input: z$1.object({ fakeIn: z$1.string() }).loose(),
+	output: z$1.object({ fakeOut: z$1.string() }).loose()
+} };
+const dataTypes = {
+	delta: z$1.object().loose(),
+	"message-metadata": z$1.object().loose(),
+	"ui-collapsed": z$1.object({
+		toolParts: z$1.number(),
+		reasoningParts: z$1.number(),
+		collapsed: z$1.boolean(),
+		parts: z$1.object().loose().array()
+	}),
+	"ui-running-tools": z$1.object({
+		toolParts: z$1.object().loose().array(),
+		textParts: z$1.object().loose().array(),
+		reasoningParts: z$1.object().loose().array()
+	})
+};
+const chunksShapeMap = {
+	"text-start": {
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"text-delta": {
+		delta: z$1.string(),
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"text-end": {
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"reasoning-start": {
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"reasoning-delta": {
+		delta: z$1.string(),
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"reasoning-end": {
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	error: { errorText: z$1.string() },
+	"tool-input-available": {
+		toolCallId: z$1.string(),
+		toolName: z$1.string(),
+		input: z$1.unknown(),
+		providerExecuted: z$1.boolean().optional(),
+		providerMetadata: providerMetadataSchema.optional(),
+		dynamic: z$1.boolean().optional()
+	},
+	"tool-input-error": {
+		toolCallId: z$1.string(),
+		toolName: z$1.string(),
+		input: z$1.unknown(),
+		providerExecuted: z$1.boolean().optional(),
+		providerMetadata: providerMetadataSchema.optional(),
+		dynamic: z$1.boolean().optional(),
+		errorText: z$1.string()
+	},
+	"tool-output-available": {
+		toolCallId: z$1.string(),
+		output: z$1.unknown(),
+		providerExecuted: z$1.boolean().optional(),
+		dynamic: z$1.boolean().optional(),
+		preliminary: z$1.boolean().optional()
+	},
+	"tool-output-error": {
+		toolCallId: z$1.string(),
+		providerExecuted: z$1.boolean().optional(),
+		dynamic: z$1.boolean().optional(),
+		errorText: z$1.string()
+	},
+	"tool-input-start": {
+		toolCallId: z$1.string(),
+		toolName: z$1.string(),
+		providerExecuted: z$1.boolean().optional(),
+		dynamic: z$1.boolean().optional()
+	},
+	"tool-input-delta": {
+		toolCallId: z$1.string(),
+		inputTextDelta: z$1.string()
+	},
+	"source-url": {
+		sourceId: z$1.string(),
+		url: z$1.string(),
+		title: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"source-document": {
+		sourceId: z$1.string(),
+		mediaType: z$1.string(),
+		title: z$1.string(),
+		filename: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	file: {
+		url: z$1.string(),
+		mediaType: z$1.string()
+	},
+	"start-step": {},
+	"finish-step": {},
+	start: {
+		messageId: z$1.string().optional(),
+		messageMetadata: messageMetadataSchema.optional()
+	},
+	finish: { messageMetadata: messageMetadataSchema.optional() },
+	abort: {},
+	"message-metadata": { messageMetadata: messageMetadataSchema }
+};
+const unknownDataChunkSchema = z$1.object({
+	type: z$1.string().regex(/^data-/),
+	id: z$1.string().optional(),
+	data: z$1.unknown(),
+	transient: z$1.boolean().optional()
+});
+const dataChunkSchema = Object.entries(dataTypes).map(([name, schema]) => z$1.object({
+	type: z$1.literal(`data-${name}`),
+	id: z$1.string().optional(),
+	data: schema,
+	transient: z$1.boolean().optional()
+}));
+const chunkSchema = Object.entries(chunksShapeMap).map(([type, schema]) => z$1.object({
+	type: z$1.literal(type),
+	...schema
+}));
+const uiMessageChunkSchema = z$1.discriminatedUnion("type", [...chunkSchema, ...dataChunkSchema]);
+const partsShapeMap = {
+	text: {
+		text: z$1.string(),
+		state: z$1.enum(["streaming", "done"]).optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	reasoning: {
+		text: z$1.string(),
+		state: z$1.enum(["streaming", "done"]).optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"source-url": {
+		sourceId: z$1.string(),
+		url: z$1.string(),
+		title: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"source-document": {
+		sourceId: z$1.string(),
+		mediaType: z$1.string(),
+		title: z$1.string(),
+		filename: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	file: {
+		url: z$1.string(),
+		mediaType: z$1.string(),
+		filename: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"step-start": {}
+};
+const dynamicToolSchema = z$1.discriminatedUnion("state", [
+	z$1.object({
+		type: z$1.literal("dynamic-tool"),
+		toolName: z$1.string(),
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-streaming"),
+		input: z$1.unknown().optional(),
+		output: z$1.never().optional(),
+		errorText: z$1.never().optional()
+	}),
+	z$1.object({
+		type: z$1.literal("dynamic-tool"),
+		toolName: z$1.string(),
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-available"),
+		input: z$1.unknown(),
+		output: z$1.never().optional(),
+		errorText: z$1.never().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	}),
+	z$1.object({
+		type: z$1.literal("dynamic-tool"),
+		toolName: z$1.string(),
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-available"),
+		input: z$1.unknown(),
+		output: z$1.unknown(),
+		errorText: z$1.never().optional(),
+		callProviderMetadata: providerMetadataSchema.optional(),
+		preliminary: z$1.boolean().optional()
+	}),
+	z$1.object({
+		type: z$1.literal("dynamic-tool"),
+		toolName: z$1.string(),
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-error"),
+		input: z$1.unknown(),
+		output: z$1.never().optional(),
+		errorText: z$1.string(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	})
+]);
+const dataPartSchema = Object.entries(dataTypes).map(([name, schema]) => z$1.object({
+	type: z$1.literal(`data-${name}`),
+	id: z$1.string().optional(),
+	data: schema
+}));
+const notDefinedDataType = z$1.string().regex(/data-/).refine((type) => !Object.keys(dataTypes).includes(type.slice(5)));
+const unknownDataPartSchema = z$1.object({
+	type: notDefinedDataType,
+	id: z$1.string().optional(),
+	data: z$1.unknown()
+});
+const notDefinedToolType = z$1.string().regex(/tool-/).refine((type) => !Object.keys(toolsShapeMap).includes(type.slice(5)));
+const unknownToolPartSchema = z$1.discriminatedUnion("state", [
+	z$1.object({
+		type: notDefinedToolType,
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-streaming"),
+		input: z$1.unknown().optional(),
+		output: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		errorText: z$1.never().optional()
+	}),
+	z$1.object({
+		type: notDefinedToolType,
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-available"),
+		input: z$1.unknown(),
+		output: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		errorText: z$1.never().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	}),
+	z$1.object({
+		type: notDefinedToolType,
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-available"),
+		input: z$1.unknown(),
+		output: z$1.unknown(),
+		errorText: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		callProviderMetadata: providerMetadataSchema.optional(),
+		preliminary: z$1.boolean().optional()
+	}),
+	z$1.object({
+		type: notDefinedToolType,
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-error"),
+		input: z$1.unknown().optional(),
+		rawInput: z$1.unknown().optional(),
+		output: z$1.never().optional(),
+		errorText: z$1.string(),
+		providerExecuted: z$1.boolean().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	})
+]);
+const partSchema = Object.entries(partsShapeMap).map(([type, schema]) => z$1.object({
+	type: z$1.literal(type),
+	...schema
+}));
+const toolsPartSchema = Object.entries(toolsShapeMap).map(([type, schema]) => z$1.discriminatedUnion("state", [
+	z$1.object({
+		type: z$1.literal(`tool-${type}`),
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-streaming"),
+		input: schema.input.partial().optional(),
+		output: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		errorText: z$1.never().optional()
+	}),
+	z$1.object({
+		type: z$1.literal(`tool-${type}`),
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-available"),
+		input: schema.input,
+		output: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		errorText: z$1.never().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	}),
+	z$1.object({
+		type: z$1.literal(`tool-${type}`),
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-available"),
+		input: schema.input,
+		output: schema.output,
+		errorText: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		callProviderMetadata: providerMetadataSchema.optional(),
+		preliminary: z$1.boolean().optional()
+	}),
+	z$1.object({
+		type: z$1.literal(`tool-${type}`),
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-error"),
+		input: schema.input.optional(),
+		rawInput: z$1.unknown().optional(),
+		output: z$1.never().optional(),
+		errorText: z$1.string(),
+		providerExecuted: z$1.boolean().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	})
+]));
+const uiMessagePartSchema = z$1.discriminatedUnion("type", [
+	...partSchema,
+	...toolsPartSchema,
+	...dataPartSchema,
+	dynamicToolSchema
+]);
+
+//#endregion
+//#region ../sdk/src/schemas/project.ts
+const projectMetaGitHubSchema = z.object({
+	repo_owner_login: z.string().optional(),
+	repo_name: z.string().optional(),
+	issue_type: z.string().optional(),
+	issue_number: z.number().optional()
+}).optional();
+const projectMetaSchema = z.object({ github: projectMetaGitHubSchema }).optional().nullable();
+const projectSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	display_name: z.string(),
+	category: z.string(),
+	description: z.string(),
+	user_id: z.string().nullable(),
+	owner_email: z.string().nullable().optional(),
+	root_branch_id: z.string().nullable(),
+	ongoing_stream_id: z.string().nullable(),
+	status: z.enum([
+		"CREATED",
+		"PROVISIONING",
+		"READY",
+		"RUNNING",
+		"PAUSED",
+		"FAILED",
+		"ARCHIVED"
+	]).nullable().optional(),
+	error_message: z.string().nullable().optional(),
+	meta: projectMetaSchema,
+	github_source_owner_id: z.number().nullable().optional(),
+	github_source_repo_id: z.number().nullable().optional(),
+	github_source_number: z.number().nullable().optional(),
+	created_at: zodJsonDate,
+	updated_at: zodJsonDate,
+	branches_total: z.number().int().nullable().optional(),
+	background_tasks_total: z.number().int().nullable().optional()
+});
+const projectMessageSchema = z.object({
+	id: z.string(),
+	role: z.enum([
+		"system",
+		"user",
+		"assistant"
+	]),
+	metadata: messageMetadataSchema.nullable().optional(),
+	parts: z.array(z.object().loose()),
+	ordinal: z.number(),
+	project_id: z.string(),
+	user_id: z.string().nullable(),
+	source_request_id: z.string().nullable().optional(),
+	event_stream_id: z.string().nullable(),
+	status: z.string().nullable(),
+	is_finished: z.boolean(),
+	created_at: zodJsonDate,
+	updated_at: zodJsonDate
+});
+const projectMessageStreamParser = new StreamResponseParser({ pipe: (input) => {
+	return input.pipeThrough(new TextDecoderStream()).pipeThrough(new BufferedLinesStream("\n\n")).pipeThrough(new SSEDataDecoderStream()).pipeThrough(new ZodStream({ schema: z.object().loose() }));
+} });
+const projectRawMessageStreamParser = new StreamResponseParser({ pipe: (input) => {
+	return input.pipeThrough(new TextDecoderStream()).pipeThrough(new BufferedLinesStream("\n\n")).pipeThrough(new SSEDataDecoderStream()).pipeThrough(new ZodStream({ schema: z.object().loose() }));
+} });
+const projectQueuedRequestSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	payload: z.unknown(),
+	requested_at: zodJsonDate,
+	summary: z.string()
+});
+const projectBackgroundTaskSchema = z.object({
+	task_id: z.string(),
+	name: z.string().nullable(),
+	action_type: z.enum(["execution", "exploration"]),
+	action_id: z.string(),
+	status: z.enum([
+		"SUCCESS",
+		"FAILURE",
+		"PENDING",
+		"STARTED"
+	]).nullable(),
+	result: z.object().loose().nullable(),
+	retries: z.number().nullable(),
+	started_at: zodJsonDate.nullable(),
+	last_polled_at: zodJsonDate.nullable(),
+	ended_at: zodJsonDate.nullable()
+});
+var BufferedLinesStream = class extends TransformStream {
+	constructor(sep = "\n") {
+		let buffer = "";
+		super({
+			transform(chunk, controller) {
+				chunk = buffer += chunk;
+				while (true) {
+					const index = chunk.indexOf(sep);
+					if (index === -1) {
+						buffer = chunk;
+						break;
+					}
+					const line = chunk.slice(0, index).trim();
+					if (line) controller.enqueue(line);
+					chunk = chunk.slice(index + sep.length);
+				}
+			},
+			flush() {
+				if (buffer) console.warn("buffered lines stream has unprocessed lines:", buffer);
+			}
+		});
+	}
+};
+var SSEDataDecoderStream = class extends TransformStream {
+	constructor() {
+		let handle = void 0;
+		super({ transform: (chunk, controller) => {
+			clearTimeout(handle);
+			handle = setTimeout(() => {
+				controller.error(/* @__PURE__ */ new Error("Read timeout, please retry."));
+			}, 15e3);
+			if (/^data:/.test(chunk)) {
+				const part = chunk.replace(/^data: /, "").trim();
+				if (part === "[DONE]") {} else try {
+					controller.enqueue(JSON.parse(part));
+				} catch (e) {
+					console.error("invalid sse chunk", chunk, e);
+					controller.error(e);
+				}
+			}
+		} });
+	}
+};
+
+//#endregion
+//#region ../sdk/src/api/projects.ts
+const listProjects = defineApi(get`/api/v1/projects?page=${"page"}&size=${"size"}&user_id=${"user_id?"}&category=${"category?"}&github_source_owner_id=${"github_source_owner_id?"}&github_source_repo_id=${"github_source_repo_id?"}`, null, paged(projectSchema));
+const listAdminProjects = defineApi(get`/api/v1/admin/projects?page=${"page"}&size=${"size"}&org_id=${"org_id?"}&user_id=${"user_id?"}&category=${"category?"}&github_source_owner_id=${"github_source_owner_id?"}&github_source_repo_id=${"github_source_repo_id?"}`, null, paged(projectSchema));
+const getProject = defineApi(get`/api/v1/projects/${"projectId"}`, null, projectSchema);
+const transferProject = defineApi(post`/api/v1/projects/${"projectId"}/transfer`, typeOf(), projectSchema);
+const createProject = defineApi(post`/api/v1/projects`, typeOf(), projectSchema);
+const listProjectMessages = defineApi(get`/api/v1/projects/${"projectId"}/messages`, null, z.object({
+	messages: projectMessageSchema.array(),
+	ongoing_stream_id: z.string().nullable()
+}));
+const deleteProjectMessage = defineApi(del`/api/v1/projects/${"projectId"}/messages/${"messageId"}`, null, "raw");
+const postProjectMessage = defineApi(post`/api/v1/projects/${"projectId"}`, typeOf(), z.object({
+	messages: projectMessageSchema.array(),
+	ongoing_stream_id: z.string().nullable()
+}));
+const continueProject = defineApi(post`/api/v1/projects/${"projectId"}/continue`, typeOf(), "raw");
+const stopProject = defineApi(post`/api/v1/projects/${"projectId"}/stop`, typeOf(), "raw");
+const getProjectBranch = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}`, null, branchSchema);
+const getProjectBranchOutput = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/output?full_output=${"fullOutput?"}`, null, "text");
+const listProjectBranches = defineApi(get`/api/v1/projects/${"projectId"}/branches?page=${"page"}&size=${"size"}`, null, paged(branchSchema));
+const listProjectBranchSnaps = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/snaps`, null, branchSnapsSchema);
+const listProjectBackgroundTasks = defineApi(get`/api/v1/projects/${"projectId"}/background_tasks?statuses=${"statuses?"}`, null, z.array(projectBackgroundTaskSchema));
+const createProjectExploration = defineApi(post`/api/v1/projects/${"projectId"}/explorations`, typeOf(), createExplorationResultSchema);
+const listProjectExplorations = defineApi(get`/api/v1/projects/${"projectId"}/explorations`, null, explorationSchema.array());
+const getProjectExplorationResult = defineApi(get`/api/v1/projects/${"projectId"}/explorations/${"explorationId"}/result`, null, explorationResultSchema);
+const getProjectBranchFs = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/fs/${"path*"}`, null, FSResponseValidator);
+const getProjectBranchFsPreview = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/preview/${"path*"}`, null, FSResponseValidator);
+
+//#endregion
+//#region ../sdk/src/api/connectors.ts
+const getGithubUser = defineApi(get`/api/v1/connectors/github/user`, null, z.object({ github_username: z.string() }).nullable());
+const disconnectGithub = defineApi(post`/api/v1/connectors/github/disconnect`, null, z.object({ success: z.boolean() }));
+const listGithubRepositories = defineApi(get`/api/v1/user/github/repositories?page=${"page"}&size=${"size"}`, null, paged(z.object({
+	repo_id: z.number(),
+	repo_name: z.string(),
+	public: z.boolean(),
+	installation_id: z.number()
+})));
+
+//#endregion
+//#region ../sdk/src/schemas/organizations.ts
+const organizationItemSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	is_personal: z.boolean(),
+	created_at: z.string().nullable(),
+	updated_at: z.string().nullable()
+});
+const organizationSchema = organizationItemSchema;
+const organizationDeleteSchema = z.object({ success: z.boolean() });
+const organizationRoleSchema = z.enum(["owner", "member"]);
+const organizationMemberSchema = z.object({
+	org_id: z.string(),
+	user_id: z.string(),
+	email: z.string().nullable().optional(),
+	github_username: z.string().nullable().optional(),
+	role: organizationRoleSchema,
+	created_at: z.string().nullable(),
+	updated_at: z.string().nullable()
+});
+const addOrgMemberResponseSchema = z.object({
+	member: organizationMemberSchema.nullable().optional(),
+	email_sent: z.boolean().nullable().optional(),
+	invite_link: z.string().nullable().optional()
+});
+const invitationStatusSchema = z.enum(["pending", "accepted"]);
+const organizationInvitationSchema = z.object({
+	id: z.string(),
+	org_id: z.string(),
+	org_role: organizationRoleSchema,
+	email: z.string().nullable(),
+	github_username: z.string().nullable(),
+	invited_by: z.string(),
+	status: invitationStatusSchema,
+	created_at: z.string().nullable(),
+	updated_at: z.string().nullable()
+});
+
+//#endregion
+//#region ../sdk/src/schemas/github.ts
+const githubAppInstallationSchema = z.object({
+	installation_id: z.number(),
+	github_account_id: z.number(),
+	github_account_login: z.string(),
+	github_account_type: z.string(),
+	org_id: z.string().nullable()
+});
+const githubAppInstallationAdminItemSchema = z.object({
+	installation_id: z.number(),
+	github_account_id: z.number(),
+	github_account_login: z.string(),
+	github_account_type: z.string(),
+	org_id: z.string().nullable(),
+	org_name: z.string().nullable(),
+	installer_user_id: z.string().nullable(),
+	installer_email: z.string().nullable(),
+	created_at: z.string().nullable(),
+	updated_at: z.string().nullable()
+});
+const githubRepositorySchema = z.object({
+	repo_id: z.number(),
+	repo_name: z.string(),
+	public: z.boolean(),
+	installation_id: z.number(),
+	enabled: z.boolean().default(false)
+});
+const githubAutoReviewConfigSchema = z.object({
+	enabled: z.boolean(),
+	enable_for_non_linked_users: z.boolean().default(false),
+	auto_incremental_review: z.boolean(),
+	labels: z.array(z.string()),
+	drafts: z.boolean(),
+	base_branches: z.array(z.string()),
+	ignore_usernames: z.array(z.string())
+});
+const githubRepoSettingsConfigSchema = z.object({
+	allow_usernames: z.array(z.string()),
+	auto_review: githubAutoReviewConfigSchema
+});
+const githubRepoSettingsPublicSchema = z.object({
+	enabled: z.boolean(),
+	config: githubRepoSettingsConfigSchema
+});
+const githubRepoSettingsUpdateSchema = z.object({
+	enabled: z.boolean().optional(),
+	config: githubRepoSettingsConfigSchema.optional()
+});
+
+//#endregion
+//#region ../sdk/src/api/organizations.ts
+const listOrganizations = defineApi(get`/api/v1/orgs?page=${"page"}&size=${"size"}`, null, paged(organizationItemSchema));
+const getOrganization = defineApi(get`/api/v1/orgs/${"orgId"}`, null, organizationSchema);
+const createOrganization = defineApi(post`/api/v1/orgs`, typeOf(), organizationSchema);
+const updateOrganization = defineApi(put`/api/v1/orgs/${"orgId"}`, typeOf(), organizationSchema);
+const deleteOrganization = defineApi(del`/api/v1/orgs/${"orgId"}`, null, organizationDeleteSchema);
+const listOrganizationMembers = defineApi(get`/api/v1/orgs/${"orgId"}/members?page=${"page"}&size=${"size"}`, null, paged(organizationMemberSchema));
+const listOrganizationInvitations = defineApi(get`/api/v1/orgs/${"orgId"}/invitations?page=${"page"}&size=${"size"}&status=${"status?"}`, null, paged(organizationInvitationSchema));
+const revokeOrganizationInvitation = defineApi(del`/api/v1/orgs/${"orgId"}/invitations/${"invitationId"}`, null, z.object({ success: z.boolean() }));
+const addOrganizationMember = defineApi(post`/api/v1/orgs/${"orgId"}/members`, typeOf(), addOrgMemberResponseSchema);
+const updateOrganizationMemberRole = defineApi(put`/api/v1/orgs/${"orgId"}/members/${"memberId"}`, typeOf(), organizationMemberSchema);
+const removeOrganizationMember = defineApi(del`/api/v1/orgs/${"orgId"}/members/${"memberId"}`, null, z.object({ success: z.boolean() }));
+const listOrganizationGithubInstallations = defineApi(get`/api/v1/orgs/${"orgId"}/github/installations`, null, z.array(githubAppInstallationSchema));
+const listOrgLinkedAccounts = defineApi(get`/api/v1/orgs/${"orgId"}/github/linked_accounts`, null, z.array(githubAppInstallationSchema));
+const listOrgLinkedRepositories = defineApi(get`/api/v1/orgs/${"orgId"}/github/linked_repositories`, null, z.array(githubRepositorySchema));
+const listOrganizationGithubRepositories = defineApi(get`/api/v1/orgs/${"orgId"}/github/installations/${"installationId"}/repos`, null, z.array(githubRepositorySchema));
+const listOrganizationProjects = defineApi(get`/api/v1/orgs/${"orgId"}/projects?page=${"page"}&size=${"size"}&query=${"query?"}&category=${"category?"}&github_source_owner_id=${"github_source_owner_id?"}&github_source_repo_id=${"github_source_repo_id?"}`, null, paged(projectSchema));
+const createOrganizationProject = defineApi(post`/api/v1/orgs/${"orgId"}/projects`, typeOf(), projectSchema);
+const getOrganizationGithubRepoSettings = defineApi(get`/api/v1/orgs/${"orgId"}/github/installations/${"installationId"}/repos/${"repoId"}/settings`, null, githubRepoSettingsPublicSchema);
+const updateOrganizationGithubRepoSettings = defineApi(put`/api/v1/orgs/${"orgId"}/github/installations/${"installationId"}/repos/${"repoId"}/settings`, typeOf(), githubRepoSettingsPublicSchema);
+
+//#endregion
+//#region ../sdk/src/api/stream-proxy.ts
+const readMessageStream = defineApi(get`/ai_stream_proxy/v2/streams/${"streamId"}/stream?format=vercel-ai-ui-message-stream-v1&skip=${"skip?"}`, null, projectMessageStreamParser);
+const readRawMessageStream = defineApi(get`/ai_stream_proxy/v2/streams/${"streamId"}/stream?format=opaque-stream-json`, null, projectRawMessageStreamParser);
+
+//#endregion
+//#region ../sdk/src/schemas/api-key.ts
+const publicApiKeySchema = z.object({
+	id: z.union([z.string(), z.number()]).transform(String),
+	description: z.string().nullable().optional(),
+	api_key_display: z.string(),
+	created_at: zodJsonDate,
+	updated_at: zodJsonDate.optional(),
+	is_active: z.boolean(),
+	user_id: z.string()
+});
+const apiKeyCreateRequestSchema = z.object({ description: z.string() });
+const apiKeyCreateResponseSchema = publicApiKeySchema.extend({ api_key: z.string() });
+
+//#endregion
+//#region ../sdk/src/api/user-api-keys.ts
+const listUserApiKeys = defineApi(get`/api/v1/user/api-keys?page=${"page"}&size=${"size"}`, null, paged(publicApiKeySchema));
+const createUserApiKey = defineApi(post`/api/v1/user/api-keys`, typeOf(), apiKeyCreateResponseSchema);
+const deleteUserApiKey = defineApi(del`/api/v1/user/api-keys/${"apiKeyId"}`, null, "raw");
+
+//#endregion
+//#region ../sdk/src/lib/api-executor.ts
+var ApiError = class extends Error {
+	response;
+	context;
+	responseBody;
+	constructor(response, context, responseBody) {
+		super(`${context.request.method} ${context.url}: ${response.status} ${response.statusText} ${getServerErrorMessage(responseBody)}`);
+		this.response = response;
+		this.context = context;
+		this.responseBody = responseBody;
+	}
+};
+function createApiExecutor({ baseUrl, headers, validateResponse }) {
+	const errorCallbacks = [];
+	function onError(callback) {
+		errorCallbacks.push(callback);
+		return () => {
+			const index = errorCallbacks.indexOf(callback);
+			if (index !== -1) errorCallbacks.splice(index, 1);
+		};
+	}
+	async function execute(api, params, requestBody, requestInit) {
+		const url = baseUrl ? new URL(api.url(params), baseUrl).toString() : api.url(params);
+		const { headers: initHeaders, ...init } = api.requestInit(requestBody);
+		const executorHeaders = new Headers(headers);
+		if (initHeaders) new Headers(initHeaders).forEach((value, key) => {
+			executorHeaders.set(key, value);
+		});
+		const request = new Request(url, {
+			...requestInit,
+			...init,
+			headers: executorHeaders,
+			credentials: "include"
+		});
+		const context = Object.freeze({
+			api,
+			params,
+			requestBody,
+			url,
+			request
+		});
+		try {
+			const response = await fetch(request);
+			await validateResponse(response, context);
+			return await api.handleResponse(response, context);
+		} catch (error) {
+			for (const callback of errorCallbacks) callback(error, context);
+			return Promise.reject(error);
+		}
+	}
+	return Object.freeze({
+		execute,
+		onError
+	});
+}
+async function validateResponse(response, context) {
+	if (!response.ok) throw new ApiError(response, context, await response.clone().json().catch(() => response.clone().text()).catch(() => void 0));
+}
+function getServerErrorMessage(error) {
+	if (error == null) return "No error message.";
+	if (typeof error === "string") return error;
+	if (typeof error === "object") {
+		for (const key of [
+			"message",
+			"error",
+			"errMsg",
+			"errorMsg",
+			"detail",
+			"details"
+		]) if (key in error) if (typeof error[key] === "string") return error[key];
+		else return JSON.stringify(error[key], void 0, 2);
+		return JSON.stringify(error, void 0, 2);
+	}
+	return String(error);
+}
+
+//#endregion
+//#region core/pantheon.ts
+const executor = createApiExecutor({
+	baseUrl: "https://pantheon-ai.tidb.ai",
+	headers: { Authorization: `Bearer ${process.env.PANTHEON_API_KEY}` },
+	validateResponse
+});
+async function getPantheonProjectInfo({ projectId }) {
+	return await executor.execute(getProject, { projectId }, null);
+}
+async function getPantheonBranch({ projectId, branchId, getOutputIfFinished = false, manifestingAsSucceed = false }) {
+	const branch = await executor.execute(getProjectBranch, {
+		projectId,
+		branchId
+	}, null);
+	if (branch.status === "succeed" || manifestingAsSucceed && (branch.status === "manifesting" || branch.status === "ready_for_manifest")) if (getOutputIfFinished) return {
+		state: "succeed",
+		output: await executor.execute(getProjectBranchOutput, {
+			projectId,
+			branchId,
+			fullOutput: true
+		}, null)
+	};
+	else return { state: "succeed" };
+	else if (branch.status === "failed") {
+		let error = branch.latest_snap?.error;
+		if (!error) {
+			error = await executor.execute(getProjectBranchOutput, {
+				projectId,
+				branchId,
+				fullOutput: true
+			}, null);
+			error = `No error message, the latest output:\n\n${error}`;
+		}
+		return {
+			state: "failed",
+			error
+		};
+	}
+	return { state: "others" };
+}
+async function executeOnPantheon({ projectId, branchId, prompt, agent }) {
+	return (await executor.execute(createProjectExploration, { projectId }, {
+		shared_prompt_sequence: [prompt],
+		num_branches: 1,
+		agent,
+		parent_branch_id: branchId
+	})).branches[0].branch_id;
+}
+
+//#endregion
+//#region core/task-list.ts
+async function startTaskListLoop(agentName, { loopInterval = 5 }, logger) {
+	logger.info("Starting task list loop...");
+	let i = 0;
+	const abortController = new AbortController();
+	let sleepTimeout;
+	process.on("SIGINT", (signal) => {
+		logger.info(`Received ${signal}, shutting down gracefully...`);
+		clearTimeout(sleepTimeout);
+		abortController.abort(signal);
+	});
+	process.on("SIGTERM", (signal) => {
+		logger.info(`Received ${signal}, force shutting down...`);
+		clearTimeout(sleepTimeout);
+		abortController.abort(signal);
+		process.exit(1);
+	});
+	const provider = new TaskListTidbProvider(agentName, logger);
+	while (!abortController.signal.aborted) {
+		await loopOnce(provider, logger.child({ name: `loop:${i++}` }));
+		await new Promise((resolve) => {
+			abortController.signal.addEventListener("abort", resolve);
+			sleepTimeout = setTimeout(() => {
+				abortController.signal.removeEventListener("abort", resolve);
+				resolve(false);
+			}, loopInterval * 1e3);
+		});
+	}
+	await provider.close();
+	process.exit(0);
+}
+async function loopOnce(provider, logger) {
+	logger.info("Loop start.");
+	const tasks = await provider.getTasks({ status: ["pending", "running"] });
+	const runningTasks = tasks.filter((task) => task.status === "running");
+	const pendingTasks = tasks.filter((task) => task.status === "pending");
+	logger.info(`Found ${tasks.length} tasks, ${runningTasks.length} running, ${pendingTasks.length} pending.`);
+	if (runningTasks.length > 1) logger.warn("More than one task is running, this is not expected. %o", runningTasks.map((task) => task.id));
+	const nextTask = pendingTasks[0];
+	if (runningTasks.length > 0) {
+		if ((await Promise.allSettled(runningTasks.map(async (task) => {
+			await pollRunningTaskState(provider, task, logger.child({ name: `task:${task.id}:poll` }));
+		}))).some((result) => result.status === "rejected")) logger.warn("Failed to poll state for one or more running tasks");
+	} else if (nextTask) try {
+		await startPendingTask(provider, pendingTasks[0], logger.child({ name: `task:${nextTask.id}:start` }));
+	} catch (e) {
+		logger.error(`Failed to start task ${nextTask.id}: ${getErrorMessage(e)}`);
+	}
+	else logger.info("No tasks to process.");
+}
+async function pollRunningTaskState(provider, state, logger) {
+	const newStatus = await getPantheonBranch({
+		projectId: state.project_id,
+		branchId: state.branch_id,
+		getOutputIfFinished: true
+	});
+	if (newStatus.state === "succeed") {
+		logger.info("Task completed with output: %s", newStatus.output);
+		await provider.completeTask(state, newStatus.output || "(no output)");
+	} else if (newStatus.state === "failed") {
+		logger.info("Task failed with error: %s", newStatus.error);
+		await provider.failTask(state, newStatus.error);
+	} else logger.info("Task is still pending");
+}
+async function startPendingTask(provider, task, logger) {
+	const config = await provider.getAgentConfig(task.project_id);
+	if (!config) {
+		logger.warn("Agent configuration not found for project %s. Skip starting tasks.", task.project_id);
+		return;
+	}
+	await provider.startTask(task, async () => {
+		return await executeOnPantheon({
+			projectId: task.project_id,
+			branchId: task.base_branch_id,
+			prompt: task.task,
+			agent: config.execute_agent
+		});
+	});
+	logger.info(`Task ${task.id} started successfully.`);
+}
+
+//#endregion
+//#region core/index.ts
+async function runAgent(name, options, logger) {
+	const agentDir = path.join(options.dataDir, "agents", name);
+	const pidFile = path.join(agentDir, "pid");
+	await fs$1.promises.mkdir(agentDir, { recursive: true });
+	await assertsSingleton(logger, pidFile);
+	await startTaskListLoop(name, { loopInterval: options.loopInterval }, logger);
+}
+async function configAgent(name, options) {
+	const provider = new TaskListTidbProvider(name, pino());
+	const previousConfig = await provider.getAgentConfig(options.projectId);
+	if (previousConfig) if (previousConfig.role === options.role) {
+		console.log(`Agent ${name} already configured as ${options.role} for project ${options.projectId}.`);
+		console.log(`Base branch id: ${previousConfig.base_branch_id}`);
+		return;
+	} else {
+		console.error(`Agent ${name} already configured as ${previousConfig.role} for project ${options.projectId}.`);
+		console.error(`Base branch id: ${previousConfig.base_branch_id}`);
+		console.error(`Cannot change role to ${options.role}`);
+		await provider.close();
+		process.exitCode = 1;
+		return;
+	}
+	console.log(`Configuring agent ${name} as ${options.role} for project ${options.projectId}.`);
+	if (!options.rootBranchId) {
+		console.log("No root branch id specified, using project root branch.");
+		const project = await getPantheonProjectInfo({ projectId: options.projectId });
+		if (!project.root_branch_id) {
+			console.error(`Project ${options.projectId} has no root branch. Project status is ${project.status}`);
+			await provider.close();
+			process.exitCode = 1;
+			return;
+		}
+		options.rootBranchId = project.root_branch_id;
+	}
+	if (options.bootstrap) {
+		const branchId = await executeOnPantheon({
+			projectId: options.projectId,
+			branchId: options.rootBranchId,
+			agent: "codex",
+			prompt: `You must follow these instructions to setup base branch for role "${options.role}":
+1. Clone the main branch from https://github.com/pingcap-inc/pantheon-agents to a temporary directory.
+2. Copy the pantheon-agents/roles/${options.role}/AGENTS.md to \`<workspace>/AGENTS.md\`.
+3. Copy the pantheon-agents/skills directory to \`<workspace>/.codex/\`
+
+Validate <workspace>: check if files and directorys exists:
+- AGENTS.md
+- .codex/skills
+`
+		});
+		let retried = 0;
+		const maxRetries = 3;
+		let i = 0;
+		console.log(`Bootstrap branch created: ${branchId}. Waiting for ready... [poll interval = 10s]`);
+		while (true) {
+			await new Promise((resolve) => {
+				setTimeout(resolve, 1e4);
+			});
+			const result = await getPantheonBranch({
+				branchId,
+				projectId: options.projectId,
+				getOutputIfFinished: true
+			}).then((result) => {
+				retried = 0;
+				return result;
+			}).catch((reason) => {
+				if (retried < maxRetries) {
+					retried++;
+					return { state: "others" };
+				} else throw new Error(`Failed to get bootstrap branch status. Retry ${retried} times. Last error: ${getErrorMessage(reason)}`);
+			});
+			if (result.state === "failed") {
+				console.error("Bootstrap failed: " + result.error);
+				await provider.close();
+				process.exit(1);
+			}
+			if (result.state === "succeed") {
+				console.log("Bootstrap succeeded. Output is:");
+				console.log(result.output);
+				break;
+			}
+			console.log(`Bootstrap in progress... [${++i}]`);
+		}
+		await provider.setAgentConfig({
+			project_id: options.projectId,
+			base_branch_id: branchId,
+			execute_agent: options.executeAgent,
+			role: options.role,
+			prototype_url: "https://github.com/pingcap-inc/pantheon-agents"
+		});
+	} else await provider.setAgentConfig({
+		project_id: options.projectId,
+		base_branch_id: options.rootBranchId,
+		execute_agent: options.executeAgent,
+		role: options.role,
+		prototype_url: "https://github.com/pingcap-inc/pantheon-agents"
+	});
+	console.log(`Agent ${name} configured successfully.`);
+	await provider.close();
+}
+async function addTask(name, options) {
+	const provider = new TaskListTidbProvider(name, pino());
+	const config = await provider.getAgentConfig(options.projectId);
+	if (!config) throw new Error(`Agent ${name} not configured for project ${options.projectId}`);
+	const task = await provider.createTask({
+		task: options.prompt,
+		project_id: options.projectId,
+		base_branch_id: config.base_branch_id
+	});
+	console.log(`Task ${task.task} queued successfully.`);
+	await provider.close();
+}
+async function assertsSingleton(logger, pidFile) {
+	try {
+		const pid = await fs$1.promises.readFile(pidFile, "utf-8");
+		process.kill(parseInt(pid), 0);
+		console.error("Failed to assert singleton agent process:");
+		process.exit(1);
+	} catch (e) {
+		await fs$1.promises.writeFile(pidFile, process.pid.toString());
+		process.on("exit", () => {
+			fs$1.promises.rm(pidFile);
+		});
+	}
+}
+
+//#endregion
+//#region ../../node_modules/dotenv/package.json
+var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "dotenv",
+		"version": "17.2.4",
+		"description": "Loads environment variables from .env file",
+		"main": "lib/main.js",
+		"types": "lib/main.d.ts",
+		"exports": {
+			".": {
+				"types": "./lib/main.d.ts",
+				"require": "./lib/main.js",
+				"default": "./lib/main.js"
+			},
+			"./config": "./config.js",
+			"./config.js": "./config.js",
+			"./lib/env-options": "./lib/env-options.js",
+			"./lib/env-options.js": "./lib/env-options.js",
+			"./lib/cli-options": "./lib/cli-options.js",
+			"./lib/cli-options.js": "./lib/cli-options.js",
+			"./package.json": "./package.json"
+		},
+		"scripts": {
+			"dts-check": "tsc --project tests/types/tsconfig.json",
+			"lint": "standard",
+			"pretest": "npm run lint && npm run dts-check",
+			"test": "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+			"test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+			"prerelease": "npm test",
+			"release": "standard-version"
+		},
+		"repository": {
+			"type": "git",
+			"url": "git://github.com/motdotla/dotenv.git"
+		},
+		"homepage": "https://github.com/motdotla/dotenv#readme",
+		"funding": "https://dotenvx.com",
+		"keywords": [
+			"dotenv",
+			"env",
+			".env",
+			"environment",
+			"variables",
+			"config",
+			"settings"
+		],
+		"readmeFilename": "README.md",
+		"license": "BSD-2-Clause",
+		"devDependencies": {
+			"@types/node": "^18.11.3",
+			"decache": "^4.6.2",
+			"sinon": "^14.0.1",
+			"standard": "^17.0.0",
+			"standard-version": "^9.5.0",
+			"tap": "^19.2.0",
+			"typescript": "^4.8.4"
+		},
+		"engines": { "node": ">=12" },
+		"browser": { "fs": false }
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/dotenv/lib/main.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("fs");
+	const path$1 = __require("path");
+	const os = __require("os");
+	const crypto = __require("crypto");
+	const version = require_package().version;
+	const TIPS = [
+		"🔐 encrypt with Dotenvx: https://dotenvx.com",
+		"🔐 prevent committing .env to code: https://dotenvx.com/precommit",
+		"🔐 prevent building .env in docker: https://dotenvx.com/prebuild",
+		"📡 add observability to secrets: https://dotenvx.com/ops",
+		"👥 sync secrets across teammates & machines: https://dotenvx.com/ops",
+		"🗂️ backup and recover secrets: https://dotenvx.com/ops",
+		"✅ audit secrets and track compliance: https://dotenvx.com/ops",
+		"🔄 add secrets lifecycle management: https://dotenvx.com/ops",
+		"🔑 add access controls to secrets: https://dotenvx.com/ops",
+		"🛠️  run anywhere with `dotenvx run -- yourcommand`",
+		"⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+		"⚙️  enable debug logging with { debug: true }",
+		"⚙️  override existing env vars with { override: true }",
+		"⚙️  suppress all logs with { quiet: true }",
+		"⚙️  write to custom object with { processEnv: myObject }",
+		"⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+	];
+	function _getRandomTip() {
+		return TIPS[Math.floor(Math.random() * TIPS.length)];
+	}
+	function parseBoolean(value) {
+		if (typeof value === "string") return ![
+			"false",
+			"0",
+			"no",
+			"off",
+			""
+		].includes(value.toLowerCase());
+		return Boolean(value);
+	}
+	function supportsAnsi() {
+		return process.stdout.isTTY;
+	}
+	function dim(text) {
+		return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text;
+	}
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	function parse(src) {
+		const obj = {};
+		let lines = src.toString();
+		lines = lines.replace(/\r\n?/gm, "\n");
+		let match;
+		while ((match = LINE.exec(lines)) != null) {
+			const key = match[1];
+			let value = match[2] || "";
+			value = value.trim();
+			const maybeQuote = value[0];
+			value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+			if (maybeQuote === "\"") {
+				value = value.replace(/\\n/g, "\n");
+				value = value.replace(/\\r/g, "\r");
+			}
+			obj[key] = value;
+		}
+		return obj;
+	}
+	function _parseVault(options) {
+		options = options || {};
+		const vaultPath = _vaultPath(options);
+		options.path = vaultPath;
+		const result = DotenvModule.configDotenv(options);
+		if (!result.parsed) {
+			const err = /* @__PURE__ */ new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+			err.code = "MISSING_DATA";
+			throw err;
+		}
+		const keys = _dotenvKey(options).split(",");
+		const length = keys.length;
+		let decrypted;
+		for (let i = 0; i < length; i++) try {
+			const attrs = _instructions(result, keys[i].trim());
+			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+			break;
+		} catch (error) {
+			if (i + 1 >= length) throw error;
+		}
+		return DotenvModule.parse(decrypted);
+	}
+	function _warn(message) {
+		console.error(`[dotenv@${version}][WARN] ${message}`);
+	}
+	function _debug(message) {
+		console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	}
+	function _log(message) {
+		console.log(`[dotenv@${version}] ${message}`);
+	}
+	function _dotenvKey(options) {
+		if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) return options.DOTENV_KEY;
+		if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) return process.env.DOTENV_KEY;
+		return "";
+	}
+	function _instructions(result, dotenvKey) {
+		let uri;
+		try {
+			uri = new URL(dotenvKey);
+		} catch (error) {
+			if (error.code === "ERR_INVALID_URL") {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			}
+			throw error;
+		}
+		const key = uri.password;
+		if (!key) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing key part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environment = uri.searchParams.get("environment");
+		if (!environment) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing environment part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+		const ciphertext = result.parsed[environmentKey];
+		if (!ciphertext) {
+			const err = /* @__PURE__ */ new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+			err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+			throw err;
+		}
+		return {
+			ciphertext,
+			key
+		};
+	}
+	function _vaultPath(options) {
+		let possibleVaultPath = null;
+		if (options && options.path && options.path.length > 0) if (Array.isArray(options.path)) {
+			for (const filepath of options.path) if (fs.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+		} else possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+		else possibleVaultPath = path$1.resolve(process.cwd(), ".env.vault");
+		if (fs.existsSync(possibleVaultPath)) return possibleVaultPath;
+		return null;
+	}
+	function _resolveHome(envPath) {
+		return envPath[0] === "~" ? path$1.join(os.homedir(), envPath.slice(1)) : envPath;
+	}
+	function _configVault(options) {
+		const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (debug || !quiet) _log("Loading env from encrypted .env.vault");
+		const parsed = DotenvModule._parseVault(options);
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		DotenvModule.populate(processEnv, parsed, options);
+		return { parsed };
+	}
+	function configDotenv(options) {
+		const dotenvPath = path$1.resolve(process.cwd(), ".env");
+		let encoding = "utf8";
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (options && options.encoding) encoding = options.encoding;
+		else if (debug) _debug("No encoding is specified. UTF-8 is used by default");
+		let optionPaths = [dotenvPath];
+		if (options && options.path) if (!Array.isArray(options.path)) optionPaths = [_resolveHome(options.path)];
+		else {
+			optionPaths = [];
+			for (const filepath of options.path) optionPaths.push(_resolveHome(filepath));
+		}
+		let lastError;
+		const parsedAll = {};
+		for (const path of optionPaths) try {
+			const parsed = DotenvModule.parse(fs.readFileSync(path, { encoding }));
+			DotenvModule.populate(parsedAll, parsed, options);
+		} catch (e) {
+			if (debug) _debug(`Failed to load ${path} ${e.message}`);
+			lastError = e;
+		}
+		const populated = DotenvModule.populate(processEnv, parsedAll, options);
+		debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+		if (debug || !quiet) {
+			const keysCount = Object.keys(populated).length;
+			const shortPaths = [];
+			for (const filePath of optionPaths) try {
+				const relative = path$1.relative(process.cwd(), filePath);
+				shortPaths.push(relative);
+			} catch (e) {
+				if (debug) _debug(`Failed to load ${filePath} ${e.message}`);
+				lastError = e;
+			}
+			_log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+		}
+		if (lastError) return {
+			parsed: parsedAll,
+			error: lastError
+		};
+		else return { parsed: parsedAll };
+	}
+	function config(options) {
+		if (_dotenvKey(options).length === 0) return DotenvModule.configDotenv(options);
+		const vaultPath = _vaultPath(options);
+		if (!vaultPath) {
+			_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+			return DotenvModule.configDotenv(options);
+		}
+		return DotenvModule._configVault(options);
+	}
+	function decrypt(encrypted, keyStr) {
+		const key = Buffer.from(keyStr.slice(-64), "hex");
+		let ciphertext = Buffer.from(encrypted, "base64");
+		const nonce = ciphertext.subarray(0, 12);
+		const authTag = ciphertext.subarray(-16);
+		ciphertext = ciphertext.subarray(12, -16);
+		try {
+			const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+			aesgcm.setAuthTag(authTag);
+			return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+		} catch (error) {
+			const isRange = error instanceof RangeError;
+			const invalidKeyLength = error.message === "Invalid key length";
+			const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+			if (isRange || invalidKeyLength) {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			} else if (decryptionFailed) {
+				const err = /* @__PURE__ */ new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+				err.code = "DECRYPTION_FAILED";
+				throw err;
+			} else throw error;
+		}
+	}
+	function populate(processEnv, parsed, options = {}) {
+		const debug = Boolean(options && options.debug);
+		const override = Boolean(options && options.override);
+		const populated = {};
+		if (typeof parsed !== "object") {
+			const err = /* @__PURE__ */ new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+			err.code = "OBJECT_REQUIRED";
+			throw err;
+		}
+		for (const key of Object.keys(parsed)) if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+			if (override === true) {
+				processEnv[key] = parsed[key];
+				populated[key] = parsed[key];
+			}
+			if (debug) if (override === true) _debug(`"${key}" is already defined and WAS overwritten`);
+			else _debug(`"${key}" is already defined and was NOT overwritten`);
+		} else {
+			processEnv[key] = parsed[key];
+			populated[key] = parsed[key];
+		}
+		return populated;
+	}
+	const DotenvModule = {
+		configDotenv,
+		_configVault,
+		_parseVault,
+		config,
+		decrypt,
+		parse,
+		populate
+	};
+	module.exports.configDotenv = DotenvModule.configDotenv;
+	module.exports._configVault = DotenvModule._configVault;
+	module.exports._parseVault = DotenvModule._parseVault;
+	module.exports.config = DotenvModule.config;
+	module.exports.decrypt = DotenvModule.decrypt;
+	module.exports.parse = DotenvModule.parse;
+	module.exports.populate = DotenvModule.populate;
+	module.exports = DotenvModule;
+}));
+
+//#endregion
+//#region ../../node_modules/dotenv/lib/env-options.js
+var require_env_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const options = {};
+	if (process.env.DOTENV_CONFIG_ENCODING != null) options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+	if (process.env.DOTENV_CONFIG_PATH != null) options.path = process.env.DOTENV_CONFIG_PATH;
+	if (process.env.DOTENV_CONFIG_QUIET != null) options.quiet = process.env.DOTENV_CONFIG_QUIET;
+	if (process.env.DOTENV_CONFIG_DEBUG != null) options.debug = process.env.DOTENV_CONFIG_DEBUG;
+	if (process.env.DOTENV_CONFIG_OVERRIDE != null) options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+	if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+	module.exports = options;
+}));
+
+//#endregion
+//#region ../../node_modules/dotenv/lib/cli-options.js
+var require_cli_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+	module.exports = function optionMatcher(args) {
+		const options = args.reduce(function(acc, cur) {
+			const matches = cur.match(re);
+			if (matches) acc[matches[1]] = matches[2];
+			return acc;
+		}, {});
+		if (!("quiet" in options)) options.quiet = "true";
+		return options;
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/dotenv/config.js
+(function() {
+	require_main().config(Object.assign({}, require_env_options(), require_cli_options()(process.argv)));
+})();
+
+//#endregion
+//#region package.json
+var version = "0.0.1";
+
+//#endregion
+//#region index.ts
+if (!process$1.env.PANTHEON_API_KEY) console.error("PANTHEON_API_KEY environment variable is not set.");
+if (!process$1.env.DATABASE_URL) console.error("DATABASE_URL environment variable is not set.");
+const configAgentCommand = createCommand("pantheon-agents config").version(version).description("Configure agent for pantheon project").argument("<name>", "The name of the agent.").argument("<role>", "The role of the agent.").argument("<project-id>", "The project id of the agent.").option("--execute-agent <agent>", "The execute agent of the agent.", "codex").option("--root-branch-id <branchId>", "The root branch id of the agent. Default to project root branch id.").option("--no-bootstrap", "Prevent bootstrap base branch for agent. Use the root branch as base branch.").action(async function() {
+	const [name, role, projectId] = this.args;
+	await configAgent(name, {
+		role,
+		projectId,
+		...this.opts()
+	});
+});
+const addTaskCommand = createCommand("pantheon-agents add-task").version(version).description("Add a task to an agent").argument("<name>", "The name of the agent.").argument("<project-id>", "The project id of the agent.").argument("<task-prompt>", "The prompt of the task.").action(async function() {
+	const [name, projectId, taskPrompt] = this.args;
+	await addTask(name, {
+		projectId,
+		prompt: taskPrompt
+	});
+});
+const runAgentCommand = createCommand("pantheon-agents run").version(version).description("Start a pantheon agents").argument("<name>", "The name of the agent.").option("--data-dir [dir]", "Data directory.", expandTilde("~/.pantheon-agents")).option("--mcp-port", "The port of the MCP server. Defaults to a random port.").option("--loop-interval <seconds>", "The interval of the loop in seconds. Defaults to 5.", (val) => parseInt(val, 10), 5).action(async function() {
+	const [name] = this.args;
+	const options = this.opts();
+	const logFileTransport = transport({
+		target: "pino-roll",
+		options: {
+			file: path.join(options.dataDir, "agents", name, "logs", "log"),
+			frequency: "daily",
+			mkdir: true
+		}
+	});
+	const prettyTransport = transport({
+		target: "pino-pretty",
+		options: {
+			colorize: true,
+			ignore: "pid,hostname,level-label"
+		}
+	});
+	await runAgent(name, options, pino({
+		timestamp: pino.stdTimeFunctions.isoTime,
+		formatters: { level(label) {
+			return { level: label.toUpperCase() };
+		} }
+	}, multistream([{ stream: logFileTransport }, { stream: prettyTransport }])));
+});
+function printCommandHelpAndExit(command) {
+	console.error(`Invalid command: ${command}. Supported commands: ${Object.keys(commands).join(", ")}.`);
+	console.error(`  Run pantheon-agents help <command> for more information.`);
+	process$1.exit(1);
+}
+const commands = {
+	"add-task": addTaskCommand,
+	config: configAgentCommand,
+	run: runAgentCommand
+};
+if (process$1.argv[2] === "help") {
+	const command = process$1.argv[3];
+	if (command in commands) commands[command].help({ error: false });
+	else printCommandHelpAndExit(command);
+}
+if (!commands[process$1.argv[2]]) printCommandHelpAndExit(process$1.argv[2]);
+commands[process$1.argv[2]].parse(process$1.argv.slice(3), { from: "user" });
+
+//#endregion
+export {  };