@inkeep/agents-manage-api 0.39.5 → 0.40.0

package/dist/routes/functionTools.js

@@ -0,0 +1,252 @@
+import { getLogger as getLogger$1 } from "../logger.js";
+import dbClient_default from "../data/db/dbClient.js";
+import { requirePermission } from "../middleware/require-permission.js";
+import { speakeasyOffsetLimitPagination } from "./shared.js";
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { FunctionToolApiInsertSchema, FunctionToolApiUpdateSchema, FunctionToolListResponse, FunctionToolResponse, PaginationQueryParamsSchema, TenantProjectAgentIdParamsSchema, TenantProjectAgentParamsSchema, commonGetErrorResponses, createApiError, createFunctionTool, deleteFunctionTool, generateId, getFunctionToolById, listFunctionTools, updateFunctionTool } from "@inkeep/agents-core";
+
+//#region src/routes/functionTools.ts
+const logger = getLogger$1("functionTools");
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requirePermission({ function: ["create"] })(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "PUT") return requirePermission({ function: ["update"] })(c, next);
+	if (c.req.method === "DELETE") return requirePermission({ function: ["delete"] })(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/",
+	summary: "List Function Tools",
+	operationId: "list-function-tools",
+	tags: ["Function Tools"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "List of function tools retrieved successfully",
+			content: { "application/json": { schema: FunctionToolListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const { page, limit } = c.req.valid("query");
+	try {
+		const result = await listFunctionTools(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		return c.json(result);
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			projectId,
+			agentId
+		}, "Failed to list function tools");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to list function tools"
+		}), 500);
+	}
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Function Tool by ID",
+	operationId: "get-function-tool",
+	tags: ["Function Tools"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		200: {
+			description: "Function tool retrieved successfully",
+			content: { "application/json": { schema: FunctionToolResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	try {
+		const functionTool = await getFunctionToolById(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			functionToolId: id
+		});
+		if (!functionTool) return c.json(createApiError({
+			code: "not_found",
+			message: "Function tool not found"
+		}), 404);
+		return c.json({ data: functionTool });
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			projectId,
+			agentId,
+			id
+		}, "Failed to get function tool");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to get function tool"
+		}), 500);
+	}
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Function Tool",
+	operationId: "create-function-tool",
+	tags: ["Function Tools"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: FunctionToolApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Function tool created successfully",
+			content: { "application/json": { schema: FunctionToolResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const body = c.req.valid("json");
+	try {
+		const id = body.id || generateId();
+		const functionTool = await createFunctionTool(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			data: {
+				...body,
+				id
+			}
+		});
+		return c.json({ data: functionTool }, 201);
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			projectId,
+			agentId,
+			body
+		}, "Failed to create function tool");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to create function tool"
+		}), 500);
+	}
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update Function Tool",
+	operationId: "update-function-tool",
+	tags: ["Function Tools"],
+	request: {
+		params: TenantProjectAgentIdParamsSchema,
+		body: { content: { "application/json": { schema: FunctionToolApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Function tool updated successfully",
+			content: { "application/json": { schema: FunctionToolResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const body = c.req.valid("json");
+	try {
+		const functionTool = await updateFunctionTool(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			functionToolId: id,
+			data: body
+		});
+		if (!functionTool) return c.json(createApiError({
+			code: "not_found",
+			message: "Function tool not found"
+		}), 404);
+		return c.json({ data: functionTool });
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			projectId,
+			agentId,
+			id,
+			body
+		}, "Failed to update function tool");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to update function tool"
+		}), 500);
+	}
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Function Tool",
+	operationId: "delete-function-tool",
+	tags: ["Function Tools"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		204: { description: "Function tool deleted successfully" },
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	try {
+		if (!await deleteFunctionTool(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			functionToolId: id
+		})) return c.json(createApiError({
+			code: "not_found",
+			message: "Function tool not found"
+		}), 404);
+		return c.body(null, 204);
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			projectId,
+			agentId,
+			id
+		}, "Failed to delete function tool");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to delete function tool"
+		}), 500);
+	}
+});
+var functionTools_default = app;
+
+//#endregion
+export { functionTools_default as default };

package/dist/routes/functions.d.ts

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

package/dist/routes/functions.js

@@ -0,0 +1,281 @@
+import { getLogger as getLogger$1 } from "../logger.js";
+import dbClient_default from "../data/db/dbClient.js";
+import { requirePermission } from "../middleware/require-permission.js";
+import { speakeasyOffsetLimitPagination } from "./shared.js";
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { FunctionApiInsertSchema, FunctionApiUpdateSchema, FunctionListResponse, FunctionResponse, PaginationQueryParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, commonGetErrorResponses, createApiError, deleteFunction, generateId, getFunction, listFunctionsPaginated, upsertFunction } from "@inkeep/agents-core";
+
+//#region src/routes/functions.ts
+const logger = getLogger$1("functions");
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requirePermission({ function: ["create"] })(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "PUT") return requirePermission({ function: ["update"] })(c, next);
+	if (c.req.method === "DELETE") return requirePermission({ function: ["delete"] })(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/",
+	summary: "List Functions",
+	operationId: "list-functions",
+	tags: ["Functions"],
+	request: {
+		params: TenantProjectParamsSchema,
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "List of functions",
+			content: { "application/json": { schema: FunctionListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const { tenantId, projectId } = c.req.valid("param");
+	const page = Number(c.req.query("page")) || 1;
+	const limit = Math.min(Number(c.req.query("limit")) || 10, 100);
+	try {
+		const result = await listFunctionsPaginated(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		return c.json(result);
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId
+		}, "Failed to list functions");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to list functions"
+		}), 500);
+	}
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Function by ID",
+	operationId: "get-function",
+	tags: ["Functions"],
+	request: { params: TenantProjectIdParamsSchema },
+	responses: {
+		200: {
+			description: "Function details",
+			content: { "application/json": { schema: FunctionResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, id } = c.req.valid("param");
+	try {
+		const functionData = await getFunction(dbClient_default)({
+			functionId: id,
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		if (!functionData) return c.json(createApiError({
+			code: "not_found",
+			message: "Function not found"
+		}), 404);
+		return c.json({ data: functionData });
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			id
+		}, "Failed to get function");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to get function"
+		}), 500);
+	}
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Function",
+	operationId: "create-function",
+	tags: ["Functions"],
+	request: {
+		params: TenantProjectParamsSchema,
+		body: { content: { "application/json": { schema: FunctionApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Function created",
+			content: { "application/json": { schema: FunctionResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId } = c.req.valid("param");
+	const functionData = c.req.valid("json");
+	try {
+		const id = functionData.id || generateId();
+		await upsertFunction(dbClient_default)({
+			data: {
+				...functionData,
+				id
+			},
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		const created = await getFunction(dbClient_default)({
+			functionId: id,
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		logger.info({
+			tenantId,
+			functionId: id
+		}, "Function created");
+		return c.json({ data: created }, 201);
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			functionData
+		}, "Failed to create function");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to create function"
+		}), 500);
+	}
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update Function",
+	operationId: "update-function",
+	tags: ["Functions"],
+	request: {
+		params: TenantProjectIdParamsSchema,
+		body: { content: { "application/json": { schema: FunctionApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Function updated",
+			content: { "application/json": { schema: FunctionResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, id } = c.req.valid("param");
+	const updateData = c.req.valid("json");
+	try {
+		const existing = await getFunction(dbClient_default)({
+			functionId: id,
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		if (!existing) return c.json(createApiError({
+			code: "not_found",
+			message: "Function not found"
+		}), 404);
+		await upsertFunction(dbClient_default)({
+			data: {
+				...existing,
+				...updateData,
+				id
+			},
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		const updated = await getFunction(dbClient_default)({
+			functionId: id,
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		logger.info({
+			tenantId,
+			functionId: id
+		}, "Function updated");
+		return c.json({ data: updated });
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			id,
+			updateData
+		}, "Failed to update function");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to update function"
+		}), 500);
+	}
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Function",
+	operationId: "delete-function",
+	tags: ["Functions"],
+	request: { params: TenantProjectIdParamsSchema },
+	responses: {
+		204: { description: "Function deleted" },
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, id } = c.req.valid("param");
+	try {
+		if (!await getFunction(dbClient_default)({
+			functionId: id,
+			scopes: {
+				tenantId,
+				projectId
+			}
+		})) return c.json(createApiError({
+			code: "not_found",
+			message: "Function not found"
+		}), 404);
+		await deleteFunction(dbClient_default)({
+			functionId: id,
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		logger.info({
+			tenantId,
+			functionId: id
+		}, "Function deleted");
+		return c.body(null, 204);
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			id
+		}, "Failed to delete function");
+		return c.json(createApiError({
+			code: "internal_server_error",
+			message: "Failed to delete function"
+		}), 500);
+	}
+});
+var functions_default = app;
+
+//#endregion
+export { functions_default as default };

package/dist/routes/index.d.ts

@@ -0,0 +1,7 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import * as hono3 from "hono";
+
+//#region src/routes/index.d.ts
+declare const app: OpenAPIHono<hono3.Env, {}, "/">;
+//#endregion
+export { app as default };

package/dist/routes/index.js

@@ -0,0 +1,54 @@
+import agent_default from "./agent.js";
+import agentFull_default from "./agentFull.js";
+import apiKeys_default from "./apiKeys.js";
+import artifactComponents_default from "./artifactComponents.js";
+import contextConfigs_default from "./contextConfigs.js";
+import conversations_default from "./conversations.js";
+import credentialStores_default from "./credentialStores.js";
+import credentials_default from "./credentials.js";
+import dataComponents_default from "./dataComponents.js";
+import externalAgents_default from "./externalAgents.js";
+import functions_default from "./functions.js";
+import functionTools_default from "./functionTools.js";
+import mcpCatalog_default from "./mcpCatalog.js";
+import projects_default from "./projects.js";
+import subAgentArtifactComponents_default from "./subAgentArtifactComponents.js";
+import subAgentDataComponents_default from "./subAgentDataComponents.js";
+import subAgentExternalAgentRelations_default from "./subAgentExternalAgentRelations.js";
+import subAgentRelations_default from "./subAgentRelations.js";
+import subAgents_default from "./subAgents.js";
+import subAgentTeamAgentRelations_default from "./subAgentTeamAgentRelations.js";
+import subAgentToolRelations_default from "./subAgentToolRelations.js";
+import thirdPartyMCPServers_default from "./thirdPartyMCPServers.js";
+import tools_default from "./tools.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/routes/index.ts
+const app = new OpenAPIHono();
+app.route("/projects", projects_default);
+app.route("/projects/:projectId/agents/:agentId/sub-agents", subAgents_default);
+app.route("/projects/:projectId/agents/:agentId/sub-agent-relations", subAgentRelations_default);
+app.route("/projects/:projectId/agents/:agentId/sub-agents/:subAgentId/external-agent-relations", subAgentExternalAgentRelations_default);
+app.route("/projects/:projectId/agents/:agentId/sub-agents/:subAgentId/team-agent-relations", subAgentTeamAgentRelations_default);
+app.route("/projects/:projectId/agents", agent_default);
+app.route("/projects/:projectId/agents/:agentId/sub-agent-tool-relations", subAgentToolRelations_default);
+app.route("/projects/:projectId/agents/:agentId/sub-agent-artifact-components", subAgentArtifactComponents_default);
+app.route("/projects/:projectId/agents/:agentId/sub-agent-data-components", subAgentDataComponents_default);
+app.route("/projects/:projectId/artifact-components", artifactComponents_default);
+app.route("/projects/:projectId/agents/:agentId/context-configs", contextConfigs_default);
+app.route("/projects/:projectId/conversations", conversations_default);
+app.route("/projects/:projectId/credentials", credentials_default);
+app.route("/projects/:projectId/credential-stores", credentialStores_default);
+app.route("/projects/:projectId/data-components", dataComponents_default);
+app.route("/projects/:projectId/external-agents", externalAgents_default);
+app.route("/projects/:projectId/agents/:agentId/function-tools", functionTools_default);
+app.route("/projects/:projectId/functions", functions_default);
+app.route("/projects/:projectId/tools", tools_default);
+app.route("/projects/:projectId/api-keys", apiKeys_default);
+app.route("/projects/:projectId/agent", agentFull_default);
+app.route("/projects/:projectId/mcp-catalog", mcpCatalog_default);
+app.route("/projects/:projectId/third-party-mcp-servers", thirdPartyMCPServers_default);
+var routes_default = app;
+
+//#endregion
+export { routes_default as default };

package/dist/routes/invitations.d.ts

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

package/dist/routes/invitations.js

@@ -0,0 +1,41 @@
+import dbClient_default from "../data/db/dbClient.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { getPendingInvitationsByEmail } from "@inkeep/agents-core";
+
+//#region src/routes/invitations.ts
+const invitationsRoutes = new OpenAPIHono();
+const PendingInvitationSchema = z.object({
+	id: z.string(),
+	email: z.string(),
+	organizationId: z.string(),
+	organizationName: z.string().nullable(),
+	organizationSlug: z.string().nullable(),
+	role: z.string().nullable(),
+	status: z.string(),
+	expiresAt: z.number(),
+	inviterId: z.string()
+});
+const PendingInvitationsResponseSchema = z.array(PendingInvitationSchema);
+invitationsRoutes.openapi(createRoute({
+	method: "get",
+	path: "/pending",
+	tags: ["invitations"],
+	summary: "Get pending invitations",
+	description: "Get all pending (non-expired) invitations for a given email address",
+	request: { query: z.object({ email: z.email().describe("Email address to check for invitations") }) },
+	responses: { 200: {
+		description: "List of pending invitations",
+		content: { "application/json": { schema: PendingInvitationsResponseSchema } }
+	} }
+}), async (c) => {
+	const { email } = c.req.valid("query");
+	const response = (await getPendingInvitationsByEmail(dbClient_default)(email)).map((inv) => ({
+		...inv,
+		expiresAt: inv.expiresAt instanceof Date ? inv.expiresAt.getTime() : inv.expiresAt
+	}));
+	return c.json(response);
+});
+var invitations_default = invitationsRoutes;
+
+//#endregion
+export { invitations_default as default };

package/dist/routes/mcp.d.ts

@@ -0,0 +1,7 @@
+import { Hono } from "hono";
+import * as hono_types3 from "hono/types";
+
+//#region src/routes/mcp.d.ts
+declare const app: Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
+//#endregion
+export { app as default };