@inkeep/agents-core 0.47.5 → 0.48.0

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

@@ -1,6 +1,7 @@
 import { getLogger } from "../../utils/logger.js";
 import { deleteExternalAgent, listExternalAgents, upsertExternalAgent } from "./externalAgents.js";
 import { deleteFunction, listFunctions, upsertFunction } from "./functions.js";
+import { listSkills, upsertSkill } from "./skills.js";
 import { deleteCredentialReference, listCredentialReferences, upsertCredentialReference } from "./credentialReferences.js";
 import { deleteTool, listTools, upsertTool } from "./tools.js";
 import { listAgents } from "./agents.js";
@@ -42,6 +43,37 @@ const createFullProjectServerSide = (db, logger = defaultLogger) => async (param
 		logger.info({ projectId: typed.id }, "Creating project metadata");
 		await createProject(db)(projectPayload);
 		logger.info({ projectId: typed.id }, "Project metadata created successfully");
+		if (typed.skills && Object.keys(typed.skills).length) {
+			logger.info({
+				projectId: typed.id,
+				count: Object.keys(typed.skills).length
+			}, "Creating project skills");
+			const skillPromises = Object.entries(typed.skills).map(async ([skillId, skill]) => {
+				try {
+					await upsertSkill(db)({
+						...skill,
+						tenantId,
+						projectId: typed.id
+					});
+					logger.info({
+						projectId: typed.id,
+						skillId
+					}, "Skill processed");
+				} catch (error) {
+					logger.error({
+						projectId: typed.id,
+						skillId,
+						error
+					}, "Failed to create skill");
+					throw error;
+				}
+			});
+			await Promise.all(skillPromises);
+			logger.info({
+				projectId: typed.id,
+				count: Object.keys(typed.skills).length
+			}, "All project skills created successfully");
+		}
 		if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
 			logger.info({
 				projectId: typed.id,
@@ -395,6 +427,37 @@ const updateFullProjectServerSide = (db, logger = defaultLogger) => async (param
 			data: projectUpdatePayload
 		});
 		logger.info({ projectId: typed.id }, "Project metadata updated successfully");
+		if (typed.skills && Object.keys(typed.skills).length) {
+			logger.info({
+				projectId: typed.id,
+				count: Object.keys(typed.skills).length
+			}, "Updating project skills");
+			const skillPromises = Object.entries(typed.skills).map(async ([skillId, skill]) => {
+				try {
+					await upsertSkill(db)({
+						...skill,
+						tenantId,
+						projectId: typed.id
+					});
+					logger.info({
+						projectId: typed.id,
+						skillId
+					}, "Skill processed");
+				} catch (error) {
+					logger.error({
+						projectId: typed.id,
+						skillId,
+						error
+					}, "Failed to update skill");
+					throw error;
+				}
+			});
+			await Promise.all(skillPromises);
+			logger.info({
+				projectId: typed.id,
+				count: Object.keys(typed.skills).length
+			}, "All project skills updated successfully");
+		}
 		if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
 			logger.info({
 				projectId: typed.id,
@@ -1009,6 +1072,39 @@ const getFullProjectInternal = (db, logger = defaultLogger) => async (params) =>
 				error
 			}, "Failed to retrieve functions for project");
 		}
+		const projectSkills = {};
+		try {
+			const skillsList = await listSkills(db)({
+				scopes: {
+					tenantId,
+					projectId
+				},
+				pagination: {
+					page: 1,
+					limit: 1e3
+				}
+			});
+			for (const skill of skillsList.data) projectSkills[skill.id] = {
+				id: skill.id,
+				name: skill.name,
+				description: skill.description,
+				content: skill.content,
+				metadata: skill.metadata,
+				createdAt: skill.createdAt,
+				updatedAt: skill.updatedAt
+			};
+			logger.info({
+				tenantId,
+				projectId,
+				skillCount: Object.keys(projectSkills).length
+			}, "Skills retrieved for project");
+		} catch (error) {
+			logger.warn({
+				tenantId,
+				projectId,
+				error
+			}, "Failed to retrieve skills for project");
+		}
 		const agents = {};
 		if (agentList.length > 0) {
 			const getAgentFn = includeRelationIds ? getFullAgentWithRelationIds : getFullAgent;
@@ -1071,6 +1167,7 @@ const getFullProjectInternal = (db, logger = defaultLogger) => async (params) =>
 			credentialReferences: Object.keys(projectCredentialReferences).length > 0 ? projectCredentialReferences : null,
 			statusUpdates: null,
 			functionTools: null,
+			skills: Object.keys(projectSkills).length > 0 ? projectSkills : void 0,
 			createdAt: project.createdAt,
 			updatedAt: project.updatedAt
 		};

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

@@ -0,0 +1,80 @@
+import { AgentScopeConfig, PaginationConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { ScheduledTrigger, ScheduledTriggerInsert, ScheduledTriggerUpdate } from "../../validation/schemas.js";
+
+//#region src/data-access/manage/scheduledTriggers.d.ts
+
+/**
+ * Get a scheduled trigger by ID (agent-scoped)
+ */
+declare const getScheduledTriggerById: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+}) => Promise<ScheduledTrigger | undefined>;
+/**
+ * List scheduled triggers for an agent with pagination
+ */
+declare const listScheduledTriggersPaginated: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  pagination?: PaginationConfig;
+}) => Promise<{
+  data: {
+    createdAt: string;
+    updatedAt: string;
+    enabled: boolean;
+    cronExpression: string | null;
+    cronTimezone: string | null;
+    runAt: string | null;
+    payload: Record<string, unknown> | null;
+    messageTemplate: string | null;
+    maxRetries: number;
+    retryDelaySeconds: number;
+    timeoutSeconds: number;
+    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 scheduled trigger (agent-scoped)
+ */
+declare const createScheduledTrigger: (db: AgentsManageDatabaseClient) => (params: ScheduledTriggerInsert) => Promise<ScheduledTrigger>;
+/**
+ * Update a scheduled trigger (agent-scoped)
+ */
+declare const updateScheduledTrigger: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  data: ScheduledTriggerUpdate;
+}) => Promise<ScheduledTrigger>;
+/**
+ * Delete a scheduled trigger (agent-scoped)
+ */
+declare const deleteScheduledTrigger: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+}) => Promise<void>;
+/**
+ * Upsert a scheduled trigger (create if it doesn't exist, update if it does)
+ */
+declare const upsertScheduledTrigger: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  data: ScheduledTriggerInsert;
+}) => Promise<ScheduledTrigger>;
+/**
+ * List all scheduled triggers for an agent (non-paginated, used by agentFull)
+ */
+declare const listScheduledTriggers: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+}) => Promise<ScheduledTrigger[]>;
+//#endregion
+export { createScheduledTrigger, deleteScheduledTrigger, getScheduledTriggerById, listScheduledTriggers, listScheduledTriggersPaginated, updateScheduledTrigger, upsertScheduledTrigger };

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

@@ -0,0 +1,76 @@
+import { scheduledTriggers } from "../../db/manage/manage-schema.js";
+import { and, count, desc, eq } from "drizzle-orm";
+
+//#region src/data-access/manage/scheduledTriggers.ts
+/**
+* Get a scheduled trigger by ID (agent-scoped)
+*/
+const getScheduledTriggerById = (db) => async (params) => {
+	const { scopes, scheduledTriggerId } = params;
+	return await db.query.scheduledTriggers.findFirst({ where: and(eq(scheduledTriggers.tenantId, scopes.tenantId), eq(scheduledTriggers.projectId, scopes.projectId), eq(scheduledTriggers.agentId, scopes.agentId), eq(scheduledTriggers.id, scheduledTriggerId)) });
+};
+/**
+* List scheduled triggers for an agent with pagination
+*/
+const listScheduledTriggersPaginated = (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(scheduledTriggers.tenantId, params.scopes.tenantId), eq(scheduledTriggers.projectId, params.scopes.projectId), eq(scheduledTriggers.agentId, params.scopes.agentId));
+	const [data, totalResult] = await Promise.all([db.select().from(scheduledTriggers).where(whereClause).limit(limit).offset(offset).orderBy(desc(scheduledTriggers.createdAt)), db.select({ count: count() }).from(scheduledTriggers).where(whereClause)]);
+	const total = totalResult[0]?.count || 0;
+	return {
+		data,
+		pagination: {
+			page,
+			limit,
+			total,
+			pages: Math.ceil(total / limit)
+		}
+	};
+};
+/**
+* Create a new scheduled trigger (agent-scoped)
+*/
+const createScheduledTrigger = (db) => async (params) => {
+	return (await db.insert(scheduledTriggers).values(params).returning())[0];
+};
+/**
+* Update a scheduled trigger (agent-scoped)
+*/
+const updateScheduledTrigger = (db) => async (params) => {
+	const updateData = {
+		...params.data,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	return (await db.update(scheduledTriggers).set(updateData).where(and(eq(scheduledTriggers.tenantId, params.scopes.tenantId), eq(scheduledTriggers.projectId, params.scopes.projectId), eq(scheduledTriggers.agentId, params.scopes.agentId), eq(scheduledTriggers.id, params.scheduledTriggerId))).returning())[0];
+};
+/**
+* Delete a scheduled trigger (agent-scoped)
+*/
+const deleteScheduledTrigger = (db) => async (params) => {
+	await db.delete(scheduledTriggers).where(and(eq(scheduledTriggers.tenantId, params.scopes.tenantId), eq(scheduledTriggers.projectId, params.scopes.projectId), eq(scheduledTriggers.agentId, params.scopes.agentId), eq(scheduledTriggers.id, params.scheduledTriggerId)));
+};
+/**
+* Upsert a scheduled trigger (create if it doesn't exist, update if it does)
+*/
+const upsertScheduledTrigger = (db) => async (params) => {
+	if (await getScheduledTriggerById(db)({
+		scopes: params.scopes,
+		scheduledTriggerId: params.data.id
+	})) return await updateScheduledTrigger(db)({
+		scopes: params.scopes,
+		scheduledTriggerId: params.data.id,
+		data: params.data
+	});
+	return await createScheduledTrigger(db)(params.data);
+};
+/**
+* List all scheduled triggers for an agent (non-paginated, used by agentFull)
+*/
+const listScheduledTriggers = (db) => async (params) => {
+	return await db.select().from(scheduledTriggers).where(and(eq(scheduledTriggers.tenantId, params.scopes.tenantId), eq(scheduledTriggers.projectId, params.scopes.projectId), eq(scheduledTriggers.agentId, params.scopes.agentId)));
+};
+
+//#endregion
+export { createScheduledTrigger, deleteScheduledTrigger, getScheduledTriggerById, listScheduledTriggers, listScheduledTriggersPaginated, updateScheduledTrigger, upsertScheduledTrigger };

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

@@ -0,0 +1,29 @@
+import { AgentScopeConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { ScheduledWorkflow, ScheduledWorkflowInsert } from "../../validation/schemas.js";
+
+//#region src/data-access/manage/scheduledWorkflows.d.ts
+
+/**
+ * Get a scheduled workflow by trigger ID (agent-scoped)
+ */
+declare const getScheduledWorkflowByTriggerId: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+}) => Promise<ScheduledWorkflow | undefined>;
+/**
+ * Create a new scheduled workflow (agent-scoped)
+ */
+declare const createScheduledWorkflow: (db: AgentsManageDatabaseClient) => (params: ScheduledWorkflowInsert) => Promise<ScheduledWorkflow>;
+/**
+ * Update workflow run ID and/or status for a scheduled workflow
+ * Used when a workflow is started/restarted/cancelled
+ */
+declare const updateScheduledWorkflowRunId: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledWorkflowId: string;
+  workflowRunId: string | null;
+  status?: "running" | "completed" | "cancelled" | "failed";
+}) => Promise<ScheduledWorkflow>;
+//#endregion
+export { createScheduledWorkflow, getScheduledWorkflowByTriggerId, updateScheduledWorkflowRunId };

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

@@ -0,0 +1,32 @@
+import { scheduledWorkflows } from "../../db/manage/manage-schema.js";
+import { and, eq } from "drizzle-orm";
+
+//#region src/data-access/manage/scheduledWorkflows.ts
+/**
+* Get a scheduled workflow by trigger ID (agent-scoped)
+*/
+const getScheduledWorkflowByTriggerId = (db) => async (params) => {
+	const { scopes, scheduledTriggerId } = params;
+	return await db.query.scheduledWorkflows.findFirst({ where: and(eq(scheduledWorkflows.tenantId, scopes.tenantId), eq(scheduledWorkflows.projectId, scopes.projectId), eq(scheduledWorkflows.agentId, scopes.agentId), eq(scheduledWorkflows.scheduledTriggerId, scheduledTriggerId)) });
+};
+/**
+* Create a new scheduled workflow (agent-scoped)
+*/
+const createScheduledWorkflow = (db) => async (params) => {
+	return (await db.insert(scheduledWorkflows).values(params).returning())[0];
+};
+/**
+* Update workflow run ID and/or status for a scheduled workflow
+* Used when a workflow is started/restarted/cancelled
+*/
+const updateScheduledWorkflowRunId = (db) => async (params) => {
+	const updateData = {
+		workflowRunId: params.workflowRunId,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (params.status) updateData.status = params.status;
+	return (await db.update(scheduledWorkflows).set(updateData).where(and(eq(scheduledWorkflows.tenantId, params.scopes.tenantId), eq(scheduledWorkflows.projectId, params.scopes.projectId), eq(scheduledWorkflows.agentId, params.scopes.agentId), eq(scheduledWorkflows.id, params.scheduledWorkflowId))).returning())[0];
+};
+
+//#endregion
+export { createScheduledWorkflow, getScheduledWorkflowByTriggerId, updateScheduledWorkflowRunId };

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

@@ -0,0 +1,109 @@
+import { AgentScopeConfig, PaginationConfig, ProjectScopeConfig, SubAgentScopeConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { SkillInsert, SkillUpdate, SubAgentSkillWithIndex } from "../../types/entities.js";
+
+//#region src/data-access/manage/skills.d.ts
+declare const getSkillById: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+  skillId: string;
+}) => Promise<{
+  id: string;
+  name: string;
+  description: string;
+  tenantId: string;
+  projectId: string;
+  createdAt: string;
+  updatedAt: string;
+  metadata: Record<string, string> | null;
+  content: string;
+} | null>;
+declare const listSkills: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+  pagination?: PaginationConfig;
+}) => Promise<{
+  data: {
+    createdAt: string;
+    updatedAt: string;
+    id: string;
+    name: string;
+    description: string;
+    content: string;
+    metadata: Record<string, string> | null;
+    projectId: string;
+    tenantId: string;
+  }[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}>;
+declare const createSkill: (db: AgentsManageDatabaseClient) => (data: SkillInsert) => Promise<{
+  id: string;
+  name: string;
+  description: string;
+  tenantId: string;
+  projectId: string;
+  createdAt: string;
+  updatedAt: string;
+  metadata: Record<string, string> | null;
+  content: string;
+}>;
+declare const upsertSkill: (db: AgentsManageDatabaseClient) => (data: SkillInsert) => Promise<{
+  id: string;
+  name: string;
+  description: string;
+  tenantId: string;
+  projectId: string;
+  createdAt: string;
+  updatedAt: string;
+  metadata: Record<string, string> | null;
+  content: string;
+}>;
+declare const updateSkill: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+  skillId: string;
+  data: SkillUpdate;
+}) => Promise<{
+  createdAt: string;
+  updatedAt: string;
+  id: string;
+  name: string;
+  description: string;
+  content: string;
+  metadata: Record<string, string> | null;
+  projectId: string;
+  tenantId: string;
+}>;
+declare const deleteSkill: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+  skillId: string;
+}) => Promise<boolean>;
+declare const getSkillsForSubAgents: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentIds: string[];
+}) => Promise<SubAgentSkillWithIndex[]>;
+declare const upsertSubAgentSkill: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: SubAgentScopeConfig;
+  skillId: string;
+  index: number;
+  alwaysLoaded?: boolean;
+}) => Promise<{
+  id: string;
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  createdAt: string;
+  updatedAt: string;
+  index: number;
+  alwaysLoaded: boolean;
+  subAgentId: string;
+  skillId: string;
+}>;
+declare const deleteSubAgentSkill: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentSkillId: string;
+}) => Promise<boolean>;
+//#endregion
+export { createSkill, deleteSkill, deleteSubAgentSkill, getSkillById, getSkillsForSubAgents, listSkills, updateSkill, upsertSkill, upsertSubAgentSkill };

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

@@ -0,0 +1,122 @@
+import { skills, subAgentSkills } from "../../db/manage/manage-schema.js";
+import { getLogger } from "../../utils/logger.js";
+import { generateId } from "../../utils/conversations.js";
+import "../../index.js";
+import { and, asc, count, desc, eq, inArray } from "drizzle-orm";
+
+//#region src/data-access/manage/skills.ts
+const logger = getLogger("skills-dal");
+const getSkillById = (db) => async (params) => {
+	return await db.query.skills.findFirst({ where: and(eq(skills.tenantId, params.scopes.tenantId), eq(skills.projectId, params.scopes.projectId), eq(skills.id, params.skillId)) }) ?? null;
+};
+const listSkills = (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(skills.tenantId, params.scopes.tenantId), eq(skills.projectId, params.scopes.projectId));
+	const [data, totalResult] = await Promise.all([db.select().from(skills).where(whereClause).limit(limit).offset(offset).orderBy(desc(skills.createdAt)), db.select({ count: count() }).from(skills).where(whereClause)]);
+	const total = totalResult[0]?.count || 0;
+	return {
+		data,
+		pagination: {
+			page,
+			limit,
+			total,
+			pages: Math.ceil(total / limit)
+		}
+	};
+};
+const createSkill = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const insertData = {
+		...data,
+		id: data.name,
+		createdAt: now,
+		updatedAt: now
+	};
+	const [result] = await db.insert(skills).values(insertData).returning();
+	return result;
+};
+const upsertSkill = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const baseData = {
+		...data,
+		id: data.name
+	};
+	if (await db.query.skills.findFirst({ where: and(eq(skills.tenantId, baseData.tenantId), eq(skills.projectId, baseData.projectId), eq(skills.id, baseData.id)) })) {
+		const [result$1] = await db.update(skills).set({
+			name: baseData.name,
+			description: baseData.description,
+			content: baseData.content,
+			metadata: baseData.metadata,
+			updatedAt: now
+		}).where(and(eq(skills.tenantId, baseData.tenantId), eq(skills.projectId, baseData.projectId), eq(skills.id, baseData.id))).returning();
+		logger.info({ skillId: baseData.id }, "Updated skill");
+		return result$1;
+	}
+	const insertData = {
+		...baseData,
+		createdAt: now,
+		updatedAt: now
+	};
+	const [result] = await db.insert(skills).values(insertData).returning();
+	logger.info({ skillId: baseData.id }, "Created skill");
+	return result;
+};
+const updateSkill = (db) => async (params) => {
+	const { tenantId: _, projectId: _2, ...data } = params.data;
+	const updateData = {
+		...data,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const [result] = await db.update(skills).set(updateData).where(and(eq(skills.tenantId, params.scopes.tenantId), eq(skills.projectId, params.scopes.projectId), eq(skills.id, params.skillId))).returning();
+	return result ?? null;
+};
+const deleteSkill = (db) => async (params) => {
+	return (await db.delete(skills).where(and(eq(skills.tenantId, params.scopes.tenantId), eq(skills.projectId, params.scopes.projectId), eq(skills.id, params.skillId))).returning()).length > 0;
+};
+const getSkillsForSubAgents = (db) => async (params) => {
+	if (!params.subAgentIds.length) return [];
+	return await db.select({
+		subAgentSkillId: subAgentSkills.id,
+		subAgentId: subAgentSkills.subAgentId,
+		index: subAgentSkills.index,
+		alwaysLoaded: subAgentSkills.alwaysLoaded,
+		id: skills.id,
+		name: skills.name,
+		description: skills.description,
+		content: skills.content,
+		metadata: skills.metadata,
+		createdAt: skills.createdAt,
+		updatedAt: skills.updatedAt
+	}).from(subAgentSkills).innerJoin(skills, and(eq(subAgentSkills.skillId, skills.id), eq(subAgentSkills.tenantId, skills.tenantId), eq(subAgentSkills.projectId, skills.projectId))).where(and(eq(subAgentSkills.tenantId, params.scopes.tenantId), eq(subAgentSkills.projectId, params.scopes.projectId), eq(subAgentSkills.agentId, params.scopes.agentId), inArray(subAgentSkills.subAgentId, params.subAgentIds))).orderBy(asc(subAgentSkills.index), asc(subAgentSkills.createdAt));
+};
+const upsertSubAgentSkill = (db) => async (params) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const existing = await db.query.subAgentSkills.findFirst({ where: and(eq(subAgentSkills.tenantId, params.scopes.tenantId), eq(subAgentSkills.projectId, params.scopes.projectId), eq(subAgentSkills.agentId, params.scopes.agentId), eq(subAgentSkills.subAgentId, params.scopes.subAgentId), eq(subAgentSkills.skillId, params.skillId)) });
+	if (existing) {
+		const [result$1] = await db.update(subAgentSkills).set({
+			index: params.index,
+			alwaysLoaded: params.alwaysLoaded ?? existing.alwaysLoaded,
+			updatedAt: now
+		}).where(eq(subAgentSkills.id, existing.id)).returning();
+		return result$1;
+	}
+	const insertData = {
+		...params.scopes,
+		id: generateId(),
+		skillId: params.skillId,
+		index: params.index,
+		alwaysLoaded: params.alwaysLoaded ?? false,
+		createdAt: now,
+		updatedAt: now
+	};
+	const [result] = await db.insert(subAgentSkills).values(insertData).returning();
+	return result;
+};
+const deleteSubAgentSkill = (db) => async (params) => {
+	return (await db.delete(subAgentSkills).where(and(eq(subAgentSkills.tenantId, params.scopes.tenantId), eq(subAgentSkills.projectId, params.scopes.projectId), eq(subAgentSkills.agentId, params.scopes.agentId), eq(subAgentSkills.id, params.subAgentSkillId))).returning()).length > 0;
+};
+
+//#endregion
+export { createSkill, deleteSkill, deleteSubAgentSkill, getSkillById, getSkillsForSubAgents, listSkills, updateSkill, upsertSkill, upsertSubAgentSkill };

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

@@ -14,9 +14,9 @@ declare const getAgentRelationById: (db: AgentsManageDatabaseClient) => (params:
   agentId: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 } | undefined>;
 declare const listAgentRelations: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
@@ -49,9 +49,9 @@ declare const getAgentRelations: (db: AgentsManageDatabaseClient) => (params: {
   agentId: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 }[]>;
 declare const getAgentRelationsByAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
@@ -62,9 +62,9 @@ declare const getAgentRelationsByAgent: (db: AgentsManageDatabaseClient) => (par
   agentId: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 }[]>;
 declare const getAgentRelationsBySource: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
@@ -131,9 +131,9 @@ declare const createSubAgentRelation: (db: AgentsManageDatabaseClient) => (param
   agentId: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 }>;
 /**
  * Check if sub-agent relation exists by agent, source, target, and relation type
@@ -150,9 +150,9 @@ declare const getAgentRelationByParams: (db: AgentsManageDatabaseClient) => (par
   agentId: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 } | undefined>;
 /**
  * Upsert agent relation (create if it doesn't exist, no-op if it does)
@@ -164,9 +164,9 @@ declare const upsertSubAgentRelation: (db: AgentsManageDatabaseClient) => (param
   agentId: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 }>;
 declare const updateAgentRelation: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;

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

@@ -51,8 +51,6 @@ declare const listTools: (db: AgentsManageDatabaseClient) => (params: {
   data: {
     createdAt: string;
     updatedAt: string;
-    name: string;
-    description: string | null;
     config: {
       type: "mcp";
       mcp: ToolMcpConfig;
@@ -64,6 +62,8 @@ declare const listTools: (db: AgentsManageDatabaseClient) => (params: {
     capabilities: ToolServerCapabilities | null;
     lastError: string | null;
     isWorkApp: boolean;
+    name: string;
+    description: string | null;
     projectId: string;
     tenantId: string;
     id: string;
@@ -102,8 +102,6 @@ declare const updateTool: (db: AgentsManageDatabaseClient) => (params: {
 }) => Promise<{
   createdAt: string;
   updatedAt: string;
-  name: string;
-  description: string | null;
   config: {
     type: "mcp";
     mcp: ToolMcpConfig;
@@ -115,6 +113,8 @@ declare const updateTool: (db: AgentsManageDatabaseClient) => (params: {
   capabilities: ToolServerCapabilities | null;
   lastError: string | null;
   isWorkApp: boolean;
+  name: string;
+  description: string | null;
   projectId: string;
   tenantId: string;
   id: string;