@inkeep/agents-api 0.0.0-dev-20260121145510

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

@@ -0,0 +1,205 @@
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { ComponentAssociationListResponse, ErrorResponseSchema, ExistsResponseSchema, FunctionToolListResponse, RemovedResponseSchema, SubAgentFunctionToolRelationApiInsertSchema, SubAgentFunctionToolRelationResponse, TenantProjectAgentParamsSchema, TenantProjectAgentSubAgentParamsSchema, addFunctionToolToSubAgent, commonGetErrorResponses, createApiError, getFunctionToolById, getFunctionToolsForSubAgent, getSubAgentById, getSubAgentsUsingFunctionTool, isFunctionToolAssociatedWithSubAgent, removeFunctionToolFromSubAgent } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/subAgentFunctionTools.ts
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.use("/sub-agent/:subAgentId/function-tool/:functionToolId", async (c, next) => {
+	if (c.req.method === "DELETE") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/sub-agent/{subAgentId}",
+	summary: "Get Function Tools for SubAgent",
+	operationId: "get-function-tools-for-sub-agent",
+	tags: ["SubAgent Function Tool Relations"],
+	request: { params: TenantProjectAgentSubAgentParamsSchema },
+	responses: {
+		200: {
+			description: "Function tools retrieved successfully",
+			content: { "application/json": { schema: FunctionToolListResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId } = c.req.valid("param");
+	const result = await getFunctionToolsForSubAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId
+	});
+	return c.json(result);
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/function-tool/{functionToolId}/sub-agents",
+	summary: "Get SubAgents Using Function Tool",
+	operationId: "get-sub-agents-using-function-tool",
+	tags: ["SubAgent Function Tool Relations"],
+	request: { params: TenantProjectAgentParamsSchema.extend({ functionToolId: z.string() }) },
+	responses: {
+		200: {
+			description: "SubAgents retrieved successfully",
+			content: { "application/json": { schema: ComponentAssociationListResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, functionToolId } = c.req.valid("param");
+	const agents = await getSubAgentsUsingFunctionTool(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		functionToolId
+	});
+	return c.json({ data: agents });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Associate Function Tool with SubAgent",
+	operationId: "associate-function-tool-with-sub-agent",
+	tags: ["SubAgent Function Tool Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentFunctionToolRelationApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "SubAgent function tool association created successfully",
+			content: { "application/json": { schema: SubAgentFunctionToolRelationResponse } }
+		},
+		409: {
+			description: "Association already exists",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const { subAgentId, functionToolId } = c.req.valid("json");
+	const [subAgent, functionTool] = await Promise.all([getSubAgentById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId
+	}), getFunctionToolById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		functionToolId
+	})]);
+	if (!subAgent) throw createApiError({
+		code: "not_found",
+		message: `SubAgent with id '${subAgentId}' not found`
+	});
+	if (!functionTool) throw createApiError({
+		code: "not_found",
+		message: `Function tool with id '${functionToolId}' not found`
+	});
+	if (await isFunctionToolAssociatedWithSubAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId,
+		functionToolId
+	})) throw createApiError({
+		code: "conflict",
+		message: "SubAgent function tool association already exists"
+	});
+	const association = await addFunctionToolToSubAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId,
+		functionToolId
+	});
+	return c.json({ data: association }, 201);
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/sub-agent/{subAgentId}/function-tool/{functionToolId}",
+	summary: "Remove Function Tool from SubAgent",
+	operationId: "remove-function-tool-from-sub-agent",
+	tags: ["SubAgent Function Tool Relations"],
+	request: { params: TenantProjectAgentSubAgentParamsSchema.extend({ functionToolId: z.string() }) },
+	responses: {
+		200: {
+			description: "Association removed successfully",
+			content: { "application/json": { schema: RemovedResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId, functionToolId } = c.req.valid("param");
+	if (!await removeFunctionToolFromSubAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId,
+		functionToolId
+	})) throw createApiError({
+		code: "not_found",
+		message: "SubAgent function tool association not found"
+	});
+	return c.json({
+		message: "Association removed successfully",
+		removed: true
+	});
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/sub-agent/{subAgentId}/function-tool/{functionToolId}/exists",
+	summary: "Check if Function Tool is Associated with SubAgent",
+	operationId: "check-function-tool-sub-agent-association",
+	tags: ["SubAgent Function Tool Relations"],
+	request: { params: TenantProjectAgentSubAgentParamsSchema.extend({ functionToolId: z.string() }) },
+	responses: {
+		200: {
+			description: "Association status retrieved successfully",
+			content: { "application/json": { schema: ExistsResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId, functionToolId } = c.req.valid("param");
+	const exists = await isFunctionToolAssociatedWithSubAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId,
+		functionToolId
+	});
+	return c.json({ exists });
+});
+var subAgentFunctionTools_default = app;
+
+//#endregion
+export { subAgentFunctionTools_default as default };

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

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

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

@@ -0,0 +1,263 @@
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { speakeasyOffsetLimitPagination } from "../../../utils/speakeasy.js";
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { ErrorResponseSchema, PaginationQueryParamsSchema, SubAgentRelationApiInsertSchema, SubAgentRelationApiUpdateSchema, SubAgentRelationListResponse, SubAgentRelationQuerySchema, SubAgentRelationResponse, TenantProjectAgentIdParamsSchema, TenantProjectAgentParamsSchema, commonGetErrorResponses, createApiError, createSubAgentRelation, deleteSubAgentRelation, generateId, getAgentRelationById, getAgentRelationsBySource, getSubAgentRelationsByTarget, listAgentRelations, updateAgentRelation, validateSubAgent } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/subAgentRelations.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 Sub Agent Relations",
+	operationId: "list-sub-agent-relations",
+	tags: ["Sub Agent Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		query: PaginationQueryParamsSchema.merge(SubAgentRelationQuerySchema)
+	},
+	responses: {
+		200: {
+			description: "List of sub agent relations retrieved successfully",
+			content: { "application/json": { schema: SubAgentRelationListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const { page = 1, limit = 10, sourceSubAgentId, targetSubAgentId } = c.req.valid("query");
+	const pageNum = Number(page);
+	const limitNum = Math.min(Number(limit), 100);
+	try {
+		let result;
+		if (sourceSubAgentId) {
+			const rawResult = await getAgentRelationsBySource(db)({
+				scopes: {
+					tenantId,
+					projectId,
+					agentId
+				},
+				sourceSubAgentId,
+				pagination: {
+					page: pageNum,
+					limit: limitNum
+				}
+			});
+			result = {
+				...rawResult,
+				data: rawResult.data
+			};
+		} else if (targetSubAgentId) {
+			const rawResult = await getSubAgentRelationsByTarget(db)({
+				scopes: {
+					tenantId,
+					projectId,
+					agentId
+				},
+				targetSubAgentId,
+				pagination: {
+					page: pageNum,
+					limit: limitNum
+				}
+			});
+			result = {
+				...rawResult,
+				data: rawResult.data
+			};
+		} else {
+			const rawResult = await listAgentRelations(db)({
+				scopes: {
+					tenantId,
+					projectId,
+					agentId
+				},
+				pagination: {
+					page: pageNum,
+					limit: limitNum
+				}
+			});
+			result = {
+				...rawResult,
+				data: rawResult.data
+			};
+		}
+		return c.json(result);
+	} catch (_error) {
+		throw createApiError({
+			code: "internal_server_error",
+			message: "Failed to retrieve sub agent relations"
+		});
+	}
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Sub Agent Relation",
+	operationId: "get-sub-agent-relation-by-id",
+	tags: ["Sub Agent Relations"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		200: {
+			description: "Sub Agent relation found",
+			content: { "application/json": { schema: SubAgentRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const agentRelation = await getAgentRelationById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		relationId: id
+	});
+	if (!agentRelation) throw createApiError({
+		code: "not_found",
+		message: "Sub Agent Relation not found"
+	});
+	return c.json({ data: agentRelation });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Sub Agent Relation",
+	operationId: "create-sub-agent-relation",
+	tags: ["Sub Agent Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentRelationApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Sub Agent Relation created successfully",
+			content: { "application/json": { schema: SubAgentRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const body = await c.req.valid("json");
+	if (body.targetSubAgentId) {
+		if (!await validateSubAgent(db)({ scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId: body.targetSubAgentId
+		} })) throw createApiError({
+			code: "bad_request",
+			message: `Sub agent with ID ${body.targetSubAgentId} not found`
+		});
+	}
+	if ((await listAgentRelations(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		pagination: {
+			page: 1,
+			limit: 1e3
+		}
+	})).data.some((relation) => {
+		if (relation.agentId !== agentId || relation.sourceSubAgentId !== body.sourceSubAgentId) return false;
+		return relation.targetSubAgentId === body.targetSubAgentId;
+	})) throw createApiError({
+		code: "unprocessable_entity",
+		message: `A relation between these agents in this agent already exists`
+	});
+	const relationData = {
+		agentId,
+		tenantId,
+		id: generateId(),
+		projectId,
+		sourceSubAgentId: body.sourceSubAgentId,
+		targetSubAgentId: body.targetSubAgentId,
+		relationType: body.relationType
+	};
+	const agentRelation = await createSubAgentRelation(db)({ ...relationData });
+	return c.json({ data: agentRelation }, 201);
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update Sub Agent Relation",
+	operationId: "update-sub-agent-relation",
+	tags: ["Sub Agent Relations"],
+	request: {
+		params: TenantProjectAgentIdParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentRelationApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Sub Agent relation updated successfully",
+			content: { "application/json": { schema: SubAgentRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const body = await c.req.valid("json");
+	const updatedAgentRelation = await updateAgentRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		relationId: id,
+		data: body
+	});
+	if (!updatedAgentRelation) throw createApiError({
+		code: "not_found",
+		message: "Sub Agent Relation not found"
+	});
+	return c.json({ data: updatedAgentRelation });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Sub Agent Relation",
+	operationId: "delete-sub-agent-relation",
+	tags: ["Sub Agent Relations"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		204: { description: "Sub Agent Relation deleted successfully" },
+		404: {
+			description: "Sub Agent 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 deleteSubAgentRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		relationId: id
+	})) throw createApiError({
+		code: "not_found",
+		message: "Sub Agent Relation not found"
+	});
+	return c.body(null, 204);
+});
+var subAgentRelations_default = app;
+
+//#endregion
+export { subAgentRelations_default as default };

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

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

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

@@ -0,0 +1,216 @@
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { speakeasyOffsetLimitPagination } from "../../../utils/speakeasy.js";
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { ErrorResponseSchema, PaginationQueryParamsSchema, SubAgentTeamAgentRelationApiInsertSchema, SubAgentTeamAgentRelationApiUpdateSchema, SubAgentTeamAgentRelationListResponse, SubAgentTeamAgentRelationResponse, TenantProjectAgentSubAgentIdParamsSchema, TenantProjectAgentSubAgentParamsSchema, commonGetErrorResponses, createApiError, createSubAgentTeamAgentRelation, deleteSubAgentTeamAgentRelation, generateId, getSubAgentTeamAgentRelationById, listSubAgentTeamAgentRelations, updateSubAgentTeamAgentRelation } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/subAgentTeamAgentRelations.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 Sub Agent Team Agent Relations",
+	operationId: "list-sub-agent-team-agent-relations",
+	tags: ["Sub Agent Team Agent Relations"],
+	request: {
+		params: TenantProjectAgentSubAgentParamsSchema,
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "List of sub agent team agent relations retrieved successfully",
+			content: { "application/json": { schema: SubAgentTeamAgentRelationListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId } = c.req.valid("param");
+	const { page = 1, limit = 10 } = c.req.valid("query");
+	const pageNum = Number(page);
+	const limitNum = Math.min(Number(limit), 100);
+	try {
+		const result = await listSubAgentTeamAgentRelations(db)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId,
+				subAgentId
+			},
+			pagination: {
+				page: pageNum,
+				limit: limitNum
+			}
+		});
+		return c.json(result);
+	} catch (_error) {
+		throw createApiError({
+			code: "internal_server_error",
+			message: "Failed to retrieve sub agent team agent relations"
+		});
+	}
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Sub Agent Team Agent Relation",
+	operationId: "get-sub-agent-team-agent-relation-by-id",
+	tags: ["Sub Agent Team Agent Relations"],
+	request: { params: TenantProjectAgentSubAgentIdParamsSchema },
+	responses: {
+		200: {
+			description: "Sub Agent team agent relation found",
+			content: { "application/json": { schema: SubAgentTeamAgentRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId, id } = c.req.valid("param");
+	const relation = await getSubAgentTeamAgentRelationById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		relationId: id
+	});
+	if (!relation) throw createApiError({
+		code: "not_found",
+		message: "Sub Agent Team Agent Relation not found"
+	});
+	return c.json({ data: relation });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Sub Agent Team Agent Relation",
+	operationId: "create-sub-agent-team-agent-relation",
+	tags: ["Sub Agent Team Agent Relations"],
+	request: {
+		params: TenantProjectAgentSubAgentParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentTeamAgentRelationApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Sub Agent Team Agent Relation created successfully",
+			content: { "application/json": { schema: SubAgentTeamAgentRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId } = c.req.valid("param");
+	const body = await c.req.valid("json");
+	if ((await listSubAgentTeamAgentRelations(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		pagination: {
+			page: 1,
+			limit: 1e3
+		}
+	})).data.some((relation$1) => relation$1.targetAgentId === body.targetAgentId && relation$1.subAgentId === subAgentId)) throw createApiError({
+		code: "unprocessable_entity",
+		message: `A relation between this sub-agent and team agent already exists`
+	});
+	const relation = await createSubAgentTeamAgentRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		relationId: generateId(),
+		data: {
+			targetAgentId: body.targetAgentId,
+			headers: body.headers || null
+		}
+	});
+	return c.json({ data: relation }, 201);
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update Sub Agent Team Agent Relation",
+	operationId: "update-sub-agent-team-agent-relation",
+	tags: ["Sub Agent Team Agent Relations"],
+	request: {
+		params: TenantProjectAgentSubAgentIdParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentTeamAgentRelationApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Sub Agent team agent relation updated successfully",
+			content: { "application/json": { schema: SubAgentTeamAgentRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId, id } = c.req.valid("param");
+	const body = await c.req.valid("json");
+	const updatedRelation = await updateSubAgentTeamAgentRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		relationId: id,
+		data: body
+	});
+	if (!updatedRelation) throw createApiError({
+		code: "not_found",
+		message: "Sub Agent Team Agent Relation not found"
+	});
+	return c.json({ data: updatedRelation });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Sub Agent Team Agent Relation",
+	operationId: "delete-sub-agent-team-agent-relation",
+	tags: ["Sub Agent Team Agent Relations"],
+	request: { params: TenantProjectAgentSubAgentIdParamsSchema },
+	responses: {
+		204: { description: "Sub Agent Team Agent Relation deleted successfully" },
+		404: {
+			description: "Sub Agent Team Agent Relation not found",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		}
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId, id } = c.req.valid("param");
+	if (!await deleteSubAgentTeamAgentRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		relationId: id
+	})) throw createApiError({
+		code: "not_found",
+		message: "Sub Agent Team Agent Relation not found"
+	});
+	return c.body(null, 204);
+});
+var subAgentTeamAgentRelations_default = app;
+
+//#endregion
+export { subAgentTeamAgentRelations_default as default };