@darkhorseprojects/circuitry 0.3.0 → 0.3.2

package/dist/node.js

@@ -5,35 +5,11 @@ import path from "node:path";
 import os from "node:os";
 
 // src/yaml.ts
-import YAML from "yaml";
+import YAML2 from "yaml";
 
 // src/graph.ts
-var CIRCUITRY_SPEC_VERSION = "0.3.0";
-var runtimeInputToText = (value) => {
-  if (typeof value === "string") return value;
-  if (value === void 0) return "";
-  return JSON.stringify(value, null, 2);
-};
-var applyCircuitryRuntimeInputs = (graph, inputs = {}) => {
-  const entries = Object.entries(inputs);
-  if (entries.length === 0) return graph;
-  const next = {
-    ...graph,
-    resources: graph.resources ? { ...graph.resources } : graph.resources
-  };
-  for (const [id, value] of entries) {
-    const text = runtimeInputToText(value);
-    const resource = next.resources?.[id];
-    if (resource) {
-      if (resource.type !== "text")
-        throw new Error(`Runtime input ${id} targets non-text resource: ${resource.type}`);
-      next.resources[id] = { ...resource, value: text };
-      continue;
-    }
-    throw new Error(`Runtime input does not match a graph text resource: ${id}`);
-  }
-  return next;
-};
+import YAML from "yaml";
+var CIRCUITRY_SPEC_VERSION = "0.3.2";
 var DEFAULT_CIRCUITRY_VALIDATION_RULES = [
   "no-self-loops",
   "no-unknown-edge-endpoints",
@@ -46,25 +22,30 @@ var DEFAULT_CIRCUITRY_VALIDATION_STANDARD = {
   rules: DEFAULT_CIRCUITRY_VALIDATION_RULES,
   executableKinds: ["agent", "tool", "output"]
 };
-var executableKindsFromRules = (rules = []) => {
-  const executableRule = rules.find(
-    (entry) => typeof entry !== "string" && entry.rule === "require-executable-inputs"
-  );
-  return executableRule?.executableKinds;
+var runtimeInputToText = (value) => {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "";
+  return YAML.stringify(value).trimEnd();
+};
+var applyCircuitryRuntimeInputs = (graph, inputs = {}) => {
+  const next = { ...graph, resources: graph.resources ? { ...graph.resources } : graph.resources };
+  for (const [id, value] of Object.entries(inputs)) {
+    const resource = next.resources?.[id];
+    if (!resource) throw new Error(`unknown arg: ${id}`);
+    if (resource.type !== "text") throw new Error(`arg is not text: ${id}`);
+    next.resources[id] = { ...resource, value: runtimeInputToText(value) };
+  }
+  return next;
 };
+var ruleName = (rule) => typeof rule === "string" ? rule : rule.rule;
+var executableKindsFromRules = (rules) => rules.find((rule) => typeof rule !== "string" && rule.rule === "require-executable-inputs")?.executableKinds;
 var createCircuitryValidationStandard = (standard = {}, graph) => {
-  const rules = [
-    ...DEFAULT_CIRCUITRY_VALIDATION_RULES,
-    ...graph?.validation?.rules || [],
-    ...standard.rules || []
-  ];
+  const rules = [...DEFAULT_CIRCUITRY_VALIDATION_RULES, ...graph?.validation?.rules || [], ...standard.rules || []];
   return {
     version: standard.version || DEFAULT_CIRCUITRY_VALIDATION_STANDARD.version,
     requireSpecVersion: standard.requireSpecVersion ?? DEFAULT_CIRCUITRY_VALIDATION_STANDARD.requireSpecVersion,
     rules,
-    executableKinds: standard.executableKinds || executableKindsFromRules(rules) || [
-      ...DEFAULT_CIRCUITRY_VALIDATION_STANDARD.executableKinds
-    ]
+    executableKinds: standard.executableKinds || executableKindsFromRules(rules) || [...DEFAULT_CIRCUITRY_VALIDATION_STANDARD.executableKinds]
   };
 };
 var expandResources = (resources) => {
@@ -72,294 +53,151 @@ var expandResources = (resources) => {
   const edges = [];
   for (const [id, resource] of Object.entries(resources)) {
     if (resource.type === "text") {
-      nodes.push({
-        id,
-        kind: "input",
-        label: resource.label || id,
-        input: { type: "text", value: resource.value }
-      });
+      nodes.push({ id, kind: "input", label: resource.label || id, input: { type: "text", value: resource.value } });
     } else if (resource.type === "agent") {
+      const agent = resource;
       nodes.push({
         id,
         kind: "agent",
-        label: resource.label || resource.identity || id,
+        label: agent.label || agent.identity || id,
         agent: {
-          identity: resource.identity || resource.label || id,
-          model: resource.model,
-          thinkingLevel: resource.thinkingLevel,
-          tools: resource.tools,
-          instructions: resource.instructions,
-          personality: resource.personality,
-          context: resource.context
+          identity: agent.identity || agent.label || id,
+          model: agent.model,
+          tools: agent.tools,
+          instructions: agent.instructions,
+          personality: agent.personality,
+          context: agent.context
         },
-        skills: resource.skills,
-        expect: resource.expect
+        skills: agent.skills,
+        expect: agent.expect
       });
-      for (const inputRef of resource.inputs || []) {
-        edges.push({ from: inputRef, to: id, kind: "dependency" });
-      }
+      for (const input of agent.inputs || []) edges.push({ from: input, to: id, kind: "dependency" });
     } else if (resource.type === "tool") {
-      nodes.push({
-        id,
-        kind: "tool",
-        label: resource.label || id,
-        agent: { instructions: resource.instructions }
-      });
-      for (const inputRef of resource.inputs || []) {
-        edges.push({ from: inputRef, to: id, kind: "dependency" });
-      }
+      const tool = resource;
+      nodes.push({ id, kind: "tool", label: tool.label || id, agent: { instructions: tool.instructions } });
+      for (const input of tool.inputs || []) edges.push({ from: input, to: id, kind: "dependency" });
+    } else {
+      const input = resource;
+      nodes.push({ id, kind: "input", label: input.label || id, input: { type: input.type, value: input.value, uri: input.uri || input.path, mimeType: input.mimeType, data: input.data } });
     }
   }
   return { nodes, edges };
 };
 var normalizeCircuitryGraph = (graph) => {
-  if (!graph.resources || Object.keys(graph.resources).length === 0) return { ...graph };
-  const { nodes, edges } = expandResources(graph.resources);
-  return { ...graph, nodes, edges };
+  if (!graph.resources) return { ...graph };
+  return { ...graph, ...expandResources(graph.resources) };
 };
-var VALID_SPEC_VERSIONS = /* @__PURE__ */ new Set(["0.3"]);
-var validateCircuitryGraphInternal = (graph, standard = {}, options) => {
-  const resolvedStandard = createCircuitryValidationStandard(
-    standard,
-    graph && typeof graph === "object" && !Array.isArray(graph) ? graph : void 0
-  );
+var validateCircuitryGraphInternal = (graph, standard = {}, source) => {
+  const resolved = createCircuitryValidationStandard(standard, graph && typeof graph === "object" && !Array.isArray(graph) ? graph : void 0);
   const errors = [];
-  const addError = (code, message, path3) => errors.push({ code, message, ...path3 ? { path: path3 } : {} });
-  if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
-    addError("invalid_graph", "Circuitry graph must be an object");
-    return { ok: false, errors, standard: resolvedStandard };
-  }
-  const graphObject = graph;
-  const rules = resolvedStandard.rules;
-  const hasRule = (name) => rules.some((entry) => (typeof entry === "string" ? entry : entry.rule) === name);
-  if (resolvedStandard.requireSpecVersion && !VALID_SPEC_VERSIONS.has(String(graphObject.circuitry))) {
-    addError(
-      "invalid_spec_version",
-      `Expected circuitry: "${CIRCUITRY_SPEC_VERSION}"`,
-      ["circuitry"]
-    );
-  }
-  if (options.sourceFormat) {
-    if (!graphObject.resources || Object.keys(graphObject.resources).length === 0) {
-      addError("missing_resources", "Circuitry v0.3 graphs must use a resources: section", ["resources"]);
-    }
-    if (graphObject.agents && Object.keys(graphObject.agents).length > 0) {
-      addError("forbidden_agents", "Circuitry v0.3 graph files must not use top-level agents:; use resources:", ["agents"]);
-    }
-    if (graphObject.inputs && Object.keys(graphObject.inputs).length > 0) {
-      addError("forbidden_inputs", "Circuitry v0.3 graph files must not use top-level inputs:; use resources:", ["inputs"]);
-    }
-    if (graphObject.nodes && graphObject.nodes.length > 0) {
-      addError("forbidden_nodes", "Circuitry v0.3 graph files must not use top-level nodes:; use resources:", ["nodes"]);
-    }
-    if (graphObject.edges && graphObject.edges.length > 0) {
-      addError("forbidden_edges", "Circuitry v0.3 graph files must not use top-level edges:; use resource inputs:", ["edges"]);
-    }
-    if (graphObject.links && graphObject.links.length > 0) {
-      addError("forbidden_links", "Circuitry v0.3 graph files must use imports: instead of links:", ["links"]);
-    }
-  }
-  const normalized = normalizeCircuitryGraph(graphObject);
+  const issue = (code, message = code, path2) => errors.push({ code, message, ...path2 ? { path: path2 } : {} });
+  if (!graph || typeof graph !== "object" || Array.isArray(graph)) return { ok: false, errors: [{ code: "invalid_graph", message: "invalid graph" }], standard: resolved };
+  const g = graph;
+  if (resolved.requireSpecVersion && g.circuitry !== resolved.version) issue("invalid_version", "invalid version", ["circuitry"]);
+  if (source) {
+    const raw = g;
+    if (!g.resources || Object.keys(g.resources).length === 0) issue("missing_resources", "missing resources", ["resources"]);
+    if (raw.agents) issue("forbidden_agents", "forbidden agents", ["agents"]);
+    if (raw.inputs) issue("forbidden_inputs", "forbidden inputs", ["inputs"]);
+    if (g.nodes?.length) issue("forbidden_nodes", "forbidden nodes", ["nodes"]);
+    if (g.edges?.length) issue("forbidden_edges", "forbidden edges", ["edges"]);
+    if (raw.links) issue("forbidden_links", "forbidden links", ["links"]);
+  }
+  const rules = new Set(resolved.rules.map(ruleName));
+  const normalized = normalizeCircuitryGraph(g);
   const ids = /* @__PURE__ */ new Set();
   for (const [index, node] of (normalized.nodes || []).entries()) {
     if (!node.id) {
-      addError("missing_node_id", "Node is missing id", ["nodes", index, "id"]);
+      issue("missing_node_id", "missing node id", ["nodes", index, "id"]);
       continue;
     }
-    if (ids.has(node.id)) {
-      addError("duplicate_node_id", `Duplicate node id: ${node.id}`, ["nodes", index, "id"]);
-    }
+    if (ids.has(node.id)) issue("duplicate_node_id", "duplicate node id", ["nodes", index, "id"]);
     ids.add(node.id);
-    if (!node.kind) {
-      addError("missing_node_kind", `Node ${node.id} is missing kind`, ["nodes", index, "kind"]);
-    }
+    if (!node.kind) issue("missing_node_kind", "missing node kind", ["nodes", index, "kind"]);
   }
   const adjacency = /* @__PURE__ */ new Map();
-  const incomingCount = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
   for (const id of ids) {
     adjacency.set(id, []);
-    incomingCount.set(id, 0);
+    incoming.set(id, 0);
   }
   for (const [index, edge] of (normalized.edges || []).entries()) {
     if (!edge.from || !edge.to) {
-      addError("missing_edge_endpoint", "Edge is missing from/to", ["edges", index]);
+      issue("missing_edge_endpoint", "missing edge endpoint", ["edges", index]);
       continue;
     }
-    if (hasRule("no-self-loops") && edge.from === edge.to) {
-      addError("self_loop", `Edge creates self loop: ${edge.from} -> ${edge.to}`, ["edges", index]);
+    if (rules.has("no-self-loops") && edge.from === edge.to) {
+      issue("self_loop", "self loop", ["edges", index]);
       continue;
     }
-    if (hasRule("no-unknown-edge-endpoints") && !ids.has(edge.from)) {
-      addError("unknown_edge_source", `Edge references unknown source: ${edge.from}`, ["edges", index, "from"]);
+    const ok = ids.has(edge.from) && ids.has(edge.to);
+    if (rules.has("no-unknown-edge-endpoints")) {
+      if (!ids.has(edge.from)) issue("unknown_edge_source", "unknown edge source", ["edges", index, "from"]);
+      if (!ids.has(edge.to)) issue("unknown_edge_target", "unknown edge target", ["edges", index, "to"]);
     }
-    if (hasRule("no-unknown-edge-endpoints") && !ids.has(edge.to)) {
-      addError("unknown_edge_target", `Edge references unknown target: ${edge.to}`, ["edges", index, "to"]);
-    }
-    if (ids.has(edge.from) && ids.has(edge.to)) {
+    if (ok) {
       adjacency.get(edge.from).push(edge.to);
-      incomingCount.set(edge.to, (incomingCount.get(edge.to) || 0) + 1);
+      incoming.set(edge.to, (incoming.get(edge.to) || 0) + 1);
     }
   }
-  const executableKinds = new Set(resolvedStandard.executableKinds);
-  if (hasRule("require-executable-inputs")) {
+  if (rules.has("require-executable-inputs")) {
+    const executable = new Set(resolved.executableKinds);
     for (const [index, node] of (normalized.nodes || []).entries()) {
-      if (executableKinds.has(node.kind) && (incomingCount.get(node.id) || 0) === 0) {
-        addError("executable_without_inputs", `Executable node has no inputs: ${node.id}`, ["nodes", index]);
-      }
-    }
-  }
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const path2 = [];
-  let cycleMessage = "";
-  const visit = (id) => {
-    if (cycleMessage) return;
-    if (visiting.has(id)) {
-      cycleMessage = [...path2.slice(path2.indexOf(id)), id].join(" -> ");
-      return;
-    }
-    if (visited.has(id)) return;
-    visiting.add(id);
-    path2.push(id);
-    for (const next of adjacency.get(id) || []) visit(next);
-    path2.pop();
-    visiting.delete(id);
-    visited.add(id);
-  };
-  if (hasRule("no-cycles")) {
-    for (const id of ids) {
-      visit(id);
-      if (cycleMessage) {
-        addError("cycle", `Graph contains cycle: ${cycleMessage}`);
-        break;
-      }
-    }
-  }
-  const additionalRules = rules.filter((rule) => {
-    if (typeof rule === "string") return false;
-    return rule.rule === "require-graph-field" || rule.rule === "require-node-field" || rule.rule === "require-edge-field" || rule.rule === "require-string" || rule.rule === "reject-string";
-  });
-  const fieldPath = (field) => field.split(".").filter(Boolean);
-  const getField = (value, field) => fieldPath(field).reduce((current, key) => {
-    if (!current || typeof current !== "object") return void 0;
-    return current[key];
-  }, value);
-  const isPresent = (value) => value !== void 0 && value !== null && value !== "";
-  for (const rule of additionalRules) {
-    if (rule.rule === "require-graph-field") {
-      if (!isPresent(getField(normalized, rule.field))) {
-        addError("missing_required_graph_field", `Graph is missing required field: ${rule.field}`, fieldPath(rule.field));
-      }
-      continue;
-    }
-    if (rule.rule === "require-node-field") {
-      const nodeKinds = new Set(rule.nodeKinds || []);
-      for (const [index, node] of (normalized.nodes || []).entries()) {
-        if (nodeKinds.size > 0 && !nodeKinds.has(node.kind)) continue;
-        if (!isPresent(getField(node, rule.field))) {
-          addError("missing_required_node_field", `Node ${node.id || "<missing id>"} is missing required field: ${rule.field}`, ["nodes", index, ...fieldPath(rule.field)]);
-        }
-      }
-      continue;
-    }
-    if (rule.rule === "require-edge-field") {
-      const edgeKinds = new Set(rule.edgeKinds || []);
-      for (const [index, edge] of (normalized.edges || []).entries()) {
-        if (edgeKinds.size > 0 && (!edge.kind || !edgeKinds.has(edge.kind))) continue;
-        if (!isPresent(getField(edge, rule.field))) {
-          addError("missing_required_edge_field", `Edge ${edge.id || index} is missing required field: ${rule.field}`, ["edges", index, ...fieldPath(rule.field)]);
-        }
-      }
-      continue;
-    }
-    const checkString = (target, subject, id, match, path3) => {
-      const value = getField(subject, match.field);
-      const text = typeof value === "string" ? value : "";
-      const includes = text.includes(match.value);
-      if (rule.rule === "require-string" && !includes) {
-        addError("missing_required_string", `${target} ${id} field ${match.field} must include string: ${match.value}`, path3);
-      }
-      if (rule.rule === "reject-string" && includes) {
-        addError("rejected_string", `${target} ${id} field ${match.field} must not include string: ${match.value}`, path3);
-      }
+      if (executable.has(node.kind) && (incoming.get(node.id) || 0) === 0) issue("missing_executable_input", "missing executable input", ["nodes", index]);
+    }
+  }
+  if (rules.has("no-cycles")) {
+    const visiting = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (id) => {
+      if (visiting.has(id)) return true;
+      if (visited.has(id)) return false;
+      visiting.add(id);
+      for (const next of adjacency.get(id) || []) if (visit(next)) return true;
+      visiting.delete(id);
+      visited.add(id);
+      return false;
     };
-    for (const match of rule.graph || []) checkString("graph", normalized, "<root>", match, fieldPath(match.field));
-    for (const match of rule.nodes || []) {
-      const nodeKinds = new Set(match.nodeKinds || []);
-      for (const [index, node] of (normalized.nodes || []).entries()) {
-        if (nodeKinds.size > 0 && !nodeKinds.has(node.kind)) continue;
-        checkString("node", node, node.id || "<missing id>", match, ["nodes", index, ...fieldPath(match.field)]);
-      }
-    }
-    for (const match of rule.edges || []) {
-      const edgeKinds = new Set(match.edgeKinds || []);
-      for (const [index, edge] of (normalized.edges || []).entries()) {
-        if (edgeKinds.size > 0 && (!edge.kind || !edgeKinds.has(edge.kind))) continue;
-        checkString("edge", edge, edge.id || String(index), match, ["edges", index, ...fieldPath(match.field)]);
-      }
+    for (const id of ids) if (visit(id)) {
+      issue("cycle", "cycle");
+      break;
     }
   }
-  return { ok: errors.length === 0, errors, standard: resolvedStandard };
-};
-var validateCircuitryGraphWithStandard = (graph, standard = {}) => validateCircuitryGraphInternal(graph, standard, { sourceFormat: true });
-var validateCircuitryExecutionGraphWithStandard = (graph, standard = {}) => validateCircuitryGraphInternal(graph, standard, { sourceFormat: false });
-var validateCircuitryGraph = (graph, standard = {}) => validateCircuitryGraphWithStandard(graph, standard).errors.map(
-  (error) => error.message
-);
-var parseCircuitryJson = (text, standard = {}, options = {}) => {
-  let graph;
-  try {
-    graph = JSON.parse(text);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not parse Circuitry JSON. Check commas, quotes, and braces.
-${message}`);
-  }
-  if (options.validate === false) return graph;
-  const errors = validateCircuitryGraph(graph, standard);
-  if (errors.length) {
-    throw new Error(`Invalid Circuitry graph:
-${errors.join("\n")}`);
-  }
-  return normalizeCircuitryGraph(graph);
-};
-var stringifyCircuitryJson = (graph) => {
-  return `${JSON.stringify(normalizeCircuitryGraph(graph), null, 2)}
-`;
+  return { ok: errors.length === 0, errors, standard: resolved };
 };
+var validateCircuitryGraphWithStandard = (graph, standard = {}) => validateCircuitryGraphInternal(graph, standard, true);
+var validateCircuitryExecutionGraphWithStandard = (graph, standard = {}) => validateCircuitryGraphInternal(graph, standard, false);
+var validateCircuitryGraph = (graph, standard = {}) => validateCircuitryGraphWithStandard(graph, standard).errors.map((error) => error.message);
 
 // src/yaml.ts
-var parseCircuitryYaml = (text, standard = {}, options = {}) => {
-  let graph;
+var parseYamlData = (text) => {
   try {
-    graph = YAML.parse(text);
+    return YAML2.parse(text);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not parse Circuitry YAML. Check indentation and quotes.
+    throw new Error(`Could not parse YAML.
 ${message}`);
   }
+};
+var stringifyYamlData = (value) => YAML2.stringify(value);
+var parseCircuitryYaml = (text, standard = {}, options = {}) => {
+  const graph = parseYamlData(text);
   if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
-    throw new Error("Could not parse Circuitry YAML. Expected a graph object.");
+    throw new Error("Circuitry YAML must be a graph object.");
   }
-  if (options.validate === false) return graph;
-  const errors = validateCircuitryGraph(graph, standard);
-  if (errors.length) {
-    throw new Error(`Invalid Circuitry graph:
+  if (options.validate !== false) {
+    const errors = validateCircuitryGraph(graph, standard);
+    if (errors.length) throw new Error(`Invalid Circuitry graph:
 ${errors.join("\n")}`);
   }
-  return normalizeCircuitryGraph(graph);
-};
-var stringifyCircuitryYaml = (graph) => {
-  return YAML.stringify(normalizeCircuitryGraph(graph));
-};
-var parseCircuitryText = (text, filename = "graph.circuitry.yaml", standard = {}, options = {}) => {
-  return filename.endsWith(".json") ? parseCircuitryJson(text, standard, options) : parseCircuitryYaml(text, standard, options);
-};
-var stringifyCircuitryText = (graph, filename = "graph.circuitry.yaml") => {
-  return filename.endsWith(".json") ? stringifyCircuitryJson(graph) : stringifyCircuitryYaml(graph);
+  return graph;
 };
+var stringifyCircuitryYaml = (graph) => YAML2.stringify(graph);
+var parseCircuitryText = (text, standard = {}, options = {}) => parseCircuitryYaml(text, standard, options);
+var stringifyCircuitryText = (graph) => stringifyCircuitryYaml(graph);
 
 // src/scheduler.ts
+import YAML3 from "yaml";
 var buildCircuitryExecutionGraph = (graph) => {
   const normalized = normalizeCircuitryGraph(graph);
   const nodes = /* @__PURE__ */ new Map();
@@ -399,7 +237,7 @@ var formatEdgeData = (data) => {
   if (!data || Object.keys(data).length === 0) {
     return "";
   }
-  return ` data=${JSON.stringify(data)}`;
+  return ` data=${YAML3.stringify(data).trimEnd()}`;
 };
 var describeEdge = (edge, direction) => {
   const otherId = direction === "incoming" ? edge.from : edge.to;
@@ -444,17 +282,17 @@ ${contextSection}`
   ].filter(Boolean).join("\n\n");
 };
 var collectImages = (contextInputs) => contextInputs.filter((item) => item.kind === "image" && item.image).map((item) => item.image);
-var stripJsonFence = (output) => {
+var stripYamlFence = (output) => {
   const trimmed = output.trim();
-  const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  const fenced = trimmed.match(/^```(?:ya?ml)?\s*([\s\S]*?)\s*```$/i);
   return fenced ? fenced[1].trim() : trimmed;
 };
 var parseExpectedOutput = (nodeId, output) => {
   try {
-    return JSON.parse(stripJsonFence(output));
+    return YAML3.parse(stripYamlFence(output));
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`Node ${nodeId} output does not match expect: output is not valid JSON (${detail})`);
+    throw new Error(`Node ${nodeId} output does not match expect: output is not valid YAML (${detail})`);
   }
 };
 var isFieldObject = (schema) => !!schema && typeof schema === "object" && !Array.isArray(schema) && typeof schema.type === "string";
@@ -537,7 +375,7 @@ ${errors.join("\n")}`);
 var executeCircuitryNode = async ({
   graph,
   item,
-  fallbackCycle,
+  cycle,
   inputPayload,
   contextInputs,
   defaultModel,
@@ -545,13 +383,13 @@ var executeCircuitryNode = async ({
   onNodeStart,
   onNodeComplete
 }) => {
-  onNodeStart?.(item.id, fallbackCycle);
+  onNodeStart?.(item.id, cycle);
   if (item.node.kind === "output") {
     const output = inputPayload.map((input) => input.output).join("\n\n");
     onNodeComplete?.(item.id, { output });
     return {
       nodeId: item.id,
-      fallbackCycle,
+      cycle,
       inputNodeIds: inputPayload.map((input) => input.nodeId),
       output
     };
@@ -563,7 +401,6 @@ var executeCircuitryNode = async ({
       nodeId: item.id,
       model: (agent.model === "inherit" ? void 0 : agent.model) || (defaultModel === "inherit" ? void 0 : defaultModel) || "inherit",
       tools: agent.tools || [],
-      thinkingLevel: agent.thinkingLevel || "off",
       personality: agent.personality || "",
       instructions: agent.instructions || "",
       context: agent.context || "",
@@ -577,7 +414,7 @@ var executeCircuitryNode = async ({
     onNodeComplete?.(item.id, { error: message });
     return {
       nodeId: item.id,
-      fallbackCycle,
+      cycle,
       inputNodeIds: inputPayload.map((input) => input.nodeId),
       output: "",
       error: message
@@ -587,7 +424,7 @@ var executeCircuitryNode = async ({
   onNodeComplete?.(item.id, { output: result.output });
   return {
     nodeId: item.id,
-    fallbackCycle,
+    cycle,
     inputNodeIds: inputPayload.map((input) => input.nodeId),
     output: result.output
   };
@@ -606,7 +443,7 @@ var runCircuitryGraphExecution = async ({
   const parallelism = Math.max(1, Math.floor(maxParallelRuns));
   const defaultModel = graph.runtime?.model;
   const runOne = async (nodeId, outputs2) => {
-    const fallbackCycle = false;
+    const cycle = false;
     const item = executionGraph.nodes.get(nodeId);
     const inputPayload = item.inputNodeIds.filter((sourceId) => outputs2.has(sourceId)).map((sourceId) => ({
       nodeId: sourceId,
@@ -620,7 +457,7 @@ var runCircuitryGraphExecution = async ({
     return executeCircuitryNode({
       graph,
       item,
-      fallbackCycle,
+      cycle,
       inputPayload,
       contextInputs,
       defaultModel,
@@ -706,7 +543,8 @@ var loadPiSDK = async () => {
       return await import(modulePath);
     }
   }
-  return await import("@earendil-works/pi-coding-agent");
+  const packageName = "@earendil-works/pi-coding-agent";
+  return await import(packageName);
 };
 var extractAssistantText = (message) => {
   if (!message || message.role !== "assistant") return "";
@@ -745,8 +583,7 @@ var runNodeWithPiSDK = async ({
   model,
   prompt,
   images = [],
-  tools = [],
-  thinkingLevel = "off"
+  tools = []
 }) => {
   let sdk;
   try {
@@ -770,7 +607,6 @@ var runNodeWithPiSDK = async ({
   const selectedModel = requestedModel && requestedModel !== "inherit" ? findRequestedModel(modelRegistry, await modelRegistry.getAvailable(), requestedModel) : void 0;
   const { session } = await createAgentSession({
     ...selectedModel ? { model: selectedModel } : {},
-    thinkingLevel,
     sessionManager: SessionManager.inMemory(),
     authStorage,
     modelRegistry,
@@ -804,6 +640,63 @@ var runNodeWithPiSDK = async ({
   }
 };
 var defaultFilename = "graph.circuitry.yaml";
+var resourceInputs = (resource) => "inputs" in resource && Array.isArray(resource.inputs) ? resource.inputs : [];
+var withResourceInputs = (resource, inputs) => "inputs" in resource ? { ...resource, inputs } : resource;
+var selectedImportResources = (imp, resources) => {
+  if (imp.resources === "*") return Object.fromEntries(Object.keys(resources).map((id) => [id, id]));
+  if (Array.isArray(imp.resources)) return Object.fromEntries(imp.resources.map((id) => [id, id]));
+  return imp.resources;
+};
+var importedId = (localId, prefix) => `${prefix || ""}${localId}`;
+var rewriteResourceInputs = (resource, aliasMap) => {
+  const inputs = resourceInputs(resource);
+  if (inputs.length === 0) return resource;
+  return withResourceInputs(resource, inputs.map((input) => aliasMap[input] || input));
+};
+var resolveCircuitryGraph = async (parsed, graphFile, text, standard, stack = []) => {
+  if (stack.includes(graphFile)) {
+    throw new Error(`Circuitry graph import cycle: ${[...stack, graphFile].join(" -> ")}`);
+  }
+  const nextStack = [...stack, graphFile];
+  const resources = {};
+  const origins = {};
+  for (const imp of parsed.imports || []) {
+    const linkedFile = path.resolve(path.dirname(graphFile), imp.path);
+    const loaded = await loadCircuitryGraphFile(linkedFile, standard, nextStack);
+    const available = loaded.graph.resources || {};
+    const aliases = selectedImportResources(imp, available);
+    const aliasMap = {};
+    for (const [sourceId, localId] of Object.entries(aliases)) aliasMap[sourceId] = importedId(localId, imp.prefix);
+    for (const [sourceId, localId] of Object.entries(aliases)) {
+      const resource = available[sourceId];
+      if (!resource) throw new Error(`Imported resource not found: ${sourceId} in ${imp.path}`);
+      const nextId = importedId(localId, imp.prefix);
+      if (resources[nextId]) throw new Error(`Imported Circuitry resource id collision: ${nextId} from ${imp.path}`);
+      resources[nextId] = rewriteResourceInputs(resource, aliasMap);
+      origins[nextId] = loaded.origins[sourceId] || linkedFile;
+    }
+  }
+  for (const [id, resource] of Object.entries(parsed.resources || {})) {
+    if (resources[id]) throw new Error(`Circuitry resource id collision: ${id} in ${graphFile}`);
+    resources[id] = resource;
+    origins[id] = graphFile;
+  }
+  const graph = normalizeCircuitryGraph({ ...parsed, imports: [], resources });
+  if (stack.length === 0) {
+    const validation = validateCircuitryExecutionGraphWithStandard(graph, standard);
+    if (validation.errors.length) {
+      throw new Error(`Invalid Circuitry graph:
+${validation.errors.map((e) => e.message).join("\n")}`);
+    }
+  }
+  return { filename: graphFile, text, graph, origins };
+};
+var loadCircuitryGraphFile = async (filename = defaultFilename, standard, stack = []) => {
+  const graphFile = path.resolve(process.cwd(), filename);
+  const text = await readFile(graphFile, "utf8");
+  const parsed = parseCircuitryText(text, standard, { validate: false });
+  return resolveCircuitryGraph(parsed, graphFile, text, standard, stack);
+};
 var NodeCircuitryHost = class {
   resolveGraphFile(filename) {
     return path.resolve(
@@ -812,7 +705,7 @@ var NodeCircuitryHost = class {
     );
   }
   runFileFor(filename) {
-    return `${filename}.run.json`;
+    return `${filename}.run.yaml`;
   }
   async exists(filename) {
     try {
@@ -829,98 +722,42 @@ var NodeCircuitryHost = class {
       path: [filename]
     };
   }
-  parseGraphForValidation(text, filename, standard) {
+  parseSourceGraph(text, filename, standard) {
     try {
-      return {
-        graph: parseCircuitryText(text || "", filename, standard, {
-          validate: false
-        })
-      };
+      return { graph: parseCircuitryText(text || "", standard, { validate: false }) };
     } catch (error) {
       return { error: this.parseIssue(error, filename) };
     }
   }
-  async resolveGraphImports(graph, filename, standard, stack = []) {
-    const graphFile = path.resolve(filename);
-    if (stack.includes(graphFile)) {
-      throw new Error(`Circuitry graph import cycle: ${[...stack, graphFile].join(" -> ")}`);
-    }
-    const importedResources = {};
-    const aliasMap = {};
-    const nextStack = [...stack, graphFile];
-    for (const imp of graph.imports || []) {
-      const linkedFile = path.resolve(path.dirname(graphFile), imp.path);
-      const linkedText = await readFile(linkedFile, "utf8");
-      const parsed = parseCircuitryText(linkedText, linkedFile, standard, { validate: false });
-      const resolved = await this.resolveGraphImports(parsed, linkedFile, standard, nextStack);
-      const resourceId = imp.resource;
-      const resource = resolved.resources?.[resourceId];
-      if (!resource) {
-        throw new Error(`Imported resource not found: ${resourceId} in ${imp.path}`);
-      }
-      const localId = imp.as || resourceId;
-      if (importedResources[localId]) {
-        throw new Error(`Imported Circuitry resource id collision: ${localId} from ${imp.path}`);
-      }
-      if (imp.as) aliasMap[resourceId] = localId;
-      const resourceWithRewrittenInputs = this.rewriteImportInputs(resource, aliasMap);
-      importedResources[localId] = resourceWithRewrittenInputs;
-    }
-    return {
-      ...graph,
-      resources: {
-        ...importedResources,
-        ...graph.resources || {}
-      }
-    };
-  }
-  /** Rewrite inputs in imported resource to use aliased resource ids. */
-  rewriteImportInputs(resource, aliasMap) {
-    if (resource.type === "agent" || resource.type === "tool") {
-      const newInputs = (resource.inputs || []).map((input) => aliasMap[input] || input);
-      return { ...resource, inputs: newInputs };
-    }
-    return resource;
-  }
   async parseAndResolveGraph(text, filename, standard) {
-    const parsed = this.parseGraphForValidation(text, filename, standard);
-    if (!parsed.graph) return parsed;
     try {
-      return { graph: await this.resolveGraphImports(parsed.graph, filename, standard) };
+      const graphFile = path.resolve(process.cwd(), filename);
+      const source = text || "";
+      const parsed = parseCircuitryText(source, standard, { validate: false });
+      return { graph: (await resolveCircuitryGraph(parsed, graphFile, source, standard)).graph };
     } catch (error) {
       return { error: this.parseIssue(error, filename) };
     }
   }
   async readGraphFile(filename) {
-    const graphFile = this.resolveGraphFile(filename);
-    const text = await readFile(graphFile, "utf8");
-    const parsed = await this.parseAndResolveGraph(text, graphFile);
-    if (!parsed.graph) throw new Error(`Invalid Circuitry graph:
-${parsed.error?.message}`);
-    const validation = validateCircuitryGraphWithStandard(parsed.graph);
-    if (validation.errors.length) {
-      throw new Error(
-        `Invalid Circuitry graph:
-${validation.errors.map((e) => e.message).join("\n")}`
-      );
-    }
-    return { graphFile, text, graph: normalizeCircuitryGraph(parsed.graph) };
+    const loaded = await loadCircuitryGraphFile(this.resolveGraphFile(filename));
+    return { graphFile: loaded.filename, text: loaded.text, graph: loaded.graph, origins: loaded.origins };
   }
   async readGraph(input = {}) {
     const { graphFile, text, graph } = await this.readGraphFile(input.filename);
     const lastRunFile = this.runFileFor(graphFile);
-    const lastRun = await this.exists(lastRunFile) ? JSON.parse(await readFile(lastRunFile, "utf8")) : void 0;
+    const lastRun = await this.exists(lastRunFile) ? parseYamlData(await readFile(lastRunFile, "utf8")) : void 0;
     return { filename: graphFile, graph, text, lastRun };
   }
   async validateGraph(input) {
     if (input.graph)
       return validateCircuitryGraphWithStandard(input.graph, input.standard);
     const filename = input.filename || defaultFilename;
-    const parsed = await this.parseAndResolveGraph(input.text, filename, input.standard);
-    if ("error" in parsed) {
+    const parsed = this.parseSourceGraph(input.text, filename, input.standard);
+    if (!("graph" in parsed)) {
       return {
         ok: false,
-        errors: [parsed.error],
+        errors: parsed.error ? [parsed.error] : [],
         standard: validateCircuitryGraphWithStandard({}, input.standard).standard
       };
     }
@@ -928,16 +765,13 @@ ${validation.errors.map((e) => e.message).join("\n")}`
   }
   async writeGraph(input) {
     const graphFile = this.resolveGraphFile(input.filename);
-    const parsed = input.graph ? { graph: input.graph } : await this.parseAndResolveGraph(
-      input.text,
-      input.filename || graphFile,
-      input.standard
-    );
-    if (!parsed.graph)
+    const parsed = input.graph ? { graph: input.graph } : this.parseSourceGraph(input.text, input.filename || graphFile, input.standard);
+    if (!("graph" in parsed))
       throw new Error(`Invalid Circuitry graph:
 ${parsed.error?.message}`);
+    const graph = parsed.graph;
     const validation = await this.validateGraph({
-      graph: parsed.graph,
+      graph,
       standard: input.standard
     });
     if (validation.errors.length)
@@ -947,12 +781,12 @@ ${validation.errors.map((e) => e.message).join("\n")}`
       );
     await writeFile(
       graphFile,
-      stringifyCircuitryText(parsed.graph, graphFile),
+      stringifyCircuitryText(graph),
       "utf8"
     );
     return {
       filename: graphFile,
-      graph: parsed.graph,
+      graph,
       mode: "replace"
     };
   }
@@ -986,7 +820,7 @@ ${validation.errors.map((e) => e.message).join("\n")}`
     if (source !== "text")
       await writeFile(
         this.runFileFor(graphFile),
-        JSON.stringify(result, null, 2),
+        stringifyYamlData(result),
         "utf8"
       );
     return result;
@@ -994,5 +828,6 @@ ${validation.errors.map((e) => e.message).join("\n")}`
 };
 export {
   NodeCircuitryHost,
+  loadCircuitryGraphFile,
   runNodeWithPiSDK
 };