@inkeep/agents-api 0.0.1

package/dist/.well-known/workflow/v1/step.cjs.debug.json

@@ -0,0 +1,8 @@
+{
+  "stepFiles": [
+    "/Users/andrew/Documents/code/agents/agents/agents-api/src/domains/evals/workflow/functions/runDatasetItem.ts",
+    "/Users/andrew/Documents/code/agents/agents/agents-api/dist/domains/evals/workflow/functions/evaluateConversation.js",
+    "/Users/andrew/Documents/code/agents/agents/agents-api/dist/domains/evals/workflow/functions/runDatasetItem.js",
+    "/Users/andrew/Documents/code/agents/agents/agents-api/src/domains/evals/workflow/functions/evaluateConversation.ts"
+  ]
+}

package/dist/.well-known/workflow/v1/webhook.mjs

@@ -0,0 +1,29 @@
+import { resumeWebhook } from 'workflow/api';
+
+async function handler(request) {
+  const url = new URL(request.url);
+  // Extract token from pathname: /.well-known/workflow/v1/webhook/{token}
+  const pathParts = url.pathname.split('/');
+  const token = decodeURIComponent(pathParts[pathParts.length - 1]);
+
+  if (!token) {
+    return new Response('Missing token', { status: 400 });
+  }
+
+  try {
+    const response = await resumeWebhook(token, request);
+    return response;
+  } catch (error) {
+    // TODO: differentiate between invalid token and other errors
+    console.error('Error during resumeWebhook', error);
+    return new Response(null, { status: 404 });
+  }
+}
+
+export const GET = handler;
+export const POST = handler;
+export const PUT = handler;
+export const PATCH = handler;
+export const DELETE = handler;
+export const HEAD = handler;
+export const OPTIONS = handler;

package/dist/createApp.d.ts

@@ -0,0 +1,10 @@
+import { AppConfig } from "./types/app.js";
+import "./types/index.js";
+import { Hono } from "hono";
+import * as hono_types0 from "hono/types";
+
+//#region src/createApp.d.ts
+declare const isWebhookRoute: (path: string) => boolean;
+declare function createAgentsHono(config: AppConfig): Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
+//#endregion
+export { createAgentsHono, isWebhookRoute };

package/dist/createApp.js

@@ -0,0 +1,170 @@
+import { getLogger } from "./logger.js";
+import { env } from "./env.js";
+import { evalRoutes } from "./domains/evals/index.js";
+import { workflowRoutes } from "./domains/evals/workflow/routes.js";
+import { sessionAuth, sessionContext } from "./middleware/sessionAuth.js";
+import { manageRoutes } from "./domains/manage/index.js";
+import { flushBatchProcessor } from "./instrumentation.js";
+import { runRoutes } from "./domains/run/index.js";
+import { authCorsConfig, defaultCorsConfig, playgroundCorsConfig, runCorsConfig, signozCorsConfig } from "./middleware/cors.js";
+import { errorHandler } from "./middleware/errorHandler.js";
+import { manageApiKeyAuth } from "./middleware/manageAuth.js";
+import { manageRefMiddleware, oauthRefMiddleware, runRefMiddleware, writeProtectionMiddleware } from "./middleware/ref.js";
+import { runApiKeyAuth, runApiKeyAuthExcept } from "./middleware/runAuth.js";
+import { requireTenantAccess } from "./middleware/tenantAccess.js";
+import "./middleware/index.js";
+import { branchScopedDbMiddleware } from "./middleware/branchScopedDb.js";
+import { evalApiKeyAuth } from "./middleware/evalsAuth.js";
+import { projectConfigMiddleware, projectConfigMiddlewareExcept } from "./middleware/projectConfig.js";
+import { executionBaggageMiddleware } from "./middleware/tracing.js";
+import { setupOpenAPIRoutes } from "./openapi.js";
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { requestId } from "hono/request-id";
+import { pinoLogger } from "hono-pino";
+
+//#region src/createApp.ts
+const logger = getLogger("agents-api");
+const isTestEnvironment = () => env.ENVIRONMENT === "test";
+const isWebhookRoute = (path) => {
+	return path.includes("/triggers/") && !path.endsWith("/triggers") && !path.endsWith("/triggers/");
+};
+function createAgentsHono(config) {
+	const { serverConfig, credentialStores, auth, sandboxConfig } = config;
+	const app = new OpenAPIHono();
+	app.use("*", requestId());
+	if (auth) {
+		app.use("/api/auth/*", cors(authCorsConfig));
+		app.on(["POST", "GET"], "/api/auth/*", (c) => {
+			return auth.handler(c.req.raw);
+		});
+	}
+	app.use("/run/*", cors(runCorsConfig));
+	app.use("/manage/tenants/*/playground/token", cors(playgroundCorsConfig));
+	app.use("/manage/tenants/*/signoz/*", cors(signozCorsConfig));
+	app.use("*", async (c, next) => {
+		if (auth && c.req.path.startsWith("/api/auth/")) return next();
+		if (c.req.path.startsWith("/run/")) return next();
+		if (c.req.path.includes("/playground/token")) return next();
+		if (c.req.path.includes("/signoz/")) return next();
+		return cors(defaultCorsConfig)(c, next);
+	});
+	app.use("*", async (c, next) => {
+		c.set("serverConfig", serverConfig);
+		c.set("credentialStores", credentialStores);
+		await next();
+	});
+	app.use("/manage/*", async (c, next) => {
+		c.set("auth", auth);
+		await next();
+	});
+	app.use("/run/*", async (c, next) => {
+		if (sandboxConfig) c.set("sandboxConfig", sandboxConfig);
+		await next();
+	});
+	app.use("/run/*", async (c, next) => {
+		if (c.req.header("content-type")?.includes("application/json")) try {
+			const body = await c.req.json();
+			c.set("requestBody", body);
+		} catch (error) {
+			logger.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
+		}
+		return next();
+	});
+	app.use(pinoLogger({
+		pino: getLogger("agents-api").getPinoInstance(),
+		http: { onResLevel(c) {
+			if (c.res.status >= 500) return "error";
+			if (c.req.path.includes("/signoz/")) return "debug";
+			return "info";
+		} }
+	}));
+	app.onError(errorHandler);
+	app.use("*", sessionContext());
+	app.openapi(createRoute({
+		method: "get",
+		path: "/health",
+		operationId: "health",
+		summary: "Health check",
+		description: "Check if the management service is healthy",
+		responses: { 204: { description: "Service is healthy" } }
+	}), (c) => {
+		return c.body(null, 204);
+	});
+	app.openapi(createRoute({
+		method: "get",
+		path: "/api/workflow/process",
+		tags: ["workflow"],
+		summary: "Process workflow jobs",
+		description: "Keeps the workflow worker active to process queued jobs (called by cron)",
+		responses: { 200: { description: "Processing complete" } }
+	}), async (c) => {
+		await new Promise((resolve) => setTimeout(resolve, 5e4));
+		return c.json({
+			processed: true,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	});
+	app.use("/manage/tenants/*", async (c, next) => {
+		if (env.DISABLE_AUTH || isTestEnvironment()) {
+			await next();
+			return;
+		}
+		if (c.req.header("Authorization")?.startsWith("Bearer ")) return manageApiKeyAuth()(c, next);
+		return sessionAuth()(c, next);
+	});
+	if (env.DISABLE_AUTH || isTestEnvironment()) app.use("/manage/tenants/:tenantId/*", async (c, next) => {
+		const tenantId = c.req.param("tenantId");
+		if (tenantId) {
+			c.set("tenantId", tenantId);
+			c.set("userId", "anonymous");
+		}
+		await next();
+	});
+	else app.use("/manage/tenants/:tenantId/*", requireTenantAccess());
+	app.use("/run/tenants/*", runApiKeyAuthExcept(isWebhookRoute));
+	app.use("/run/agents/*", runApiKeyAuth());
+	app.use("/run/v1/*", runApiKeyAuth());
+	app.use("/run/api/*", runApiKeyAuth());
+	app.use("/evals/tenants/*", evalApiKeyAuth());
+	app.use("/manage/tenants/*", async (c, next) => manageRefMiddleware(c, next));
+	app.use("/manage/tenants/*", (c, next) => writeProtectionMiddleware(c, next));
+	app.use("/manage/tenants/*", async (c, next) => branchScopedDbMiddleware(c, next));
+	app.use("/manage/oauth/login", async (c, next) => oauthRefMiddleware(c, next));
+	app.use("/manage/oauth/login", async (c, next) => branchScopedDbMiddleware(c, next));
+	app.use("/run/*", async (c, next) => runRefMiddleware(c, next));
+	app.use("/run/tenants/*", projectConfigMiddlewareExcept(isWebhookRoute));
+	app.use("/run/agents/*", projectConfigMiddleware);
+	app.use("/run/v1/*", projectConfigMiddleware);
+	app.use("/run/api/*", projectConfigMiddleware);
+	app.use("/run/*", async (c, next) => {
+		return executionBaggageMiddleware()(c, next);
+	});
+	app.route("/manage", manageRoutes);
+	app.route("/run", runRoutes);
+	app.route("/.well-known", workflowRoutes);
+	app.post("/index", async (c) => {
+		const originalUrl = new URL(c.req.url);
+		const bodyBuffer = await c.req.arrayBuffer();
+		const targetUrl = new URL("/.well-known/workflow/v1/flow", originalUrl.origin);
+		const forwardedRequest = new Request(targetUrl.toString(), {
+			method: "POST",
+			headers: new Headers(c.req.raw.headers),
+			body: bodyBuffer
+		});
+		return fetch(forwardedRequest);
+	});
+	app.route("/evals", evalRoutes);
+	setupOpenAPIRoutes(app);
+	app.use("/run/*", async (_c, next) => {
+		await next();
+		await flushBatchProcessor();
+	});
+	const base = new Hono();
+	base.route("/", app);
+	return base;
+}
+
+//#endregion
+export { createAgentsHono, isWebhookRoute };

package/dist/data/db/index.d.ts

@@ -0,0 +1,4 @@
+import manageDbClient from "./manageDbClient.js";
+import manageDbPool from "./manageDbPool.js";
+import runDbClient from "./runDbClient.js";
+export { manageDbClient, manageDbPool, runDbClient };

package/dist/data/db/index.js

@@ -0,0 +1,5 @@
+import manageDbClient_default from "./manageDbClient.js";
+import manageDbPool_default from "./manageDbPool.js";
+import runDbClient_default from "./runDbClient.js";
+
+export { manageDbClient_default as manageDbClient, manageDbPool_default as manageDbPool, runDbClient_default as runDbClient };

package/dist/data/db/manageDbClient.d.ts

@@ -0,0 +1,6 @@
+import * as _inkeep_agents_core0 from "@inkeep/agents-core";
+
+//#region src/data/db/manageDbClient.d.ts
+declare const manageDbClient: _inkeep_agents_core0.AgentsManageDatabaseClient;
+//#endregion
+export { manageDbClient as default };

package/dist/data/db/manageDbClient.js

@@ -0,0 +1,9 @@
+import { env } from "../../env.js";
+import { createAgentsManageDatabaseClient } from "@inkeep/agents-core";
+
+//#region src/data/db/manageDbClient.ts
+const manageDbClient = createAgentsManageDatabaseClient({ connectionString: env.INKEEP_AGENTS_MANAGE_DATABASE_URL });
+var manageDbClient_default = manageDbClient;
+
+//#endregion
+export { manageDbClient_default as default };

package/dist/data/db/manageDbPool.d.ts

@@ -0,0 +1,6 @@
+import * as pg0 from "pg";
+
+//#region src/data/db/manageDbPool.d.ts
+declare const manageDbPool: pg0.Pool;
+//#endregion
+export { manageDbPool as default };

package/dist/data/db/manageDbPool.js

@@ -0,0 +1,9 @@
+import { env } from "../../env.js";
+import { createAgentsManageDatabasePool } from "@inkeep/agents-core";
+
+//#region src/data/db/manageDbPool.ts
+const manageDbPool = createAgentsManageDatabasePool({ connectionString: env.INKEEP_AGENTS_MANAGE_DATABASE_URL });
+var manageDbPool_default = manageDbPool;
+
+//#endregion
+export { manageDbPool_default as default };

package/dist/data/db/runDbClient.d.ts

@@ -0,0 +1,6 @@
+import * as _inkeep_agents_core0 from "@inkeep/agents-core";
+
+//#region src/data/db/runDbClient.d.ts
+declare const runDbClient: _inkeep_agents_core0.AgentsRunDatabaseClient;
+//#endregion
+export { runDbClient as default };

package/dist/data/db/runDbClient.js

@@ -0,0 +1,9 @@
+import { env } from "../../env.js";
+import { createAgentsRunDatabaseClient } from "@inkeep/agents-core";
+
+//#region src/data/db/runDbClient.ts
+const runDbClient = createAgentsRunDatabaseClient({ connectionString: env.INKEEP_AGENTS_RUN_DATABASE_URL });
+var runDbClient_default = runDbClient;
+
+//#endregion
+export { runDbClient_default as default };

package/dist/domains/evals/index.d.ts

@@ -0,0 +1,13 @@
+import { AppVariables } from "../../types/app.js";
+import "../../types/index.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/domains/evals/index.d.ts
+declare function createEvalRoutes(): OpenAPIHono<{
+  Variables: AppVariables;
+}, {}, "/">;
+declare const evalRoutes: OpenAPIHono<{
+  Variables: AppVariables;
+}, {}, "/">;
+//#endregion
+export { createEvalRoutes, evalRoutes };

package/dist/domains/evals/index.js

@@ -0,0 +1,13 @@
+import routes_default from "./routes/index.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/domains/evals/index.ts
+function createEvalRoutes() {
+	const app = new OpenAPIHono();
+	app.route("/tenants/:tenantId/projects/:projectId/", routes_default);
+	return app;
+}
+const evalRoutes = createEvalRoutes();
+
+//#endregion
+export { createEvalRoutes, evalRoutes };

package/dist/domains/evals/routes/datasetTriggers.d.ts

@@ -0,0 +1,7 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import * as hono7 from "hono";
+
+//#region src/domains/evals/routes/datasetTriggers.d.ts
+declare const app: OpenAPIHono<hono7.Env, {}, "/">;
+//#endregion
+export { app as default };

package/dist/domains/evals/routes/datasetTriggers.js

@@ -0,0 +1,65 @@
+import { getLogger as getLogger$1 } from "../../../logger.js";
+import { queueDatasetRunItems } from "../services/datasetRun.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { TenantProjectParamsSchema, TriggerDatasetRunSchema } from "@inkeep/agents-core";
+
+//#region src/domains/evals/routes/datasetTriggers.ts
+const app = new OpenAPIHono();
+const logger = getLogger$1("workflow-triggers");
+app.openapi(createRoute({
+	method: "post",
+	path: "/run-dataset-items",
+	summary: "Run dataset items",
+	description: "Runs dataset items for processing through the chat API",
+	operationId: "run-dataset-items",
+	tags: ["Workflows"],
+	request: {
+		params: TenantProjectParamsSchema,
+		body: { content: { "application/json": { schema: TriggerDatasetRunSchema } } }
+	},
+	responses: {
+		202: {
+			description: "Workflows queued successfully",
+			content: { "application/json": { schema: z.object({
+				queued: z.number(),
+				failed: z.number(),
+				datasetRunId: z.string()
+			}) } }
+		},
+		400: { description: "Invalid request" },
+		500: { description: "Internal server error" }
+	}
+}), async (c) => {
+	const { tenantId, projectId } = c.req.valid("param");
+	const { datasetRunId, items, evaluatorIds, evaluationRunId } = c.req.valid("json");
+	logger.info({
+		tenantId,
+		projectId,
+		datasetRunId,
+		itemCount: items.length
+	}, "Triggering dataset run workflow");
+	const { queued, failed } = await queueDatasetRunItems({
+		tenantId,
+		projectId,
+		datasetRunId,
+		items,
+		evaluatorIds,
+		evaluationRunId
+	});
+	logger.info({
+		tenantId,
+		projectId,
+		datasetRunId,
+		queued,
+		failed
+	}, "Dataset run workflow trigger complete");
+	return c.json({
+		queued,
+		failed,
+		datasetRunId
+	}, 202);
+});
+var datasetTriggers_default = app;
+
+//#endregion
+export { datasetTriggers_default as default };

package/dist/domains/evals/routes/evaluationTriggers.d.ts

@@ -0,0 +1,11 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { ResolvedRef } from "@inkeep/agents-core";
+
+//#region src/domains/evals/routes/evaluationTriggers.d.ts
+declare const app: OpenAPIHono<{
+  Variables: {
+    resolvedRef: ResolvedRef;
+  };
+}, {}, "/">;
+//#endregion
+export { app as default };