@dypai-ai/workflow-core 0.1.0

package/src/adapters/refToLegacyPlaceholder.ts

@@ -0,0 +1,33 @@
+import { isRefIR, refToPlaceholder } from "../ir/refs";
+import type { RefIR } from "../ir/types";
+
+export { refToPlaceholder };
+
+export function serializeConfigValue(value: unknown): unknown {
+  if (isRefIR(value)) return refToPlaceholder(value);
+  if (Array.isArray(value)) return value.map((item) => serializeConfigValue(item));
+  if (value && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [key, nested] of Object.entries(value as Record<string, unknown>)) {
+      out[key] = serializeConfigValue(nested);
+    }
+    return out;
+  }
+  return value;
+}
+
+export function serializeConfig(config: Record<string, unknown>): Record<string, unknown> {
+  return serializeConfigValue(config) as Record<string, unknown>;
+}
+
+export function refToLegacyPlaceholder(ref: RefIR): string {
+  return refToPlaceholder(ref);
+}
+
+export function responseMapToComposeFields(responseMap: Record<string, RefIR>): Record<string, string> {
+  const fields: Record<string, string> = {};
+  for (const [key, ref] of Object.entries(responseMap)) {
+    fields[key] = refToPlaceholder(ref);
+  }
+  return fields;
+}

package/src/adapters/sqlBuilders.ts

@@ -0,0 +1,81 @@
+import { isRefIR } from "../ir/refs";
+import { serializeConfigValue } from "./refToLegacyPlaceholder";
+
+function quoteSqlString(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+function sqlLiteral(value: unknown): string {
+  if (value === null || value === undefined) return "NULL";
+  if (typeof value === "number" && !Number.isNaN(value)) return String(value);
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (typeof value === "string") return quoteSqlString(value);
+  return quoteSqlString(JSON.stringify(value));
+}
+
+function sqlExpression(value: unknown): string {
+  if (isRefIR(value)) return serializeConfigValue(value) as string;
+  return sqlLiteral(value);
+}
+
+export function buildInsertSql(config: {
+  table: string;
+  values: Record<string, unknown>;
+  returning?: string[];
+}): string {
+  const columns = Object.keys(config.values).sort();
+  const assignments = columns.map((column) => sqlExpression(config.values[column]));
+  const returning = config.returning?.length
+    ? config.returning.join(", ")
+    : "*";
+  return [
+    `INSERT INTO ${config.table} (${columns.join(", ")})`,
+    `VALUES (${assignments.join(", ")})`,
+    `RETURNING ${returning}`,
+  ].join("\n");
+}
+
+export function buildUpdateSql(config: {
+  table: string;
+  where: Record<string, unknown>;
+  set: Record<string, unknown>;
+  returning?: string[];
+}): string {
+  const setColumns = Object.keys(config.set).sort();
+  const whereColumns = Object.keys(config.where).sort();
+  const setClause = setColumns
+    .map((column) => `${column} = ${sqlExpression(config.set[column])}`)
+    .join(",\n    ");
+  const whereClause = whereColumns
+    .map((column) => `${column} = ${sqlExpression(config.where[column])}`)
+    .join("\n  AND ");
+  const returning = config.returning?.length
+    ? `\nRETURNING ${config.returning.join(", ")}`
+    : "";
+  return [
+    `UPDATE ${config.table}`,
+    `SET ${setClause}`,
+    `WHERE ${whereClause}${returning}`,
+  ].join("\n");
+}
+
+export function buildListSql(config: {
+  table: string;
+  where?: Record<string, unknown>;
+  orderBy?: string;
+  limit?: unknown;
+  offset?: unknown;
+}): string {
+  const lines = [`SELECT * FROM ${config.table}`];
+  const whereColumns = config.where ? Object.keys(config.where).sort() : [];
+  if (whereColumns.length) {
+    const whereClause = whereColumns
+      .map((column) => `${column} = ${sqlExpression(config.where![column])}`)
+      .join("\n  AND ");
+    lines.push(`WHERE ${whereClause}`);
+  }
+  if (config.orderBy?.trim()) lines.push(`ORDER BY ${config.orderBy.trim()}`);
+  if (config.limit !== undefined) lines.push(`LIMIT ${sqlExpression(config.limit)}`);
+  if (config.offset !== undefined) lines.push(`OFFSET ${sqlExpression(config.offset)}`);
+  return lines.join("\n");
+}

package/src/adapters/triggers.ts

@@ -0,0 +1,86 @@
+import { isRecord } from "../ir/schema";
+import type { AuthIR, HttpMethod, TriggerIR } from "../ir/types";
+
+export function authFromLegacyTrigger(
+  trigger: Record<string, unknown>,
+  allowedRoles: string[] | undefined,
+): AuthIR {
+  const httpApi = trigger.http_api === true ? {} : trigger.http_api;
+  const authMode = isRecord(httpApi)
+    ? String(httpApi.auth_mode || httpApi.mode || "jwt").toLowerCase()
+    : "jwt";
+
+  if (authMode === "public" || authMode === "none") {
+    return { mode: "public" };
+  }
+
+  const roles = (allowedRoles || []).filter((role) => role.trim().length > 0);
+  return { mode: "jwt", allowedRoles: roles };
+}
+
+export function triggerFromLegacyDoc(
+  trigger: unknown,
+  method: HttpMethod,
+): TriggerIR {
+  const value = isRecord(trigger) ? trigger : {};
+  if (isRecord(value.schedule) || value.schedule === true) {
+    const schedule = value.schedule === true ? {} : value.schedule;
+    return {
+      type: "schedule",
+      cron: isRecord(schedule) && typeof schedule.cron === "string" ? schedule.cron : "",
+    };
+  }
+  if (value.webhook) {
+    const webhook = value.webhook === true ? {} : value.webhook;
+    return {
+      type: "webhook",
+      provider: isRecord(webhook) && typeof webhook.provider === "string"
+        ? webhook.provider
+        : undefined,
+    };
+  }
+  return { type: "http", method };
+}
+
+export function triggersToEngineConfig(
+  trigger: TriggerIR,
+  auth: AuthIR,
+): { triggers: Record<string, unknown> } {
+  const out: Record<string, unknown> = {
+    webhook: { path: "", enabled: false },
+    http_api: { enabled: false, auth_mode: "jwt" },
+    schedule: { enabled: false },
+  };
+
+  if (trigger.type === "http") {
+    out.http_api = {
+      enabled: true,
+      auth_mode: auth.mode === "public" ? "public" : "jwt",
+    };
+  } else if (trigger.type === "webhook") {
+    out.http_api = { enabled: false, auth_mode: "jwt" };
+    out.webhook = { path: "", enabled: true, ...(trigger.provider ? { provider: trigger.provider } : {}) };
+  } else if (trigger.type === "schedule") {
+    out.http_api = { enabled: false, auth_mode: "jwt" };
+    out.schedule = { enabled: true, cron: trigger.cron };
+  }
+
+  return { triggers: out };
+}
+
+export function responseCardinalityFromLegacy(value: unknown): "single" | "many" | "none" | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "single" || normalized === "one") return "single";
+  if (normalized === "many") return "many";
+  if (normalized === "none") return "none";
+  return undefined;
+}
+
+export function normalizeHttpMethod(value: unknown, fallback: HttpMethod = "GET"): HttpMethod {
+  const method = typeof value === "string" ? value.trim().toUpperCase() : fallback;
+  if (method === "GET" || method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE") {
+    return method;
+  }
+  return fallback;
+}

package/src/adapters/types.ts

@@ -0,0 +1,15 @@
+import type { AdapterTarget } from "../ir/types";
+
+export type AdapterDeclaration = {
+  target: AdapterTarget;
+  implemented: boolean;
+  notes?: string;
+};
+
+export type AdapterRegistry = Record<string, AdapterDeclaration[]>;
+
+export const pendingAdapters: AdapterRegistry = {
+  "dypai.db": [{ target: "workflow_code.v2", implemented: true }],
+  "dypai.email": [{ target: "workflow_code.v2", implemented: true }],
+  "dypai.flow": [{ target: "workflow_code.v2", implemented: true }],
+};

package/src/adapters/workflowCodeTypes.ts

@@ -0,0 +1,45 @@
+export type EngineWorkflowNode = {
+  id: string;
+  node_type: string;
+  parameters: Record<string, unknown>;
+  variable?: string;
+  is_return?: boolean;
+};
+
+export type EngineWorkflowEdge = {
+  source: string;
+  target: string;
+  condition?: unknown;
+  source_handle?: string;
+  target_handle?: string;
+};
+
+export type WorkflowCodeV2 = {
+  schema_version: "2.0";
+  nodes: EngineWorkflowNode[];
+  edges: EngineWorkflowEdge[];
+  execution_config: {
+    triggers: Record<string, unknown>;
+  };
+  metadata?: {
+    ir_name?: string;
+    ir_version?: string;
+    capability_catalog_hash?: string;
+    capability_engine_version?: string;
+    response_cardinality?: string;
+    source?: {
+      kind?: string;
+      file?: string;
+    };
+  };
+};
+
+export type AdapterResult<T> = {
+  ok: boolean;
+  value?: T;
+  diagnostics: import("../ir/types").IRDiagnostic[];
+};
+
+export type ImportYamlResult = AdapterResult<import("../ir/types").WorkflowIR>;
+
+export type AdaptWorkflowCodeResult = AdapterResult<WorkflowCodeV2>;

package/src/capabilities/agentBrief.ts

@@ -0,0 +1,42 @@
+import { CapabilityRegistry } from "./capabilityRegistry";
+import type { CapabilityCatalog } from "./types";
+
+export function generateCapabilityBrief(registry: CapabilityRegistry): string {
+  const lines: string[] = [
+    "# DYPAI Capability Brief",
+    "",
+    "Grouped authoring capabilities synced from the engine catalog.",
+    "",
+  ];
+
+  for (const namespace of registry.listNamespaces()) {
+    lines.push(`## ${namespace}`);
+    lines.push("");
+
+    for (const group of registry.listGroupsByNamespace(namespace)) {
+      lines.push(`### ${group.id}`);
+      if (group.docs) {
+        lines.push(group.docs);
+        lines.push("");
+      }
+
+      for (const operation of group.operations) {
+        lines.push(`- ${operation.authoring_signature}`);
+        if (operation.description) {
+          lines.push(`  ${operation.description}`);
+        }
+        if (operation.required_credentials?.length) {
+          lines.push(`  Credentials: ${operation.required_credentials.join(", ")}`);
+        }
+      }
+
+      lines.push("");
+    }
+  }
+
+  return lines.join("\n").trimEnd();
+}
+
+export function generateCapabilityBriefFromCatalog(catalog: CapabilityCatalog): string {
+  return generateCapabilityBrief(CapabilityRegistry.fromCatalog(catalog));
+}

package/src/capabilities/capabilities.test.ts

@@ -0,0 +1,126 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, test } from "bun:test";
+import { flowDefinitionToIr } from "../adapters/flowDefinitionToIr";
+import { irToWorkflowCodeV2 } from "../adapters/irToWorkflowCodeV2";
+import {
+  CapabilityRegistry,
+  generateCapabilityBrief,
+  isCapabilityCatalog,
+  type CapabilityCatalog,
+} from "../capabilities";
+import { WORKFLOW_IR_VERSION, type WorkflowIR } from "../ir/types";
+import { validateWorkflowIR } from "../ir/validate";
+
+const fixturePath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "fixtures", "capability-catalog.json");
+const fixtureCatalog = JSON.parse(readFileSync(fixturePath, "utf-8")) as CapabilityCatalog;
+
+describe("dynamic capability catalog", () => {
+  test("loads fixture catalog", () => {
+    expect(isCapabilityCatalog(fixtureCatalog)).toBe(true);
+    expect(fixtureCatalog.groups.length).toBeGreaterThan(0);
+  });
+
+  test("lists groups by namespace from catalog", () => {
+    const registry = CapabilityRegistry.fromCatalog(fixtureCatalog);
+    expect(registry.listNamespaces()).toEqual(["dypai", "google", "stripe"]);
+    expect(registry.resolveCall("stripe.checkout.createSession")).toEqual({
+      node: "stripe.checkout",
+      operation: "createSession",
+      version: 1,
+    });
+  });
+
+  test("generates brief from dynamic catalog", () => {
+    const registry = CapabilityRegistry.fromCatalog(fixtureCatalog);
+    const brief = generateCapabilityBrief(registry);
+    expect(brief).toContain("### dypai.db");
+    expect(brief).toContain("stripe.checkout.createSession");
+  });
+
+  test("validates and adapts grouped workflow using catalog fixture", () => {
+    const workflow: WorkflowIR = {
+      version: WORKFLOW_IR_VERSION,
+      name: "checkout",
+      trigger: { type: "http", method: "POST" },
+      auth: { mode: "public" },
+      inputSchema: { type: "object", properties: {} },
+      outputSchema: { type: "object", properties: { url: { type: "string" } } },
+      response: { cardinality: "single" },
+      steps: [
+        {
+          id: "checkout",
+          node: "stripe.checkout",
+          operation: "createSession",
+          version: 1,
+          config: {
+            mode: "payment",
+            price_id: "price_123",
+            success_url: "https://example.com/success",
+            cancel_url: "https://example.com/cancel",
+          },
+        },
+        {
+          id: "return",
+          node: "dypai.flow",
+          operation: "return",
+          version: 1,
+          config: {},
+          return: true,
+        },
+      ],
+      responseMap: { url: { kind: "literal", value: "https://checkout.test" } },
+    };
+
+    expect(validateWorkflowIR(workflow, { capabilityCatalog: fixtureCatalog }).ok).toBe(true);
+    const adapted = irToWorkflowCodeV2(workflow, { capabilityCatalog: fixtureCatalog });
+    expect(adapted.ok).toBe(true);
+    expect(adapted.value?.nodes.find((node) => node.id === "checkout")).toMatchObject({
+      node_type: "stripe",
+      parameters: {
+        operation: "stripe_create_checkout_session",
+        price_id: "price_123",
+      },
+    });
+    expect(adapted.value?.metadata?.capability_catalog_hash).toBe("fixture-capability-catalog");
+  });
+
+  test("keeps legacy db/email aliases without catalog", () => {
+    const workflow = flowDefinitionToIr({
+      name: "legacy-alias",
+      trigger: { type: "http", method: "GET" },
+      auth: { mode: "public" },
+      input: { type: "object", properties: {} },
+      output: { type: "object", properties: { ok: { type: "boolean" } } },
+      steps: [{ id: "ping", call: "db.query", config: { sql: "SELECT 1 AS ok" } }],
+      returns: { ok: { kind: "literal", value: true } },
+    });
+
+    expect(workflow.steps[0]).toMatchObject({ node: "dypai.db", operation: "query" });
+    expect(validateWorkflowIR(workflow).ok).toBe(true);
+    expect(irToWorkflowCodeV2(workflow).ok).toBe(true);
+  });
+
+  test("resolves grouped flow calls using catalog fixture", () => {
+    const workflow = flowDefinitionToIr({
+      name: "grouped-flow",
+      trigger: { type: "http", method: "POST" },
+      auth: { mode: "public" },
+      input: { type: "object", properties: {} },
+      output: { type: "object", properties: { rows: { type: "array" } } },
+      steps: [{
+        id: "sheet",
+        call: "google.sheets.readRows",
+        config: { spreadsheet_id: "abc123" },
+      }],
+      returns: { rows: { kind: "literal", value: [] } },
+    }, { capabilityCatalog: fixtureCatalog });
+
+    expect(workflow.steps[0]).toMatchObject({
+      node: "google.sheets",
+      operation: "readRows",
+    });
+    expect(validateWorkflowIR(workflow, { capabilityCatalog: fixtureCatalog }).ok).toBe(true);
+  });
+});

package/src/capabilities/capabilityRegistry.ts

@@ -0,0 +1,112 @@
+import type { NodeDefinition } from "../ir/types";
+import { nodeDefinitionsFromCatalog } from "./fromCatalog";
+import type {
+  CapabilityCallResolution,
+  CapabilityCatalog,
+  CapabilityGroupJson,
+  CapabilityLookup,
+  CapabilityOperationJson,
+} from "./types";
+import { isCapabilityCatalog } from "./catalogSchema";
+
+export class CapabilityRegistry {
+  private readonly groups = new Map<string, CapabilityGroupJson>();
+  private readonly operations = new Map<string, CapabilityOperationJson>();
+  private catalog: CapabilityCatalog | null = null;
+
+  static fromCatalog(catalog: CapabilityCatalog): CapabilityRegistry {
+    const registry = new CapabilityRegistry();
+    registry.loadCatalog(catalog);
+    return registry;
+  }
+
+  loadCatalog(catalog: CapabilityCatalog): void {
+    if (!isCapabilityCatalog(catalog)) {
+      throw new Error("Invalid capability catalog payload.");
+    }
+    this.catalog = catalog;
+    this.groups.clear();
+    this.operations.clear();
+    for (const group of catalog.groups) {
+      this.groups.set(group.id, group);
+      for (const operation of group.operations) {
+        this.operations.set(operation.id, operation);
+      }
+    }
+  }
+
+  getCatalog(): CapabilityCatalog | null {
+    return this.catalog;
+  }
+
+  getGroup(groupId: string): CapabilityGroupJson | undefined {
+    return this.groups.get(groupId);
+  }
+
+  listGroups(): CapabilityGroupJson[] {
+    return [...this.groups.values()].sort((a, b) => a.id.localeCompare(b.id));
+  }
+
+  listGroupsByNamespace(namespace: string): CapabilityGroupJson[] {
+    return this.listGroups().filter((group) => group.namespace === namespace);
+  }
+
+  listNamespaces(): string[] {
+    return [...new Set(this.listGroups().map((group) => group.namespace))].sort();
+  }
+
+  lookup(groupId: string, operation: string, version: number): CapabilityLookup | undefined {
+    const group = this.groups.get(groupId);
+    if (!group || group.version !== version) return undefined;
+    const op = group.operations.find((item) => item.operation === operation);
+    if (!op) return undefined;
+    return { group, operation: op };
+  }
+
+  resolveCall(call: string): CapabilityCallResolution | null {
+    const trimmed = call.trim();
+    if (!trimmed) return null;
+
+    const parts = trimmed.split(".");
+    for (let splitAt = parts.length - 1; splitAt >= 1; splitAt -= 1) {
+      const groupId = parts.slice(0, splitAt).join(".");
+      const operation = parts.slice(splitAt).join(".");
+      const group = this.groups.get(groupId);
+      if (!group) continue;
+      const match = group.operations.find((item) => item.operation === operation);
+      if (!match) continue;
+      return {
+        node: groupId,
+        operation,
+        version: group.version,
+      };
+    }
+
+    return null;
+  }
+
+  listNodeDefinitions(): NodeDefinition[] {
+    if (!this.catalog) return [];
+    return nodeDefinitionsFromCatalog(this.catalog);
+  }
+
+  listOperationSignatures(groupId?: string): string[] {
+    const groups = groupId
+      ? this.listGroups().filter((group) => group.id === groupId)
+      : this.listGroups();
+    const signatures: string[] = [];
+    for (const group of groups) {
+      for (const operation of group.operations) {
+        signatures.push(operation.authoring_signature);
+      }
+    }
+    return signatures.sort();
+  }
+}
+
+export function resolveCapabilityCall(
+  call: string,
+  registry: CapabilityRegistry,
+): CapabilityCallResolution | null {
+  return registry.resolveCall(call);
+}

package/src/capabilities/catalogSchema.ts

@@ -0,0 +1,14 @@
+import type { CapabilityCatalog, CapabilityGroupJson } from "./types";
+
+export function isCapabilityCatalog(value: unknown): value is CapabilityCatalog {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value as CapabilityCatalog;
+  return candidate.version === "capability-catalog.v1" && Array.isArray(candidate.groups);
+}
+
+export function flattenCapabilityOperations(catalog: CapabilityCatalog): CapabilityGroupJson[] {
+  return catalog.groups.map((group) => ({
+    ...group,
+    operations: [...group.operations].sort((a, b) => a.operation.localeCompare(b.operation)),
+  })).sort((a, b) => a.id.localeCompare(b.id));
+}

package/src/capabilities/fromCatalog.ts

@@ -0,0 +1,30 @@
+import { defineNode, defineOperation } from "../registry/defineNode";
+import type { NodeDefinition } from "../ir/types";
+import type { CapabilityCatalog, CapabilityGroupJson, CapabilityOperationJson } from "./types";
+import { flattenCapabilityOperations } from "./catalogSchema";
+
+function operationFromJson(group: CapabilityGroupJson, operation: CapabilityOperationJson) {
+  return defineOperation({
+    label: operation.name,
+    docs: operation.description,
+    inputSchema: operation.input_schema,
+    outputSchema: operation.output_schema ?? { type: "object" },
+    sideEffects: operation.side_effects,
+  });
+}
+
+export function nodeDefinitionsFromCatalog(catalog: CapabilityCatalog): NodeDefinition[] {
+  return flattenCapabilityOperations(catalog).map((group) => defineNode({
+    id: group.id,
+    version: group.version,
+    label: group.label,
+    category: group.category,
+    docs: group.docs,
+    operations: Object.fromEntries(
+      group.operations.map((operation) => [
+        operation.operation,
+        operationFromJson(group, operation),
+      ]),
+    ),
+  }));
+}

package/src/capabilities/index.ts

@@ -0,0 +1,35 @@
+import type { CapabilityCatalog } from "./types";
+import { CapabilityRegistry } from "./capabilityRegistry";
+import { generateCapabilityBrief } from "./agentBrief";
+
+export type {
+  CapabilityCallResolution,
+  CapabilityCatalog,
+  CapabilityGroupJson,
+  CapabilityLookup,
+  CapabilityOperationJson,
+  EngineBindingJson,
+} from "./types";
+
+export { isCapabilityCatalog, flattenCapabilityOperations } from "./catalogSchema";
+export { nodeDefinitionsFromCatalog } from "./fromCatalog";
+export { CapabilityRegistry, resolveCapabilityCall } from "./capabilityRegistry";
+export { generateCapabilityBrief, generateCapabilityBriefFromCatalog } from "./agentBrief";
+
+export function createCapabilityRegistry(catalog?: CapabilityCatalog | null): CapabilityRegistry {
+  if (!catalog) return new CapabilityRegistry();
+  return CapabilityRegistry.fromCatalog(catalog);
+}
+
+export function mergeNodeRegistryDefinitions(
+  baseDefinitions: import("../ir/types").NodeDefinition[],
+  catalog?: CapabilityCatalog | null,
+): import("../ir/types").NodeDefinition[] {
+  if (!catalog) return baseDefinitions;
+  const registry = CapabilityRegistry.fromCatalog(catalog);
+  const byId = new Map(baseDefinitions.map((node) => [node.id, node]));
+  for (const node of registry.listNodeDefinitions()) {
+    byId.set(node.id, node);
+  }
+  return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}

package/src/capabilities/types.ts

@@ -0,0 +1,57 @@
+import type { JsonSchema, SideEffectKind } from "../ir/types";
+
+/** JSON-serializable engine binding stored in DB/API/MCP artifacts. */
+export type EngineBindingJson = {
+  node_type: string;
+  operation?: string;
+  parameter_map?: Record<string, string>;
+  static_parameters?: Record<string, unknown>;
+  /** Special adapter hint for compile-time transforms (e.g. dypai.db SQL builders). */
+  adapter?: "dypai.db" | "dypai.email";
+};
+
+export type CapabilityOperationJson = {
+  id: string;
+  group_id: string;
+  operation: string;
+  name: string;
+  description?: string;
+  authoring_signature: string;
+  input_schema: JsonSchema;
+  output_schema?: JsonSchema;
+  required_credentials?: string[];
+  side_effects?: SideEffectKind[];
+  examples?: Record<string, unknown>[];
+  engine_binding: EngineBindingJson;
+};
+
+export type CapabilityGroupJson = {
+  id: string;
+  namespace: string;
+  resource: string;
+  version: number;
+  label: string;
+  category: string;
+  provider?: string;
+  docs?: string;
+  operations: CapabilityOperationJson[];
+};
+
+export type CapabilityCatalog = {
+  version: "capability-catalog.v1";
+  engine_version?: string;
+  content_hash?: string;
+  synced_at?: string;
+  groups: CapabilityGroupJson[];
+};
+
+export type CapabilityCallResolution = {
+  node: string;
+  operation: string;
+  version: number;
+};
+
+export type CapabilityLookup = {
+  group: CapabilityGroupJson;
+  operation: CapabilityOperationJson;
+};