@inkeep/agents-api 0.0.1

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

@@ -0,0 +1,285 @@
+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 { FunctionApiInsertSchema, FunctionApiUpdateSchema, FunctionListResponse, FunctionResponse, PaginationQueryParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, commonGetErrorResponses, createApiError, deleteFunction, generateId, getFunction, listFunctionsPaginated, upsertFunction } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/functions.ts
+const logger = getLogger$1("functions");
+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 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 db = c.get("db");
+	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(db)({
+			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 db = c.get("db");
+	const { tenantId, projectId, id } = c.req.valid("param");
+	try {
+		const functionData = await getFunction(db)({
+			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 db = c.get("db");
+	const { tenantId, projectId } = c.req.valid("param");
+	const functionData = c.req.valid("json");
+	try {
+		const id = functionData.id || generateId();
+		await upsertFunction(db)({
+			data: {
+				...functionData,
+				id
+			},
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		const created = await getFunction(db)({
+			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 db = c.get("db");
+	const { tenantId, projectId, id } = c.req.valid("param");
+	const updateData = c.req.valid("json");
+	try {
+		const existing = await getFunction(db)({
+			functionId: id,
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		if (!existing) return c.json(createApiError({
+			code: "not_found",
+			message: "Function not found"
+		}), 404);
+		await upsertFunction(db)({
+			data: {
+				...existing,
+				...updateData,
+				id
+			},
+			scopes: {
+				tenantId,
+				projectId
+			}
+		});
+		const updated = await getFunction(db)({
+			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 db = c.get("db");
+	const { tenantId, projectId, id } = c.req.valid("param");
+	try {
+		if (!await getFunction(db)({
+			functionId: id,
+			scopes: {
+				tenantId,
+				projectId
+			}
+		})) return c.json(createApiError({
+			code: "not_found",
+			message: "Function not found"
+		}), 404);
+		await deleteFunction(db)({
+			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/domains/manage/routes/index.d.ts

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

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

@@ -0,0 +1,68 @@
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+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 branches_default from "./branches.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 projectMembers_default from "./projectMembers.js";
+import projectPermissions_default from "./projectPermissions.js";
+import projects_default from "./projects.js";
+import ref_default from "./ref.js";
+import subAgentArtifactComponents_default from "./subAgentArtifactComponents.js";
+import subAgentDataComponents_default from "./subAgentDataComponents.js";
+import subAgentExternalAgentRelations_default from "./subAgentExternalAgentRelations.js";
+import subAgentFunctionTools_default from "./subAgentFunctionTools.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 triggers_default from "./triggers.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/domains/manage/routes/index.ts
+const app = new OpenAPIHono();
+app.route("/projects", projects_default);
+app.use("/projects/:projectId/*", requireProjectPermission("view"));
+app.route("/projects/:projectId/branches", branches_default);
+app.route("/projects/:projectId/refs", ref_default);
+app.route("/projects/:projectId/members", projectMembers_default);
+app.route("/projects/:projectId/permissions", projectPermissions_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/agents/:agentId/sub-agent-function-tools", subAgentFunctionTools_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);
+app.route("/projects/:projectId/agents/:agentId/triggers", triggers_default);
+var routes_default = app;
+
+//#endregion
+export { routes_default as default };

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

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

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

@@ -0,0 +1,41 @@
+import runDbClient_default from "../../../data/db/runDbClient.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { getPendingInvitationsByEmail } from "@inkeep/agents-core";
+
+//#region src/domains/manage/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(runDbClient_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/domains/manage/routes/mcp.d.ts

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

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

@@ -0,0 +1,45 @@
+import { env } from "../../../env.js";
+import { Hono } from "hono";
+import { StreamableHTTPTransport } from "@hono/mcp";
+import { HeaderForwardingHook, InkeepAgentsCore, SDKHooks, createConsoleLogger, createMCPServer } from "@inkeep/agents-manage-mcp";
+
+//#region src/domains/manage/routes/mcp.ts
+const app = new Hono();
+/**
+* Headers to forward from incoming requests to downstream API calls.
+* x-forwarded-cookie is mapped to cookie for browser compatibility
+* (browsers don't allow setting Cookie header directly).
+*/
+const FORWARDED_HEADERS = [
+	"x-forwarded-cookie",
+	"authorization",
+	"cookie"
+];
+app.all("/", async (c) => {
+	const transport = new StreamableHTTPTransport();
+	const noOpLogger = createConsoleLogger("error");
+	const headersToForward = {};
+	for (const headerName of FORWARDED_HEADERS) {
+		const value = c.req.header(headerName);
+		if (value) headersToForward[headerName] = value;
+	}
+	if (headersToForward["x-forwarded-cookie"] && !headersToForward.cookie) headersToForward.cookie = headersToForward["x-forwarded-cookie"];
+	const createSDKWithHeaders = () => {
+		const hooks = new SDKHooks();
+		hooks.registerBeforeRequestHook(new HeaderForwardingHook(headersToForward));
+		return new InkeepAgentsCore({
+			serverURL: env.INKEEP_AGENTS_API_URL,
+			hooks
+		});
+	};
+	await createMCPServer({
+		logger: noOpLogger,
+		serverURL: env.INKEEP_AGENTS_API_URL,
+		getSDK: createSDKWithHeaders
+	}).connect(transport);
+	return transport.handleRequest(c);
+});
+var mcp_default = app;
+
+//#endregion
+export { mcp_default as default };

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

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