@inkeep/agents-api 0.0.1

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

@@ -0,0 +1,202 @@
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { ArtifactComponentArrayResponse, ComponentAssociationListResponse, ErrorResponseSchema, ExistsResponseSchema, RemovedResponseSchema, SubAgentArtifactComponentApiInsertSchema, SubAgentArtifactComponentResponse, TenantProjectAgentParamsSchema, TenantProjectAgentSubAgentParamsSchema, associateArtifactComponentWithAgent, commonGetErrorResponses, createApiError, getAgentsUsingArtifactComponent, getArtifactComponentById, getArtifactComponentsForAgent, getSubAgentById, isArtifactComponentAssociatedWithAgent, removeArtifactComponentFromAgent } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/subAgentArtifactComponents.ts
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.use("/agent/:subAgentId/component/:artifactComponentId", async (c, next) => {
+	if (c.req.method === "DELETE") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/agent/{subAgentId}",
+	summary: "Get Artifact Components for Agent",
+	operationId: "get-artifact-components-for-agent",
+	tags: ["Agent Artifact Component Relations"],
+	request: { params: TenantProjectAgentSubAgentParamsSchema },
+	responses: {
+		200: {
+			description: "Artifact components retrieved successfully",
+			content: { "application/json": { schema: ArtifactComponentArrayResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId } = c.req.valid("param");
+	const artifactComponents = await getArtifactComponentsForAgent(db)({ scopes: {
+		tenantId,
+		projectId,
+		agentId,
+		subAgentId
+	} });
+	return c.json({ data: artifactComponents });
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/component/{artifactComponentId}/agents",
+	summary: "Get Agents Using Artifact Component",
+	operationId: "get-agents-using-artifact-component",
+	tags: ["Agent Artifact Component Relations"],
+	request: { params: TenantProjectAgentParamsSchema.extend({ artifactComponentId: z.string() }) },
+	responses: {
+		200: {
+			description: "Agents retrieved successfully",
+			content: { "application/json": { schema: ComponentAssociationListResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, artifactComponentId } = c.req.valid("param");
+	const agents = await getAgentsUsingArtifactComponent(db)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		artifactComponentId
+	});
+	return c.json({ data: agents });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Associate Artifact Component with Agent",
+	operationId: "associate-artifact-component-with-agent",
+	tags: ["Agent Artifact Component Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentArtifactComponentApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Agent artifact component association created successfully",
+			content: { "application/json": { schema: SubAgentArtifactComponentResponse } }
+		},
+		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, artifactComponentId } = c.req.valid("json");
+	const agent = await getSubAgentById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId
+	});
+	const artifactComponent = await getArtifactComponentById(db)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		id: artifactComponentId
+	});
+	if (!agent) throw createApiError({
+		code: "not_found",
+		message: `Agent with id '${subAgentId}' not found`
+	});
+	if (!artifactComponent) throw createApiError({
+		code: "not_found",
+		message: `Artifact component with id '${artifactComponentId}' not found`
+	});
+	if (await isArtifactComponentAssociatedWithAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		artifactComponentId
+	})) throw createApiError({
+		code: "conflict",
+		message: "Agent artifact component association already exists"
+	});
+	const association = await associateArtifactComponentWithAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		artifactComponentId
+	});
+	return c.json({ data: association }, 201);
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/agent/{subAgentId}/component/{artifactComponentId}",
+	summary: "Remove Artifact Component from Agent",
+	operationId: "remove-artifact-component-from-agent",
+	tags: ["Agent Artifact Component Relations"],
+	request: { params: TenantProjectAgentSubAgentParamsSchema.extend({ artifactComponentId: 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, artifactComponentId } = c.req.valid("param");
+	if (!await removeArtifactComponentFromAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		artifactComponentId
+	})) throw createApiError({
+		code: "not_found",
+		message: "Agent artifact component association not found"
+	});
+	return c.json({
+		message: "Association removed successfully",
+		removed: true
+	});
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/agent/{subAgentId}/component/{artifactComponentId}/exists",
+	summary: "Check if Artifact Component is Associated with Agent",
+	operationId: "check-artifact-component-agent-association",
+	tags: ["Agent Artifact Component Relations"],
+	request: { params: TenantProjectAgentSubAgentParamsSchema.extend({ artifactComponentId: 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, artifactComponentId } = c.req.valid("param");
+	const exists = await isArtifactComponentAssociatedWithAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		artifactComponentId
+	});
+	return c.json({ exists });
+});
+var subAgentArtifactComponents_default = app;
+
+//#endregion
+export { subAgentArtifactComponents_default as default };

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

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

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

@@ -0,0 +1,201 @@
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { ComponentAssociationListResponse, DataComponentArrayResponse, ErrorResponseSchema, ExistsResponseSchema, RemovedResponseSchema, SubAgentDataComponentApiInsertSchema, SubAgentDataComponentResponse, TenantProjectAgentParamsSchema, TenantProjectAgentSubAgentParamsSchema, associateDataComponentWithAgent, commonGetErrorResponses, createApiError, getAgentsUsingDataComponent, getDataComponent, getDataComponentsForAgent, getSubAgentById, isDataComponentAssociatedWithAgent, removeDataComponentFromAgent } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/subAgentDataComponents.ts
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.use("/agent/:subAgentId/component/:dataComponentId", async (c, next) => {
+	if (c.req.method === "DELETE") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/agent/{subAgentId}",
+	summary: "Get Data Components for Agent",
+	operationId: "get-data-components-for-agent",
+	tags: ["Agent Data Component Relations"],
+	request: { params: TenantProjectAgentSubAgentParamsSchema },
+	responses: {
+		200: {
+			description: "Data components retrieved successfully",
+			content: { "application/json": { schema: DataComponentArrayResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId } = c.req.valid("param");
+	const dataComponents = await getDataComponentsForAgent(db)({ scopes: {
+		tenantId,
+		projectId,
+		agentId,
+		subAgentId
+	} });
+	return c.json({ data: dataComponents });
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/component/{dataComponentId}/agents",
+	summary: "Get Agents Using Data Component",
+	operationId: "get-agents-using-data-component",
+	tags: ["Agent Data Component Relations"],
+	request: { params: TenantProjectAgentParamsSchema.extend({ dataComponentId: z.string() }) },
+	responses: {
+		200: {
+			description: "Agents retrieved successfully",
+			content: { "application/json": { schema: ComponentAssociationListResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, dataComponentId } = c.req.valid("param");
+	const agents = await getAgentsUsingDataComponent(db)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		dataComponentId
+	});
+	return c.json({ data: agents });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Associate Data Component with Agent",
+	operationId: "associate-data-component-with-agent",
+	tags: ["Agent Data Component Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentDataComponentApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Agent data component association created successfully",
+			content: { "application/json": { schema: SubAgentDataComponentResponse } }
+		},
+		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, dataComponentId } = c.req.valid("json");
+	const [agent, dataComponent] = await Promise.all([getSubAgentById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId
+	}), getDataComponent(db)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		dataComponentId
+	})]);
+	if (!agent) throw createApiError({
+		code: "not_found",
+		message: `Agent with id '${subAgentId}' not found`
+	});
+	if (!dataComponent) throw createApiError({
+		code: "not_found",
+		message: `Data component with id '${dataComponentId}' not found`
+	});
+	if (await isDataComponentAssociatedWithAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		dataComponentId
+	})) throw createApiError({
+		code: "conflict",
+		message: "Agent data component association already exists"
+	});
+	const association = await associateDataComponentWithAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		dataComponentId
+	});
+	return c.json({ data: association }, 201);
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/agent/{subAgentId}/component/{dataComponentId}",
+	summary: "Remove Data Component from Agent",
+	operationId: "remove-data-component-from-agent",
+	tags: ["Agent Data Component Relations"],
+	request: { params: TenantProjectAgentSubAgentParamsSchema.extend({ dataComponentId: 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, dataComponentId } = c.req.valid("param");
+	if (!await removeDataComponentFromAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		dataComponentId
+	})) throw createApiError({
+		code: "not_found",
+		message: "Agent data component association not found"
+	});
+	return c.json({
+		message: "Association removed successfully",
+		removed: true
+	});
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/agent/{subAgentId}/component/{dataComponentId}/exists",
+	summary: "Check if Data Component is Associated with Agent",
+	operationId: "check-data-component-agent-association",
+	tags: ["Agent Data Component Relations"],
+	request: { params: TenantProjectAgentSubAgentParamsSchema.extend({ dataComponentId: 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, dataComponentId } = c.req.valid("param");
+	const exists = await isDataComponentAssociatedWithAgent(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		dataComponentId
+	});
+	return c.json({ exists });
+});
+var subAgentDataComponents_default = app;
+
+//#endregion
+export { subAgentDataComponents_default as default };

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

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

package/dist/domains/manage/routes/subAgentExternalAgentRelations.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, SubAgentExternalAgentRelationApiInsertSchema, SubAgentExternalAgentRelationApiUpdateSchema, SubAgentExternalAgentRelationListResponse, SubAgentExternalAgentRelationResponse, TenantProjectAgentSubAgentIdParamsSchema, TenantProjectAgentSubAgentParamsSchema, commonGetErrorResponses, createApiError, createSubAgentExternalAgentRelation, deleteSubAgentExternalAgentRelation, generateId, getSubAgentExternalAgentRelationById, listSubAgentExternalAgentRelations, updateSubAgentExternalAgentRelation } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/subAgentExternalAgentRelations.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 External Agent Relations",
+	operationId: "list-sub-agent-external-agent-relations",
+	tags: ["Sub Agent External Agent Relations"],
+	request: {
+		params: TenantProjectAgentSubAgentParamsSchema,
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "List of sub agent external agent relations retrieved successfully",
+			content: { "application/json": { schema: SubAgentExternalAgentRelationListResponse } }
+		},
+		...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 listSubAgentExternalAgentRelations(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 external agent relations"
+		});
+	}
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Sub Agent External Agent Relation",
+	operationId: "get-sub-agent-external-agent-relation-by-id",
+	tags: ["Sub Agent External Agent Relations"],
+	request: { params: TenantProjectAgentSubAgentIdParamsSchema },
+	responses: {
+		200: {
+			description: "Sub Agent external agent relation found",
+			content: { "application/json": { schema: SubAgentExternalAgentRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, projectId, agentId, subAgentId, id } = c.req.valid("param");
+	const relation = await getSubAgentExternalAgentRelationById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		relationId: id
+	});
+	if (!relation) throw createApiError({
+		code: "not_found",
+		message: "Sub Agent External Agent Relation not found"
+	});
+	return c.json({ data: relation });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Sub Agent External Agent Relation",
+	operationId: "create-sub-agent-external-agent-relation",
+	tags: ["Sub Agent External Agent Relations"],
+	request: {
+		params: TenantProjectAgentSubAgentParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentExternalAgentRelationApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Sub Agent External Agent Relation created successfully",
+			content: { "application/json": { schema: SubAgentExternalAgentRelationResponse } }
+		},
+		...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 listSubAgentExternalAgentRelations(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		pagination: {
+			page: 1,
+			limit: 1e3
+		}
+	})).data.some((relation$1) => relation$1.externalAgentId === body.externalAgentId && relation$1.subAgentId === subAgentId)) throw createApiError({
+		code: "unprocessable_entity",
+		message: `A relation between this sub-agent and external agent already exists`
+	});
+	const relation = await createSubAgentExternalAgentRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		relationId: generateId(),
+		data: {
+			externalAgentId: body.externalAgentId,
+			headers: body.headers || null
+		}
+	});
+	return c.json({ data: relation }, 201);
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update Sub Agent External Agent Relation",
+	operationId: "update-sub-agent-external-agent-relation",
+	tags: ["Sub Agent External Agent Relations"],
+	request: {
+		params: TenantProjectAgentSubAgentIdParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentExternalAgentRelationApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Sub Agent external agent relation updated successfully",
+			content: { "application/json": { schema: SubAgentExternalAgentRelationResponse } }
+		},
+		...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 updateSubAgentExternalAgentRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		relationId: id,
+		data: body
+	});
+	if (!updatedRelation) throw createApiError({
+		code: "not_found",
+		message: "Sub Agent External Agent Relation not found"
+	});
+	return c.json({ data: updatedRelation });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Sub Agent External Agent Relation",
+	operationId: "delete-sub-agent-external-agent-relation",
+	tags: ["Sub Agent External Agent Relations"],
+	request: { params: TenantProjectAgentSubAgentIdParamsSchema },
+	responses: {
+		204: { description: "Sub Agent External Agent Relation deleted successfully" },
+		404: {
+			description: "Sub Agent External 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 deleteSubAgentExternalAgentRelation(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		relationId: id
+	})) throw createApiError({
+		code: "not_found",
+		message: "Sub Agent External Agent Relation not found"
+	});
+	return c.body(null, 204);
+});
+var subAgentExternalAgentRelations_default = app;
+
+//#endregion
+export { subAgentExternalAgentRelations_default as default };

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

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