@inkeep/agents-api 0.0.1

package/dist/domains/manage/routes/tools.js

@@ -0,0 +1,261 @@
+import { getLogger as getLogger$1 } from "../../../logger.js";
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { speakeasyOffsetLimitPagination } from "../../../utils/speakeasy.js";
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { CredentialReferenceApiSelectSchema, CredentialReferenceResponse, McpToolListResponse, McpToolResponse, PaginationQueryParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, ToolApiInsertSchema, ToolApiUpdateSchema, ToolStatusSchema, commonGetErrorResponses, createApiError, createTool, dbResultToMcpTool, deleteTool, generateId, getToolById, getUserScopedCredentialReference, listTools, updateTool } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/tools.ts
+const logger = getLogger$1("tools");
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "PUT") return requireProjectPermission("edit")(c, next);
+	if (c.req.method === "DELETE") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/",
+	summary: "List Tools",
+	operationId: "list-tools",
+	tags: ["Tools"],
+	request: {
+		params: TenantProjectParamsSchema,
+		query: PaginationQueryParamsSchema.extend({ status: ToolStatusSchema.optional() })
+	},
+	responses: {
+		200: {
+			description: "List of tools retrieved successfully",
+			content: { "application/json": { schema: McpToolListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId } = c.req.valid("param");
+	const { page, limit, status } = c.req.valid("query");
+	let result;
+	const credentialStores = c.get("credentialStores");
+	const userId = c.get("userId");
+	if (status) {
+		const dbResult = await listTools(db)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: (await Promise.all(dbResult.data.map(async (tool) => await dbResultToMcpTool(tool, db, credentialStores, void 0, userId)))).filter((tool) => tool.status === status),
+			pagination: dbResult.pagination
+		};
+	} else {
+		const dbResult = await listTools(db)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: await Promise.all(dbResult.data.map(async (tool) => await dbResultToMcpTool(tool, db, credentialStores, void 0, userId))),
+			pagination: dbResult.pagination
+		};
+	}
+	return c.json(result);
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Tool",
+	operationId: "get-tool",
+	tags: ["Tools"],
+	request: { params: TenantProjectIdParamsSchema },
+	responses: {
+		200: {
+			description: "Tool found",
+			content: { "application/json": { schema: McpToolResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, id } = c.req.valid("param");
+	const tool = await getToolById(db)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		toolId: id
+	});
+	if (!tool) throw createApiError({
+		code: "not_found",
+		message: "Tool not found"
+	});
+	const credentialStores = c.get("credentialStores");
+	const userId = c.get("userId");
+	return c.json({ data: await dbResultToMcpTool(tool, db, credentialStores, void 0, userId) });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Tool",
+	operationId: "create-tool",
+	tags: ["Tools"],
+	request: {
+		params: TenantProjectParamsSchema,
+		body: { content: { "application/json": { schema: ToolApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Tool created successfully",
+			content: { "application/json": { schema: McpToolResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const credentialStores = c.get("credentialStores");
+	const userId = c.get("userId");
+	logger.info({ body }, "body");
+	const id = body.id || generateId();
+	const tool = await createTool(db)({
+		tenantId,
+		projectId,
+		id,
+		name: body.name,
+		config: body.config,
+		credentialReferenceId: body.credentialReferenceId,
+		credentialScope: body.credentialScope,
+		imageUrl: body.imageUrl,
+		headers: body.headers
+	});
+	return c.json({ data: await dbResultToMcpTool(tool, db, credentialStores, void 0, userId) }, 201);
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update Tool",
+	operationId: "update-tool",
+	tags: ["Tools"],
+	request: {
+		params: TenantProjectIdParamsSchema,
+		body: { content: { "application/json": { schema: ToolApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Tool updated successfully",
+			content: { "application/json": { schema: McpToolResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, id } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const credentialStores = c.get("credentialStores");
+	const userId = c.get("userId");
+	if (Object.keys(body).length === 0) throw createApiError({
+		code: "bad_request",
+		message: "No fields to update"
+	});
+	const updatedTool = await updateTool(db)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		toolId: id,
+		data: {
+			name: body.name,
+			config: body.config,
+			credentialReferenceId: body.credentialReferenceId,
+			credentialScope: body.credentialScope,
+			imageUrl: body.imageUrl,
+			headers: body.headers
+		}
+	});
+	if (!updatedTool) throw createApiError({
+		code: "not_found",
+		message: "Tool not found"
+	});
+	return c.json({ data: await dbResultToMcpTool(updatedTool, db, credentialStores, void 0, userId) });
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}/user-credential",
+	summary: "Get User Credential for Tool",
+	operationId: "get-user-credential-for-tool",
+	tags: ["Tools"],
+	request: { params: TenantProjectIdParamsSchema },
+	responses: {
+		200: {
+			description: "User credential retrieved successfully",
+			content: { "application/json": { schema: CredentialReferenceResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, id: toolId } = c.req.valid("param");
+	const db = c.get("db");
+	const userId = c.get("userId");
+	if (!userId) throw createApiError({
+		code: "unauthorized",
+		message: "User ID required for user-scoped credential lookup"
+	});
+	const credential = await getUserScopedCredentialReference(db)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		toolId,
+		userId
+	});
+	if (!credential) throw createApiError({
+		code: "not_found",
+		message: "User credential not found for this tool"
+	});
+	const validatedCredential = CredentialReferenceApiSelectSchema.parse(credential);
+	return c.json({ data: validatedCredential });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Tool",
+	operationId: "delete-tool",
+	tags: ["Tools"],
+	request: { params: TenantProjectIdParamsSchema },
+	responses: {
+		204: { description: "Tool deleted successfully" },
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, id } = c.req.valid("param");
+	if (!await deleteTool(db)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		toolId: id
+	})) throw createApiError({
+		code: "not_found",
+		message: "Tool not found"
+	});
+	return c.body(null, 204);
+});
+var tools_default = app;
+
+//#endregion
+export { tools_default as default };

package/dist/domains/manage/routes/triggers.d.ts

@@ -0,0 +1,9 @@
+import { ManageAppVariables } from "../../../types/app.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/domains/manage/routes/triggers.d.ts
+declare const app: OpenAPIHono<{
+  Variables: ManageAppVariables;
+}, {}, "/">;
+//#endregion
+export { app as default };

package/dist/domains/manage/routes/triggers.js

@@ -0,0 +1,423 @@
+import { getLogger as getLogger$1 } from "../../../logger.js";
+import { env } from "../../../env.js";
+import runDbClient_default from "../../../data/db/runDbClient.js";
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { speakeasyOffsetLimitPagination } from "../../../utils/speakeasy.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { PaginationQueryParamsSchema, TenantProjectAgentIdParamsSchema, TenantProjectAgentParamsSchema, TriggerApiInsertSchema, TriggerApiSelectSchema, TriggerApiUpdateSchema, TriggerInvocationListResponse, TriggerInvocationResponse, TriggerInvocationStatusEnum, commonGetErrorResponses, createApiError, createTrigger, deleteTrigger, generateId, getTriggerById, getTriggerInvocationById, listTriggerInvocationsPaginated, listTriggersPaginated, updateTrigger } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/triggers.ts
+const logger = getLogger$1("triggers");
+const app = new OpenAPIHono();
+const TriggerResponse = z.object({ data: TriggerApiSelectSchema.extend({ webhookUrl: z.string().describe("Fully qualified webhook URL for this trigger") }) });
+const TriggerListResponse = z.object({
+	data: z.array(TriggerApiSelectSchema.extend({ webhookUrl: z.string().describe("Fully qualified webhook URL for this trigger") })),
+	pagination: z.object({
+		page: z.number(),
+		limit: z.number(),
+		total: z.number(),
+		pages: z.number()
+	})
+});
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "PATCH") return requireProjectPermission("edit")(c, next);
+	if (c.req.method === "DELETE") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+/**
+* Generate webhook URL for a trigger
+*/
+function generateWebhookUrl(params) {
+	const { baseUrl, tenantId, projectId, agentId, triggerId } = params;
+	return `${baseUrl}/run/tenants/${tenantId}/projects/${projectId}/agents/${agentId}/triggers/${triggerId}`;
+}
+/**
+* List Triggers for an Agent
+*/
+app.openapi(createRoute({
+	method: "get",
+	path: "/",
+	summary: "List Triggers",
+	operationId: "list-triggers",
+	tags: ["Triggers"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "List of triggers retrieved successfully",
+			content: { "application/json": { schema: TriggerListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const { page, limit } = c.req.valid("query");
+	const apiBaseUrl = env.INKEEP_AGENTS_API_URL;
+	const result = await listTriggersPaginated(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		pagination: {
+			page,
+			limit
+		}
+	});
+	const dataWithWebhookUrl = result.data.map((trigger) => {
+		const { tenantId: _tid, projectId: _pid, agentId: _aid, ...triggerWithoutScopes } = trigger;
+		return {
+			...triggerWithoutScopes,
+			webhookUrl: generateWebhookUrl({
+				baseUrl: apiBaseUrl,
+				tenantId,
+				projectId,
+				agentId,
+				triggerId: trigger.id
+			})
+		};
+	});
+	return c.json({
+		data: dataWithWebhookUrl,
+		pagination: result.pagination
+	});
+});
+/**
+* Get Trigger by ID
+*/
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Trigger",
+	operationId: "get-trigger-by-id",
+	tags: ["Triggers"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		200: {
+			description: "Trigger found",
+			content: { "application/json": { schema: TriggerResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const apiBaseUrl = env.INKEEP_AGENTS_API_URL;
+	const trigger = await getTriggerById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		triggerId: id
+	});
+	if (!trigger) throw createApiError({
+		code: "not_found",
+		message: "Trigger not found"
+	});
+	const { tenantId: _tid, projectId: _pid, agentId: _aid, ...triggerWithoutScopes } = trigger;
+	return c.json({ data: {
+		...triggerWithoutScopes,
+		webhookUrl: generateWebhookUrl({
+			baseUrl: apiBaseUrl,
+			tenantId,
+			projectId,
+			agentId,
+			triggerId: trigger.id
+		})
+	} });
+});
+/**
+* Create Trigger
+*/
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Trigger",
+	operationId: "create-trigger",
+	tags: ["Triggers"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: TriggerApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Trigger created successfully",
+			content: { "application/json": { schema: TriggerResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const apiBaseUrl = env.INKEEP_AGENTS_API_URL;
+	const id = body.id || generateId();
+	logger.info({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId: id
+	}, "Creating trigger");
+	const trigger = await createTrigger(db)({
+		id,
+		tenantId,
+		projectId,
+		agentId,
+		name: body.name,
+		description: body.description,
+		enabled: body.enabled !== void 0 ? body.enabled : true,
+		inputSchema: body.inputSchema,
+		outputTransform: body.outputTransform,
+		messageTemplate: body.messageTemplate,
+		authentication: body.authentication,
+		signingSecret: body.signingSecret
+	});
+	const { tenantId: _tid, projectId: _pid, agentId: _aid, ...triggerWithoutScopes } = trigger;
+	return c.json({ data: {
+		...triggerWithoutScopes,
+		webhookUrl: generateWebhookUrl({
+			baseUrl: apiBaseUrl,
+			tenantId,
+			projectId,
+			agentId,
+			triggerId: trigger.id
+		})
+	} }, 201);
+});
+/**
+* Update Trigger
+*/
+app.openapi(createRoute({
+	method: "patch",
+	path: "/{id}",
+	summary: "Update Trigger",
+	operationId: "update-trigger",
+	tags: ["Triggers"],
+	request: {
+		params: TenantProjectAgentIdParamsSchema,
+		body: { content: { "application/json": { schema: TriggerApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Trigger updated successfully",
+			content: { "application/json": { schema: TriggerResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const apiBaseUrl = env.INKEEP_AGENTS_API_URL;
+	if (!(body.name !== void 0 || body.description !== void 0 || body.enabled !== void 0 || body.inputSchema !== void 0 || body.outputTransform !== void 0 || body.messageTemplate !== void 0 || body.authentication !== void 0 || body.signingSecret !== void 0)) throw createApiError({
+		code: "bad_request",
+		message: "No fields to update"
+	});
+	logger.info({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId: id
+	}, "Updating trigger");
+	const updatedTrigger = await updateTrigger(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		triggerId: id,
+		data: {
+			name: body.name,
+			description: body.description,
+			enabled: body.enabled,
+			inputSchema: body.inputSchema,
+			outputTransform: body.outputTransform,
+			messageTemplate: body.messageTemplate,
+			authentication: body.authentication,
+			signingSecret: body.signingSecret
+		}
+	});
+	if (!updatedTrigger) throw createApiError({
+		code: "not_found",
+		message: "Trigger not found"
+	});
+	const { tenantId: _tid, projectId: _pid, agentId: _aid, ...triggerWithoutScopes } = updatedTrigger;
+	return c.json({ data: {
+		...triggerWithoutScopes,
+		webhookUrl: generateWebhookUrl({
+			baseUrl: apiBaseUrl,
+			tenantId,
+			projectId,
+			agentId,
+			triggerId: updatedTrigger.id
+		})
+	} });
+});
+/**
+* Delete Trigger
+*/
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Trigger",
+	operationId: "delete-trigger",
+	tags: ["Triggers"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		204: { description: "Trigger deleted successfully" },
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	logger.info({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId: id
+	}, "Deleting trigger");
+	if (!await getTriggerById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		triggerId: id
+	})) throw createApiError({
+		code: "not_found",
+		message: "Trigger not found"
+	});
+	await deleteTrigger(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		triggerId: id
+	});
+	return c.body(null, 204);
+});
+/**
+* ========================================
+* Trigger Invocation Endpoints
+* ========================================
+*/
+const TriggerInvocationQueryParamsSchema = PaginationQueryParamsSchema.extend({
+	status: TriggerInvocationStatusEnum.optional().openapi({ description: "Filter by invocation status" }),
+	from: z.string().datetime().optional().openapi({ description: "Start date for filtering (ISO8601)" }),
+	to: z.string().datetime().optional().openapi({ description: "End date for filtering (ISO8601)" })
+}).openapi("TriggerInvocationQueryParams");
+/**
+* List Trigger Invocations
+*/
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}/invocations",
+	summary: "List Trigger Invocations",
+	operationId: "list-trigger-invocations",
+	tags: ["Triggers"],
+	request: {
+		params: TenantProjectAgentIdParamsSchema,
+		query: TriggerInvocationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "List of trigger invocations retrieved successfully",
+			content: { "application/json": { schema: TriggerInvocationListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const { tenantId, projectId, agentId, id: triggerId } = c.req.valid("param");
+	const { page, limit, status, from, to } = c.req.valid("query");
+	logger.info({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId,
+		status,
+		from,
+		to
+	}, "Listing trigger invocations");
+	const result = await listTriggerInvocationsPaginated(runDbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		triggerId,
+		pagination: {
+			page,
+			limit
+		},
+		filters: {
+			status,
+			from,
+			to
+		}
+	});
+	const dataWithoutScopes = result.data.map((invocation) => {
+		const { tenantId: _tid, projectId: _pid, agentId: _aid, ...rest } = invocation;
+		return rest;
+	});
+	return c.json({
+		data: dataWithoutScopes,
+		pagination: result.pagination
+	});
+});
+/**
+* Get Trigger Invocation by ID
+*/
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}/invocations/{invocationId}",
+	summary: "Get Trigger Invocation",
+	operationId: "get-trigger-invocation-by-id",
+	tags: ["Triggers"],
+	request: { params: TenantProjectAgentIdParamsSchema.extend({ invocationId: z.string().describe("Trigger Invocation ID") }) },
+	responses: {
+		200: {
+			description: "Trigger invocation found",
+			content: { "application/json": { schema: TriggerInvocationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id: triggerId, invocationId } = c.req.valid("param");
+	logger.info({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId,
+		invocationId
+	}, "Getting trigger invocation");
+	const invocation = await getTriggerInvocationById(runDbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		triggerId,
+		invocationId
+	});
+	if (!invocation) throw createApiError({
+		code: "not_found",
+		message: "Trigger invocation not found"
+	});
+	const { tenantId: _tid, projectId: _pid, agentId: _aid, ...invocationWithoutScopes } = invocation;
+	return c.json({ data: invocationWithoutScopes });
+});
+var triggers_default = app;
+
+//#endregion
+export { triggers_default as default };

package/dist/domains/manage/routes/userOrganizations.d.ts

@@ -0,0 +1,9 @@
+import { ManageAppVariables } from "../../../types/app.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/domains/manage/routes/userOrganizations.d.ts
+declare const userOrganizationsRoutes: OpenAPIHono<{
+  Variables: ManageAppVariables;
+}, {}, "/">;
+//#endregion
+export { userOrganizationsRoutes as default };