@inkeep/agents-core 0.41.1 → 0.42.0

package/dist/data-access/{tools.d.ts → manage/tools.d.ts}

@@ -1,36 +1,43 @@
-import { McpTool, ToolInsert, ToolSelect, ToolUpdate } from "../types/entities.js";
-import "../types/index.js";
-import { CredentialStoreRegistry } from "../credential-stores/CredentialStoreRegistry.js";
-import "../credential-stores/index.js";
-import "../index.js";
-import { AgentScopeConfig, PaginationConfig, ProjectScopeConfig, ToolMcpConfig, ToolServerCapabilities } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
+import { AgentScopeConfig, PaginationConfig, ProjectScopeConfig, ToolMcpConfig, ToolServerCapabilities } from "../../types/utility.js";
+import "../../types/index.js";
+import { CredentialStoreRegistry } from "../../credential-stores/CredentialStoreRegistry.js";
+import "../../credential-stores/index.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import "../../index.js";
+import { McpTool, ToolInsert, ToolSelect, ToolUpdate } from "../../types/entities.js";
 
-//#region src/data-access/tools.d.ts
-declare const dbResultToMcpTool: (dbResult: ToolSelect, dbClient: DatabaseClient, credentialStoreRegistry?: CredentialStoreRegistry, relationshipId?: string, userId?: string) => Promise<McpTool>;
-declare const getToolById: (db: DatabaseClient) => (params: {
+//#region src/data-access/manage/tools.d.ts
+declare const dbResultToMcpTool: (dbResult: ToolSelect, dbClient: AgentsManageDatabaseClient, credentialStoreRegistry?: CredentialStoreRegistry, relationshipId?: string, userId?: string) => Promise<McpTool>;
+declare const getToolById: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   toolId: string;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
   name: string;
-  createdAt: string;
-  updatedAt: string;
   description: string | null;
-  tenantId: string;
-  projectId: string;
-  credentialReferenceId: string | null;
   config: {
     type: "mcp";
     mcp: ToolMcpConfig;
   };
-  credentialScope: string;
+  credentialReferenceId: string | null;
+  createdAt: string;
+  updatedAt: string;
   headers: Record<string, string> | null;
+  credentialScope: string;
   imageUrl: string | null;
   capabilities: ToolServerCapabilities | null;
   lastError: string | null;
 } | null>;
-declare const listTools: (db: DatabaseClient) => (params: {
+declare const getMcpToolById: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+  toolId: string;
+  relationshipId?: string;
+  credentialStoreRegistry?: CredentialStoreRegistry;
+  userId?: string;
+}) => Promise<McpTool | null>;
+declare const listTools: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   pagination?: PaginationConfig;
 }) => Promise<{
@@ -60,26 +67,26 @@ declare const listTools: (db: DatabaseClient) => (params: {
     pages: number;
   };
 }>;
-declare const createTool: (db: DatabaseClient) => (params: ToolInsert) => Promise<{
+declare const createTool: (db: AgentsManageDatabaseClient) => (params: ToolInsert) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
   name: string;
-  createdAt: string;
-  updatedAt: string;
   description: string | null;
-  tenantId: string;
-  projectId: string;
-  credentialReferenceId: string | null;
   config: {
     type: "mcp";
     mcp: ToolMcpConfig;
   };
-  credentialScope: string;
+  credentialReferenceId: string | null;
+  createdAt: string;
+  updatedAt: string;
   headers: Record<string, string> | null;
+  credentialScope: string;
   imageUrl: string | null;
   capabilities: ToolServerCapabilities | null;
   lastError: string | null;
 }>;
-declare const updateTool: (db: DatabaseClient) => (params: {
+declare const updateTool: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   toolId: string;
   data: ToolUpdate;
@@ -102,11 +109,11 @@ declare const updateTool: (db: DatabaseClient) => (params: {
   tenantId: string;
   id: string;
 }>;
-declare const deleteTool: (db: DatabaseClient) => (params: {
+declare const deleteTool: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   toolId: string;
 }) => Promise<boolean>;
-declare const addToolToAgent: (db: DatabaseClient) => (params: {
+declare const addToolToAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   subAgentId: string;
   toolId: string;
@@ -116,43 +123,43 @@ declare const addToolToAgent: (db: DatabaseClient) => (params: {
     needsApproval?: boolean;
   }> | null;
 }) => Promise<{
-  id: string;
-  createdAt: string;
-  updatedAt: string;
   tenantId: string;
   projectId: string;
+  id: string;
   agentId: string;
+  createdAt: string;
+  updatedAt: string;
   toolId: string;
-  subAgentId: string;
   headers: Record<string, string> | null;
-  selectedTools: string[] | null;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
+  subAgentId: string;
+  selectedTools: string[] | null;
 }>;
-declare const removeToolFromAgent: (db: DatabaseClient) => (params: {
+declare const removeToolFromAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   subAgentId: string;
   toolId: string;
 }) => Promise<{
-  id: string;
-  createdAt: string;
-  updatedAt: string;
   tenantId: string;
   projectId: string;
+  id: string;
   agentId: string;
+  createdAt: string;
+  updatedAt: string;
   toolId: string;
-  subAgentId: string;
   headers: Record<string, string> | null;
-  selectedTools: string[] | null;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
+  subAgentId: string;
+  selectedTools: string[] | null;
 }>;
 /**
  * Upsert agent-tool relation (create if it doesn't exist, update if it does)
  */
-declare const upsertSubAgentToolRelation: (db: DatabaseClient) => (params: {
+declare const upsertSubAgentToolRelation: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   subAgentId: string;
   toolId: string;
@@ -163,43 +170,43 @@ declare const upsertSubAgentToolRelation: (db: DatabaseClient) => (params: {
   }> | null;
   relationId?: string;
 }) => Promise<{
-  id: string;
-  createdAt: string;
-  updatedAt: string;
   tenantId: string;
   projectId: string;
+  id: string;
   agentId: string;
+  createdAt: string;
+  updatedAt: string;
   toolId: string;
-  subAgentId: string;
   headers: Record<string, string> | null;
-  selectedTools: string[] | null;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
+  subAgentId: string;
+  selectedTools: string[] | null;
 }>;
 /**
  * Upsert a tool (create if it doesn't exist, update if it does)
  */
-declare const upsertTool: (db: DatabaseClient) => (params: {
+declare const upsertTool: (db: AgentsManageDatabaseClient) => (params: {
   data: ToolInsert;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
   name: string;
-  createdAt: string;
-  updatedAt: string;
   description: string | null;
-  tenantId: string;
-  projectId: string;
-  credentialReferenceId: string | null;
   config: {
     type: "mcp";
     mcp: ToolMcpConfig;
   };
-  credentialScope: string;
+  credentialReferenceId: string | null;
+  createdAt: string;
+  updatedAt: string;
   headers: Record<string, string> | null;
+  credentialScope: string;
   imageUrl: string | null;
   capabilities: ToolServerCapabilities | null;
   lastError: string | null;
 }>;
 //#endregion
-export { addToolToAgent, createTool, dbResultToMcpTool, deleteTool, getToolById, listTools, removeToolFromAgent, updateTool, upsertSubAgentToolRelation, upsertTool };
+export { addToolToAgent, createTool, dbResultToMcpTool, deleteTool, getMcpToolById, getToolById, listTools, removeToolFromAgent, updateTool, upsertSubAgentToolRelation, upsertTool };

package/dist/data-access/{tools.js → manage/tools.js}

@@ -1,22 +1,20 @@
-import { CredentialStoreType, MCPServerType, MCPTransportType } from "../types/utility.js";
-import { subAgentToolRelations, tools } from "../db/schema.js";
-import { detectAuthenticationRequired } from "../utils/auth-detection.js";
-import { getLogger } from "../utils/logger.js";
-import { getCredentialStoreLookupKeyFromRetrievalParams } from "../utils/credential-store-utils.js";
-import { CredentialStuffer } from "../credential-stuffer/CredentialStuffer.js";
-import { generateId } from "../utils/conversations.js";
+import { CredentialStoreType, MCPServerType, MCPTransportType } from "../../types/utility.js";
+import { subAgentToolRelations, tools } from "../../db/manage/manage-schema.js";
+import { detectAuthenticationRequired } from "../../utils/auth-detection.js";
+import { getLogger } from "../../utils/logger.js";
+import { getCredentialStoreLookupKeyFromRetrievalParams } from "../../utils/credential-store-utils.js";
+import { CredentialStuffer } from "../../credential-stuffer/CredentialStuffer.js";
+import "../../credential-stuffer/index.js";
+import { generateId } from "../../utils/conversations.js";
 import { updateAgentToolRelation } from "./subAgentRelations.js";
-import "../credential-stuffer/index.js";
-import { toISODateString } from "../utils/date.js";
-import { McpClient } from "../utils/mcp-client.js";
-import { isThirdPartyMCPServerAuthenticated } from "../utils/third-party-mcp-servers/third-party-check.js";
-import "../utils/index.js";
+import { toISODateString } from "../../utils/date.js";
+import { McpClient } from "../../utils/mcp-client.js";
+import { isThirdPartyMCPServerAuthenticated } from "../../utils/third-party-mcp-servers/third-party-check.js";
+import "../../utils/index.js";
 import { getCredentialReference, getUserScopedCredentialReference } from "./credentialReferences.js";
-import { ContextResolver } from "../context/ContextResolver.js";
-import "../context/index.js";
 import { and, count, desc, eq } from "drizzle-orm";
 
-//#region src/data-access/tools.ts
+//#region src/data-access/manage/tools.ts
 const logger = getLogger("tools");
 /**
 * Extract expiration date from credential data stored in credential store
@@ -49,7 +47,10 @@ async function getCredentialExpiresAt(credentialReference, credentialStoreRegist
 * - parameters (direct) - alternative format
 * - schema - another possible location
 */
-function extractInputSchema(toolDef) {
+function extractInputSchema(toolDef, _toolName, _toolOverrides) {
+	return extractOriginalSchema(toolDef);
+}
+function extractOriginalSchema(toolDef) {
 	if (toolDef.inputSchema) return toolDef.inputSchema;
 	if (toolDef.parameters?.properties) return toolDef.parameters.properties;
 	if (toolDef.parameters && typeof toolDef.parameters === "object") return toolDef.parameters;
@@ -65,7 +66,8 @@ const convertToMCPToolConfig = (tool) => {
 		serverUrl: tool.config.mcp.server.url,
 		mcpType: tool.config.mcp.server.url.includes("api.nango.dev") ? MCPServerType.nango : MCPServerType.generic,
 		transport: tool.config.mcp.transport,
-		headers: tool.headers
+		headers: tool.headers,
+		toolOverrides: tool.config.mcp.toolOverrides
 	};
 };
 const discoverToolsFromServer = async (tool, dbClient, credentialStoreRegistry, userId) => {
@@ -92,7 +94,7 @@ const discoverToolsFromServer = async (tool, dbClient, credentialStoreRegistry,
 				retrievalParams: credentialReference.retrievalParams || {}
 			};
 			if (!credentialStoreRegistry) throw new Error("CredentialStoreRegistry is required for authenticated tools");
-			serverConfig = await new CredentialStuffer(credentialStoreRegistry, new ContextResolver(tool.tenantId, tool.projectId, dbClient, credentialStoreRegistry)).buildMcpServerConfig({
+			serverConfig = await new CredentialStuffer(credentialStoreRegistry).buildMcpServerConfig({
 				tenantId: tool.tenantId,
 				projectId: tool.projectId
 			}, convertToMCPToolConfig(tool), storeReference);
@@ -122,11 +124,15 @@ const discoverToolsFromServer = async (tool, dbClient, credentialStoreRegistry,
 		await client.connect();
 		const serverTools = await client.tools();
 		await client.disconnect();
-		return Object.entries(serverTools).map(([name, toolDef]) => ({
-			name,
-			description: toolDef.description || "",
-			inputSchema: extractInputSchema(toolDef)
-		}));
+		const toolOverrides = tool.config.mcp.toolOverrides;
+		return Object.entries(serverTools).map(([name, toolDef]) => {
+			const schema = extractInputSchema(toolDef, name, toolOverrides);
+			return {
+				name,
+				description: toolDef.description || "",
+				inputSchema: schema
+			};
+		});
 	} catch (error) {
 		logger.error({
 			toolId: tool.id,
@@ -196,17 +202,25 @@ const dbResultToMcpTool = async (dbResult, dbClient, credentialStoreRegistry, re
 		}
 	}
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	await updateTool(dbClient)({
-		scopes: {
-			tenantId: dbResult.tenantId,
-			projectId: dbResult.projectId
-		},
-		toolId: dbResult.id,
-		data: {
-			updatedAt: now,
-			lastError: lastErrorComputed
-		}
-	});
+	try {
+		await updateTool(dbClient)({
+			scopes: {
+				tenantId: dbResult.tenantId,
+				projectId: dbResult.projectId
+			},
+			toolId: dbResult.id,
+			data: {
+				updatedAt: now,
+				lastError: lastErrorComputed
+			}
+		});
+	} catch (updateError) {
+		if (updateError instanceof Error && (updateError.message.includes("serialization failure") || updateError.message.includes("40001") || updateError.cause?.code === "XX000")) logger.debug({ toolId: dbResult.id }, "Skipping tool metadata update due to serialization conflict (concurrent request)");
+		else logger.warn({
+			toolId: dbResult.id,
+			error: updateError
+		}, "Failed to update tool metadata - continuing with stale data");
+	}
 	return {
 		...rest,
 		status,
@@ -226,6 +240,14 @@ const dbResultToMcpTool = async (dbResult, dbClient, credentialStoreRegistry, re
 const getToolById = (db) => async (params) => {
 	return await db.query.tools.findFirst({ where: and(eq(tools.tenantId, params.scopes.tenantId), eq(tools.projectId, params.scopes.projectId), eq(tools.id, params.toolId)) }) ?? null;
 };
+const getMcpToolById = (db) => async (params) => {
+	const tool = await getToolById(db)({
+		scopes: params.scopes,
+		toolId: params.toolId
+	});
+	if (!tool) return null;
+	return await dbResultToMcpTool(tool, db, params.credentialStoreRegistry, params.relationshipId, params.userId);
+};
 const listTools = (db) => async (params) => {
 	const page = params.pagination?.page || 1;
 	const limit = Math.min(params.pagination?.limit || 10, 100);
@@ -329,4 +351,4 @@ const upsertTool = (db) => async (params) => {
 };
 
 //#endregion
-export { addToolToAgent, createTool, dbResultToMcpTool, deleteTool, getToolById, listTools, removeToolFromAgent, updateTool, upsertSubAgentToolRelation, upsertTool };
+export { addToolToAgent, createTool, dbResultToMcpTool, deleteTool, getMcpToolById, getToolById, listTools, removeToolFromAgent, updateTool, upsertSubAgentToolRelation, upsertTool };

package/dist/data-access/manage/triggers.d.ts

@@ -0,0 +1,80 @@
+import { AgentScopeConfig, PaginationConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { TriggerInsert, TriggerSelect, TriggerUpdate } from "../../types/entities.js";
+
+//#region src/data-access/manage/triggers.d.ts
+
+/**
+ * Get a trigger by ID (agent-scoped)
+ */
+declare const getTriggerById: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  triggerId: string;
+}) => Promise<TriggerSelect | undefined>;
+/**
+ * List all triggers for an agent
+ */
+declare const listTriggers: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+}) => Promise<TriggerSelect[]>;
+/**
+ * List triggers for an agent with pagination
+ */
+declare const listTriggersPaginated: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  pagination?: PaginationConfig;
+}) => Promise<{
+  data: {
+    createdAt: string;
+    updatedAt: string;
+    enabled: boolean;
+    inputSchema: Record<string, unknown> | null;
+    outputTransform: {
+      jmespath?: string;
+      objectTransformation?: Record<string, string>;
+    } | null;
+    messageTemplate: string | null;
+    authentication: unknown;
+    signingSecret: string | null;
+    name: string;
+    description: string | null;
+    agentId: string;
+    projectId: string;
+    tenantId: string;
+    id: string;
+  }[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}>;
+/**
+ * Create a new trigger (agent-scoped)
+ */
+declare const createTrigger: (db: AgentsManageDatabaseClient) => (params: TriggerInsert) => Promise<TriggerSelect>;
+/**
+ * Update a trigger (agent-scoped)
+ */
+declare const updateTrigger: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  triggerId: string;
+  data: TriggerUpdate;
+}) => Promise<TriggerSelect>;
+/**
+ * Delete a trigger (agent-scoped)
+ */
+declare const deleteTrigger: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  triggerId: string;
+}) => Promise<void>;
+/**
+ * Upsert a trigger (create or update based on existence)
+ */
+declare const upsertTrigger: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  data: TriggerInsert;
+}) => Promise<TriggerSelect>;
+//#endregion
+export { createTrigger, deleteTrigger, getTriggerById, listTriggers, listTriggersPaginated, updateTrigger, upsertTrigger };

package/dist/data-access/manage/triggers.js

@@ -0,0 +1,81 @@
+import { triggers } from "../../db/manage/manage-schema.js";
+import { and, count, desc, eq } from "drizzle-orm";
+
+//#region src/data-access/manage/triggers.ts
+/**
+* Get a trigger by ID (agent-scoped)
+*/
+const getTriggerById = (db) => async (params) => {
+	const { scopes, triggerId } = params;
+	return await db.query.triggers.findFirst({ where: and(eq(triggers.tenantId, scopes.tenantId), eq(triggers.projectId, scopes.projectId), eq(triggers.agentId, scopes.agentId), eq(triggers.id, triggerId)) });
+};
+/**
+* List all triggers for an agent
+*/
+const listTriggers = (db) => async (params) => {
+	return await db.query.triggers.findMany({ where: and(eq(triggers.tenantId, params.scopes.tenantId), eq(triggers.projectId, params.scopes.projectId), eq(triggers.agentId, params.scopes.agentId)) });
+};
+/**
+* List triggers for an agent with pagination
+*/
+const listTriggersPaginated = (db) => async (params) => {
+	const page = params.pagination?.page || 1;
+	const limit = Math.min(params.pagination?.limit || 10, 100);
+	const offset = (page - 1) * limit;
+	const whereClause = and(eq(triggers.tenantId, params.scopes.tenantId), eq(triggers.projectId, params.scopes.projectId), eq(triggers.agentId, params.scopes.agentId));
+	const [data, totalResult] = await Promise.all([db.select().from(triggers).where(whereClause).limit(limit).offset(offset).orderBy(desc(triggers.createdAt)), db.select({ count: count() }).from(triggers).where(whereClause)]);
+	const total = totalResult[0]?.count || 0;
+	return {
+		data,
+		pagination: {
+			page,
+			limit,
+			total,
+			pages: Math.ceil(total / limit)
+		}
+	};
+};
+/**
+* Create a new trigger (agent-scoped)
+*/
+const createTrigger = (db) => async (params) => {
+	return (await db.insert(triggers).values(params).returning())[0];
+};
+/**
+* Update a trigger (agent-scoped)
+*/
+const updateTrigger = (db) => async (params) => {
+	const updateData = {
+		...params.data,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	return (await db.update(triggers).set(updateData).where(and(eq(triggers.tenantId, params.scopes.tenantId), eq(triggers.projectId, params.scopes.projectId), eq(triggers.agentId, params.scopes.agentId), eq(triggers.id, params.triggerId))).returning())[0];
+};
+/**
+* Delete a trigger (agent-scoped)
+*/
+const deleteTrigger = (db) => async (params) => {
+	await db.delete(triggers).where(and(eq(triggers.tenantId, params.scopes.tenantId), eq(triggers.projectId, params.scopes.projectId), eq(triggers.agentId, params.scopes.agentId), eq(triggers.id, params.triggerId)));
+};
+/**
+* Upsert a trigger (create or update based on existence)
+*/
+const upsertTrigger = (db) => async (params) => {
+	const { scopes, data } = params;
+	if (await db.query.triggers.findFirst({ where: and(eq(triggers.tenantId, scopes.tenantId), eq(triggers.projectId, scopes.projectId), eq(triggers.agentId, scopes.agentId), eq(triggers.id, data.id)) })) {
+		const updateData = {
+			...data,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		return (await db.update(triggers).set(updateData).where(and(eq(triggers.tenantId, scopes.tenantId), eq(triggers.projectId, scopes.projectId), eq(triggers.agentId, scopes.agentId), eq(triggers.id, data.id))).returning())[0];
+	}
+	return (await db.insert(triggers).values({
+		...data,
+		tenantId: scopes.tenantId,
+		projectId: scopes.projectId,
+		agentId: scopes.agentId
+	}).returning())[0];
+};
+
+//#endregion
+export { createTrigger, deleteTrigger, getTriggerById, listTriggers, listTriggersPaginated, updateTrigger, upsertTrigger };

package/dist/data-access/{apiKeys.d.ts → runtime/apiKeys.d.ts}

@@ -1,57 +1,57 @@
-import { ApiKeyInsert, ApiKeySelect, ApiKeyUpdate } from "../types/entities.js";
-import { ApiKeyCreateResult, CreateApiKeyParams, PaginationConfig, ProjectScopeConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
+import { ApiKeyCreateResult, CreateApiKeyParams, PaginationConfig, ProjectScopeConfig } from "../../types/utility.js";
+import { AgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
+import { ApiKeyInsert, ApiKeySelect, ApiKeyUpdate } from "../../types/entities.js";
 
-//#region src/data-access/apiKeys.d.ts
-declare const getApiKeyById: (db: DatabaseClient) => (params: {
+//#region src/data-access/runtime/apiKeys.d.ts
+declare const getApiKeyById: (db: AgentsRunDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   id: string;
 }) => Promise<{
-  id: string;
-  name: string | null;
-  createdAt: string;
-  updatedAt: string;
   tenantId: string;
   projectId: string;
+  id: string;
+  name: string | null;
   agentId: string;
   publicId: string;
   keyHash: string;
   keyPrefix: string;
   lastUsedAt: string | null;
   expiresAt: string | null;
-} | undefined>;
-declare const getApiKeyByPublicId: (db: DatabaseClient) => (publicId: string) => Promise<{
-  id: string;
-  name: string | null;
   createdAt: string;
   updatedAt: string;
+} | undefined>;
+declare const getApiKeyByPublicId: (db: AgentsRunDatabaseClient) => (publicId: string) => Promise<{
   tenantId: string;
   projectId: string;
+  id: string;
+  name: string | null;
   agentId: string;
   publicId: string;
   keyHash: string;
   keyPrefix: string;
   lastUsedAt: string | null;
   expiresAt: string | null;
+  createdAt: string;
+  updatedAt: string;
 } | undefined>;
-declare const listApiKeys: (db: DatabaseClient) => (params: {
+declare const listApiKeys: (db: AgentsRunDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   agentId?: string;
 }) => Promise<{
-  id: string;
-  name: string | null;
-  createdAt: string;
-  updatedAt: string;
   tenantId: string;
   projectId: string;
+  id: string;
+  name: string | null;
   agentId: string;
   publicId: string;
   keyHash: string;
   keyPrefix: string;
   lastUsedAt: string | null;
   expiresAt: string | null;
+  createdAt: string;
+  updatedAt: string;
 }[]>;
-declare const listApiKeysPaginated: (db: DatabaseClient) => (params: {
+declare const listApiKeysPaginated: (db: AgentsRunDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   pagination?: PaginationConfig;
   agentId?: string;
@@ -64,48 +64,48 @@ declare const listApiKeysPaginated: (db: DatabaseClient) => (params: {
     pages: number;
   };
 }>;
-declare const createApiKey: (db: DatabaseClient) => (params: ApiKeyInsert) => Promise<{
-  id: string;
-  name: string | null;
-  createdAt: string;
-  updatedAt: string;
+declare const createApiKey: (db: AgentsRunDatabaseClient) => (params: ApiKeyInsert) => Promise<{
   tenantId: string;
   projectId: string;
+  id: string;
+  name: string | null;
   agentId: string;
   publicId: string;
   keyHash: string;
   keyPrefix: string;
   lastUsedAt: string | null;
   expiresAt: string | null;
+  createdAt: string;
+  updatedAt: string;
 }>;
-declare const updateApiKey: (db: DatabaseClient) => (params: {
+declare const updateApiKey: (db: AgentsRunDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   id: string;
   data: ApiKeyUpdate;
 }) => Promise<{
   createdAt: string;
   updatedAt: string;
+  agentId: string;
   publicId: string;
   keyHash: string;
   keyPrefix: string;
   name: string | null;
   lastUsedAt: string | null;
   expiresAt: string | null;
-  agentId: string;
   projectId: string;
   tenantId: string;
   id: string;
 }>;
-declare const deleteApiKey: (db: DatabaseClient) => (params: {
+declare const deleteApiKey: (db: AgentsRunDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   id: string;
 }) => Promise<boolean>;
-declare const hasApiKey: (db: DatabaseClient) => (params: {
+declare const hasApiKey: (db: AgentsRunDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   id: string;
 }) => Promise<boolean>;
-declare const updateApiKeyLastUsed: (db: DatabaseClient) => (id: string) => Promise<void>;
-declare const countApiKeys: (db: DatabaseClient) => (params: {
+declare const updateApiKeyLastUsed: (db: AgentsRunDatabaseClient) => (id: string) => Promise<void>;
+declare const countApiKeys: (db: AgentsRunDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   agentId?: string;
 }) => Promise<number>;
@@ -113,10 +113,10 @@ declare const countApiKeys: (db: DatabaseClient) => (params: {
  * Create a new API key
  * Returns both the API key record and the full key (which should be shown to the user only once)
  */
-declare const generateAndCreateApiKey: (params: CreateApiKeyParams, db: DatabaseClient) => Promise<ApiKeyCreateResult>;
+declare const generateAndCreateApiKey: (params: CreateApiKeyParams, db: AgentsRunDatabaseClient) => Promise<ApiKeyCreateResult>;
 /**
  * Validate an API key and return the associated record if valid
  */
-declare const validateAndGetApiKey: (key: string, db: DatabaseClient) => Promise<ApiKeySelect | null>;
+declare const validateAndGetApiKey: (key: string, db: AgentsRunDatabaseClient) => Promise<ApiKeySelect | null>;
 //#endregion
 export { countApiKeys, createApiKey, deleteApiKey, generateAndCreateApiKey, getApiKeyById, getApiKeyByPublicId, hasApiKey, listApiKeys, listApiKeysPaginated, updateApiKey, updateApiKeyLastUsed, validateAndGetApiKey };