@inkeep/agents-manage-api 0.39.4 → 0.40.0

package/dist/routes/subAgents.js

@@ -0,0 +1,210 @@
+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 { ErrorResponseSchema, PaginationQueryParamsSchema, SubAgentApiInsertSchema, SubAgentApiUpdateSchema, SubAgentIsDefaultError, SubAgentListResponse, SubAgentResponse, TenantProjectAgentIdParamsSchema, TenantProjectAgentParamsSchema, commonGetErrorResponses, createApiError, createSubAgent, deleteSubAgent, generateId, getSubAgentById, listSubAgentsPaginated, updateSubAgent } from "@inkeep/agents-core";
+
+//#region src/routes/subAgents.ts
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requirePermission({ sub_agent: ["create"] })(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "PUT") return requirePermission({ sub_agent: ["update"] })(c, next);
+	if (c.req.method === "DELETE") return requirePermission({ sub_agent: ["delete"] })(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/",
+	summary: "List SubAgents",
+	operationId: "list-subagents",
+	tags: ["SubAgent"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "List of subAgents retrieved successfully",
+			content: { "application/json": { schema: SubAgentListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const page = Number(c.req.query("page")) || 1;
+	const limit = Math.min(Number(c.req.query("limit")) || 10, 100);
+	const result = await listSubAgentsPaginated(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		pagination: {
+			page,
+			limit
+		}
+	});
+	const dataWithType = {
+		...result,
+		data: result.data.map((subAgent) => ({
+			...subAgent,
+			type: "internal"
+		}))
+	};
+	return c.json(dataWithType);
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get SubAgent",
+	operationId: "get-subagent-by-id",
+	tags: ["SubAgent"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		200: {
+			description: "SubAgent found",
+			content: { "application/json": { schema: SubAgentResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const subAgent = await getSubAgentById(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId: id
+	});
+	if (!subAgent) throw createApiError({
+		code: "not_found",
+		message: "SubAgent not found"
+	});
+	const subAgentWithType = {
+		...subAgent,
+		type: "internal"
+	};
+	return c.json({ data: subAgentWithType });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create SubAgent",
+	operationId: "create-subagent",
+	tags: ["SubAgent"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "SubAgent created successfully",
+			content: { "application/json": { schema: SubAgentResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const subAgentId = body.id ? String(body.id) : generateId();
+	const subAgentWithType = {
+		...await createSubAgent(dbClient_default)({
+			...body,
+			id: subAgentId,
+			tenantId,
+			projectId,
+			agentId
+		}),
+		type: "internal"
+	};
+	return c.json({ data: subAgentWithType }, 201);
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update SubAgent",
+	operationId: "update-subagent",
+	tags: ["SubAgent"],
+	request: {
+		params: TenantProjectAgentIdParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "SubAgent updated successfully",
+			content: { "application/json": { schema: SubAgentResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const updatedSubAgent = await updateSubAgent(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId: id,
+		data: body
+	});
+	if (!updatedSubAgent) throw createApiError({
+		code: "not_found",
+		message: "SubAgent not found"
+	});
+	const subAgentWithType = {
+		...updatedSubAgent,
+		type: "internal"
+	};
+	return c.json({ data: subAgentWithType });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete SubAgent",
+	operationId: "delete-subagent",
+	tags: ["SubAgent"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		204: { description: "SubAgent deleted successfully" },
+		404: {
+			description: "SubAgent not found",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		},
+		409: {
+			description: "SubAgent is set as default and cannot be deleted",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		}
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	try {
+		if (!await deleteSubAgent(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			subAgentId: id
+		})) throw createApiError({
+			code: "not_found",
+			message: "SubAgent not found"
+		});
+		return c.body(null, 204);
+	} catch (error) {
+		if (error instanceof SubAgentIsDefaultError) throw createApiError({
+			code: "conflict",
+			message: error.message
+		});
+		throw error;
+	}
+});
+var subAgents_default = app;
+
+//#endregion
+export { subAgents_default as default };

package/dist/routes/thirdPartyMCPServers.d.ts

@@ -0,0 +1,14 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { CredentialStoreRegistry, ServerConfig } from "@inkeep/agents-core";
+
+//#region src/routes/thirdPartyMCPServers.d.ts
+type AppVariables = {
+  serverConfig: ServerConfig;
+  credentialStores: CredentialStoreRegistry;
+  userId?: string;
+};
+declare const app: OpenAPIHono<{
+  Variables: AppVariables;
+}, {}, "/">;
+//#endregion
+export { app as default };

package/dist/routes/thirdPartyMCPServers.js

@@ -0,0 +1,72 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { TenantProjectParamsSchema, ThirdPartyMCPServerResponse, commonGetErrorResponses, createApiError, fetchSingleComposioServer, getComposioOAuthRedirectUrl } from "@inkeep/agents-core";
+
+//#region src/routes/thirdPartyMCPServers.ts
+const app = new OpenAPIHono();
+const ThirdPartyMCPServerBodySchema = z.object({
+	url: z.url().describe("The MCP server URL to fetch details for"),
+	credentialScope: z.enum(["project", "user"]).default("project").optional()
+});
+const GetOAuthRedirectBodySchema = z.object({
+	url: z.url().describe("The MCP server URL"),
+	credentialScope: z.enum(["project", "user"]).describe("The credential scope")
+});
+const OAuthRedirectResponse = z.object({ data: z.object({ redirectUrl: z.string().nullable() }) });
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Get Third-Party MCP Server Details",
+	operationId: "get-third-party-mcp-server",
+	tags: ["Third-Party MCP Servers"],
+	description: "Fetch details for a specific third-party MCP server (e.g., Composio) including authentication status and connect URL",
+	request: {
+		params: TenantProjectParamsSchema,
+		body: { content: { "application/json": { schema: ThirdPartyMCPServerBodySchema } } }
+	},
+	responses: {
+		200: {
+			description: "Third-party MCP server details",
+			content: { "application/json": { schema: ThirdPartyMCPServerResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId } = c.req.valid("param");
+	const { url, credentialScope } = c.req.valid("json");
+	const userId = c.get("userId");
+	const server = await fetchSingleComposioServer(tenantId, projectId, url, credentialScope ?? "project", userId);
+	return c.json({ data: server });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/oauth-redirect",
+	summary: "Get OAuth Redirect URL",
+	operationId: "get-oauth-redirect-url",
+	tags: ["Third-Party MCP Servers"],
+	description: "Get the OAuth redirect URL for a third-party MCP server. Call this after scope selection to get the correct URL for the selected scope.",
+	request: {
+		params: TenantProjectParamsSchema,
+		body: { content: { "application/json": { schema: GetOAuthRedirectBodySchema } } }
+	},
+	responses: {
+		200: {
+			description: "OAuth redirect URL",
+			content: { "application/json": { schema: OAuthRedirectResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId } = c.req.valid("param");
+	const { url, credentialScope } = c.req.valid("json");
+	const userId = c.get("userId");
+	if (credentialScope === "user" && !userId) throw createApiError({
+		code: "bad_request",
+		message: "User ID required for user-scoped credentials"
+	});
+	const redirectUrl = await getComposioOAuthRedirectUrl(tenantId, projectId, url, credentialScope, userId);
+	return c.json({ data: { redirectUrl } });
+});
+var thirdPartyMCPServers_default = app;
+
+//#endregion
+export { thirdPartyMCPServers_default as default };

package/dist/routes/tools.d.ts

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

package/dist/routes/tools.js

@@ -0,0 +1,256 @@
+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 { 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/routes/tools.ts
+const logger = getLogger$1("tools");
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requirePermission({ tool: ["create"] })(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "PUT") return requirePermission({ tool: ["update"] })(c, next);
+	if (c.req.method === "DELETE") return requirePermission({ tool: ["delete"] })(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 { 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(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: (await Promise.all(dbResult.data.map(async (tool) => await dbResultToMcpTool(tool, dbClient_default, credentialStores, void 0, userId)))).filter((tool) => tool.status === status),
+			pagination: dbResult.pagination
+		};
+	} else {
+		const dbResult = await listTools(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: await Promise.all(dbResult.data.map(async (tool) => await dbResultToMcpTool(tool, dbClient_default, 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 { tenantId, projectId, id } = c.req.valid("param");
+	const tool = await getToolById(dbClient_default)({
+		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, dbClient_default, 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 { 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(dbClient_default)({
+		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, dbClient_default, 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 { 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(dbClient_default)({
+		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, dbClient_default, 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 userId = c.get("userId");
+	if (!userId) throw createApiError({
+		code: "unauthorized",
+		message: "User ID required for user-scoped credential lookup"
+	});
+	const credential = await getUserScopedCredentialReference(dbClient_default)({
+		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 { tenantId, projectId, id } = c.req.valid("param");
+	if (!await deleteTool(dbClient_default)({
+		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/routes/userOrganizations.d.ts

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

package/dist/routes/userOrganizations.js

@@ -0,0 +1,58 @@
+import dbClient_default from "../data/db/dbClient.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { addUserToOrganization, getUserOrganizations } from "@inkeep/agents-core";
+import { AddUserToOrganizationRequestSchema, AddUserToOrganizationResponseSchema, UserOrganizationsResponseSchema } from "@inkeep/agents-core/auth/validation";
+
+//#region src/routes/userOrganizations.ts
+const userOrganizationsRoutes = new OpenAPIHono();
+userOrganizationsRoutes.openapi(createRoute({
+	method: "get",
+	path: "/",
+	tags: ["user-organizations"],
+	summary: "List user organizations",
+	description: "Get all organizations associated with a user",
+	request: { params: z.object({ userId: z.string().describe("User ID") }) },
+	responses: { 200: {
+		description: "List of user organizations",
+		content: { "application/json": { schema: UserOrganizationsResponseSchema } }
+	} }
+}), async (c) => {
+	const { userId } = c.req.valid("param");
+	const userOrganizations = (await getUserOrganizations(dbClient_default)(userId)).map((org) => ({
+		...org,
+		createdAt: org.createdAt.toISOString()
+	}));
+	return c.json(userOrganizations);
+});
+userOrganizationsRoutes.openapi(createRoute({
+	method: "post",
+	path: "/",
+	tags: ["user-organizations"],
+	summary: "Add user to organization",
+	description: "Associate a user with an organization",
+	request: {
+		params: z.object({ userId: z.string().describe("User ID") }),
+		body: { content: { "application/json": { schema: AddUserToOrganizationRequestSchema } } }
+	},
+	responses: { 201: {
+		description: "User added to organization",
+		content: { "application/json": { schema: AddUserToOrganizationResponseSchema } }
+	} }
+}), async (c) => {
+	const { userId } = c.req.valid("param");
+	const { organizationId, role } = c.req.valid("json");
+	await addUserToOrganization(dbClient_default)({
+		userId,
+		organizationId,
+		role
+	});
+	return c.json({
+		organizationId,
+		role,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	}, 201);
+});
+var userOrganizations_default = userOrganizationsRoutes;
+
+//#endregion
+export { userOrganizations_default as default };

package/dist/sso-helpers.d.ts

@@ -0,0 +1,20 @@
+import { SSOProviderConfig } from "@inkeep/agents-core/auth";
+
+//#region src/sso-helpers.d.ts
+interface OIDCProviderOptions {
+  providerId: string;
+  clientId: string;
+  clientSecret: string;
+  domain: string;
+  organizationId?: string;
+  scopes?: string[];
+  pkce?: boolean;
+}
+declare function createOIDCProvider(options: OIDCProviderOptions): Promise<SSOProviderConfig | null>;
+declare function createAuth0Provider(options: {
+  domain: string;
+  clientId: string;
+  clientSecret: string;
+}): Promise<SSOProviderConfig | null>;
+//#endregion
+export { OIDCProviderOptions, createAuth0Provider, createOIDCProvider };