@inkeep/agents-manage-api 0.39.5 → 0.41.0

package/dist/routes/projects.js

@@ -0,0 +1,188 @@
+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, ProjectApiInsertSchema, ProjectApiUpdateSchema, ProjectListResponse, ProjectResponse, TenantIdParamsSchema, TenantParamsSchema, commonGetErrorResponses, createApiError, createProject, deleteProject, getProject, listProjectsPaginated, updateProject } from "@inkeep/agents-core";
+
+//#region src/routes/projects.ts
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requirePermission({ project: ["create"] })(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "PATCH") return requirePermission({ project: ["update"] })(c, next);
+	if (c.req.method === "DELETE") return requirePermission({ project: ["delete"] })(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/",
+	summary: "List Projects",
+	description: "List all projects within a tenant with pagination",
+	operationId: "list-projects",
+	tags: ["Projects"],
+	request: {
+		params: TenantParamsSchema,
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "List of projects retrieved successfully",
+			content: { "application/json": { schema: ProjectListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const { tenantId } = 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 listProjectsPaginated(dbClient_default)({
+		tenantId,
+		pagination: {
+			page,
+			limit
+		}
+	});
+	return c.json(result);
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Project",
+	description: "Get a single project by ID",
+	operationId: "get-project-by-id",
+	tags: ["Projects"],
+	request: { params: TenantIdParamsSchema },
+	responses: {
+		200: {
+			description: "Project found",
+			content: { "application/json": { schema: ProjectResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, id } = c.req.valid("param");
+	const project = await getProject(dbClient_default)({ scopes: {
+		tenantId,
+		projectId: id
+	} });
+	if (!project) throw createApiError({
+		code: "not_found",
+		message: "Project not found"
+	});
+	return c.json({ data: project });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Project",
+	description: "Create a new project",
+	operationId: "create-project",
+	tags: ["Projects"],
+	request: {
+		params: TenantParamsSchema,
+		body: { content: { "application/json": { schema: ProjectApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Project created successfully",
+			content: { "application/json": { schema: ProjectResponse } }
+		},
+		409: {
+			description: "Project already exists",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId } = c.req.valid("param");
+	const body = c.req.valid("json");
+	try {
+		const project = await createProject(dbClient_default)({
+			tenantId,
+			...body
+		});
+		return c.json({ data: project }, 201);
+	} catch (error) {
+		if (error?.cause?.code === "23505") throw createApiError({
+			code: "conflict",
+			message: "Project with this ID already exists"
+		});
+		throw error;
+	}
+});
+app.openapi(createRoute({
+	method: "patch",
+	path: "/{id}",
+	summary: "Update Project",
+	description: "Update an existing project",
+	operationId: "update-project",
+	tags: ["Projects"],
+	request: {
+		params: TenantIdParamsSchema,
+		body: { content: { "application/json": { schema: ProjectApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Project updated successfully",
+			content: { "application/json": { schema: ProjectResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, id } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const project = await updateProject(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId: id
+		},
+		data: body
+	});
+	if (!project) throw createApiError({
+		code: "not_found",
+		message: "Project not found"
+	});
+	return c.json({ data: project });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Project",
+	description: "Delete a project. Will fail if the project has existing resources.",
+	operationId: "delete-project",
+	tags: ["Projects"],
+	request: { params: TenantIdParamsSchema },
+	responses: {
+		204: { description: "Project deleted successfully" },
+		409: {
+			description: "Cannot delete project with existing resources",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, id } = c.req.valid("param");
+	try {
+		if (!await deleteProject(dbClient_default)({ scopes: {
+			tenantId,
+			projectId: id
+		} })) throw createApiError({
+			code: "not_found",
+			message: "Project not found"
+		});
+		return c.body(null, 204);
+	} catch (error) {
+		if (error.message?.includes("Cannot delete project with existing resources")) throw createApiError({
+			code: "conflict",
+			message: "Cannot delete project with existing resources"
+		});
+		throw error;
+	}
+});
+var projects_default = app;
+
+//#endregion
+export { projects_default as default };

package/dist/routes/shared.d.ts

@@ -0,0 +1,93 @@
+//#region src/routes/shared.d.ts
+/**
+ * Shared route configurations and helpers
+ */
+/**
+ * Speakeasy pagination input configuration
+ */
+type SpeakeasyPaginationInput = {
+  name: string;
+  in: 'parameters' | 'requestBody';
+  type: 'page' | 'limit' | 'offset' | 'cursor';
+};
+/**
+ * Speakeasy pagination output configuration
+ * Uses JSONPath expressions to locate pagination values in the response
+ */
+type SpeakeasyPaginationOutputs = {
+  numPages?: string;
+  nextCursor?: string;
+  results?: string;
+};
+/**
+ * Speakeasy pagination extension type
+ */
+type SpeakeasyPaginationExtension = {
+  'x-speakeasy-pagination': {
+    type: 'offsetLimit' | 'cursor';
+    inputs: SpeakeasyPaginationInput[];
+    outputs: SpeakeasyPaginationOutputs;
+  };
+};
+/**
+ * Standard pagination response shape that all paginated endpoints should return.
+ * This ensures consistency with the JSONPath '$.pagination.pages' in the Speakeasy extension.
+ */
+type StandardPaginationResponse<T> = {
+  data: T[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+};
+/**
+ * Creates a Speakeasy pagination extension configuration.
+ * This factory function allows for different pagination strategies while maintaining type safety.
+ *
+ * @example
+ * ```ts
+ * // Offset-limit pagination (default)
+ * const pagination = createSpeakeasyPagination('offsetLimit');
+ *
+ * // Cursor-based pagination (future use)
+ * const cursorPagination = createSpeakeasyPagination('cursor', {
+ *   inputs: [
+ *     { name: 'cursor', in: 'parameters', type: 'cursor' },
+ *     { name: 'limit', in: 'parameters', type: 'limit' },
+ *   ],
+ *   outputs: { nextCursor: '$.pagination.nextCursor' },
+ * });
+ * ```
+ */
+declare function createSpeakeasyPagination(type: 'offsetLimit', config?: Partial<{
+  inputs: SpeakeasyPaginationInput[];
+  outputs: SpeakeasyPaginationOutputs;
+}>): SpeakeasyPaginationExtension;
+declare function createSpeakeasyPagination(type: 'cursor', config: {
+  inputs: SpeakeasyPaginationInput[];
+  outputs: SpeakeasyPaginationOutputs;
+}): SpeakeasyPaginationExtension;
+/**
+ * Speakeasy pagination extension for offset-limit pagination.
+ * Use this in createRoute() calls for list endpoints that support pagination.
+ *
+ * IMPORTANT: Endpoints using this extension MUST return responses matching
+ * the StandardPaginationResponse<T> shape with data from a *Paginated() function
+ * (e.g., listAgentsPaginated, listProjectsPaginated) to ensure the JSONPath
+ * '$.pagination.pages' correctly resolves.
+ *
+ * @example
+ * ```ts
+ * createRoute({
+ *   method: 'get',
+ *   path: '/',
+ *   // ... other config
+ *   ...speakeasyOffsetLimitPagination,
+ * })
+ * ```
+ */
+declare const speakeasyOffsetLimitPagination: SpeakeasyPaginationExtension;
+//#endregion
+export { StandardPaginationResponse, createSpeakeasyPagination, speakeasyOffsetLimitPagination };

package/dist/routes/shared.js

@@ -0,0 +1,44 @@
+//#region src/routes/shared.ts
+function createSpeakeasyPagination(type, config) {
+	if (type === "offsetLimit") return { "x-speakeasy-pagination": {
+		type: "offsetLimit",
+		inputs: config?.inputs ?? [{
+			name: "page",
+			in: "parameters",
+			type: "page"
+		}, {
+			name: "limit",
+			in: "parameters",
+			type: "limit"
+		}],
+		outputs: config?.outputs ?? { numPages: "$.pagination.pages" }
+	} };
+	return { "x-speakeasy-pagination": {
+		type: "cursor",
+		inputs: config?.inputs ?? [],
+		outputs: config?.outputs ?? {}
+	} };
+}
+/**
+* Speakeasy pagination extension for offset-limit pagination.
+* Use this in createRoute() calls for list endpoints that support pagination.
+*
+* IMPORTANT: Endpoints using this extension MUST return responses matching
+* the StandardPaginationResponse<T> shape with data from a *Paginated() function
+* (e.g., listAgentsPaginated, listProjectsPaginated) to ensure the JSONPath
+* '$.pagination.pages' correctly resolves.
+*
+* @example
+* ```ts
+* createRoute({
+*   method: 'get',
+*   path: '/',
+*   // ... other config
+*   ...speakeasyOffsetLimitPagination,
+* })
+* ```
+*/
+const speakeasyOffsetLimitPagination = createSpeakeasyPagination("offsetLimit");
+
+//#endregion
+export { createSpeakeasyPagination, speakeasyOffsetLimitPagination };

package/dist/routes/signoz.d.ts

@@ -0,0 +1,10 @@
+import { BaseAppVariables } from "../types/app.js";
+import { Hono } from "hono";
+import * as hono_types3 from "hono/types";
+
+//#region src/routes/signoz.d.ts
+declare const app: Hono<{
+  Variables: BaseAppVariables;
+}, hono_types3.BlankSchema, "/">;
+//#endregion
+export { app as default };

package/dist/routes/signoz.js

@@ -0,0 +1,155 @@
+import { env } from "../env.js";
+import { getLogger as getLogger$1 } from "../logger.js";
+import dbClient_default from "../data/db/dbClient.js";
+import { enforceProjectFilter } from "../utils/signoz-helpers.js";
+import { Hono } from "hono";
+import { projectExists } from "@inkeep/agents-core";
+import axios from "axios";
+
+//#region src/routes/signoz.ts
+const logger = getLogger$1("signoz-proxy");
+const app = new Hono();
+app.post("/query", async (c) => {
+	let payload = await c.req.json();
+	const requestedProjectId = payload.projectId;
+	const tenantId = c.get("tenantId");
+	logger.info({
+		tenantId,
+		projectId: requestedProjectId,
+		hasProjectId: !!requestedProjectId
+	}, "Processing SigNoz query request");
+	if (requestedProjectId) {
+		if (!await projectExists(dbClient_default)({
+			tenantId,
+			projectId: requestedProjectId
+		})) {
+			logger.warn({
+				tenantId,
+				projectId: requestedProjectId
+			}, "Project not found or access denied");
+			return c.json({
+				error: "Forbidden",
+				message: "You do not have access to this project"
+			}, 403);
+		}
+		payload = enforceProjectFilter(payload, requestedProjectId);
+		logger.debug({ projectId: requestedProjectId }, "Project filter enforced");
+	}
+	const signozUrl = env.SIGNOZ_URL || env.PUBLIC_SIGNOZ_URL;
+	const signozApiKey = env.SIGNOZ_API_KEY;
+	if (!signozUrl || !signozApiKey) {
+		logger.error({}, "SigNoz not configured");
+		return c.json({
+			error: "Service Unavailable",
+			message: "SigNoz is not configured"
+		}, 500);
+	}
+	try {
+		const signozEndpoint = `${signozUrl}/api/v4/query_range`;
+		logger.debug({ endpoint: signozEndpoint }, "Proxying to SigNoz");
+		const response = await axios.post(signozEndpoint, payload, {
+			headers: {
+				"Content-Type": "application/json",
+				"SIGNOZ-API-KEY": signozApiKey
+			},
+			timeout: 3e4
+		});
+		logger.info({ status: response.status }, "SigNoz query successful");
+		return c.json(response.data);
+	} catch (error) {
+		if (axios.isAxiosError(error)) {
+			if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+				logger.error({ error: error.message }, "SigNoz service unavailable");
+				return c.json({
+					error: "Service Unavailable",
+					message: "SigNoz service is unavailable"
+				}, 503);
+			}
+			if (error.response?.status === 401 || error.response?.status === 403) {
+				logger.error({ status: error.response.status }, "SigNoz authentication failed");
+				return c.json({
+					error: "Internal Server Error",
+					message: "SigNoz authentication failed"
+				}, 500);
+			}
+			if (error.response?.status === 400) {
+				logger.warn({ status: error.response.status }, "Invalid SigNoz query");
+				return c.json({
+					error: "Bad Request",
+					message: "Invalid query parameters"
+				}, 400);
+			}
+		}
+		logger.error({ error }, "SigNoz query failed");
+		return c.json({
+			error: "Internal Server Error",
+			message: "Failed to query SigNoz"
+		}, 500);
+	}
+});
+app.get("/health", async (c) => {
+	const signozUrl = env.SIGNOZ_URL || env.PUBLIC_SIGNOZ_URL;
+	const signozApiKey = env.SIGNOZ_API_KEY;
+	logger.info({
+		hasUrl: !!signozUrl,
+		hasApiKey: !!signozApiKey,
+		url: signozUrl
+	}, "Checking SigNoz configuration");
+	if (!signozUrl || !signozApiKey) {
+		logger.warn({}, "SigNoz credentials not set");
+		return c.json({
+			status: "not_configured",
+			configured: false,
+			error: "SIGNOZ_URL or SIGNOZ_API_KEY not set"
+		});
+	}
+	try {
+		const testPayload = {
+			start: Date.now() - 3e5,
+			end: Date.now(),
+			step: 60,
+			compositeQuery: {
+				queryType: "builder",
+				panelType: "table",
+				builderQueries: {}
+			}
+		};
+		const signozEndpoint = `${signozUrl}/api/v4/query_range`;
+		logger.info({ endpoint: signozEndpoint }, "Testing SigNoz connection");
+		await axios.post(signozEndpoint, testPayload, {
+			headers: {
+				"Content-Type": "application/json",
+				"SIGNOZ-API-KEY": signozApiKey
+			},
+			timeout: 5e3,
+			validateStatus: (status) => status === 200 || status === 400
+		});
+		logger.info({}, "SigNoz health check successful");
+		return c.json({
+			status: "ok",
+			configured: true
+		});
+	} catch (error) {
+		logger.error({
+			error,
+			message: error instanceof Error ? error.message : "Unknown error",
+			code: axios.isAxiosError(error) ? error.code : void 0,
+			status: axios.isAxiosError(error) ? error.response?.status : void 0
+		}, "SigNoz connection test failed");
+		let errorMessage = "Failed to connect to SigNoz";
+		if (axios.isAxiosError(error)) {
+			if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") errorMessage = "Check SIGNOZ_URL";
+			else if (error.response?.status === 401 || error.response?.status === 403) errorMessage = "Invalid SIGNOZ_API_KEY";
+			else if (error.code === "ETIMEDOUT" || error.code === "ECONNABORTED") errorMessage = "SigNoz connection timed out";
+		}
+		return c.json({
+			status: "connection_failed",
+			configured: false,
+			error: errorMessage
+		});
+	}
+});
+var signoz_default = app;
+
+//#endregion
+export { signoz_default as default };

package/dist/routes/subAgentArtifactComponents.d.ts

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

package/dist/routes/subAgentArtifactComponents.js

@@ -0,0 +1,198 @@
+import dbClient_default from "../data/db/dbClient.js";
+import { requirePermission } from "../middleware/require-permission.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/routes/subAgentArtifactComponents.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("/agent/:subAgentId/component/:artifactComponentId", async (c, next) => {
+	if (c.req.method === "DELETE") return requirePermission({ sub_agent: ["delete"] })(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 { tenantId, projectId, agentId, subAgentId } = c.req.valid("param");
+	const artifactComponents = await getArtifactComponentsForAgent(dbClient_default)({ 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 { tenantId, projectId, artifactComponentId } = c.req.valid("param");
+	const agents = await getAgentsUsingArtifactComponent(dbClient_default)({
+		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 { tenantId, projectId, agentId } = c.req.valid("param");
+	const { subAgentId, artifactComponentId } = c.req.valid("json");
+	const agent = await getSubAgentById(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		subAgentId
+	});
+	const artifactComponent = await getArtifactComponentById(dbClient_default)({
+		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(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		artifactComponentId
+	})) throw createApiError({
+		code: "conflict",
+		message: "Agent artifact component association already exists"
+	});
+	const association = await associateArtifactComponentWithAgent(dbClient_default)({
+		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 { tenantId, projectId, agentId, subAgentId, artifactComponentId } = c.req.valid("param");
+	if (!await removeArtifactComponentFromAgent(dbClient_default)({
+		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 { tenantId, projectId, agentId, subAgentId, artifactComponentId } = c.req.valid("param");
+	const exists = await isArtifactComponentAssociatedWithAgent(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		},
+		artifactComponentId
+	});
+	return c.json({ exists });
+});
+var subAgentArtifactComponents_default = app;
+
+//#endregion
+export { subAgentArtifactComponents_default as default };