@inkeep/agents-api 0.0.0-dev-20260121145510

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

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

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

@@ -0,0 +1,289 @@
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { speakeasyOffsetLimitPagination } from "../../../utils/speakeasy.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { ErrorResponseSchema, PaginationQueryParamsSchema, SubAgentToolRelationApiInsertSchema, SubAgentToolRelationApiUpdateSchema, SubAgentToolRelationListResponse, SubAgentToolRelationResponse, TenantProjectAgentIdParamsSchema, TenantProjectAgentParamsSchema, commonGetErrorResponses, createAgentToolRelation, createApiError, deleteAgentToolRelation, getAgentToolRelationByAgent, getAgentToolRelationById, getAgentToolRelationByTool, getAgentsForTool, listAgentToolRelations, updateAgentToolRelation } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/subAgentToolRelations.ts
+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 SubAgent Tool Relations",
+	operationId: "list-subagent-tool-relations",
+	tags: ["SubAgent Tool Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		query: PaginationQueryParamsSchema.extend({
+			subAgentId: z.string().optional(),
+			toolId: z.string().optional()
+		})
+	},
+	responses: {
+		200: {
+			description: "List of subAgent tool relations retrieved successfully",
+			content: { "application/json": { schema: SubAgentToolRelationListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const { page, limit, subAgentId, toolId } = c.req.valid("query");
+	let result;
+	if (subAgentId) {
+		const dbResult = await getAgentToolRelationByAgent(db)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId,
+				subAgentId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: dbResult.data,
+			pagination: dbResult.pagination
+		};
+	} else if (toolId) {
+		const dbResult = await getAgentToolRelationByTool(db)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			toolId,
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: dbResult.data,
+			pagination: dbResult.pagination
+		};
+	} else {
+		const dbResult = await listAgentToolRelations(db)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: dbResult.data,
+			pagination: dbResult.pagination
+		};
+	}
+	return c.json(result);
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get SubAgent Tool Relation",
+	operationId: "get-subagent-tool-relation",
+	tags: ["SubAgent Tool Relations"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		200: {
+			description: "SubAgent tool relation found",
+			content: { "application/json": { schema: SubAgentToolRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const agentToolRelation = await getAgentToolRelationById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId: id
+		},
+		relationId: id
+	});
+	if (!agentToolRelation) throw createApiError({
+		code: "not_found",
+		message: "SubAgent tool relation not found"
+	});
+	return c.json({ data: agentToolRelation });
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/tool/{toolId}/sub-agents",
+	summary: "Get SubAgents for Tool",
+	operationId: "get-subagents-for-tool",
+	tags: ["SubAgent Tool Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema.extend({ toolId: z.string() }),
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "SubAgents for tool retrieved successfully",
+			content: { "application/json": { schema: SubAgentToolRelationListResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, toolId } = c.req.valid("param");
+	const { page, limit } = c.req.valid("query");
+	const dbResult = await getAgentsForTool(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		toolId,
+		pagination: {
+			page,
+			limit
+		}
+	});
+	return c.json(dbResult);
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create SubAgent Tool Relation",
+	operationId: "create-subagent-tool-relation",
+	tags: ["SubAgent Tool Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentToolRelationApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "SubAgent tool relation created successfully",
+			content: { "application/json": { schema: SubAgentToolRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const body = c.req.valid("json");
+	if ((await listAgentToolRelations(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		pagination: { limit: 1e3 }
+	})).data.some((relation) => {
+		const typedRelation = relation;
+		return typedRelation.subAgentId === body.subAgentId && typedRelation.toolId === body.toolId;
+	})) throw createApiError({
+		code: "unprocessable_entity",
+		message: "SubAgent tool relation already exists"
+	});
+	try {
+		const agentToolRelation = await createAgentToolRelation(db)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			data: body
+		});
+		return c.json({ data: agentToolRelation }, 201);
+	} catch (error) {
+		if (error?.cause?.code === "23503") throw createApiError({
+			code: "bad_request",
+			message: "Invalid subAgent ID or tool ID - referenced entity does not exist"
+		});
+		throw error;
+	}
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update SubAgent Tool Relation",
+	operationId: "update-subagent-tool-relation",
+	tags: ["SubAgent Tool Relations"],
+	request: {
+		params: TenantProjectAgentIdParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentToolRelationApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "SubAgent tool relation updated successfully",
+			content: { "application/json": { schema: SubAgentToolRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const body = await c.req.valid("json");
+	if (Object.keys(body).length === 0) throw createApiError({
+		code: "bad_request",
+		message: "No fields to update"
+	});
+	const updatedAgentToolRelation = await updateAgentToolRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		relationId: id,
+		data: body
+	});
+	if (!updatedAgentToolRelation) throw createApiError({
+		code: "not_found",
+		message: "SubAgent tool relation not found"
+	});
+	return c.json({ data: updatedAgentToolRelation });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete SubAgent Tool Relation",
+	operationId: "delete-subagent-tool-relation",
+	tags: ["SubAgent Tool Relations"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		204: { description: "SubAgent tool relation deleted successfully" },
+		404: {
+			description: "SubAgent tool relation not found",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		}
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	if (!await deleteAgentToolRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		relationId: id
+	})) throw createApiError({
+		code: "not_found",
+		message: "SubAgent tool relation not found"
+	});
+	return c.body(null, 204);
+});
+var subAgentToolRelations_default = app;
+
+//#endregion
+export { subAgentToolRelations_default as default };

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

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

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

@@ -0,0 +1,220 @@
+import runDbClient_default from "../../../data/db/runDbClient.js";
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { speakeasyOffsetLimitPagination } from "../../../utils/speakeasy.js";
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { ErrorResponseSchema, PaginationQueryParamsSchema, SubAgentApiInsertSchema, SubAgentApiUpdateSchema, SubAgentIsDefaultError, SubAgentListResponse, SubAgentResponse, TenantProjectAgentIdParamsSchema, TenantProjectAgentParamsSchema, cascadeDeleteBySubAgent, commonGetErrorResponses, createApiError, createSubAgent, deleteSubAgent, generateId, getSubAgentById, listSubAgentsPaginated, updateSubAgent } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/subAgents.ts
+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 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(c.get("db"))({
+		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(c.get("db"))({
+		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(c.get("db"))({
+			...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(c.get("db"))({
+		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");
+	const db = c.get("db");
+	const resolvedRef = c.get("resolvedRef");
+	try {
+		await cascadeDeleteBySubAgent(runDbClient_default)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			subAgentId: id,
+			fullBranchName: resolvedRef.name
+		});
+		if (!await deleteSubAgent(db)({
+			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/domains/manage/routes/thirdPartyMCPServers.d.ts

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

package/dist/domains/manage/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/domains/manage/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/domains/manage/routes/tools.d.ts

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