@inkeep/agents-core 0.47.4 → 0.48.0

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;

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

@@ -40,13 +40,13 @@ declare const listTriggersPaginated: (db: AgentsManageDatabaseClient) => (params
       algorithm: "sha256" | "sha512" | "sha384" | "sha1" | "md5";
       encoding: "hex" | "base64";
       signature: {
-        source: "query" | "body" | "header";
+        source: "query" | "header" | "body";
         key: string;
         prefix?: string | undefined;
         regex?: string | undefined;
       };
       signedComponents: {
-        source: "literal" | "body" | "header";
+        source: "literal" | "header" | "body";
         required: boolean;
         key?: string | undefined;
         value?: string | undefined;

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

@@ -23,12 +23,12 @@ declare const createConversation: (db: AgentsRunDatabaseClient) => (params: Conv
   createdAt: string;
   updatedAt: string;
   metadata: ConversationMetadata | null;
+  userId: string | null;
   ref: {
     type: "commit" | "tag" | "branch";
     name: string;
     hash: string;
   } | null;
-  userId: string | null;
   activeSubAgentId: string;
   lastContextResolution: string | null;
 }>;
@@ -92,12 +92,12 @@ declare const getConversation: (db: AgentsRunDatabaseClient) => (params: {
   createdAt: string;
   updatedAt: string;
   metadata: ConversationMetadata | null;
+  userId: string | null;
   ref: {
     type: "commit" | "tag" | "branch";
     name: string;
     hash: string;
   } | null;
-  userId: string | null;
   activeSubAgentId: string;
   lastContextResolution: string | null;
 } | undefined>;
@@ -128,12 +128,12 @@ declare const createOrGetConversation: (db: AgentsRunDatabaseClient) => (input:
   createdAt: string;
   updatedAt: string;
   metadata: ConversationMetadata | null;
+  userId: string | null;
   ref: {
     type: "commit" | "tag" | "branch";
     name: string;
     hash: string;
   } | null;
-  userId: string | null;
   activeSubAgentId: string;
   lastContextResolution: string | null;
 }>;
@@ -160,12 +160,12 @@ declare const getActiveAgentForConversation: (db: AgentsRunDatabaseClient) => (p
   createdAt: string;
   updatedAt: string;
   metadata: ConversationMetadata | null;
+  userId: string | null;
   ref: {
     type: "commit" | "tag" | "branch";
     name: string;
     hash: string;
   } | null;
-  userId: string | null;
   activeSubAgentId: string;
   lastContextResolution: string | null;
 } | undefined>;