@inkeep/agents-core 0.41.2 → 0.42.0

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 };

package/dist/db/manage/dolt-cleanup.js

@@ -0,0 +1,132 @@
+import { loadEnvironmentFiles } from "../../env.js";
+import { createAgentsManageDatabaseClient } from "./manage-client.js";
+import { sql } from "drizzle-orm";
+
+//#region src/db/manage/dolt-cleanup.ts
+loadEnvironmentFiles();
+/**
+* Get a database client for cleanup operations
+* Allows passing a custom client or uses a default one
+*/
+const getIntegrationTestClient = (db) => {
+	if (db) return db;
+	return createAgentsManageDatabaseClient({});
+};
+/**
+* Delete all branches matching a prefix pattern
+* Used for cleaning up integration test data
+*/
+const cleanupBranchesByPrefix = async (prefix, db) => {
+	const dbClient = getIntegrationTestClient(db);
+	try {
+		const branches = await dbClient.execute(sql.raw(`SELECT name FROM dolt_branches WHERE name LIKE '${prefix}%'`));
+		for (const branch of branches.rows) {
+			const branchName = branch.name;
+			try {
+				await dbClient.execute(sql.raw(` DOLT_BRANCH('-D', '${branchName}')`));
+			} catch (error) {
+				console.debug(`Could not delete branch ${branchName}:`, error);
+			}
+		}
+	} catch (error) {
+		console.error(`Error cleaning up branches with prefix ${prefix}:`, error);
+	}
+};
+/**
+* Delete all tags matching a prefix pattern
+* Used for cleaning up integration test data
+*/
+const cleanupTagsByPrefix = async (prefix, db) => {
+	const dbClient = getIntegrationTestClient(db);
+	try {
+		const tags = await dbClient.execute(sql.raw(`SELECT tag_name FROM dolt_tags WHERE tag_name LIKE '${prefix}%'`));
+		for (const tag of tags.rows) {
+			const tagName = tag.tag_name;
+			try {
+				await dbClient.execute(sql.raw(`SELECT DOLT_TAG('-d', '${tagName}')`));
+			} catch (error) {
+				console.debug(`Could not delete tag ${tagName}:`, error);
+			}
+		}
+	} catch (error) {
+		console.error(`Error cleaning up tags with prefix ${prefix}:`, error);
+	}
+};
+/**
+* Delete specific branches by name
+* Used for cleaning up integration test data
+*/
+const cleanupBranches = async (branchNames, db) => {
+	const dbClient = getIntegrationTestClient(db);
+	for (const branchName of branchNames) try {
+		await dbClient.execute(sql.raw(`SELECT DOLT_BRANCH('-D', '${branchName}')`));
+	} catch (error) {
+		console.debug(`Could not delete branch ${branchName}:`, error);
+	}
+};
+/**
+* Delete specific tags by name
+* Used for cleaning up integration test data
+*/
+const cleanupTags = async (tagNames, db) => {
+	const dbClient = getIntegrationTestClient(db);
+	for (const tagName of tagNames) try {
+		await dbClient.execute(sql.raw(`SELECT DOLT_TAG('-d', '${tagName}')`));
+	} catch (error) {
+		console.debug(`Could not delete tag ${tagName}:`, error);
+	}
+};
+/**
+* Comprehensive cleanup for test data by prefix
+* Used for cleaning up integration test data
+*/
+const cleanupTestData = async (prefix, branches, tags, db) => {
+	if (tags && tags.size > 0) await cleanupTags(tags, db);
+	await cleanupTagsByPrefix(prefix, db);
+	if (branches && branches.size > 0) await cleanupBranches(branches, db);
+	await cleanupBranchesByPrefix(prefix, db);
+};
+/**
+* Delete all branches matching a tenant prefix
+* Used for cleaning up integration test data
+*/
+const cleanupTenantBranches = async (tenantId, db) => {
+	const dbClient = getIntegrationTestClient(db);
+	try {
+		const pattern = `${tenantId}_%`;
+		const branches = await dbClient.execute(sql.raw(`SELECT name FROM dolt_branches WHERE name LIKE '${pattern}'`));
+		for (const branch of branches.rows) {
+			const branchName = branch.name;
+			try {
+				await dbClient.execute(sql.raw(`SELECT DOLT_BRANCH('-D', '${branchName}')`));
+			} catch (error) {
+				console.debug(`Could not delete branch ${branchName}:`, error);
+			}
+		}
+	} catch (error) {
+		console.error(`Error cleaning up branches for tenant ${tenantId}:`, error);
+	}
+};
+/**
+* Comprehensive cleanup for a tenant: deletes tags and branches
+* Used for cleaning up integration test data
+*/
+const cleanupTenant = async (tenantId, tagNames, db) => {
+	try {
+		if (tagNames && tagNames.size > 0) await cleanupTags(tagNames, db);
+		await cleanupTenantBranches(tenantId, db);
+	} catch (error) {
+		console.error(`Error cleaning up tenant ${tenantId}:`, error);
+	}
+};
+/**
+* Cleanup multiple tenants
+* Used for cleaning up integration test data
+*/
+const cleanupTenants = async (tenantIds, tagNames, db) => {
+	if (tagNames && tagNames.size > 0) await cleanupTags(tagNames, db);
+	for (const tenantId of tenantIds) await cleanupTenantBranches(tenantId, db);
+};
+
+//#endregion
+export { cleanupBranches, cleanupBranchesByPrefix, cleanupTags, cleanupTagsByPrefix, cleanupTenant, cleanupTenantBranches, cleanupTenants, cleanupTestData, getIntegrationTestClient };

package/dist/db/manage/manage-client.d.ts

@@ -0,0 +1,26 @@
+import { manage_schema_d_exports } from "./manage-schema.js";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import { PgliteDatabase } from "drizzle-orm/pglite";
+
+//#region src/db/manage/manage-client.d.ts
+type AgentsManageDatabaseClient = NodePgDatabase<typeof manage_schema_d_exports> | PgliteDatabase<typeof manage_schema_d_exports>;
+interface AgentsManageDatabaseConfig {
+  connectionString?: string;
+  poolSize?: number;
+  ssl?: boolean;
+  logger?: {
+    logQuery: (query: string, params: unknown[]) => void;
+  };
+}
+declare function createAgentsManageDatabasePool(config: AgentsManageDatabaseConfig): Pool;
+/**
+ * Creates a PostgreSQL database client with connection pooling
+ */
+declare function createAgentsManageDatabaseClient(config: AgentsManageDatabaseConfig): AgentsManageDatabaseClient;
+declare function createAgentManageDatabaseConnection(config: AgentsManageDatabaseConfig): Promise<{
+  db: AgentsManageDatabaseClient;
+  release: () => Promise<void>;
+}>;
+//#endregion
+export { AgentsManageDatabaseClient, AgentsManageDatabaseConfig, createAgentManageDatabaseConnection, createAgentsManageDatabaseClient, createAgentsManageDatabasePool };

package/dist/db/manage/manage-client.js

@@ -0,0 +1,68 @@
+import { manage_schema_exports } from "./manage-schema.js";
+import { env, loadEnvironmentFiles } from "../../env.js";
+import { createTestManageDatabaseClientNoMigrations } from "./test-manage-client.js";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+
+//#region src/db/manage/manage-client.ts
+loadEnvironmentFiles();
+function createAgentsManageDatabasePool(config) {
+	const connectionString = config.connectionString || env.INKEEP_AGENTS_MANAGE_DATABASE_URL;
+	if (!connectionString) throw new Error("INKEEP_AGENTS_MANAGE_DATABASE_URL environment variable is required. Please set it to your PostgreSQL connection string.");
+	const pool = new Pool({
+		connectionString,
+		max: config.poolSize || Number(env.POSTGRES_POOL_SIZE) || 100
+	});
+	pool.on("error", (err) => {
+		console.error("Unexpected PostgreSQL pool error:", err);
+	});
+	return pool;
+}
+/**
+* Creates a PostgreSQL database client with connection pooling
+*/
+function createAgentsManageDatabaseClient(config) {
+	const connectionString = config.connectionString || env.INKEEP_AGENTS_MANAGE_DATABASE_URL;
+	if (env.ENVIRONMENT === "test") return createTestManageDatabaseClientNoMigrations();
+	if (!connectionString) throw new Error("INKEEP_AGENTS_MANAGE_DATABASE_URL environment variable is required. Please set it to your PostgreSQL connection string.");
+	const pool = new Pool({
+		connectionString,
+		max: config.poolSize || Number(env.POSTGRES_POOL_SIZE) || 100
+	});
+	pool.on("error", (err) => {
+		console.error("Unexpected PostgreSQL pool error:", err);
+	});
+	return drizzle(pool, {
+		schema: manage_schema_exports,
+		logger: config.logger
+	});
+}
+function createAgentManageDatabaseConnection(config) {
+	const connectionString = config.connectionString || env.INKEEP_AGENTS_MANAGE_DATABASE_URL;
+	if (env.ENVIRONMENT === "test") throw new Error("createAgentManageDatabaseConnection is not supported in test environment");
+	if (!connectionString) throw new Error("INKEEP_AGENTS_MANAGE_DATABASE_URL environment variable is required. Please set it to your PostgreSQL connection string.");
+	const pool = new Pool({
+		connectionString,
+		max: 1
+	});
+	pool.on("error", (err) => {
+		console.error("Unexpected PostgreSQL pool error:", err);
+	});
+	return pool.connect().then((connection) => {
+		const db = drizzle(connection, {
+			schema: manage_schema_exports,
+			logger: config.logger
+		});
+		const release = async () => {
+			connection.release();
+			await pool.end();
+		};
+		return {
+			db,
+			release
+		};
+	});
+}
+
+//#endregion
+export { createAgentManageDatabaseConnection, createAgentsManageDatabaseClient, createAgentsManageDatabasePool };