@inkeep/agents-core 0.41.2 → 0.43.0

package/dist/data-access/runtime/projects.d.ts

@@ -0,0 +1,62 @@
+import { PaginationConfig } from "../../types/utility.js";
+import { AgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
+import { ProjectMetadataInsert, ProjectMetadataSelect } from "../../types/entities.js";
+
+//#region src/data-access/runtime/projects.d.ts
+interface ProjectMetadataPaginatedResult {
+  data: ProjectMetadataSelect[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}
+/**
+ * Get a project from the runtime DB by ID
+ */
+declare const getProjectMetadata: (db: AgentsRunDatabaseClient) => (params: {
+  tenantId: string;
+  projectId: string;
+}) => Promise<ProjectMetadataSelect | null>;
+/**
+ * List all runtimeProjects for a tenant from the runtime DB
+ */
+declare const listProjectsMetadata: (db: AgentsRunDatabaseClient) => (params: {
+  tenantId: string;
+}) => Promise<ProjectMetadataSelect[]>;
+/**
+ * List runtimeProjects with pagination from the runtime DB
+ * @param projectIds - Optional array of project IDs to filter by. If undefined, returns all projects.
+ */
+declare const listProjectsMetadataPaginated: (db: AgentsRunDatabaseClient) => (params: {
+  tenantId: string;
+  pagination?: PaginationConfig;
+  projectIds?: string[];
+}) => Promise<ProjectMetadataPaginatedResult>;
+/**
+ * Create a project in the runtime DB
+ */
+declare const createProjectMetadata: (db: AgentsRunDatabaseClient) => (params: ProjectMetadataInsert) => Promise<ProjectMetadataSelect>;
+/**
+ * Delete a project from the runtime DB
+ */
+declare const deleteProjectMetadata: (db: AgentsRunDatabaseClient) => (params: {
+  tenantId: string;
+  projectId: string;
+}) => Promise<boolean>;
+/**
+ * Check if a project exists in the runtime DB
+ */
+declare const projectsMetadataExists: (db: AgentsRunDatabaseClient) => (params: {
+  tenantId: string;
+  projectId: string;
+}) => Promise<boolean>;
+/**
+ * Count runtimeProjects for a tenant
+ */
+declare const countProjectsInRuntime: (db: AgentsRunDatabaseClient) => (params: {
+  tenantId: string;
+}) => Promise<number>;
+//#endregion
+export { ProjectMetadataPaginatedResult, countProjectsInRuntime, createProjectMetadata, deleteProjectMetadata, getProjectMetadata, listProjectsMetadata, listProjectsMetadataPaginated, projectsMetadataExists };

package/dist/data-access/runtime/projects.js

@@ -0,0 +1,90 @@
+import { projectMetadata } from "../../db/runtime/runtime-schema.js";
+import { and, count, desc, eq, inArray } from "drizzle-orm";
+
+//#region src/data-access/runtime/projects.ts
+/**
+* Get a project from the runtime DB by ID
+*/
+const getProjectMetadata = (db) => async (params) => {
+	return await db.query.projectMetadata.findFirst({ where: and(eq(projectMetadata.tenantId, params.tenantId), eq(projectMetadata.id, params.projectId)) }) ?? null;
+};
+/**
+* List all runtimeProjects for a tenant from the runtime DB
+*/
+const listProjectsMetadata = (db) => async (params) => {
+	return await db.query.projectMetadata.findMany({
+		where: eq(projectMetadata.tenantId, params.tenantId),
+		orderBy: [desc(projectMetadata.createdAt)]
+	});
+};
+/**
+* List runtimeProjects with pagination from the runtime DB
+* @param projectIds - Optional array of project IDs to filter by. If undefined, returns all projects.
+*/
+const listProjectsMetadataPaginated = (db) => async (params) => {
+	const page = params.pagination?.page || 1;
+	const limit = Math.min(params.pagination?.limit || 10, 100);
+	const offset = (page - 1) * limit;
+	const conditions = [eq(projectMetadata.tenantId, params.tenantId)];
+	if (params.projectIds !== void 0) {
+		if (params.projectIds.length === 0) return {
+			data: [],
+			pagination: {
+				page,
+				limit,
+				total: 0,
+				pages: 0
+			}
+		};
+		conditions.push(inArray(projectMetadata.id, params.projectIds));
+	}
+	const whereClause = and(...conditions);
+	const [data, totalResult] = await Promise.all([db.select().from(projectMetadata).where(whereClause).limit(limit).offset(offset).orderBy(desc(projectMetadata.createdAt)), db.select({ count: count() }).from(projectMetadata).where(whereClause)]);
+	const total = totalResult[0]?.count || 0;
+	const totalNumber = typeof total === "string" ? Number.parseInt(total, 10) : total;
+	return {
+		data,
+		pagination: {
+			page,
+			limit,
+			total: totalNumber,
+			pages: Math.ceil(totalNumber / limit)
+		}
+	};
+};
+/**
+* Create a project in the runtime DB
+*/
+const createProjectMetadata = (db) => async (params) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [project] = await db.insert(projectMetadata).values({
+		id: params.id,
+		tenantId: params.tenantId,
+		createdBy: params.createdBy ?? null,
+		mainBranchName: params.mainBranchName,
+		createdAt: now
+	}).returning();
+	return project;
+};
+/**
+* Delete a project from the runtime DB
+*/
+const deleteProjectMetadata = (db) => async (params) => {
+	return (await db.delete(projectMetadata).where(and(eq(projectMetadata.tenantId, params.tenantId), eq(projectMetadata.id, params.projectId))).returning()).length > 0;
+};
+/**
+* Check if a project exists in the runtime DB
+*/
+const projectsMetadataExists = (db) => async (params) => {
+	return await getProjectMetadata(db)(params) !== null;
+};
+/**
+* Count runtimeProjects for a tenant
+*/
+const countProjectsInRuntime = (db) => async (params) => {
+	const total = (await db.select({ count: count() }).from(projectMetadata).where(eq(projectMetadata.tenantId, params.tenantId)))[0]?.count || 0;
+	return typeof total === "string" ? Number.parseInt(total, 10) : total;
+};
+
+//#endregion
+export { countProjectsInRuntime, createProjectMetadata, deleteProjectMetadata, getProjectMetadata, listProjectsMetadata, listProjectsMetadataPaginated, projectsMetadataExists };

package/dist/data-access/runtime/tasks.d.ts

@@ -0,0 +1,55 @@
+import { TaskMetadataConfig } from "../../types/utility.js";
+import "../../types/index.js";
+import { AgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
+import "../../index.js";
+import { TaskInsert, TaskSelect } from "../../types/entities.js";
+
+//#region src/data-access/runtime/tasks.d.ts
+declare const createTask: (db: AgentsRunDatabaseClient) => (params: TaskInsert) => Promise<{
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+  ref: {
+    type: "commit" | "tag" | "branch";
+    name: string;
+    hash: string;
+  } | null;
+  metadata: TaskMetadataConfig | null;
+  status: string;
+  tenantId: string;
+  agentId: string;
+  projectId: string;
+  contextId: string;
+  subAgentId: string;
+}>;
+declare const getTask: (db: AgentsRunDatabaseClient) => (params: {
+  id: string;
+}) => Promise<TaskSelect | null>;
+declare const updateTask: (db: AgentsRunDatabaseClient) => (params: {
+  taskId: string;
+  data: {
+    status?: string;
+    metadata?: any;
+  };
+}) => Promise<{
+  createdAt: string;
+  updatedAt: string;
+  contextId: string;
+  ref: {
+    type: "commit" | "tag" | "branch";
+    name: string;
+    hash: string;
+  } | null;
+  status: string;
+  metadata: TaskMetadataConfig | null;
+  subAgentId: string;
+  agentId: string;
+  projectId: string;
+  tenantId: string;
+  id: string;
+}>;
+declare const listTaskIdsByContextId: (db: AgentsRunDatabaseClient) => (params: {
+  contextId: string;
+}) => Promise<string[]>;
+//#endregion
+export { createTask, getTask, listTaskIdsByContextId, updateTask };

package/dist/data-access/{tasks.js → runtime/tasks.js}

@@ -1,7 +1,7 @@
-import { tasks } from "../db/schema.js";
+import { tasks } from "../../db/runtime/runtime-schema.js";
 import { and, eq } from "drizzle-orm";
 
-//#region src/data-access/tasks.ts
+//#region src/data-access/runtime/tasks.ts
 const createTask = (db) => async (params) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	const [created] = await db.insert(tasks).values({

package/dist/data-access/runtime/triggerInvocations.d.ts

@@ -0,0 +1,62 @@
+import { AgentScopeConfig, PaginationConfig } from "../../types/utility.js";
+import { AgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
+import { TriggerInvocationInsert, TriggerInvocationSelect, TriggerInvocationUpdate } from "../../types/entities.js";
+
+//#region src/data-access/runtime/triggerInvocations.d.ts
+
+/**
+ * Get a trigger invocation by ID (agent-scoped)
+ */
+declare const getTriggerInvocationById: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  triggerId: string;
+  invocationId: string;
+}) => Promise<TriggerInvocationSelect | undefined>;
+/**
+ * List trigger invocations with optional filtering (agent-scoped)
+ */
+declare const listTriggerInvocationsPaginated: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  triggerId: string;
+  pagination?: PaginationConfig;
+  filters?: {
+    status?: "pending" | "success" | "failed";
+    from?: string;
+    to?: string;
+  };
+}) => Promise<{
+  data: {
+    triggerId: string;
+    conversationId: string | null;
+    status: string;
+    requestPayload: unknown;
+    transformedPayload: unknown;
+    errorMessage: string | null;
+    createdAt: string;
+    agentId: string;
+    projectId: string;
+    tenantId: string;
+    id: string;
+  }[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}>;
+/**
+ * Create a new trigger invocation (agent-scoped)
+ */
+declare const createTriggerInvocation: (db: AgentsRunDatabaseClient) => (params: TriggerInvocationInsert) => Promise<TriggerInvocationSelect>;
+/**
+ * Update trigger invocation status (agent-scoped)
+ */
+declare const updateTriggerInvocationStatus: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  triggerId: string;
+  invocationId: string;
+  data: TriggerInvocationUpdate;
+}) => Promise<TriggerInvocationSelect>;
+//#endregion
+export { createTriggerInvocation, getTriggerInvocationById, listTriggerInvocationsPaginated, updateTriggerInvocationStatus };

package/dist/data-access/runtime/triggerInvocations.js

@@ -0,0 +1,54 @@
+import { triggerInvocations } from "../../db/runtime/runtime-schema.js";
+import { and, count, desc, eq, gte, lte } from "drizzle-orm";
+
+//#region src/data-access/runtime/triggerInvocations.ts
+/**
+* Get a trigger invocation by ID (agent-scoped)
+*/
+const getTriggerInvocationById = (db) => async (params) => {
+	return await db.query.triggerInvocations.findFirst({ where: and(eq(triggerInvocations.tenantId, params.scopes.tenantId), eq(triggerInvocations.projectId, params.scopes.projectId), eq(triggerInvocations.agentId, params.scopes.agentId), eq(triggerInvocations.triggerId, params.triggerId), eq(triggerInvocations.id, params.invocationId)) });
+};
+/**
+* List trigger invocations with optional filtering (agent-scoped)
+*/
+const listTriggerInvocationsPaginated = (db) => async (params) => {
+	const page = params.pagination?.page || 1;
+	const limit = Math.min(params.pagination?.limit || 10, 100);
+	const offset = (page - 1) * limit;
+	const conditions = [
+		eq(triggerInvocations.tenantId, params.scopes.tenantId),
+		eq(triggerInvocations.projectId, params.scopes.projectId),
+		eq(triggerInvocations.agentId, params.scopes.agentId),
+		eq(triggerInvocations.triggerId, params.triggerId)
+	];
+	if (params.filters?.status) conditions.push(eq(triggerInvocations.status, params.filters.status));
+	if (params.filters?.from) conditions.push(gte(triggerInvocations.createdAt, params.filters.from));
+	if (params.filters?.to) conditions.push(lte(triggerInvocations.createdAt, params.filters.to));
+	const whereClause = and(...conditions);
+	const [data, totalResult] = await Promise.all([db.select().from(triggerInvocations).where(whereClause).limit(limit).offset(offset).orderBy(desc(triggerInvocations.createdAt)), db.select({ count: count() }).from(triggerInvocations).where(whereClause)]);
+	const total = totalResult[0]?.count || 0;
+	return {
+		data,
+		pagination: {
+			page,
+			limit,
+			total,
+			pages: Math.ceil(total / limit)
+		}
+	};
+};
+/**
+* Create a new trigger invocation (agent-scoped)
+*/
+const createTriggerInvocation = (db) => async (params) => {
+	return (await db.insert(triggerInvocations).values(params).returning())[0];
+};
+/**
+* Update trigger invocation status (agent-scoped)
+*/
+const updateTriggerInvocationStatus = (db) => async (params) => {
+	return (await db.update(triggerInvocations).set(params.data).where(and(eq(triggerInvocations.tenantId, params.scopes.tenantId), eq(triggerInvocations.projectId, params.scopes.projectId), eq(triggerInvocations.agentId, params.scopes.agentId), eq(triggerInvocations.triggerId, params.triggerId), eq(triggerInvocations.id, params.invocationId))).returning())[0];
+};
+
+//#endregion
+export { createTriggerInvocation, getTriggerInvocationById, listTriggerInvocationsPaginated, updateTriggerInvocationStatus };

package/dist/data-access/runtime/users.d.ts

@@ -0,0 +1,19 @@
+import { AgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
+import { User } from "../../auth/auth-validation-schemas.js";
+
+//#region src/data-access/runtime/users.d.ts
+
+/**
+ * User data access layer
+ * All database queries for Better Auth's user table
+ */
+/**
+ * Get user by ID
+ */
+declare const getUserById: (db: AgentsRunDatabaseClient) => (userId: string) => Promise<User | null>;
+/**
+ * Get user by email
+ */
+declare const getUserByEmail: (db: AgentsRunDatabaseClient) => (email: string) => Promise<User | null>;
+//#endregion
+export { getUserByEmail, getUserById };

package/dist/data-access/{users.js → runtime/users.js}

@@ -1,7 +1,7 @@
-import { user } from "../auth/auth-schema.js";
+import { user } from "../../auth/auth-schema.js";
 import { eq } from "drizzle-orm";
 
-//#region src/data-access/users.ts
+//#region src/data-access/runtime/users.ts
 /**
 * User data access layer
 * All database queries for Better Auth's user table

package/dist/data-access/validation.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseClient } from "../db/client.js";
+import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
 
 //#region src/data-access/validation.d.ts
 
@@ -6,16 +6,16 @@ import { DatabaseClient } from "../db/client.js";
  * Validates that a project exists before performing database operations
  * This provides runtime validation even when foreign key constraints are not enforced
  */
-declare const validateProjectExists: (db: DatabaseClient, tenantId: string, projectId: string) => Promise<void>;
+declare const validateProjectExists: (db: AgentsManageDatabaseClient, tenantId: string, projectId: string) => Promise<void>;
 /**
  * Wraps a database operation with project validation
  * Ensures the project exists before executing the operation
  */
-declare const withProjectValidation: <T extends (...args: any[]) => Promise<any>>(db: DatabaseClient, operation: T) => (params: Parameters<T>[0]) => Promise<ReturnType<T>>;
+declare const withProjectValidation: <T extends (...args: any[]) => Promise<any>>(db: AgentsManageDatabaseClient, operation: T) => (params: Parameters<T>[0]) => Promise<ReturnType<T>>;
 /**
  * Creates a validated version of data access functions
  * Automatically adds project validation to insert/update operations
  */
-declare const createValidatedDataAccess: <T extends Record<string, any>>(db: DatabaseClient, dataAccessFunctions: T) => T;
+declare const createValidatedDataAccess: <T extends Record<string, any>>(db: AgentsManageDatabaseClient, dataAccessFunctions: T) => T;
 //#endregion
 export { createValidatedDataAccess, validateProjectExists, withProjectValidation };

package/dist/data-access/validation.js

@@ -1,4 +1,4 @@
-import { projectExistsInTable } from "./projects.js";
+import { projectExistsInTable } from "./manage/projects.js";
 
 //#region src/data-access/validation.ts
 /**

package/dist/db/clean.d.ts

@@ -1,8 +1,12 @@
+import { AgentsManageDatabaseClient } from "./manage/manage-client.js";
+import { AgentsRunDatabaseClient } from "./runtime/runtime-client.js";
+
 //#region src/db/clean.d.ts
+
 /**
- * Truncates all tables in the database, respecting foreign key constraints
- * Tables are cleared in dependency order (child tables first, then parent tables)
+ * Cleans up test database by removing all data but keeping schema
+ * Dynamically gets all tables from the public schema and truncates them
  */
-declare function cleanDatabase(): Promise<void>;
+declare function cleanupDatabase(db: AgentsManageDatabaseClient | AgentsRunDatabaseClient): Promise<void>;
 //#endregion
-export { cleanDatabase };
+export { cleanupDatabase };

package/dist/db/clean.js

@@ -1,115 +1,24 @@
-import { agents, artifactComponents, contextCache, contextConfigs, conversations, credentialReferences, dataComponents, externalAgents, ledgerArtifacts, messages, subAgentArtifactComponents, subAgentDataComponents, subAgentRelations, subAgentToolRelations, subAgents, taskRelations, tasks, tools } from "./schema.js";
-import { env } from "../env.js";
-import { createDatabaseClient } from "./client.js";
-import "../index.js";
+import { sql } from "drizzle-orm";
 
 //#region src/db/clean.ts
-const dbClient = createDatabaseClient();
 /**
-* Truncates all tables in the database, respecting foreign key constraints
-* Tables are cleared in dependency order (child tables first, then parent tables)
+* Cleans up test database by removing all data but keeping schema
+* Dynamically gets all tables from the public schema and truncates them
 */
-async function cleanDatabase() {
-	console.log(`🗑️  Cleaning database for environment: ${env.ENVIRONMENT}`);
+async function cleanupDatabase(db) {
 	try {
-		const tablesToClear = [
-			{
-				table: messages,
-				name: "messages"
-			},
-			{
-				table: conversations,
-				name: "conversations"
-			},
-			{
-				table: taskRelations,
-				name: "task_relations"
-			},
-			{
-				table: tasks,
-				name: "tasks"
-			},
-			{
-				table: subAgentArtifactComponents,
-				name: "agent_artifact_components"
-			},
-			{
-				table: subAgentDataComponents,
-				name: "agent_data_components"
-			},
-			{
-				table: subAgentToolRelations,
-				name: "agent_tool_relations"
-			},
-			{
-				table: subAgentRelations,
-				name: "agent_relations"
-			},
-			{
-				table: agents,
-				name: "agent"
-			},
-			{
-				table: artifactComponents,
-				name: "artifact_components"
-			},
-			{
-				table: dataComponents,
-				name: "data_components"
-			},
-			{
-				table: tools,
-				name: "tools"
-			},
-			{
-				table: subAgents,
-				name: "agents"
-			},
-			{
-				table: externalAgents,
-				name: "external_agents"
-			},
-			{
-				table: ledgerArtifacts,
-				name: "ledger_artifacts"
-			},
-			{
-				table: credentialReferences,
-				name: "credential_references"
-			},
-			{
-				table: contextConfigs,
-				name: "context_configs"
-			},
-			{
-				table: contextCache,
-				name: "context_cache"
-			}
-		];
-		for (const { table, name } of tablesToClear) try {
-			await dbClient.delete(table);
-			console.log(`✅ Cleared table: ${name}`);
-		} catch (error) {
-			const errorMessage = error?.message || "";
-			const causeMessage = error?.cause?.message || "";
-			const errorCode = error?.code || error?.cause?.code || "";
-			if (errorMessage.includes("no such table") || causeMessage.includes("no such table") || errorMessage.includes("does not exist") || causeMessage.includes("does not exist") || errorCode === "42P01") console.log(`⚠️  Table ${name} doesn't exist, skipping`);
-			else throw error;
-		}
-		console.log("---");
-		console.log("🎉 Database cleaned successfully");
+		const tables = (await db.execute(sql.raw(`
+      SELECT tablename 
+      FROM pg_tables 
+      WHERE schemaname = 'public'
+    `))).rows.map((row) => row.tablename);
+		if (tables.length === 0) return;
+		const tableList = tables.map((t) => `"${t}"`).join(", ");
+		await db.execute(sql.raw(`TRUNCATE TABLE ${tableList} RESTART IDENTITY CASCADE`));
 	} catch (error) {
-		console.error("❌ Failed to clean database:", error);
-		throw error;
+		console.debug("Could not clean database:", error);
 	}
 }
-if (import.meta.url === new URL(import.meta.url).href) cleanDatabase().then(() => {
-	console.log("Database cleanup completed");
-	process.exit(0);
-}).catch((error) => {
-	console.error("Database cleanup failed:", error);
-	process.exit(1);
-});
 
 //#endregion
-export { cleanDatabase };
+export { cleanupDatabase };

package/dist/db/delete.d.ts

@@ -3,6 +3,6 @@
  * Drops all tables, sequences, types, and functions from the public schema
  * WARNING: This is destructive and cannot be undone!
  */
-declare function deleteDatabase(): Promise<void>;
+declare function deleteDatabase(type: 'manage' | 'run'): Promise<void>;
 //#endregion
 export { deleteDatabase };

package/dist/db/delete.js

@@ -1,5 +1,6 @@
 import { env } from "../env.js";
-import { createDatabaseClient } from "./client.js";
+import { createAgentsManageDatabaseClient } from "./manage/manage-client.js";
+import { createAgentsRunDatabaseClient } from "./runtime/runtime-client.js";
 import { sql } from "drizzle-orm";
 
 //#region src/db/delete.ts
@@ -7,11 +8,14 @@ import { sql } from "drizzle-orm";
 * Drops all tables, sequences, types, and functions from the public schema
 * WARNING: This is destructive and cannot be undone!
 */
-async function deleteDatabase() {
+async function deleteDatabase(type) {
 	console.log(`🗑️  Deleting all database objects for environment: ${env.ENVIRONMENT}`);
 	console.log("---");
-	const dbClient = createDatabaseClient();
+	const dbClient = type === "manage" ? createAgentsManageDatabaseClient({}) : createAgentsRunDatabaseClient({});
 	try {
+		console.log("Dropping workflow schema...");
+		await dbClient.execute(sql`DROP SCHEMA IF EXISTS workflow CASCADE`);
+		console.log("✅ Workflow schema dropped");
 		console.log("Dropping public schema and all objects...");
 		await dbClient.execute(sql`DROP SCHEMA IF EXISTS public CASCADE`);
 		console.log("✅ Public schema dropped");
@@ -25,13 +29,6 @@ async function deleteDatabase() {
 		throw error;
 	}
 }
-if (import.meta.url === new URL(import.meta.url).href) deleteDatabase().then(() => {
-	console.log("Database deletion completed");
-	process.exit(0);
-}).catch((error) => {
-	console.error("Database deletion failed:", error);
-	process.exit(1);
-});
 
 //#endregion
 export { deleteDatabase };

package/dist/db/manage/dolt-cleanup.d.ts

@@ -0,0 +1,51 @@
+import { AgentsManageDatabaseClient } from "./manage-client.js";
+
+//#region src/db/manage/dolt-cleanup.d.ts
+
+/**
+ * Get a database client for cleanup operations
+ * Allows passing a custom client or uses a default one
+ */
+declare const getIntegrationTestClient: (db?: AgentsManageDatabaseClient) => AgentsManageDatabaseClient;
+/**
+ * Delete all branches matching a prefix pattern
+ * Used for cleaning up integration test data
+ */
+declare const cleanupBranchesByPrefix: (prefix: string, db?: AgentsManageDatabaseClient) => Promise<void>;
+/**
+ * Delete all tags matching a prefix pattern
+ * Used for cleaning up integration test data
+ */
+declare const cleanupTagsByPrefix: (prefix: string, db?: AgentsManageDatabaseClient) => Promise<void>;
+/**
+ * Delete specific branches by name
+ * Used for cleaning up integration test data
+ */
+declare const cleanupBranches: (branchNames: Set<string>, db?: AgentsManageDatabaseClient) => Promise<void>;
+/**
+ * Delete specific tags by name
+ * Used for cleaning up integration test data
+ */
+declare const cleanupTags: (tagNames: Set<string>, db?: AgentsManageDatabaseClient) => Promise<void>;
+/**
+ * Comprehensive cleanup for test data by prefix
+ * Used for cleaning up integration test data
+ */
+declare const cleanupTestData: (prefix: string, branches?: Set<string>, tags?: Set<string>, db?: AgentsManageDatabaseClient) => Promise<void>;
+/**
+ * Delete all branches matching a tenant prefix
+ * Used for cleaning up integration test data
+ */
+declare const cleanupTenantBranches: (tenantId: string, db?: AgentsManageDatabaseClient) => Promise<void>;
+/**
+ * Comprehensive cleanup for a tenant: deletes tags and branches
+ * Used for cleaning up integration test data
+ */
+declare const cleanupTenant: (tenantId: string, tagNames?: Set<string>, db?: AgentsManageDatabaseClient) => Promise<void>;
+/**
+ * Cleanup multiple tenants
+ * Used for cleaning up integration test data
+ */
+declare const cleanupTenants: (tenantIds: Set<string>, tagNames?: Set<string>, db?: AgentsManageDatabaseClient) => Promise<void>;
+//#endregion
+export { cleanupBranches, cleanupBranchesByPrefix, cleanupTags, cleanupTagsByPrefix, cleanupTenant, cleanupTenantBranches, cleanupTenants, cleanupTestData, getIntegrationTestClient };