@plasm_lang/vercel-agent 0.3.63

package/src/index.ts

@@ -0,0 +1,296 @@
+export {
+  createAgentFromDefinition,
+  createAgentFromProject,
+  createPlasmAgentConfig,
+  defineAgent,
+  resolveAgentDefinition,
+} from "./define-agent.js";
+export type {
+  AgentBuildConfig,
+  AgentCompactionConfig,
+  AgentDefinition,
+  AgentExperimentalConfig,
+  AgentModelOptions,
+  AgentWorkflowDefinition,
+  AgentWorkflowWorldDefinition,
+  CreateAgentFromDefinitionOptions,
+  ResolvedAgentDefinition,
+} from "./define-agent.js";
+
+export {
+  createAuthoringContext,
+} from "./authoring/context.js";
+export type { AuthoringContext, CreateAuthoringContextOptions } from "./authoring/context.js";
+export { defineChannel, validateChannelRoute, isChannelDefinition } from "./authoring/define-channel.js";
+export type {
+  ChannelDefinition,
+  ChannelHandler,
+  ChannelRoute,
+  DefineChannelInput,
+  HttpMethod,
+} from "./authoring/define-channel.js";
+export { defineHook, isHookDefinition } from "./authoring/define-hook.js";
+export type { DefineHookInput, HookDefinition, HookEvent, HookHandler } from "./authoring/define-hook.js";
+export { HookRunner } from "./authoring/hook-runner.js";
+export { defineSchedule, cronIntervalMs, isScheduleDefinition } from "./authoring/define-schedule.js";
+export type { DefineScheduleInput, ScheduleDefinition, ScheduleHandler } from "./authoring/define-schedule.js";
+export { defineSkill, isSkillDefinition } from "./authoring/define-skill.js";
+export type { DefineSkillInput, SkillDefinition } from "./authoring/define-skill.js";
+export {
+  loadAuthoredSlots,
+  summarizeLoadedSlots,
+} from "./authoring/slot-loader.js";
+export type {
+  LoadedChannel,
+  LoadedHook,
+  LoadedProjectSlots,
+  LoadedSchedule,
+  LoadedSkill,
+  LoadedSlotsSummary,
+  LoadAuthoredSlotsOptions,
+} from "./authoring/slot-loader.js";
+export { tryHandleChannelRoute, listChannelRoutes } from "./authoring/channel-dispatch.js";
+export {
+  exportScheduleCronManifest,
+  startScheduleTimers,
+  tryHandleScheduleCronRoute,
+} from "./authoring/schedule-manager.js";
+export type { ScheduleCronManifest, ScheduleHandle } from "./authoring/schedule-manager.js";
+export {
+  createSubagentRegistry,
+  loadSubagents,
+  summarizeSubagents,
+} from "./authoring/subagent-loader.js";
+export type { LoadedSubagent, SubagentRegistry } from "./authoring/subagent-loader.js";
+export { createHarnessTools, renderSkillIndex } from "./tools/harness-tools.js";
+export { maybeCompactMessages } from "./runtime/compaction.js";
+
+export { defineEval, isEvalDefinition } from "./evals/define-eval.js";
+export type { DefineEvalInput, EvalAssert, EvalDefinition, EvalToolName } from "./evals/define-eval.js";
+export {
+  discoverEvalFiles,
+  runAllEvals,
+  runEval,
+  runEvalFile,
+  requireLiveEvalGateway,
+} from "./evals/run-eval.js";
+export type { EvalRunResult } from "./evals/run-eval.js";
+
+export {
+  authoredSlots,
+  walkAgentProject,
+} from "./discovery/project-walker.js";
+export type {
+  AuthoredSlot,
+  DiscoveredCatalog,
+  DiscoveredInstructions,
+  DiscoveredNamedFile,
+  DiscoveredSubagent,
+  DiscoveryDiagnostic,
+  ProjectDiscovery,
+} from "./discovery/project-walker.js";
+
+export { createDevServer, startDevServer } from "./dev/server.js";
+export type { DevServerHandle, DevServerOptions } from "./dev/server.js";
+
+export {
+  createPlasmApp,
+  handlePlasmRequest,
+  handlePlasmOperatorRequest,
+  normalizePlasmPathname,
+  rewriteRequestPath,
+  vercelPlasmHandler,
+} from "./server/plasm-handler.js";
+export type { PlasmApp, PlasmAppMode, PlasmAppOptions, VercelHandler } from "./server/plasm-handler.js";
+
+export { SymbolRegistry } from "./symbol-registry.js";
+export type { SymbolBinding, SymbolKind, SymbolRegistrySnapshot } from "./symbol-registry.js";
+
+export {
+  LocalSessionStore,
+  SessionManager,
+} from "./session-state.js";
+export type {
+  AgentSessionState,
+  ExecuteSessionRef,
+  SessionStore,
+  TeachingWave,
+} from "./session-state.js";
+
+export {
+  CatalogManifestSchema,
+  FilesystemCatalogLoader,
+} from "./catalog/loader.js";
+export type {
+  CatalogLoader,
+  CatalogManifest,
+  LoadedCatalog,
+} from "./catalog/loader.js";
+
+export { StubPlasmEngine, NapiPlasmEngine, createEngine, isNativeEngineAvailable } from "./engine/napi-binding.js";
+export { createDefaultHostTransport } from "./engine/host-transport.js";
+export type { HostTransportOptions } from "./engine/host-transport.js";
+export { createProductionHostTransport } from "./engine/create-host-transport.js";
+export { loadAgentEnv } from "./load-env.js";
+export {
+  connectorUidForEntry,
+  connectAuthOptionsForEntry,
+  resolveConnectBearer,
+  ConnectAuthorizationRequiredError,
+} from "./engine/connect-auth.js";
+export type { ConnectAuthOptions, ConnectTokenSubject } from "./engine/connect-auth.js";
+export type {
+  DryRunResult,
+  HostTransportFn,
+  HostTransportRequest,
+  HostTransportResponse,
+  PlasmEngine,
+  ResolvedPlanPayload,
+  TeachingExposureResult,
+} from "./engine/napi-binding.js";
+
+export {
+  PlasmSpanAttributes,
+  createAgentTelemetry,
+  registerAgentInstrumentation,
+} from "./instrumentation.js";
+export type { AgentInstrumentationOptions } from "./instrumentation.js";
+
+export { AgentRuntime } from "./runtime/agent-runtime.js";
+export type {
+  AgentArchiveStore,
+  AgentRuntimeConfig,
+  DiscoverInput,
+  PlasmContextInput,
+  PlasmPlanInput,
+  PlasmRunInput,
+} from "./runtime/agent-runtime.js";
+
+export { PlasmAgent } from "./runtime/plasm-agent.js";
+export type { AgentTurnResult, PlasmAgentConfig } from "./runtime/plasm-agent.js";
+
+export {
+  formatLogicalSessionWireRef,
+  mintLogicalSessionId,
+  parseLogicalSessionWireRef,
+} from "./runtime/logical-session.js";
+
+export { createPlasmTools } from "./tools/plasm-tools.js";
+export type { PlasmTools } from "./tools/plasm-tools.js";
+
+export {
+  DISCOVER_TOOL_DESCRIPTION,
+  PLASM_CONTEXT_TOOL_DESCRIPTION,
+  PLASM_RUN_TOOL_DESCRIPTION,
+  PLASM_TOOL_DESCRIPTION,
+} from "./tools/descriptions.js";
+
+export { createOperatorRoutes, nitroOperatorHandler } from "./operator/routes.js";
+export { renderOperatorShell } from "./operator/ui-shell.js";
+export type { NitroHandler, OperatorHandler, OperatorRouteContext } from "./operator/routes.js";
+
+export {
+  createAgentStateStore,
+  resolveStateBackend,
+} from "./state/define-state.js";
+export type { AgentStateStore, StateBackend } from "./state/define-state.js";
+
+export {
+  bootstrapWorkflowWorld,
+  resolveWorkflowWorldType,
+} from "./workflow/world-bootstrap.js";
+export type { WorkflowWorldType } from "./workflow/world-bootstrap.js";
+
+export {
+  LocalArchiveStore,
+  computeRunId,
+  resolveArchivePaths,
+  UnimplementedBlobArchiveAdapter,
+  UnimplementedKvArchiveIndexAdapter,
+} from "./archive/index.js";
+export { createArchiveStore, resolveArchiveBackend } from "./archive/resolve-backend.js";
+export { ProdArchiveStore } from "./archive/prod-archive-store.js";
+export { VercelBlobArchiveAdapter } from "./archive/vercel-blob-adapter.js";
+export { VercelKvArchiveIndexAdapter } from "./archive/vercel-kv-adapter.js";
+export { PostgresArchiveIndexAdapter } from "./archive/postgres-kv-adapter.js";
+export type {
+  ArchivePaths,
+  BlobArchiveAdapter,
+  KvArchiveIndexAdapter,
+  PlanArchiveSnapshot,
+  RunSnapshot,
+  RunIdBundle,
+  TraceDetail,
+  TraceRecord,
+  TraceSummary,
+} from "./archive/index.js";
+
+export { plasmSpans, withPlasmSpan, activeTraceId } from "./telemetry/plasm-spans.js";
+export type { PlasmSpanContext } from "./telemetry/plasm-spans.js";
+export type {
+  OperatorCatalogEntry,
+  OperatorCatalogsResponse,
+  OperatorHealthResponse,
+  OperatorOpsResponse,
+  OperatorPlanCommit,
+  OperatorPlansResponse,
+  OperatorSessionEntry,
+  OperatorSessionsResponse,
+  OperatorStubFreshness,
+} from "./operator/types.js";
+
+export {
+  computeCatalogCgsHash,
+  generateAllStubs,
+  generateStubForCatalog,
+  parseCgsDomain,
+  parseDomainYaml,
+  readStubProvenance,
+  renderStubModule,
+  stubFreshness,
+} from "./stubs/generator.js";
+export type {
+  ParsedCapability,
+  ParsedCgsDomain,
+  ParsedDomain,
+  ParsedEntity,
+  StubGenerationResult,
+  StubProvenance,
+} from "./stubs/generator.js";
+
+export {
+  assignCapabilityBindings,
+  assignEntitySymbols,
+  stubEntityNames,
+} from "./stubs/stub-symbols.js";
+export type { CapabilityBinding, EntitySymbolBinding } from "./stubs/stub-symbols.js";
+
+export {
+  valueDomainToTsType,
+  renderEntityType,
+  renderCapabilityInputType,
+} from "./stubs/cgs-ts-types.js";
+
+export {
+  createCatalogClient,
+  dryRunProgram,
+  ensureCatalogLoaded,
+  ensureStubSession,
+  executeRows,
+  buildDottedArgs,
+  plasmLiteral,
+  plasmNumber,
+  plasmBoolean,
+} from "./stubs/catalog-client.js";
+export type {
+  CatalogClientOptions,
+  ExecuteRowsResult,
+  StubInvokeOptions,
+} from "./stubs/catalog-client.js";
+
+export { createProgramBuilder } from "./stubs/program-builder.js";
+export type {
+  ProgramBuilder,
+  ProgramBuilderOptions,
+  ProgramBuilderProvenance,
+} from "./stubs/program-builder.js";

package/src/instrumentation.ts

@@ -0,0 +1,56 @@
+import { OpenTelemetryIntegration } from "@ai-sdk/otel";
+import type { AttributeValue } from "@opentelemetry/api";
+import {
+  registerTelemetryIntegration,
+  type TelemetryIntegration,
+  type TelemetrySettings,
+} from "ai";
+
+/** OpenTelemetry attribute keys for Plasm agent spans (Section 9). */
+export const PlasmSpanAttributes = {
+  SESSION_ID: "plasm.session_id",
+  INTENT: "plasm.intent",
+  LOGICAL_SESSION_REF: "plasm.logical_session_ref",
+  CATALOG_CGS_HASH: "plasm.catalog_cgs_hash",
+  PLAN_COMMIT_REF: "plasm.plan_commit_ref",
+  RUN_ID: "plasm.run_id",
+  ENTRY_ID: "plasm.entry_id",
+  TOOL_NAME: "plasm.tool.name",
+  TRANSPORT_HOST: "plasm.transport.host",
+  TRANSPORT_STATUS: "plasm.transport.status",
+} as const;
+
+export interface AgentInstrumentationOptions {
+  serviceName?: string;
+  tracer?: TelemetrySettings["tracer"];
+}
+
+let registered = false;
+
+function otelIntegration(options: AgentInstrumentationOptions): TelemetryIntegration {
+  return new OpenTelemetryIntegration({ tracer: options.tracer }) as unknown as TelemetryIntegration;
+}
+
+/** Register global AI SDK OTEL integration (eve-style auto-discovered instrumentation). */
+export function registerAgentInstrumentation(
+  options: AgentInstrumentationOptions = {},
+): void {
+  if (registered) return;
+  registerTelemetryIntegration(otelIntegration(options));
+  registered = true;
+  void options.serviceName;
+}
+
+/** Per-call AI SDK telemetry settings with OpenTelemetry integration. */
+export function createAgentTelemetry(
+  options: AgentInstrumentationOptions = {},
+): TelemetrySettings {
+  registerAgentInstrumentation(options);
+  return {
+    isEnabled: true,
+    metadata: {
+      "service.name": options.serviceName ?? "plasm-agent",
+    } satisfies Record<string, AttributeValue>,
+    integrations: otelIntegration(options),
+  };
+}

package/src/load-env.ts

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+/** Repo root (`plasm/`) from `packages/plasm-agent`. */
+export function defaultEnvFileCandidates(): string[] {
+  return [
+    path.join(packageRoot, ".env"),
+    path.join(packageRoot, "../../.env"),
+    path.join(packageRoot, "../../../.env"),
+    path.join(packageRoot, "agent", ".env"),
+  ];
+}
+
+function parseEnvLine(line: string): { key: string; value: string } | null {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) return null;
+  const withoutExport = trimmed.startsWith("export ")
+    ? trimmed.slice("export ".length).trim()
+    : trimmed;
+  const eq = withoutExport.indexOf("=");
+  if (eq <= 0) return null;
+  const key = withoutExport.slice(0, eq).trim();
+  let value = withoutExport.slice(eq + 1).trim();
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    value = value.slice(1, -1);
+  }
+  return { key, value };
+}
+
+/** Load `.env` into `process.env` without overriding existing variables. */
+export function loadAgentEnv(files: string[] = defaultEnvFileCandidates()): string | undefined {
+  let loaded: string | undefined;
+  for (const file of files) {
+    if (!existsSync(file)) continue;
+    const text = readFileSync(file, "utf8");
+    for (const line of text.split(/\r?\n/)) {
+      const parsed = parseEnvLine(line);
+      if (!parsed) continue;
+      if (process.env[parsed.key] === undefined) {
+        process.env[parsed.key] = parsed.value;
+      }
+    }
+    loaded = file;
+  }
+
+  // User alias → Vercel AI Gateway canonical name.
+  if (!process.env.AI_GATEWAY_API_KEY?.trim()) {
+    const alias =
+      process.env.AI_API_GATEWAY_KEY?.trim() ??
+      process.env.AI_GATEWAY_KEY?.trim();
+    if (alias) {
+      process.env.AI_GATEWAY_API_KEY = alias;
+    }
+  }
+
+  return loaded;
+}

package/src/operator/routes.ts

@@ -0,0 +1,287 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+import { FilesystemCatalogLoader } from "../catalog/loader.js";
+import type { LoadedCatalog } from "../catalog/loader.js";
+import { isNativeEngineAvailable } from "../engine/napi-binding.js";
+import { AgentRuntime } from "../runtime/agent-runtime.js";
+import { createAgentStateStore } from "../state/define-state.js";
+import {
+  parseDomainYaml,
+  stubFreshness,
+} from "../stubs/generator.js";
+import { resolveCatalogLiveHash } from "../stubs/catalog-hash.js";
+
+import type {
+  OperatorCatalogsResponse,
+  OperatorHealthResponse,
+  OperatorOpsResponse,
+  OperatorPlansResponse,
+  OperatorSessionsResponse,
+} from "./types.js";
+
+export type NitroHandler = (event: {
+  req: { method?: string; url?: string };
+  res: { statusCode: number; end: (body: string) => void };
+}) => void | Promise<void>;
+
+export interface OperatorRouteContext {
+  agentRoot: string;
+  tenantScope?: string;
+  /** Pre-bootstrapped runtime; when omitted, catalog routes bootstrap on first request. */
+  runtime?: AgentRuntime;
+}
+
+export interface OperatorHandler {
+  health(): Promise<OperatorHealthResponse>;
+  listCatalogs(): Promise<OperatorCatalogsResponse>;
+  listSessions(): Promise<OperatorSessionsResponse>;
+  listPlans(): Promise<OperatorPlansResponse>;
+  ops(): Promise<OperatorOpsResponse>;
+  listTraces(): Promise<{ traces: unknown[] }>;
+  listArchives(): Promise<{ plans: unknown[]; runs: unknown[]; paths: unknown }>;
+  listRuns(): Promise<{ runs: unknown[] }>;
+}
+
+interface BootstrappedCatalog {
+  catalog: LoadedCatalog;
+  catalogCgsHash: string;
+  authScheme?: string;
+  entityCount: number;
+  capabilityCount: number;
+}
+
+async function resolveLiveHash(catalog: LoadedCatalog, runtime?: AgentRuntime): Promise<string> {
+  if (catalog.manifest.cgsHash) return catalog.manifest.cgsHash;
+  if (runtime) {
+    const loaded = runtime.listCatalogs().find((c) => c.manifest.entryId === catalog.manifest.entryId);
+    if (loaded?.manifest.cgsHash) return loaded.manifest.cgsHash;
+  }
+  return resolveCatalogLiveHash(catalog.rootDir);
+}
+
+async function bootstrapCatalogs(ctx: OperatorRouteContext): Promise<BootstrappedCatalog[]> {
+  let runtime = ctx.runtime;
+  if (!runtime) {
+    runtime = new AgentRuntime({ agentRoot: ctx.agentRoot });
+    await runtime.bootstrap();
+    ctx.runtime = runtime;
+  }
+
+  const loader = new FilesystemCatalogLoader();
+  const discovered = await loader.discover(ctx.agentRoot);
+  const loaded = runtime.listCatalogs();
+
+  const byEntry = new Map<string, LoadedCatalog>();
+  for (const catalog of [...discovered, ...loaded]) {
+    byEntry.set(catalog.manifest.entryId, catalog);
+  }
+
+  const bootstrapped: BootstrappedCatalog[] = [];
+  for (const catalog of byEntry.values()) {
+    const domainYaml = await readFile(path.join(catalog.rootDir, "domain.yaml"), "utf8");
+    const parsed = parseDomainYaml(domainYaml, path.basename(catalog.rootDir));
+    const catalogCgsHash = await resolveLiveHash(catalog, runtime);
+    bootstrapped.push({
+      catalog: {
+        ...catalog,
+        manifest: { ...catalog.manifest, cgsHash: catalogCgsHash },
+      },
+      catalogCgsHash,
+      authScheme: parsed.authScheme,
+      entityCount: parsed.entities.length,
+      capabilityCount: parsed.capabilities.length,
+    });
+  }
+
+  bootstrapped.sort((a, b) => a.catalog.manifest.entryId.localeCompare(b.catalog.manifest.entryId));
+  return bootstrapped;
+}
+
+export function createOperatorRoutes(ctx: OperatorRouteContext): OperatorHandler {
+  return {
+    async health() {
+      return { status: "ok" };
+    },
+
+    async listCatalogs() {
+      const bootstrapped = await bootstrapCatalogs(ctx);
+      const stubsDir = path.join(ctx.agentRoot, ".plasm", "stubs");
+      const catalogs = await Promise.all(
+        bootstrapped.map(async (item) => {
+          const stubPath = path.join(stubsDir, `${item.catalog.manifest.entryId}.ts`);
+          const stub = await stubFreshness(item.catalogCgsHash, stubPath);
+          return {
+            entryId: item.catalog.manifest.entryId,
+            label: item.catalog.manifest.label ?? item.catalog.manifest.entryId,
+            rootDir: item.catalog.rootDir,
+            catalogCgsHash: item.catalogCgsHash,
+            authScheme: item.authScheme,
+            entityCount: item.entityCount,
+            capabilityCount: item.capabilityCount,
+            stub,
+          };
+        }),
+      );
+      return { catalogs, generatedAt: new Date().toISOString() };
+    },
+
+    async listSessions() {
+      const store = createAgentStateStore({
+        agentRoot: ctx.agentRoot,
+        tenantScope: ctx.tenantScope ?? "local",
+      });
+      const intents = await store.listIntents();
+      const sessions = await Promise.all(
+        intents.map(async (intent) => {
+          const state = await store.get(intent);
+          if (!state) return null;
+          return {
+            intent: state.intent,
+            logicalSessionRef: state.logicalSessionRef,
+            logicalSessionId: state.logicalSessionId,
+            waveCount: state.waves.length,
+            seedCount: state.seeds.length,
+            planCommitCount: state.planCommits.length,
+            updatedAt: state.updatedAt,
+          };
+        }),
+      );
+      return {
+        sessions: sessions.filter((s): s is NonNullable<typeof s> => s !== null),
+      };
+    },
+
+    async listPlans() {
+      const store = createAgentStateStore({
+        agentRoot: ctx.agentRoot,
+        tenantScope: ctx.tenantScope ?? "local",
+      });
+      const intents = await store.listIntents();
+      const plans = [];
+      for (const intent of intents) {
+        const state = await store.get(intent);
+        if (!state) continue;
+        for (const commit of state.planCommits) {
+          plans.push({
+            intent: state.intent,
+            logicalSessionRef: state.logicalSessionRef,
+            ref: commit.ref,
+            program: commit.program,
+            at: commit.at,
+          });
+        }
+      }
+      plans.sort((a, b) => b.at.localeCompare(a.at));
+      return { plans };
+    },
+
+    async ops() {
+      const bootstrapped = await bootstrapCatalogs(ctx);
+      const store = createAgentStateStore({
+        agentRoot: ctx.agentRoot,
+        tenantScope: ctx.tenantScope ?? "local",
+      });
+      const intents = await store.listIntents();
+      let planCommitCount = 0;
+      for (const intent of intents) {
+        const state = await store.get(intent);
+        planCommitCount += state?.planCommits.length ?? 0;
+      }
+      const native = isNativeEngineAvailable();
+      return {
+        nativeEngineAvailable: native,
+        engineMode: native ? "napi" : "stub",
+        agentRoot: ctx.agentRoot,
+        catalogCount: bootstrapped.length,
+        sessionCount: intents.length,
+        planCommitCount,
+      };
+    },
+
+    async listTraces() {
+      const { LocalArchiveStore } = await import("../archive/index.js");
+      const archive = LocalArchiveStore.fromAgentRoot(ctx.agentRoot);
+      const tenantScope = ctx.tenantScope ?? "local";
+      const traces = await archive.listTraces(tenantScope);
+      return { traces };
+    },
+
+    async listArchives() {
+      const { LocalArchiveStore } = await import("../archive/index.js");
+      const archive = LocalArchiveStore.fromAgentRoot(ctx.agentRoot);
+      const { plans, runs, paths } = await archive.listArchives();
+      return { plans, runs, paths };
+    },
+
+    async listRuns() {
+      const { LocalArchiveStore } = await import("../archive/index.js");
+      const archive = LocalArchiveStore.fromAgentRoot(ctx.agentRoot);
+      const runs = await archive.listRuns();
+      return { runs };
+    },
+  };
+}
+
+function routePath(url: string): string {
+  const pathOnly = url.split("?")[0] ?? url;
+  if (pathOnly.startsWith("/operator/")) {
+    return pathOnly.slice("/operator".length);
+  }
+  return pathOnly;
+}
+
+function matchesRoute(pathOnly: string, route: string): boolean {
+  return pathOnly === route || pathOnly.startsWith(`${route}?`);
+}
+
+export function nitroOperatorHandler(ctx: OperatorRouteContext): NitroHandler {
+  const routes = createOperatorRoutes(ctx);
+  return async (event) => {
+    const pathOnly = routePath(event.req.url ?? "/");
+
+    if (matchesRoute(pathOnly, "/health") || matchesRoute(pathOnly, "/ops/health")) {
+      event.res.statusCode = 200;
+      event.res.end(JSON.stringify(await routes.health()));
+      return;
+    }
+    if (matchesRoute(pathOnly, "/catalogs")) {
+      event.res.statusCode = 200;
+      event.res.end(JSON.stringify(await routes.listCatalogs()));
+      return;
+    }
+    if (matchesRoute(pathOnly, "/sessions")) {
+      event.res.statusCode = 200;
+      event.res.end(JSON.stringify(await routes.listSessions()));
+      return;
+    }
+    if (matchesRoute(pathOnly, "/plans")) {
+      event.res.statusCode = 200;
+      event.res.end(JSON.stringify(await routes.listPlans()));
+      return;
+    }
+    if (matchesRoute(pathOnly, "/ops")) {
+      event.res.statusCode = 200;
+      event.res.end(JSON.stringify(await routes.ops()));
+      return;
+    }
+    if (matchesRoute(pathOnly, "/traces")) {
+      event.res.statusCode = 200;
+      event.res.end(JSON.stringify(await routes.listTraces()));
+      return;
+    }
+    if (matchesRoute(pathOnly, "/archives")) {
+      event.res.statusCode = 200;
+      event.res.end(JSON.stringify(await routes.listArchives()));
+      return;
+    }
+    if (matchesRoute(pathOnly, "/runs")) {
+      event.res.statusCode = 200;
+      event.res.end(JSON.stringify(await routes.listRuns()));
+      return;
+    }
+
+    event.res.statusCode = 404;
+    event.res.end(JSON.stringify({ error: "not_found", path: pathOnly }));
+  };
+}