@darkhorseprojects/circuitry 0.4.0 → 0.4.2

package/dist/node.js

@@ -1,824 +0,0 @@
-// src/node.ts
-import { access, readFile, writeFile } from "node:fs/promises";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-// src/yaml.ts
-import YAML2 from "yaml";
-
-// src/graph.ts
-import YAML from "yaml";
-var CIRCUITRY_SPEC_VERSION = "0.4";
-var DEFAULT_CIRCUITRY_VALIDATION_STANDARD = {
-  version: CIRCUITRY_SPEC_VERSION,
-  requireSpecVersion: true
-};
-var createCircuitryValidationStandard = (standard = {}) => ({
-  version: standard.version || DEFAULT_CIRCUITRY_VALIDATION_STANDARD.version,
-  requireSpecVersion: standard.requireSpecVersion ?? DEFAULT_CIRCUITRY_VALIDATION_STANDARD.requireSpecVersion
-});
-var getResourceInputs = (resource) => {
-  const inputs = resource.inputs;
-  if (!inputs) return [];
-  if (Array.isArray(inputs)) return inputs.map((from) => ({ from, to: "" }));
-  return Object.entries(inputs).map(([name, from]) => ({ from, to: "", name }));
-};
-var resourceInputIds = (resource) => getResourceInputs(resource).map((dependency) => dependency.from);
-var getCircuitryDependencies = (graph) => {
-  const dependencies = [];
-  for (const [to, resource] of Object.entries(graph.resources || {})) {
-    for (const dependency of getResourceInputs(resource)) dependencies.push({ ...dependency, to });
-  }
-  return dependencies;
-};
-var getCircuitryRunSet = (graph, entry = graph.entry) => {
-  if (!entry) return [];
-  const visited = /* @__PURE__ */ new Set();
-  const visit = (id) => {
-    if (visited.has(id)) return;
-    const resource = graph.resources?.[id];
-    if (!resource) return;
-    for (const input of resourceInputIds(resource)) visit(input);
-    visited.add(id);
-  };
-  visit(entry);
-  return [...visited];
-};
-var toposortCircuitryResources = (graph, entry) => {
-  const ids = entry ? new Set(getCircuitryRunSet(graph, entry)) : new Set(Object.keys(graph.resources || {}));
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const ordered = [];
-  const visit = (id) => {
-    if (!ids.has(id) || visited.has(id)) return;
-    if (visiting.has(id)) throw new Error(`Circuitry resource dependency cycle at ${id}`);
-    visiting.add(id);
-    const resource = graph.resources?.[id];
-    if (resource) for (const input of resourceInputIds(resource)) visit(input);
-    visiting.delete(id);
-    visited.add(id);
-    ordered.push(id);
-  };
-  for (const id of ids) visit(id);
-  return ordered;
-};
-var runtimeInputToText = (value) => {
-  if (typeof value === "string") return value;
-  if (value === void 0) return "";
-  return YAML.stringify(value).trimEnd();
-};
-var resolveCircuitrySource = (graph) => {
-  const inputs = graph.inputs || graph.args || {};
-  const resources = { ...graph.resources || {} };
-  for (const [id, input] of Object.entries(inputs)) {
-    if (!resources[id]) {
-      resources[id] = {
-        type: "input",
-        from: id,
-        label: input.label,
-        description: input.description,
-        mime: input.mime || input.mimeType
-      };
-    }
-  }
-  return { ...graph, circuitry: CIRCUITRY_SPEC_VERSION, imports: graph.imports || [], inputs, resources };
-};
-var applyCircuitryRuntimeInputs = (graph, inputs = {}) => {
-  const next = resolveCircuitrySource(graph);
-  const resources = { ...next.resources || {} };
-  for (const [id, value] of Object.entries(inputs)) {
-    const resource = resources[id];
-    if (!resource) throw new Error(`unknown input: ${id}`);
-    if (resource.type === "input") resources[id] = { ...resource, value, from: resource.from || id };
-    else resources[id] = { ...resource, value: runtimeInputToText(value) };
-  }
-  return { ...next, resources };
-};
-var validateCircuitrySource = (graph, standard = {}) => {
-  const resolvedStandard = createCircuitryValidationStandard(standard);
-  const errors = [];
-  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: resolvedStandard };
-  }
-  const g = graph;
-  if (resolvedStandard.requireSpecVersion && g.circuitry !== resolvedStandard.version) issue("invalid_version", "invalid version", ["circuitry"]);
-  if (!g.resources || Object.keys(g.resources).length === 0) issue("missing_resources", "missing resources", ["resources"]);
-  if (g.nodes) issue("forbidden_nodes", "forbidden nodes", ["nodes"]);
-  if (g.edges) issue("forbidden_edges", "forbidden edges", ["edges"]);
-  if (g.agents) issue("forbidden_agents", "forbidden agents", ["agents"]);
-  const resolved = resolveCircuitrySource(g);
-  const ids = new Set(Object.keys(resolved.resources || {}));
-  if (resolved.entry && !ids.has(resolved.entry)) issue("unknown_entry", "unknown entry", ["entry"]);
-  for (const [name, target] of Object.entries(resolved.entries || {})) {
-    if (!ids.has(target)) issue("unknown_entry", `unknown entry: ${name}`, ["entries", name]);
-  }
-  for (const [id, resource] of Object.entries(resolved.resources || {})) {
-    if (!resource.type) issue("missing_resource_type", "missing resource type", ["resources", id, "type"]);
-    for (const input of resourceInputIds(resource)) {
-      if (!ids.has(input)) issue("unknown_resource_input", `unknown resource input: ${input}`, ["resources", id, "inputs"]);
-      if (input === id) issue("self_input", "self input", ["resources", id, "inputs"]);
-    }
-  }
-  for (const [name, output] of Object.entries(resolved.outputs || {})) {
-    const root = output.from.split(".")[0];
-    if (!ids.has(root)) issue("unknown_output_source", `unknown output source: ${output.from}`, ["outputs", name, "from"]);
-  }
-  try {
-    toposortCircuitryResources(resolved);
-  } catch {
-    issue("cycle", "cycle");
-  }
-  return { ok: errors.length === 0, errors, standard: resolvedStandard };
-};
-var validateCircuitryGraphWithStandard = validateCircuitrySource;
-var validateCircuitryExecutionGraphWithStandard = validateCircuitrySource;
-var validateCircuitryGraph = (graph, standard = {}) => validateCircuitrySource(graph, standard).errors.map((error) => error.message);
-var normalizeCircuitryGraph = (graph) => {
-  const resolved = resolveCircuitrySource(graph);
-  const nodes = [];
-  for (const [id, resource] of Object.entries(resolved.resources || {})) {
-    if (resource.type === "agent") nodes.push({ id, kind: "agent", label: resource.label || resource.identity || id, agent: { identity: resource.identity, model: resource.model, tools: resource.tools, instructions: resource.instructions, personality: resource.personality, context: resource.context }, skills: resource.skills, expect: resource.expect });
-    else nodes.push({ id, kind: resource.type === "tool" ? "tool" : "input", label: resource.label || id, input: { type: resource.type, value: typeof resource.value === "string" ? resource.value : void 0, uri: resource.uri || resource.path, mimeType: resource.mime || resource.mimeType, data: resource.data } });
-  }
-  const edges = getCircuitryDependencies(resolved).map(({ from, to }) => ({ from, to, kind: "dependency" }));
-  return { ...resolved, nodes, edges };
-};
-
-// src/yaml.ts
-var parseYamlData = (text) => {
-  try {
-    return YAML2.parse(text);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not parse YAML.
-${message}`);
-  }
-};
-var stringifyYamlData = (value) => YAML2.stringify(value, {
-  aliasDuplicateObjects: false,
-  defaultKeyType: "PLAIN",
-  defaultStringType: "QUOTE_DOUBLE",
-  doubleQuotedAsJSON: true
-});
-var parseCircuitryYaml = (text, standard = {}, options = {}) => {
-  const graph = parseYamlData(text);
-  if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
-    throw new Error("Circuitry YAML must be a graph object.");
-  }
-  if (options.validate !== false) {
-    const errors = validateCircuitryGraph(graph, standard);
-    if (errors.length) throw new Error(`Invalid Circuitry graph:
-${errors.join("\n")}`);
-  }
-  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();
-  const inputSets = /* @__PURE__ */ new Map();
-  const outputSets = /* @__PURE__ */ new Map();
-  for (const node of normalized.nodes || []) {
-    if (node.kind !== "agent" && node.kind !== "tool" && node.kind !== "output" && node.kind !== "input") {
-      continue;
-    }
-    nodes.set(node.id, {
-      id: node.id,
-      node,
-      inputNodeIds: [],
-      outputNodeIds: [],
-      // Input nodes are already "done" with their value as output
-      ...node.kind === "input" ? { output: node.input?.value || "", completed: true } : {}
-    });
-    inputSets.set(node.id, /* @__PURE__ */ new Set());
-    outputSets.set(node.id, /* @__PURE__ */ new Set());
-  }
-  for (const edge of normalized.edges || []) {
-    if (!nodes.has(edge.to)) {
-      continue;
-    }
-    inputSets.get(edge.to).add(edge.from);
-    if (nodes.has(edge.from)) {
-      outputSets.get(edge.from).add(edge.to);
-    }
-  }
-  for (const [id, node] of nodes) {
-    node.inputNodeIds = [...inputSets.get(id)];
-    node.outputNodeIds = [...outputSets.get(id)];
-  }
-  return { nodes };
-};
-var formatEdgeData = (data) => {
-  if (!data || Object.keys(data).length === 0) {
-    return "";
-  }
-  return ` data=${YAML3.stringify(data).trimEnd()}`;
-};
-var describeEdge = (edge, direction) => {
-  const otherId = direction === "incoming" ? edge.from : edge.to;
-  const kind = edge.kind ? ` [${edge.kind}]` : "";
-  const label = edge.label ? `: ${edge.label}` : "";
-  return `- ${direction === "incoming" ? "from" : "to"} ${otherId}${kind}${label}${formatEdgeData(edge.data)}`;
-};
-var composeCircuitryPrompt = (graph, node, inputs, contextInputs) => {
-  const agent = node.agent || {};
-  const upstreamSection = inputs.length ? inputs.map(
-    (input, index) => `Upstream ${index + 1} from ${input.nodeId}:
-${input.output}`
-  ).join("\n\n") : "No upstream node outputs.";
-  const contextSection = contextInputs.length ? contextInputs.map(
-    (input, index) => input.kind === "text" ? `Context ${index + 1} [text] from ${input.sourceId}:
-${input.text || ""}` : `Context ${index + 1} [${input.kind}] from ${input.sourceId}${input.text ? `:
-${input.text}` : ""}`
-  ).join("\n\n") : "No connected external context.";
-  const incomingEdges = (graph.edges || []).filter((edge) => edge.to === node.id);
-  const outgoingEdges = (graph.edges || []).filter((edge) => edge.from === node.id);
-  const wiringSection = [
-    "Canvas Wiring:",
-    "Incoming edges:",
-    incomingEdges.length ? incomingEdges.map((edge) => describeEdge(edge, "incoming")).join("\n") : "- none",
-    "Outgoing edges:",
-    outgoingEdges.length ? outgoingEdges.map((edge) => describeEdge(edge, "outgoing")).join("\n") : "- none"
-  ].join("\n");
-  return [
-    `Node label: ${node.label}`,
-    agent.identity ? `Identity: ${agent.identity}` : "",
-    agent.context ? `Context:
-${agent.context}` : "",
-    agent.personality ? `Personality:
-${agent.personality}` : "",
-    agent.instructions ? `Instructions:
-${agent.instructions}` : "",
-    wiringSection,
-    `Upstream Node Outputs:
-${upstreamSection}`,
-    `Connected Context Inputs:
-${contextSection}`
-  ].filter(Boolean).join("\n\n");
-};
-var collectImages = (contextInputs) => contextInputs.filter((item) => item.kind === "image" && item.image).map((item) => item.image);
-var stripYamlFence = (output) => {
-  const trimmed = output.trim();
-  const fenced = trimmed.match(/^```(?:ya?ml)?\s*([\s\S]*?)\s*```$/i);
-  return fenced ? fenced[1].trim() : trimmed;
-};
-var parseExpectedOutput = (nodeId, output) => {
-  try {
-    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 YAML (${detail})`);
-  }
-};
-var isFieldObject = (schema) => !!schema && typeof schema === "object" && !Array.isArray(schema) && typeof schema.type === "string";
-var describeExpectedType = (schema) => Array.isArray(schema) ? "list" : typeof schema === "string" ? schema : isFieldObject(schema) ? schema.type : "dict";
-var matchesPrimitiveType = (value, type) => {
-  switch (type) {
-    case "str":
-      return typeof value === "string";
-    case "int":
-      return Number.isInteger(value);
-    case "float":
-      return typeof value === "number" && Number.isFinite(value);
-    case "bool":
-      return typeof value === "boolean";
-    case "list":
-      return Array.isArray(value);
-    case "dict":
-      return !!value && typeof value === "object" && !Array.isArray(value);
-    default:
-      return true;
-  }
-};
-var validateExpectValue = (value, schema, path2, errors) => {
-  if (typeof schema === "string") {
-    if (!matchesPrimitiveType(value, schema)) {
-      errors.push(`${path2} expected ${schema}, got ${Array.isArray(value) ? "list" : typeof value}`);
-    }
-    return;
-  }
-  if (Array.isArray(schema)) {
-    if (!Array.isArray(value)) {
-      errors.push(`${path2} expected list, got ${typeof value}`);
-      return;
-    }
-    if (schema.length > 0) {
-      value.forEach((item, index) => validateExpectValue(item, schema[0], `${path2}[${index}]`, errors));
-    }
-    return;
-  }
-  if (isFieldObject(schema)) {
-    if (schema.optional && value === void 0) return;
-    if (!matchesPrimitiveType(value, schema.type)) {
-      errors.push(`${path2} expected ${schema.type}, got ${Array.isArray(value) ? "list" : typeof value}`);
-      return;
-    }
-    if (schema.contains && typeof value === "string" && !value.includes(schema.contains)) {
-      errors.push(`${path2} must include string: ${schema.contains}`);
-    }
-    if (schema.type === "list" && schema.items && Array.isArray(value)) {
-      value.forEach((item, index) => validateExpectValue(item, schema.items, `${path2}[${index}]`, errors));
-    }
-    return;
-  }
-  if (schema && typeof schema === "object") {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      errors.push(`${path2} expected dict, got ${Array.isArray(value) ? "list" : typeof value}`);
-      return;
-    }
-    for (const [key, childSchema] of Object.entries(schema)) {
-      const childOptional = isFieldObject(childSchema) && childSchema.optional;
-      const childValue = value[key];
-      if (childValue === void 0 && !childOptional) {
-        errors.push(`${path2}.${key} is missing required field of type ${describeExpectedType(childSchema)}`);
-        continue;
-      }
-      validateExpectValue(childValue, childSchema, `${path2}.${key}`, errors);
-    }
-  }
-};
-var assertExpectedOutput = (node, output) => {
-  if (!node.expect) return;
-  const parsed = parseExpectedOutput(node.id, output);
-  const errors = [];
-  validateExpectValue(parsed, node.expect, node.id, errors);
-  if (errors.length) {
-    throw new Error(`Node ${node.id} output does not match expect:
-${errors.join("\n")}`);
-  }
-};
-var executeCircuitryNode = async ({
-  graph,
-  item,
-  cycle,
-  inputPayload,
-  contextInputs,
-  defaultModel,
-  executeNode,
-  onNodeStart,
-  onNodeComplete
-}) => {
-  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,
-      cycle,
-      inputNodeIds: inputPayload.map((input) => input.nodeId),
-      output
-    };
-  }
-  const agent = item.node.agent || {};
-  let result;
-  try {
-    result = await executeNode({
-      nodeId: item.id,
-      model: (agent.model === "inherit" ? void 0 : agent.model) || (defaultModel === "inherit" ? void 0 : defaultModel) || "inherit",
-      tools: agent.tools || [],
-      personality: agent.personality || "",
-      instructions: agent.instructions || "",
-      context: agent.context || "",
-      inputs: inputPayload,
-      contextInputs,
-      images: collectImages(contextInputs),
-      prompt: composeCircuitryPrompt(graph, item.node, inputPayload, contextInputs)
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    onNodeComplete?.(item.id, { error: message });
-    return {
-      nodeId: item.id,
-      cycle,
-      inputNodeIds: inputPayload.map((input) => input.nodeId),
-      output: "",
-      error: message
-    };
-  }
-  assertExpectedOutput(item.node, result.output);
-  onNodeComplete?.(item.id, { output: result.output });
-  return {
-    nodeId: item.id,
-    cycle,
-    inputNodeIds: inputPayload.map((input) => input.nodeId),
-    output: result.output
-  };
-};
-var runCircuitryGraphExecution = async ({
-  graph,
-  selectedNodeId,
-  executeNode,
-  resolveContextInputs,
-  onNodeStart,
-  onNodeComplete,
-  maxParallelRuns = 4
-}) => {
-  const executionGraph = buildCircuitryExecutionGraph(graph);
-  const runs = [];
-  const parallelism = Math.max(1, Math.floor(maxParallelRuns));
-  const defaultModel = typeof graph.runtime?.model === "string" ? graph.runtime.model : void 0;
-  const runOne = async (nodeId, outputs2) => {
-    const cycle = false;
-    const item = executionGraph.nodes.get(nodeId);
-    const inputPayload = item.inputNodeIds.filter((sourceId) => outputs2.has(sourceId)).map((sourceId) => ({
-      nodeId: sourceId,
-      output: outputs2.get(sourceId)
-    }));
-    const contextInputs = await resolveContextInputs?.({
-      nodeId,
-      inputNodeIds: new Set(item.inputNodeIds),
-      graph
-    }) || [];
-    return executeCircuitryNode({
-      graph,
-      item,
-      cycle,
-      inputPayload,
-      contextInputs,
-      defaultModel,
-      executeNode,
-      onNodeStart,
-      onNodeComplete
-    });
-  };
-  if (selectedNodeId) {
-    if (!executionGraph.nodes.has(selectedNodeId)) {
-      return runs;
-    }
-    runs.push(await runOne(selectedNodeId, /* @__PURE__ */ new Map()));
-    return runs;
-  }
-  const completed = /* @__PURE__ */ new Set();
-  const queued = /* @__PURE__ */ new Set();
-  const outputs = /* @__PURE__ */ new Map();
-  const nodeIds = [...executionGraph.nodes.keys()];
-  const remainingDependencies = /* @__PURE__ */ new Map();
-  const ready = [];
-  for (const nodeId of nodeIds) {
-    const node = executionGraph.nodes.get(nodeId);
-    if (!node.completed) continue;
-    completed.add(nodeId);
-    outputs.set(nodeId, node.output || "");
-  }
-  for (const nodeId of nodeIds) {
-    if (completed.has(nodeId)) continue;
-    const node = executionGraph.nodes.get(nodeId);
-    const count = node.inputNodeIds.filter(
-      (sourceId) => executionGraph.nodes.has(sourceId) && !completed.has(sourceId)
-    ).length;
-    remainingDependencies.set(nodeId, count);
-    if (count === 0) {
-      ready.push(nodeId);
-      queued.add(nodeId);
-    }
-  }
-  while (completed.size < nodeIds.length) {
-    if (ready.length === 0) {
-      const blocked = nodeIds.filter((id) => !completed.has(id));
-      throw new Error(`Circuitry execution stalled; unresolved dependencies: ${blocked.join(", ")}`);
-    }
-    const chunk = ready.splice(0, parallelism);
-    const chunkResults = await Promise.all(
-      chunk.map(async (nodeId) => ({
-        nodeId,
-        result: await runOne(nodeId, outputs)
-      }))
-    );
-    for (const { nodeId, result } of chunkResults) {
-      outputs.set(nodeId, result.output);
-      completed.add(nodeId);
-      runs.push(result);
-      for (const outputNodeId of executionGraph.nodes.get(nodeId).outputNodeIds) {
-        if (completed.has(outputNodeId) || queued.has(outputNodeId)) {
-          continue;
-        }
-        const nextCount = Math.max(
-          0,
-          (remainingDependencies.get(outputNodeId) || 0) - 1
-        );
-        remainingDependencies.set(outputNodeId, nextCount);
-        if (nextCount === 0) {
-          ready.push(outputNodeId);
-          queued.add(outputNodeId);
-        }
-      }
-    }
-  }
-  return runs;
-};
-
-// src/node.ts
-var loadPiSDK = async () => {
-  const possiblePaths = [
-    path.join(process.cwd(), "node_modules/@earendil-works/pi-coding-agent/dist/index.js"),
-    path.join(os.homedir(), ".npm-global/lib/node_modules/@earendil-works/pi-coding-agent/dist/index.js")
-  ];
-  for (const modulePath of possiblePaths) {
-    if (fs.existsSync(modulePath)) {
-      return await import(modulePath);
-    }
-  }
-  const packageName = "@earendil-works/pi-coding-agent";
-  return await import(packageName);
-};
-var extractAssistantText = (message) => {
-  if (!message || message.role !== "assistant") return "";
-  if (typeof message.content === "string") return message.content;
-  if (!Array.isArray(message.content)) return "";
-  return message.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
-};
-var findRequestedModel = (modelRegistry, available, requestedModel) => {
-  const [provider, ...modelParts] = requestedModel.split("/");
-  const modelId = modelParts.join("/");
-  const found = (provider && modelId ? modelRegistry.find(provider, modelId) : void 0) || available.find(
-    (entry) => `${entry.provider}/${entry.id}` === requestedModel || entry.id === requestedModel
-  );
-  if (!found) {
-    throw new Error(`Requested Pi model is not available: ${requestedModel}`);
-  }
-  return found;
-};
-var withTimeout = async (promise, timeoutMs) => {
-  let timeout;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        timeout = setTimeout(
-          () => reject(new Error(`Pi SDK request timed out after ${timeoutMs}ms`)),
-          timeoutMs
-        );
-      })
-    ]);
-  } finally {
-    clearTimeout(timeout);
-  }
-};
-var runNodeWithPiSDK = async ({
-  model,
-  prompt,
-  images = [],
-  tools = []
-}) => {
-  let sdk;
-  try {
-    sdk = await loadPiSDK();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      [
-        "Circuitry could not load the Pi SDK package for execution.",
-        "Ensure @earendil-works/pi-coding-agent is installed.",
-        message
-      ].join("\n")
-    );
-  }
-  const { AuthStorage, ModelRegistry, SessionManager, SettingsManager, createAgentSession } = sdk;
-  const authStorage = AuthStorage.create();
-  const modelRegistry = ModelRegistry.create(authStorage);
-  const settingsManager = SettingsManager.create(process.cwd());
-  await settingsManager.reload();
-  const requestedModel = String(model || "");
-  const selectedModel = requestedModel && requestedModel !== "inherit" ? findRequestedModel(modelRegistry, await modelRegistry.getAvailable(), requestedModel) : void 0;
-  const { session } = await createAgentSession({
-    ...selectedModel ? { model: selectedModel } : {},
-    sessionManager: SessionManager.inMemory(),
-    authStorage,
-    modelRegistry,
-    settingsManager
-  });
-  session.setActiveToolsByName(Array.isArray(tools) ? tools.map((tool) => String(tool)) : []);
-  let output = "";
-  const unsubscribe = session.subscribe((event) => {
-    if ((event.type === "message_update" || event.type === "message_end") && event.message?.role === "assistant") {
-      output = extractAssistantText(event.message);
-    }
-    if (event.type === "agent_end" && Array.isArray(event.messages)) {
-      const assistantMessage = [...event.messages].reverse().find((message) => message.role === "assistant");
-      output = extractAssistantText(assistantMessage);
-    }
-  });
-  try {
-    const promptImages = images.filter((image) => image?.mediaType && image?.data).map((image) => ({
-      type: "image",
-      source: { type: "base64", mediaType: image.mediaType, data: image.data }
-    }));
-    await withTimeout(session.prompt(prompt, { images: promptImages }), 18e4);
-    const assistantMessage = [...session.messages].reverse().find((message) => message.role === "assistant");
-    if (assistantMessage?.errorMessage || assistantMessage?.stopReason === "error") {
-      throw new Error(assistantMessage.errorMessage || "Pi SDK model returned an error");
-    }
-    return { output: output.trim() };
-  } finally {
-    unsubscribe();
-    session.dispose();
-  }
-};
-var defaultFilename = "graph.circuitry.yaml";
-var resourceInputs = (resource) => {
-  if (!("inputs" in resource) || !resource.inputs) return [];
-  return Array.isArray(resource.inputs) ? resource.inputs : Object.values(resource.inputs);
-};
-var withResourceInputs = (resource, inputs) => {
-  if (!("inputs" in resource) || !resource.inputs) return resource;
-  if (Array.isArray(resource.inputs)) return { ...resource, inputs };
-  const inputMap = resource.inputs;
-  const names = Object.keys(inputMap);
-  return { ...resource, inputs: Object.fromEntries(names.map((name, index) => [name, inputs[index] || inputMap[name]])) };
-};
-var selectedImportResources = (imp, resources) => {
-  if (!imp.resources || 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 = { ...parsed, circuitry: "0.4", imports: [], inputs: parsed.inputs || parsed.args || {}, 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(
-      process.cwd(),
-      filename || process.env.CIRCUITRY_GRAPH || defaultFilename
-    );
-  }
-  runFileFor(filename) {
-    return `${filename}.run.yaml`;
-  }
-  async exists(filename) {
-    try {
-      await access(filename);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  parseIssue(error, filename) {
-    return {
-      code: "parse_error",
-      message: error instanceof Error ? error.message : String(error),
-      path: [filename]
-    };
-  }
-  parseSourceGraph(text, filename, standard) {
-    try {
-      return { graph: parseCircuitryText(text || "", standard, { validate: false }) };
-    } catch (error) {
-      return { error: this.parseIssue(error, filename) };
-    }
-  }
-  async parseAndResolveGraph(text, filename, standard) {
-    try {
-      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 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) ? 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 = this.parseSourceGraph(input.text, filename, input.standard);
-    if (!("graph" in parsed)) {
-      return {
-        ok: false,
-        errors: parsed.error ? [parsed.error] : [],
-        standard: validateCircuitryGraphWithStandard({}, input.standard).standard
-      };
-    }
-    return validateCircuitryGraphWithStandard(parsed.graph, input.standard);
-  }
-  async writeGraph(input) {
-    const graphFile = this.resolveGraphFile(input.filename);
-    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,
-      standard: input.standard
-    });
-    if (validation.errors.length)
-      throw new Error(
-        `Invalid Circuitry graph:
-${validation.errors.map((e) => e.message).join("\n")}`
-      );
-    await writeFile(
-      graphFile,
-      stringifyCircuitryText(graph),
-      "utf8"
-    );
-    return {
-      filename: graphFile,
-      graph,
-      mode: "replace"
-    };
-  }
-  async runGraph(input = {}) {
-    const source = input.source || (input.text ? "text" : "current");
-    const graphFile = this.resolveGraphFile(input.filename);
-    const parsed = source === "text" ? await this.parseAndResolveGraph(
-      input.text,
-      input.filename || graphFile,
-      input.standard
-    ) : { graph: (await this.readGraphFile(input.filename)).graph };
-    if (!parsed.graph)
-      throw new Error(`Invalid Circuitry graph:
-${parsed.error?.message}`);
-    const runnableGraph = applyCircuitryRuntimeInputs(parsed.graph, input.inputs);
-    const validation = validateCircuitryExecutionGraphWithStandard(
-      runnableGraph,
-      input.standard
-    );
-    if (validation.errors.length)
-      throw new Error(
-        `Invalid Circuitry graph:
-${validation.errors.map((e) => e.message).join("\n")}`
-      );
-    const runItems = await runCircuitryGraphExecution({
-      graph: runnableGraph,
-      selectedNodeId: input.selectedNodeId,
-      executeNode: (req) => runNodeWithPiSDK(req)
-    });
-    const result = { completedAt: (/* @__PURE__ */ new Date()).toISOString(), runItems };
-    if (source !== "text")
-      await writeFile(
-        this.runFileFor(graphFile),
-        stringifyYamlData(result),
-        "utf8"
-      );
-    return result;
-  }
-};
-export {
-  NodeCircuitryHost,
-  loadCircuitryGraphFile,
-  runNodeWithPiSDK
-};