@nairon-ai/aegis 0.2.0

package/src/shared/config.ts

@@ -0,0 +1,154 @@
+import {
+	DEFAULT_AGENT_MODEL,
+	DEFAULT_APPROVAL_REQUIRED_LABELS,
+	DEFAULT_APPROVAL_REQUIRED_PATHS,
+	DEFAULT_BASE_BRANCH,
+	DEFAULT_BLOCKED_LABEL,
+	DEFAULT_BUG_LABEL,
+	DEFAULT_IN_PROGRESS_LABEL,
+	DEFAULT_LOG_LOOKBACK_MINUTES,
+	DEFAULT_NEEDS_INFO_LABEL,
+	DEFAULT_PR_OPENED_LABEL,
+	DEFAULT_READY_LABEL,
+} from "./constants.js";
+import type { AegisCliConfig, AegisConfig, Bindings } from "./types.js";
+
+export function configFromBindings(env: Bindings): AegisConfig {
+	return normalizeConfig({
+		workerUrl: env.AEGIS_WORKER_URL,
+		monitoredRepo: env.MONITORED_REPO,
+		baseBranch: env.BASE_BRANCH,
+		automationMode: env.AUTOMATION_MODE,
+		contextProfile: env.CONTEXT_PROFILE,
+		maxConcurrentRuns: parseInteger(env.MAX_CONCURRENT_RUNS, 1),
+		readyLabel: env.READY_LABEL,
+		bugLabel: env.BUG_LABEL,
+		inProgressLabel: env.IN_PROGRESS_LABEL,
+		needsInfoLabel: env.NEEDS_INFO_LABEL,
+		blockedLabel: env.BLOCKED_LABEL,
+		prOpenedLabel: env.PR_OPENED_LABEL,
+		lowRiskLabels: parseList(env.LOW_RISK_LABELS),
+		alwaysRequireApprovalLabels: parseList(env.ALWAYS_REQUIRE_APPROVAL_LABELS),
+		alwaysRequireApprovalPaths: parseList(env.ALWAYS_REQUIRE_APPROVAL_PATHS),
+		github: {
+			appId: env.GITHUB_APP_ID,
+			privateKey: env.GITHUB_APP_PRIVATE_KEY,
+			installationId: env.GITHUB_INSTALLATION_ID,
+			webhookSecret: env.GITHUB_WEBHOOK_SECRET,
+			token: env.GITHUB_TOKEN,
+		},
+		linear: {
+			apiKey: env.LINEAR_API_KEY,
+			webhookSecret: env.LINEAR_WEBHOOK_SECRET,
+			teamId: env.LINEAR_TEAM_ID,
+			projectId: env.LINEAR_PROJECT_ID,
+			readyStatusName: env.LINEAR_READY_STATUS ?? "Ready to Implement",
+			inProgressStatusName: env.LINEAR_IN_PROGRESS_STATUS ?? "In Progress",
+			needsInfoStatusName: env.LINEAR_NEEDS_INFO_STATUS ?? "Needs Info",
+			blockedStatusName: env.LINEAR_BLOCKED_STATUS ?? "Blocked",
+			bugLabel: env.LINEAR_BUG_LABEL ?? env.BUG_LABEL ?? DEFAULT_BUG_LABEL,
+			readyLabel: env.LINEAR_READY_LABEL,
+		},
+		telegram: {
+			botToken: env.TELEGRAM_BOT_TOKEN,
+			chatId: env.TELEGRAM_CHAT_ID,
+			webhookSecret: env.TELEGRAM_WEBHOOK_SECRET,
+		},
+		production: {
+			databaseUrl: env.DATABASE_URL,
+			vercelToken: env.VERCEL_TOKEN,
+			vercelProjectId: env.VERCEL_PROJECT_ID,
+			vercelTeamId: env.VERCEL_TEAM_ID,
+			logLookbackMinutes: parseInteger(
+				env.VERCEL_LOG_LOOKBACK_MINUTES,
+				DEFAULT_LOG_LOOKBACK_MINUTES,
+			),
+		},
+		model: env.AGENT_MODEL,
+	});
+}
+
+export function configFromCli(cli: AegisCliConfig): AegisConfig {
+	return normalizeConfig({
+		workerUrl: cli.workerUrl,
+		monitoredRepo: cli.monitoredRepo ?? "",
+		baseBranch: cli.baseBranch,
+		automationMode: cli.automationMode,
+		contextProfile: cli.contextProfile,
+		readyLabel: cli.readyLabel,
+		bugLabel: cli.bugLabel,
+		github: {
+			appId: cli.githubAppId,
+			privateKey: cli.githubAppPrivateKey,
+			installationId: cli.githubInstallationId,
+			webhookSecret: cli.githubWebhookSecret,
+			token: cli.githubToken,
+		},
+		linear: {
+			apiKey: cli.linearApiKey,
+			webhookSecret: cli.linearWebhookSecret,
+			teamId: cli.linearTeamId,
+			projectId: cli.linearProjectId,
+			readyStatusName: cli.linearReadyStatus ?? "Ready to Implement",
+			inProgressStatusName: cli.linearInProgressStatus ?? "In Progress",
+			needsInfoStatusName: cli.linearNeedsInfoStatus ?? "Needs Info",
+			blockedStatusName: cli.linearBlockedStatus ?? "Blocked",
+			bugLabel: cli.linearBugLabel ?? cli.bugLabel ?? DEFAULT_BUG_LABEL,
+		},
+		telegram: {
+			botToken: cli.telegramBotToken,
+			chatId: cli.telegramChatId,
+			webhookSecret: cli.telegramWebhookSecret,
+		},
+		production: {
+			databaseUrl: cli.databaseUrl,
+			vercelToken: cli.vercelToken,
+			vercelProjectId: cli.vercelProjectId,
+			vercelTeamId: cli.vercelTeamId,
+			logLookbackMinutes: DEFAULT_LOG_LOOKBACK_MINUTES,
+		},
+		model: cli.agentModel,
+	});
+}
+
+function normalizeConfig(input: Partial<AegisConfig> & { monitoredRepo: string }): AegisConfig {
+	const automationMode = input.automationMode ?? "plan-first";
+	const contextProfile = input.contextProfile ?? "minimal";
+	return {
+		workerUrl: input.workerUrl,
+		monitoredRepo: input.monitoredRepo,
+		baseBranch: input.baseBranch ?? DEFAULT_BASE_BRANCH,
+		automationMode,
+		contextProfile,
+		maxConcurrentRuns: input.maxConcurrentRuns ?? 1,
+		readyLabel: input.readyLabel ?? DEFAULT_READY_LABEL,
+		bugLabel: input.bugLabel ?? DEFAULT_BUG_LABEL,
+		inProgressLabel: input.inProgressLabel ?? DEFAULT_IN_PROGRESS_LABEL,
+		needsInfoLabel: input.needsInfoLabel ?? DEFAULT_NEEDS_INFO_LABEL,
+		blockedLabel: input.blockedLabel ?? DEFAULT_BLOCKED_LABEL,
+		prOpenedLabel: input.prOpenedLabel ?? DEFAULT_PR_OPENED_LABEL,
+		lowRiskLabels: input.lowRiskLabels ?? ["low-risk"],
+		alwaysRequireApprovalLabels:
+			input.alwaysRequireApprovalLabels ?? DEFAULT_APPROVAL_REQUIRED_LABELS,
+		alwaysRequireApprovalPaths: input.alwaysRequireApprovalPaths ?? DEFAULT_APPROVAL_REQUIRED_PATHS,
+		github: input.github,
+		linear: input.linear,
+		telegram: input.telegram,
+		production: input.production ?? { logLookbackMinutes: DEFAULT_LOG_LOOKBACK_MINUTES },
+		model: input.model ?? DEFAULT_AGENT_MODEL,
+	};
+}
+
+export function parseList(value: string | undefined): string[] {
+	if (!value) return [];
+	return value
+		.split(",")
+		.map((item) => item.trim())
+		.filter(Boolean);
+}
+
+function parseInteger(value: string | undefined, fallback: number): number {
+	if (!value) return fallback;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) ? parsed : fallback;
+}

package/src/shared/constants.ts

@@ -0,0 +1,30 @@
+export const DEFAULT_READY_LABEL = "ready to implement";
+export const DEFAULT_BUG_LABEL = "bug";
+export const DEFAULT_IN_PROGRESS_LABEL = "aegis:in-progress";
+export const DEFAULT_NEEDS_INFO_LABEL = "aegis:needs-info";
+export const DEFAULT_BLOCKED_LABEL = "aegis:blocked";
+export const DEFAULT_PR_OPENED_LABEL = "aegis:pr-opened";
+export const DEFAULT_BASE_BRANCH = "main";
+export const DEFAULT_AGENT_MODEL = "openai/gpt-5.1";
+export const DEFAULT_LOG_LOOKBACK_MINUTES = 45;
+export const BRANCH_PREFIX = "aegis/bug-";
+export const AGENT_CONTEXT_PATH = "/tmp/aegis-context.json";
+export const SANDBOX_REPO_PATH = "/workspace/project";
+export const BUG_FIX_SKILL = "bug-fix";
+
+export const DEFAULT_APPROVAL_REQUIRED_LABELS = [
+	"security",
+	"payment",
+	"billing",
+	"data-loss",
+	"migration",
+];
+
+export const DEFAULT_APPROVAL_REQUIRED_PATHS = [
+	"auth/**",
+	"billing/**",
+	"payments/**",
+	"db/**",
+	"database/**",
+	"migrations/**",
+];

package/src/shared/format.ts

@@ -0,0 +1,84 @@
+import { BRANCH_PREFIX } from "./constants.js";
+import type { AgentPlanResult, WorkItem } from "./types.js";
+
+export function slugify(value: string, maxLength = 48): string {
+	const slug = value
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+		.slice(0, maxLength)
+		.replace(/-+$/g, "");
+	return slug || "bug";
+}
+
+export function branchNameFor(item: WorkItem): string {
+	const id = item.source === "github" ? `gh-${item.number ?? item.id}` : item.identifier;
+	return `${BRANCH_PREFIX}${slugify(`${id}-${item.title}`, 64)}`;
+}
+
+export function compactText(value: string, maxLength = 1200): string {
+	const clean = value.replace(/\r/g, "").trim();
+	if (clean.length <= maxLength) return clean;
+	return `${clean.slice(0, maxLength - 12).trim()}...`;
+}
+
+export function formatReadyDecisionLine(
+	item: WorkItem,
+	decision: { ready: boolean; reason: string },
+) {
+	const state = decision.ready ? "would run" : "needs info";
+	return `${item.source}:${item.identifier} ${state} - ${decision.reason}`;
+}
+
+export function formatTelegramPlanMessage(
+	runId: string,
+	item: WorkItem,
+	plan: AgentPlanResult,
+): string {
+	const risk = plan.risk[0]?.toUpperCase() + plan.risk.slice(1);
+	return [
+		`Aegis found a likely fix for ${item.identifier}`,
+		"",
+		`Bug: ${compactText(item.title, 180)}`,
+		"",
+		compactText(plan.humanSummary, 700),
+		"",
+		`Fix: ${compactText(plan.proposedFix, 420)}`,
+		`Risk: ${risk}`,
+		"",
+		`Approve: /aegis proceed ${runId}`,
+		`Ask: /aegis ask ${runId} <question>`,
+		`Stop: /aegis stop ${runId}`,
+	].join("\n");
+}
+
+export function formatIssuePlanComment(runId: string, plan: AgentPlanResult): string {
+	return `## Aegis RCA checkpoint
+
+**Run:** \`${runId}\`
+**Confidence:** ${plan.confidence}
+**Risk:** ${plan.risk}
+
+### Human summary
+${plan.humanSummary}
+
+### Technical details
+${plan.technicalSummary}
+
+### Proposed fix
+${plan.proposedFix}
+
+Reply with:
+- \`/aegis proceed ${runId}\` to approve implementation
+- \`/aegis ask ${runId} <question>\` to add context
+- \`/aegis stop ${runId}\` to cancel
+`;
+}
+
+export function formatNeedsInfoComment(question: string): string {
+	return `Aegis needs one detail before it can safely pick this up:
+
+${question}
+
+Add the missing context, then mark the bug ready again.`;
+}

package/src/shared/index.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./config.js";
+export * from "./format.js";
+export * from "./readiness.js";
+export * from "./run-state.js";

package/src/shared/readiness.ts

@@ -0,0 +1,116 @@
+import type { AegisConfig, ReadinessDecision, WorkItem } from "./types.js";
+
+const BUG_WORDS = [
+	"bug",
+	"crash",
+	"error",
+	"exception",
+	"fails",
+	"failure",
+	"broken",
+	"regression",
+	"incorrect",
+	"wrong",
+];
+
+const CONTEXT_WORDS = [
+	"expected",
+	"actual",
+	"reproduce",
+	"steps",
+	"stack",
+	"trace",
+	"error",
+	"logs",
+	"when",
+	"click",
+	"route",
+	"page",
+	"api",
+];
+
+export function evaluateReadiness(item: WorkItem, config: AegisConfig): ReadinessDecision {
+	const labels = normalizedLabels(item.labels);
+	const titleAndBody = `${item.title}\n${item.body}`.toLowerCase();
+
+	if (!isBug(item, config, labels, titleAndBody)) {
+		return {
+			ready: false,
+			reason: "not labeled or described as a bug",
+			question: "Please label this as a bug once it describes broken behavior.",
+		};
+	}
+
+	if (!isReady(item, config, labels)) {
+		return {
+			ready: false,
+			reason: "not marked ready to implement",
+			question: `Please add the "${config.readyLabel}" label or move it to the configured ready status.`,
+		};
+	}
+
+	if (!item.repo) {
+		return {
+			ready: false,
+			reason: "no repository mapping",
+			question: "Which GitHub repository should Aegis fix this in?",
+		};
+	}
+
+	if (item.body.trim().length < 40 || !hasEnoughBugContext(titleAndBody)) {
+		return {
+			ready: false,
+			reason: "bug report is too thin",
+			question:
+				"What happened, what should have happened, and where can Aegis look to reproduce or verify it?",
+		};
+	}
+
+	const risk = hasRiskyLabel(labels, config) ? "high" : "low";
+	const autoImplementAllowed =
+		config.automationMode === "auto-low-risk" &&
+		risk === "low" &&
+		config.lowRiskLabels.some((label) => labels.has(label.toLowerCase()));
+
+	return {
+		ready: true,
+		reason: autoImplementAllowed
+			? "ready low-risk bug; auto-implement allowed"
+			: "ready bug; approval checkpoint required",
+		risk,
+		autoImplementAllowed,
+	};
+}
+
+function isBug(
+	item: WorkItem,
+	config: AegisConfig,
+	labels: Set<string>,
+	titleAndBody: string,
+): boolean {
+	return (
+		labels.has(config.bugLabel.toLowerCase()) ||
+		labels.has(config.linear?.bugLabel?.toLowerCase() ?? "") ||
+		BUG_WORDS.some((word) => titleAndBody.includes(word))
+	);
+}
+
+function isReady(item: WorkItem, config: AegisConfig, labels: Set<string>): boolean {
+	return (
+		labels.has(config.readyLabel.toLowerCase()) ||
+		item.statusName?.toLowerCase() === config.linear?.readyStatusName.toLowerCase()
+	);
+}
+
+function hasEnoughBugContext(text: string): boolean {
+	const hits = CONTEXT_WORDS.filter((word) => text.includes(word)).length;
+	return hits >= 2;
+}
+
+function hasRiskyLabel(labels: Set<string>, config: AegisConfig): boolean {
+	return config.alwaysRequireApprovalLabels.some((label) => labels.has(label.toLowerCase()));
+}
+
+function normalizedLabels(labels: string[]): Set<string> {
+	return new Set(labels.map((label) => label.toLowerCase()));
+}

package/src/shared/run-state.ts

@@ -0,0 +1,32 @@
+import { branchNameFor } from "./format.js";
+import type { AutomationMode, WorkItem, WorkRun } from "./types.js";
+
+export function runIdFor(item: WorkItem): string {
+	const sourceId =
+		item.source === "github" ? `gh-${item.repo.replace("/", "-")}-${item.number}` : item.identifier;
+	return sourceId.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+}
+
+export function runFromItem(item: WorkItem, mode: AutomationMode): WorkRun {
+	const now = new Date().toISOString();
+	return {
+		id: runIdFor(item),
+		source: item.source,
+		externalId: item.id,
+		identifier: item.identifier,
+		repo: item.repo,
+		branchName: branchNameFor(item),
+		status: "claimed",
+		mode,
+		createdAt: now,
+		updatedAt: now,
+		itemUrl: item.url,
+	};
+}
+
+export function isActivelyTracked(item: WorkItem, labels: string[]): boolean {
+	const lowered = labels.map((label) => label.toLowerCase());
+	return lowered.some((label) =>
+		["aegis:in-progress", "aegis:needs-info", "aegis:blocked", "aegis:pr-opened"].includes(label),
+	);
+}

package/src/shared/types.ts

@@ -0,0 +1,257 @@
+/**
+ * Shared types for Aegis - an issue-driven AFK bug-fixing agent.
+ */
+
+export type WorkSource = "github" | "linear";
+
+export type AutomationMode = "plan-first" | "auto-low-risk";
+
+export type ContextProfile = "minimal" | "production";
+
+export type WorkItemStatus =
+	| "ready"
+	| "needs-info"
+	| "claimed"
+	| "planning"
+	| "awaiting-approval"
+	| "implementing"
+	| "pr-opened"
+	| "blocked"
+	| "failed"
+	| "cancelled";
+
+export type RiskLevel = "low" | "medium" | "high";
+
+export type WorkItem = {
+	source: WorkSource;
+	id: string;
+	number?: number;
+	identifier: string;
+	title: string;
+	body: string;
+	url: string;
+	repo: string;
+	labels: string[];
+	statusName?: string;
+	createdAt?: string;
+	updatedAt?: string;
+	author?: string;
+};
+
+export type ReadinessDecision =
+	| {
+			ready: true;
+			reason: string;
+			risk: RiskLevel;
+			autoImplementAllowed: boolean;
+	  }
+	| {
+			ready: false;
+			reason: string;
+			question: string;
+	  };
+
+export type WorkRun = {
+	id: string;
+	source: WorkSource;
+	externalId: string;
+	identifier: string;
+	repo: string;
+	branchName: string;
+	status: WorkItemStatus;
+	mode: AutomationMode;
+	createdAt: string;
+	updatedAt: string;
+	itemUrl: string;
+	prUrl?: string;
+	lastError?: string;
+	planSummary?: string;
+};
+
+export type RunRef = {
+	runId: string;
+	source: WorkSource;
+	identifier: string;
+	repo: string;
+	branchName: string;
+	itemUrl: string;
+};
+
+export type AgentCommand = "plan" | "implement";
+
+export type AgentRunContext = {
+	runId: string;
+	command: AgentCommand;
+	mode: AutomationMode;
+	contextProfile: ContextProfile;
+	item: WorkItem;
+	branchName: string;
+	baseBranch: string;
+	repoCloneUrl: string;
+	production?: {
+		databaseUrl?: string;
+		vercelToken?: string;
+		vercelProjectId?: string;
+		vercelTeamId?: string;
+		logLookbackMinutes: number;
+	};
+	approval?: {
+		approvedBy: string;
+		approvedAt: string;
+	};
+};
+
+export type AgentPlanResult = {
+	outcome: "awaiting-approval" | "needs-info" | "blocked";
+	confidence: "low" | "medium" | "high";
+	risk: RiskLevel;
+	technicalSummary: string;
+	humanSummary: string;
+	proposedFix: string;
+	question?: string;
+	blocker?: string;
+	requiresApproval: boolean;
+};
+
+export type AgentImplementationResult = {
+	outcome: "implemented" | "blocked" | "needs-info";
+	confidence: "low" | "medium" | "high";
+	risk: RiskLevel;
+	technicalSummary: string;
+	humanSummary: string;
+	filesChanged: string[];
+	testsRun: string[];
+	branchName?: string;
+	commitSha?: string;
+	prTitle?: string;
+	prBody?: string;
+	question?: string;
+	blocker?: string;
+};
+
+export type AegisConfig = {
+	workerUrl?: string;
+	monitoredRepo: string;
+	baseBranch: string;
+	automationMode: AutomationMode;
+	contextProfile: ContextProfile;
+	maxConcurrentRuns: number;
+	readyLabel: string;
+	bugLabel: string;
+	inProgressLabel: string;
+	needsInfoLabel: string;
+	blockedLabel: string;
+	prOpenedLabel: string;
+	lowRiskLabels: string[];
+	alwaysRequireApprovalLabels: string[];
+	alwaysRequireApprovalPaths: string[];
+	github?: {
+		appId?: string;
+		privateKey?: string;
+		installationId?: string;
+		webhookSecret?: string;
+		token?: string;
+	};
+	linear?: {
+		apiKey?: string;
+		webhookSecret?: string;
+		teamId?: string;
+		projectId?: string;
+		readyStatusName: string;
+		inProgressStatusName: string;
+		needsInfoStatusName?: string;
+		blockedStatusName?: string;
+		bugLabel: string;
+		readyLabel?: string;
+	};
+	telegram?: {
+		botToken?: string;
+		chatId?: string;
+		webhookSecret?: string;
+	};
+	production?: {
+		databaseUrl?: string;
+		vercelToken?: string;
+		vercelProjectId?: string;
+		vercelTeamId?: string;
+		logLookbackMinutes: number;
+	};
+	model: string;
+};
+
+export type Bindings = {
+	Sandbox: DurableObjectNamespace;
+	AEGIS_WORKER_URL?: string;
+	MONITORED_REPO: string;
+	BASE_BRANCH?: string;
+	AUTOMATION_MODE?: AutomationMode;
+	CONTEXT_PROFILE?: ContextProfile;
+	MAX_CONCURRENT_RUNS?: string;
+	READY_LABEL?: string;
+	BUG_LABEL?: string;
+	IN_PROGRESS_LABEL?: string;
+	NEEDS_INFO_LABEL?: string;
+	BLOCKED_LABEL?: string;
+	PR_OPENED_LABEL?: string;
+	LOW_RISK_LABELS?: string;
+	ALWAYS_REQUIRE_APPROVAL_LABELS?: string;
+	ALWAYS_REQUIRE_APPROVAL_PATHS?: string;
+	GITHUB_APP_ID?: string;
+	GITHUB_APP_PRIVATE_KEY?: string;
+	GITHUB_INSTALLATION_ID?: string;
+	GITHUB_WEBHOOK_SECRET?: string;
+	GITHUB_TOKEN?: string;
+	LINEAR_API_KEY?: string;
+	LINEAR_WEBHOOK_SECRET?: string;
+	LINEAR_TEAM_ID?: string;
+	LINEAR_PROJECT_ID?: string;
+	LINEAR_READY_STATUS?: string;
+	LINEAR_IN_PROGRESS_STATUS?: string;
+	LINEAR_NEEDS_INFO_STATUS?: string;
+	LINEAR_BLOCKED_STATUS?: string;
+	LINEAR_BUG_LABEL?: string;
+	LINEAR_READY_LABEL?: string;
+	TELEGRAM_BOT_TOKEN?: string;
+	TELEGRAM_CHAT_ID?: string;
+	TELEGRAM_WEBHOOK_SECRET?: string;
+	DATABASE_URL?: string;
+	VERCEL_TOKEN?: string;
+	VERCEL_PROJECT_ID?: string;
+	VERCEL_TEAM_ID?: string;
+	VERCEL_LOG_LOOKBACK_MINUTES?: string;
+	AGENT_MODEL?: string;
+	OPENAI_API_KEY?: string;
+};
+
+export type AegisCliConfig = {
+	workerUrl?: string;
+	monitoredRepo?: string;
+	baseBranch?: string;
+	automationMode?: AutomationMode;
+	contextProfile?: ContextProfile;
+	readyLabel?: string;
+	bugLabel?: string;
+	githubAppId?: string;
+	githubAppPrivateKey?: string;
+	githubInstallationId?: string;
+	githubWebhookSecret?: string;
+	githubToken?: string;
+	linearApiKey?: string;
+	linearWebhookSecret?: string;
+	linearTeamId?: string;
+	linearProjectId?: string;
+	linearReadyStatus?: string;
+	linearInProgressStatus?: string;
+	linearNeedsInfoStatus?: string;
+	linearBlockedStatus?: string;
+	linearBugLabel?: string;
+	telegramBotToken?: string;
+	telegramChatId?: string;
+	telegramWebhookSecret?: string;
+	databaseUrl?: string;
+	vercelToken?: string;
+	vercelProjectId?: string;
+	vercelTeamId?: string;
+	agentModel?: string;
+	openaiApiKey?: string;
+};