@dypai-ai/workflow-core 0.1.0

package/src/adapters/irToWorkflowCodeV2.ts

@@ -0,0 +1,293 @@
+import { serializeConfig } from "./refToLegacyPlaceholder";
+import { buildEngineParameters } from "./engineBinding";
+import { buildInsertSql, buildListSql, buildUpdateSql } from "./sqlBuilders";
+import { responseMapToComposeFields } from "./refToLegacyPlaceholder";
+import { triggersToEngineConfig } from "./triggers";
+import { CapabilityRegistry } from "../capabilities/capabilityRegistry";
+import type { CapabilityCatalog } from "../capabilities/types";
+import type {
+  AdaptWorkflowCodeResult,
+  EngineWorkflowEdge,
+  EngineWorkflowNode,
+  WorkflowCodeV2,
+} from "./workflowCodeTypes";
+import type { IRDiagnostic, WorkflowIR, WorkflowStepIR } from "../ir/types";
+import { withSourceLocation } from "../ir/sourceMap";
+
+export type AdaptWorkflowCodeOptions = {
+  capabilityCatalog?: CapabilityCatalog;
+};
+
+const COMPOSE_STEP_ID = "__response";
+
+function isFlowReturnStep(step: WorkflowStepIR): boolean {
+  return step.node === "dypai.flow" && step.operation === "return";
+}
+
+function adaptDatabaseStep(step: WorkflowStepIR): EngineWorkflowNode {
+  const config = step.config;
+  let query = "";
+
+  if (step.operation === "query") {
+    query = typeof config.sql === "string" ? config.sql.trim() : "";
+  } else if (step.operation === "insert") {
+    query = buildInsertSql({
+      table: String(config.table || ""),
+      values: (config.values as Record<string, unknown>) || {},
+      returning: Array.isArray(config.returning)
+        ? config.returning.filter((item): item is string => typeof item === "string")
+        : undefined,
+    });
+  } else if (step.operation === "update") {
+    query = buildUpdateSql({
+      table: String(config.table || ""),
+      where: (config.where as Record<string, unknown>) || {},
+      set: (config.set as Record<string, unknown>) || {},
+      returning: Array.isArray(config.returning)
+        ? config.returning.filter((item): item is string => typeof item === "string")
+        : undefined,
+    });
+  } else if (step.operation === "list") {
+    query = buildListSql({
+      table: String(config.table || ""),
+      where: config.where as Record<string, unknown> | undefined,
+      orderBy: typeof config.orderBy === "string" ? config.orderBy : undefined,
+      limit: config.limit,
+      offset: config.offset,
+    });
+  }
+
+  return {
+    id: step.id,
+    node_type: "dypai_database",
+    variable: step.id,
+    parameters: {
+      operation: "query",
+      query,
+      ...(config.params ? { params: serializeConfig(config.params as Record<string, unknown>) } : {}),
+    },
+  };
+}
+
+function adaptEmailStep(step: WorkflowStepIR): EngineWorkflowNode {
+  const config = serializeConfig(step.config);
+  return {
+    id: step.id,
+    node_type: "resend",
+    variable: step.id,
+    parameters: {
+      to: config.to,
+      subject: config.subject,
+      body: config.body,
+      template: config.template,
+      variables: config.variables,
+    },
+  };
+}
+
+function adaptCapabilityStep(
+  step: WorkflowStepIR,
+  registry: CapabilityRegistry,
+): EngineWorkflowNode | null {
+  if (step.node === "dypai.db") {
+    return adaptDatabaseStep(step);
+  }
+  if (step.node === "dypai.email") {
+    return adaptEmailStep(step);
+  }
+
+  const resolved = registry.lookup(step.node, step.operation, step.version);
+  if (!resolved) return null;
+
+  return {
+    id: step.id,
+    node_type: resolved.operation.engine_binding.node_type,
+    variable: step.id,
+    parameters: buildEngineParameters(step.config, resolved.operation.engine_binding),
+  };
+}
+
+function adaptLegacyStep(step: WorkflowStepIR): EngineWorkflowNode {
+  const legacy = step.config.legacyNode;
+  const node = legacy && typeof legacy === "object" && !Array.isArray(legacy)
+    ? legacy as Record<string, unknown>
+    : {};
+  const {
+    id = step.id,
+    type,
+    node_type,
+    variable,
+    return: returnFlag,
+    is_return,
+    parameters,
+    ...inline
+  } = node;
+  const resolvedType = typeof type === "string" ? type : typeof node_type === "string" ? node_type : "unknown";
+  const params = parameters && typeof parameters === "object" && !Array.isArray(parameters)
+    ? parameters as Record<string, unknown>
+    : inline;
+  return {
+    id: typeof id === "string" ? id : step.id,
+    node_type: resolvedType,
+    variable: typeof variable === "string" ? variable : step.id,
+    ...(returnFlag === true || is_return === true ? { is_return: true } : {}),
+    parameters: serializeConfig(params as Record<string, unknown>),
+  };
+}
+
+function buildComposeNode(workflow: WorkflowIR): EngineWorkflowNode {
+  return {
+    id: COMPOSE_STEP_ID,
+    node_type: "set_fields",
+    variable: COMPOSE_STEP_ID,
+    is_return: true,
+    parameters: {
+      operation: "compose",
+      fields: responseMapToComposeFields(workflow.responseMap),
+    },
+  };
+}
+
+function normalizeEdges(
+  workflow: WorkflowIR,
+  dataStepIds: string[],
+  returnStepIds: string[],
+): EngineWorkflowEdge[] {
+  const edges: EngineWorkflowEdge[] = [];
+  const declared = workflow.edges || [];
+  const dataSteps = new Set(dataStepIds);
+  const returnSteps = new Set(returnStepIds);
+  const emittedNodes = new Set([...dataStepIds, COMPOSE_STEP_ID]);
+
+  for (const edge of declared) {
+    if (edge.from === "$trigger") continue;
+    const source = returnSteps.has(edge.from) ? COMPOSE_STEP_ID : edge.from;
+    const target = returnSteps.has(edge.to) ? COMPOSE_STEP_ID : edge.to;
+    if (source === target) continue;
+    if (!emittedNodes.has(source) || !emittedNodes.has(target)) continue;
+    edges.push({ source, target });
+  }
+
+  const composeTargets = new Set(
+    edges.filter((edge) => edge.target === COMPOSE_STEP_ID).map((edge) => edge.source),
+  );
+
+  for (const stepId of dataSteps) {
+    if (!composeTargets.has(stepId)) {
+      edges.push({ source: stepId, target: COMPOSE_STEP_ID });
+    }
+  }
+
+  edges.sort((a, b) => `${a.source}:${a.target}`.localeCompare(`${b.source}:${b.target}`));
+  return edges;
+}
+
+function validateGeneratedWorkflowCode(workflowCode: WorkflowCodeV2): IRDiagnostic[] {
+  const diagnostics: IRDiagnostic[] = [];
+  for (const node of workflowCode.nodes) {
+    if (node.node_type === "dypai_database") {
+      const operation = node.parameters.operation;
+      const query = node.parameters.query;
+      if (operation === "mutation" && query) {
+        diagnostics.push({
+          severity: "error",
+          rule: "adapter_mutation_with_query",
+          message: `Generated node '${node.id}' contains invalid operation: mutation with query.`,
+        });
+      }
+      if (node.parameters.config) {
+        diagnostics.push({
+          severity: "error",
+          rule: "adapter_config_nesting",
+          message: `Generated node '${node.id}' nests parameters under config.`,
+        });
+      }
+    }
+    if (node.node_type === "set_fields" && node.is_return && node.parameters.operation !== "compose") {
+      diagnostics.push({
+        severity: "error",
+        rule: "adapter_return_not_compose",
+        message: `Generated return node '${node.id}' must use set_fields operation: compose.`,
+      });
+    }
+  }
+  return diagnostics;
+}
+
+export function irToWorkflowCodeV2(
+  workflow: WorkflowIR,
+  options: AdaptWorkflowCodeOptions = {},
+): AdaptWorkflowCodeResult {
+  const diagnostics: IRDiagnostic[] = [];
+  const capabilityRegistry = options.capabilityCatalog
+    ? CapabilityRegistry.fromCatalog(options.capabilityCatalog)
+    : new CapabilityRegistry();
+  const dataSteps = workflow.steps.filter((step) => !isFlowReturnStep(step));
+  const returnStepIds = workflow.steps.filter(isFlowReturnStep).map((step) => step.id);
+  const nodes: EngineWorkflowNode[] = [];
+
+  for (const step of dataSteps) {
+    if (step.node === "legacy.workflow") {
+      nodes.push(adaptLegacyStep(step));
+      continue;
+    }
+
+    const adapted = adaptCapabilityStep(step, capabilityRegistry);
+    if (adapted) {
+      nodes.push(adapted);
+      continue;
+    }
+
+    diagnostics.push(withSourceLocation({
+      severity: "error",
+      rule: "adapter_unsupported_node",
+      message: `No workflow_code adapter for ${step.node}.${step.operation}@v${step.version}.`,
+      fixHint: capabilityRegistry.getGroup(step.node)
+        ? `Available operations: ${capabilityRegistry.getGroup(step.node)!.operations.map((item) => item.operation).sort().join(", ")}`
+        : "Load capability catalog or use legacy.workflow for unsupported runtime nodes.",
+      path: `steps.${step.id}`,
+    }, step.source));
+  }
+
+  nodes.push(buildComposeNode(workflow));
+  nodes.sort((a, b) => a.id.localeCompare(b.id));
+
+  const workflowCode: WorkflowCodeV2 = {
+    schema_version: "2.0",
+    nodes,
+    edges: normalizeEdges(workflow, dataSteps.map((step) => step.id), returnStepIds),
+    execution_config: triggersToEngineConfig(workflow.trigger, workflow.auth),
+    metadata: {
+      ir_name: workflow.name,
+      ir_version: workflow.version,
+      ...(options.capabilityCatalog?.content_hash
+        ? { capability_catalog_hash: options.capabilityCatalog.content_hash }
+        : {}),
+      ...(options.capabilityCatalog?.engine_version
+        ? { capability_engine_version: options.capabilityCatalog.engine_version }
+        : {}),
+      ...(workflow.response.cardinality ? { response_cardinality: workflow.response.cardinality } : {}),
+      ...(workflow.source ? { source: { kind: workflow.source.kind, file: workflow.source.file } } : {}),
+    },
+  };
+
+  diagnostics.push(...validateGeneratedWorkflowCode(workflowCode));
+
+  return {
+    ok: !diagnostics.some((item) => item.severity === "error"),
+    value: workflowCode,
+    diagnostics,
+  };
+}
+
+export function stableStringifyWorkflowCode(workflowCode: WorkflowCodeV2): string {
+  return JSON.stringify(workflowCode, (_key, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return Object.keys(value as Record<string, unknown>).sort().reduce((acc, key) => {
+        acc[key] = (value as Record<string, unknown>)[key];
+        return acc;
+      }, {} as Record<string, unknown>);
+    }
+    return value;
+  }, 2);
+}

package/src/adapters/legacyYamlToIr.ts

@@ -0,0 +1,340 @@
+import { parse as parseYaml } from "yaml";
+import { composeFieldsToResponseMap } from "./placeholderToRef";
+import {
+  authFromLegacyTrigger,
+  normalizeHttpMethod,
+  responseCardinalityFromLegacy,
+  triggerFromLegacyDoc,
+} from "./triggers";
+import type { ImportYamlResult } from "./workflowCodeTypes";
+import { isRecord, schemaPropertyNames } from "../ir/schema";
+import { withSourceLocation } from "../ir/sourceMap";
+import type {
+  IRDiagnostic,
+  JsonSchema,
+  RefIR,
+  SourceLocation,
+  WorkflowIR,
+  WorkflowStepIR,
+} from "../ir/types";
+import { WORKFLOW_IR_VERSION } from "../ir/types";
+
+function nodeSource(file: string | undefined, index: number, stepId?: string): SourceLocation {
+  return {
+    file,
+    yamlPath: `workflow.nodes[${index}]`,
+    stepId,
+  };
+}
+
+function liftStartTriggerNodes(workflow: Record<string, unknown>) {
+  const allNodes = Array.isArray(workflow.nodes) ? workflow.nodes.filter(isRecord) : [];
+  const allEdges = Array.isArray(workflow.edges) ? workflow.edges.filter(isRecord) : [];
+  const startNodes = allNodes.filter((node) => (node.type ?? node.node_type) === "start_trigger");
+  if (!startNodes.length) {
+    return { nodes: allNodes, edges: allEdges, inferredTrigger: null as Record<string, unknown> | null };
+  }
+
+  const startIds = new Set(startNodes.map((node) => String(node.id || "")));
+  const nodes = allNodes.filter((node) => !startIds.has(String(node.id || "")));
+  const edges = allEdges.filter((edge) => (
+    !startIds.has(String(edge.from ?? edge.source ?? ""))
+    && !startIds.has(String(edge.to ?? edge.target ?? ""))
+  ));
+
+  const first = startNodes[0];
+  const params = isRecord(first.parameters) ? first.parameters : first;
+  const triggerType = params.trigger_type || params.triggerType || "http_api";
+  let inferredTrigger: Record<string, unknown>;
+  switch (triggerType) {
+    case "webhook":
+      inferredTrigger = { webhook: params.path ? { path: params.path } : {} };
+      break;
+    case "schedule":
+      inferredTrigger = {
+        schedule: {
+          ...(params.cron ? { cron: params.cron } : {}),
+          ...(params.timezone ? { timezone: params.timezone } : {}),
+        },
+      };
+      break;
+    default:
+      inferredTrigger = { http_api: { auth_mode: params.auth_mode || params.mode || "jwt" } };
+  }
+
+  return { nodes, edges, inferredTrigger };
+}
+
+function importDatabaseNode(
+  node: Record<string, unknown>,
+  source: SourceLocation,
+  diagnostics: IRDiagnostic[],
+): WorkflowStepIR {
+  const id = String(node.id || "database");
+  const operation = typeof node.operation === "string" ? node.operation : "";
+  const query = typeof node.query === "string" ? node.query.trim() : "";
+
+  if (operation === "mutation" && query) {
+    diagnostics.push(withSourceLocation({
+      severity: "error",
+      rule: "legacy_mutation_with_query",
+      message: `Legacy node '${id}' uses operation: mutation with query. Importing as dypai.db.query for compatibility review.`,
+      fixHint: "Change YAML to operation: query or use declarative mutation fields without query.",
+    }, source));
+    return {
+      id,
+      node: "dypai.db",
+      operation: "query",
+      version: 1,
+      config: { sql: query },
+      source,
+    };
+  }
+
+  if (operation === "query" || operation === "custom_query" || query) {
+    return {
+      id,
+      node: "dypai.db",
+      operation: "query",
+      version: 1,
+      config: {
+        sql: query,
+        ...(isRecord(node.params) ? { params: node.params } : {}),
+      },
+      source,
+    };
+  }
+
+  if (operation === "mutation") {
+    if (node.insert) {
+      return {
+        id,
+        node: "dypai.db",
+        operation: "insert",
+        version: 1,
+        config: {
+          table: String(node.table || ""),
+          values: isRecord(node.insert) ? node.insert : {},
+          ...(Array.isArray(node.returning) ? { returning: node.returning } : {}),
+        },
+        source,
+      };
+    }
+    if (node.update) {
+      return {
+        id,
+        node: "dypai.db",
+        operation: "update",
+        version: 1,
+        config: {
+          table: String(node.table || ""),
+          set: isRecord(node.update) ? node.update : {},
+          where: isRecord(node.where) ? node.where : {},
+          ...(Array.isArray(node.returning) ? { returning: node.returning } : {}),
+        },
+        source,
+      };
+    }
+  }
+
+  diagnostics.push(withSourceLocation({
+    severity: "warn",
+    rule: "legacy_database_unmapped",
+    message: `Legacy database node '${id}' was preserved as legacy.workflow.`,
+    fixHint: "Prefer operation: query or declarative dypai.db operations in WorkflowIR.",
+  }, source));
+
+  return {
+    id,
+    node: "legacy.workflow",
+    operation: "node",
+    version: 1,
+    config: { legacyNode: node },
+    source,
+  };
+}
+
+function responseMapFromOutputSchema(
+  outputSchema: JsonSchema,
+  stepId: string,
+): Record<string, RefIR> {
+  const properties = schemaPropertyNames(outputSchema);
+  const responseMap: Record<string, RefIR> = {};
+  for (const key of properties) {
+    responseMap[key] = { kind: "step", stepId, path: [key] };
+  }
+  return responseMap;
+}
+
+function importLegacyNode(
+  node: Record<string, unknown>,
+  index: number,
+  file: string | undefined,
+  diagnostics: IRDiagnostic[],
+): { step?: WorkflowStepIR; returnMap?: Record<string, RefIR>; isReturn?: boolean } {
+  const type = String(node.type ?? node.node_type ?? "");
+  const id = String(node.id || `step_${index}`);
+  const source = nodeSource(file, index, id);
+  const isReturn = node.return === true || node.is_return === true;
+
+  if (type === "dypai_database") {
+    return { step: importDatabaseNode(node, source, diagnostics), isReturn };
+  }
+
+  if (type === "set_fields" && isReturn && node.operation === "compose" && isRecord(node.fields)) {
+    return {
+      step: {
+        id,
+        node: "dypai.flow",
+        operation: "return",
+        version: 1,
+        config: {},
+        return: true,
+        source,
+      },
+      returnMap: composeFieldsToResponseMap(node.fields),
+      isReturn: true,
+    };
+  }
+
+  if (type === "set_fields" && isReturn) {
+    diagnostics.push(withSourceLocation({
+      severity: "warn",
+      rule: "legacy_return_not_compose",
+      message: `Legacy set_fields node '${id}' uses return without compose.`,
+      fixHint: "Use operation: compose for endpoint responses.",
+    }, source));
+  }
+
+  return {
+    step: {
+      id,
+      node: "legacy.workflow",
+      operation: "node",
+      version: 1,
+      config: { legacyNode: node },
+      source,
+      ...(isReturn ? { return: true } : {}),
+    },
+    isReturn,
+  };
+}
+
+export function legacyYamlDocumentToIr(
+  doc: Record<string, unknown>,
+  options: { file?: string } = {},
+): ImportYamlResult {
+  const diagnostics: IRDiagnostic[] = [];
+  const file = options.file;
+
+  const name = typeof doc.name === "string" && doc.name.trim()
+    ? doc.name.trim()
+    : file?.split("/").pop()?.replace(/\.(ya?ml|json)$/i, "") || "endpoint";
+  const method = normalizeHttpMethod(doc.method);
+  const workflowRaw = isRecord(doc.workflow) ? doc.workflow : {};
+  const lifted = liftStartTriggerNodes(workflowRaw);
+  const triggerValue = doc.trigger || lifted.inferredTrigger || { http_api: { auth_mode: "jwt" } };
+  const allowedRoles = Array.isArray(doc.allowed_roles)
+    ? doc.allowed_roles.filter((item): item is string => typeof item === "string")
+    : undefined;
+
+  const steps: WorkflowStepIR[] = [];
+  let responseMap: Record<string, RefIR> = {};
+  let sawFlowReturn = false;
+
+  lifted.nodes.forEach((node, index) => {
+    if (!isRecord(node)) return;
+    const imported = importLegacyNode(node, index, file, diagnostics);
+    if (imported.step) steps.push(imported.step);
+    if (imported.returnMap) {
+      responseMap = imported.returnMap;
+      sawFlowReturn = true;
+    } else if (imported.isReturn && imported.step?.node === "dypai.db") {
+      const output = isRecord(doc.output) ? doc.output as JsonSchema : { type: "object", properties: {} };
+      responseMap = responseMapFromOutputSchema(output, imported.step.id);
+      sawFlowReturn = true;
+    }
+  });
+
+  if (!sawFlowReturn) {
+    steps.push({
+      id: "return",
+      node: "dypai.flow",
+      operation: "return",
+      version: 1,
+      config: {},
+      return: true,
+      source: { file, yamlPath: "workflow.response" },
+    });
+    const output = isRecord(doc.output) ? doc.output as JsonSchema : { type: "object", properties: {} };
+    responseMap = responseMapFromOutputSchema(output, steps[0]?.id || "return");
+  } else if (!steps.some((step) => step.node === "dypai.flow" && step.operation === "return")) {
+    steps.push({
+      id: "return",
+      node: "dypai.flow",
+      operation: "return",
+      version: 1,
+      config: {},
+      return: true,
+      source: { file, yamlPath: "workflow.response" },
+    });
+  }
+
+  const edges = lifted.edges
+    .map((edge) => ({
+      from: String(edge.from ?? edge.source ?? ""),
+      to: String(edge.to ?? edge.target ?? ""),
+    }))
+    .filter((edge) => edge.from && edge.to);
+
+  const workflow: WorkflowIR = {
+    version: WORKFLOW_IR_VERSION,
+    name,
+    source: file ? { kind: "legacy-yaml", file } : undefined,
+    trigger: triggerFromLegacyDoc(triggerValue, method),
+    auth: authFromLegacyTrigger(
+      isRecord(triggerValue) ? triggerValue : {},
+      allowedRoles,
+    ),
+    inputSchema: isRecord(doc.input) ? doc.input as JsonSchema : { type: "object", properties: {} },
+    outputSchema: isRecord(doc.output) ? doc.output as JsonSchema : { type: "object", properties: {} },
+    response: {
+      cardinality: responseCardinalityFromLegacy(doc.response_cardinality),
+    },
+    steps,
+    edges: edges.length ? edges : undefined,
+    responseMap,
+  };
+
+  return {
+    ok: !diagnostics.some((item) => item.severity === "error"),
+    value: workflow,
+    diagnostics,
+  };
+}
+
+export function legacyYamlToIr(yamlText: string, options: { file?: string } = {}): ImportYamlResult {
+  try {
+    const parsed = parseYaml(yamlText);
+    if (!isRecord(parsed)) {
+      return {
+        ok: false,
+        diagnostics: [{
+          severity: "error",
+          rule: "legacy_yaml_invalid_root",
+          message: "Legacy endpoint YAML root must be an object.",
+        }],
+      };
+    }
+    return legacyYamlDocumentToIr(parsed, options);
+  } catch (error) {
+    return {
+      ok: false,
+      diagnostics: [{
+        severity: "error",
+        rule: "legacy_yaml_parse_error",
+        message: error instanceof Error ? error.message : "Failed to parse legacy YAML.",
+      }],
+    };
+  }
+}

package/src/adapters/placeholderToRef.ts

@@ -0,0 +1,74 @@
+import type { RefIR } from "../ir/types";
+
+const INPUT_REF = /^\$\{\s*input\.([a-zA-Z0-9_.[\]]+)\s*\}$/;
+const CURRENT_USER_REF = /^\$\{\s*current_user_id\s*\}$/;
+const VARS_REF = /^\$\{\s*vars\.([a-zA-Z0-9_]+)((?:\[\d+\])?(?:\.[a-zA-Z0-9_[\]]+)*)\s*\}$/;
+const ENV_REF = /^\$\{\s*env\.([A-Z0-9_]+)\s*\}$/;
+
+function splitRefPath(path: string): string[] {
+  const parts: string[] = [];
+  const regex = /([a-zA-Z0-9_]+)|\[(\d+)\]/g;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(path)) !== null) {
+    if (match[1]) parts.push(match[1]);
+    if (match[2]) parts.push(match[2]);
+  }
+  return parts;
+}
+
+export function placeholderToRef(value: unknown): RefIR | unknown {
+  if (typeof value !== "string") return value;
+
+  const trimmed = value.trim();
+  if (CURRENT_USER_REF.test(trimmed)) return { kind: "currentUserId" };
+
+  const inputMatch = trimmed.match(INPUT_REF);
+  if (inputMatch) {
+    return { kind: "input", path: splitRefPath(inputMatch[1]) };
+  }
+
+  const varsMatch = trimmed.match(VARS_REF);
+  if (varsMatch) {
+    const stepId = varsMatch[1];
+    const tail = varsMatch[2]?.replace(/^\./, "").trim();
+    return {
+      kind: "step",
+      stepId,
+      path: tail ? splitRefPath(tail) : undefined,
+    };
+  }
+
+  const envMatch = trimmed.match(ENV_REF);
+  if (envMatch) return { kind: "env", name: envMatch[1] };
+
+  return value;
+}
+
+export function mapObjectPlaceholdersToRefs(value: unknown): unknown {
+  const ref = placeholderToRef(value);
+  if (ref !== value) return ref;
+  if (Array.isArray(value)) return value.map((item) => mapObjectPlaceholdersToRefs(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] = mapObjectPlaceholdersToRefs(nested);
+    }
+    return out;
+  }
+  return value;
+}
+
+export function composeFieldsToResponseMap(
+  fields: Record<string, unknown>,
+): Record<string, RefIR> {
+  const responseMap: Record<string, RefIR> = {};
+  for (const [key, value] of Object.entries(fields)) {
+    const mapped = mapObjectPlaceholdersToRefs(value);
+    if (mapped && typeof mapped === "object" && !Array.isArray(mapped) && "kind" in mapped) {
+      responseMap[key] = mapped as RefIR;
+    } else if (typeof mapped === "string" || typeof mapped === "number" || typeof mapped === "boolean") {
+      responseMap[key] = { kind: "literal", value: mapped };
+    }
+  }
+  return responseMap;
+}