@inkeep/agents-core 0.47.5 → 0.48.1

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/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" | "header" | "body";
+        source: "query" | "body" | "header";
         key: string;
         prefix?: string | undefined;
         regex?: string | undefined;
       };
       signedComponents: {
-        source: "literal" | "header" | "body";
+        source: "literal" | "body" | "header";
         required: boolean;
         key?: string | undefined;
         value?: string | undefined;

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

@@ -0,0 +1,233 @@
+import { AgentScopeConfig, PaginationConfig } from "../../types/utility.js";
+import { AgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
+import { ScheduledTriggerInvocation, ScheduledTriggerInvocationInsert, ScheduledTriggerInvocationStatus, ScheduledTriggerInvocationUpdate } from "../../validation/schemas.js";
+
+//#region src/data-access/runtime/scheduledTriggerInvocations.d.ts
+
+/**
+ * Get a scheduled trigger invocation by ID (agent-scoped)
+ */
+declare const getScheduledTriggerInvocationById: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  invocationId: string;
+}) => Promise<ScheduledTriggerInvocation | undefined>;
+/**
+ * Get a scheduled trigger invocation by idempotency key
+ * Used to check if an invocation already exists for a given schedule
+ */
+declare const getScheduledTriggerInvocationByIdempotencyKey: (db: AgentsRunDatabaseClient) => (params: {
+  idempotencyKey: string;
+}) => Promise<ScheduledTriggerInvocation | undefined>;
+/**
+ * List scheduled trigger invocations with optional filtering (agent-scoped)
+ */
+declare const listScheduledTriggerInvocationsPaginated: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  pagination?: PaginationConfig;
+  filters?: {
+    status?: ScheduledTriggerInvocationStatus;
+    from?: string;
+    to?: string;
+  };
+}) => Promise<{
+  data: {
+    scheduledTriggerId: string;
+    status: "pending" | "failed" | "running" | "completed" | "cancelled";
+    scheduledFor: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    resolvedPayload: Record<string, unknown> | null;
+    conversationIds: string[] | null;
+    attemptNumber: number;
+    idempotencyKey: string;
+    createdAt: string;
+    agentId: string;
+    projectId: string;
+    tenantId: string;
+    id: string;
+  }[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}>;
+/**
+ * List pending invocations for a trigger, ordered by scheduledFor (earliest first)
+ * Used by workflow to get the next invocation to execute
+ */
+declare const listPendingScheduledTriggerInvocations: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  limit?: number;
+}) => Promise<ScheduledTriggerInvocation[]>;
+/**
+ * Delete all pending invocations for a trigger
+ * Used when cron expression changes or trigger is disabled
+ */
+declare const deletePendingInvocationsForTrigger: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+}) => Promise<number>;
+/**
+ * Create a new scheduled trigger invocation (agent-scoped)
+ */
+declare const createScheduledTriggerInvocation: (db: AgentsRunDatabaseClient) => (params: ScheduledTriggerInvocationInsert) => Promise<ScheduledTriggerInvocation>;
+/**
+ * Update scheduled trigger invocation status (agent-scoped)
+ */
+declare const updateScheduledTriggerInvocationStatus: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  invocationId: string;
+  data: ScheduledTriggerInvocationUpdate;
+}) => Promise<ScheduledTriggerInvocation>;
+/**
+ * Mark invocation as running
+ */
+declare const markScheduledTriggerInvocationRunning: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  invocationId: string;
+}) => Promise<ScheduledTriggerInvocation>;
+/**
+ * Mark invocation as completed
+ * Note: Will not update if status is already 'cancelled' to respect user cancellation
+ */
+declare const markScheduledTriggerInvocationCompleted: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  invocationId: string;
+}) => Promise<ScheduledTriggerInvocation | undefined>;
+/**
+ * Mark invocation as failed
+ * Note: Will not update if status is already 'cancelled' to respect user cancellation
+ */
+declare const markScheduledTriggerInvocationFailed: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  invocationId: string;
+}) => Promise<ScheduledTriggerInvocation | undefined>;
+/**
+ * Add a conversation ID to the invocation's conversationIds array
+ * Used to track all conversations created during retries
+ */
+declare const addConversationIdToInvocation: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  invocationId: string;
+  conversationId: string;
+}) => Promise<ScheduledTriggerInvocation | undefined>;
+/**
+ * Mark invocation as cancelled
+ */
+declare const markScheduledTriggerInvocationCancelled: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+  invocationId: string;
+}) => Promise<ScheduledTriggerInvocation>;
+/**
+ * Cancel all pending invocations for a trigger
+ * Used when a trigger is deleted
+ */
+declare const cancelPendingInvocationsForTrigger: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+}) => Promise<number>;
+/**
+ * Cancel only PAST pending invocations for a trigger (scheduledFor <= now)
+ * Used when a trigger is disabled - keeps future invocations pending
+ */
+declare const cancelPastPendingInvocationsForTrigger: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  scheduledTriggerId: string;
+}) => Promise<number>;
+/**
+ * Get run info for multiple scheduled triggers in a single query
+ * Returns last run (completed/failed) and next pending run for each trigger
+ */
+declare const getScheduledTriggerRunInfoBatch: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: Omit<AgentScopeConfig, "agentId">;
+  triggerIds: Array<{
+    agentId: string;
+    triggerId: string;
+  }>;
+}) => Promise<Map<string, {
+  lastRunAt: string | null;
+  lastRunStatus: "completed" | "failed" | null;
+  lastRunConversationIds: string[];
+  nextRunAt: string | null;
+}>>;
+/**
+ * List upcoming invocations across ALL triggers for an agent with pagination
+ * Used for the upcoming runs dashboard with full pagination support
+ */
+declare const listUpcomingInvocationsForAgentPaginated: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: Omit<AgentScopeConfig, "agentId"> & {
+    agentId: string;
+  };
+  pagination?: PaginationConfig;
+  includeRunning?: boolean;
+}) => Promise<{
+  data: {
+    scheduledTriggerId: string;
+    status: "pending" | "failed" | "running" | "completed" | "cancelled";
+    scheduledFor: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    resolvedPayload: Record<string, unknown> | null;
+    conversationIds: string[] | null;
+    attemptNumber: number;
+    idempotencyKey: string;
+    createdAt: string;
+    agentId: string;
+    projectId: string;
+    tenantId: string;
+    id: string;
+  }[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}>;
+/**
+ * List all invocations across ALL triggers for a PROJECT with pagination
+ * Used for the project-level invocations dashboard
+ */
+declare const listProjectScheduledTriggerInvocationsPaginated: (db: AgentsRunDatabaseClient) => (params: {
+  scopes: Omit<AgentScopeConfig, "agentId">;
+  pagination?: PaginationConfig;
+  filters?: {
+    status?: ScheduledTriggerInvocationStatus;
+  };
+}) => Promise<{
+  data: {
+    scheduledTriggerId: string;
+    status: "pending" | "failed" | "running" | "completed" | "cancelled";
+    scheduledFor: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    resolvedPayload: Record<string, unknown> | null;
+    conversationIds: string[] | null;
+    attemptNumber: number;
+    idempotencyKey: string;
+    createdAt: string;
+    agentId: string;
+    projectId: string;
+    tenantId: string;
+    id: string;
+  }[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}>;
+//#endregion
+export { addConversationIdToInvocation, cancelPastPendingInvocationsForTrigger, cancelPendingInvocationsForTrigger, createScheduledTriggerInvocation, deletePendingInvocationsForTrigger, getScheduledTriggerInvocationById, getScheduledTriggerInvocationByIdempotencyKey, getScheduledTriggerRunInfoBatch, listPendingScheduledTriggerInvocations, listProjectScheduledTriggerInvocationsPaginated, listScheduledTriggerInvocationsPaginated, listUpcomingInvocationsForAgentPaginated, markScheduledTriggerInvocationCancelled, markScheduledTriggerInvocationCompleted, markScheduledTriggerInvocationFailed, markScheduledTriggerInvocationRunning, updateScheduledTriggerInvocationStatus };