@darkhorseprojects/circuitry 0.2.15 → 0.2.16

package/dist/host.d.ts

@@ -0,0 +1,40 @@
+import type { CircuitryGraph, CircuitryValidationResult, CircuitryValidationStandard } from "./graph";
+import type { SimulationRunItem } from "./simulation";
+export interface CircuitryHost {
+    readGraph(input: {
+        filename?: string;
+    }): Promise<{
+        filename: string;
+        graph: CircuitryGraph;
+        text: string;
+        lastRun?: any;
+    }>;
+    validateGraph(input: {
+        text?: string;
+        filename?: string;
+        graph?: CircuitryGraph;
+        standard?: CircuitryValidationStandard;
+    }): Promise<CircuitryValidationResult>;
+    writeGraph(input: {
+        text?: string;
+        filename?: string;
+        graph?: CircuitryGraph;
+        mode?: "replace";
+        standard?: CircuitryValidationStandard;
+    }): Promise<{
+        filename: string;
+        graph: CircuitryGraph;
+        mode: "replace";
+    }>;
+    runGraph(input: {
+        source?: "current" | "text";
+        text?: string;
+        filename?: string;
+        selectedNodeId?: string;
+        standard?: CircuitryValidationStandard;
+        hostModel?: string;
+    }): Promise<{
+        completedAt: string;
+        runItems: SimulationRunItem[];
+    }>;
+}

package/dist/index.d.ts

@@ -6,3 +6,6 @@ export * from "./scheduler";
 export * from "./simulation";
 export * from "./bundle";
 export * from "./runtime";
+export * from "./host";
+export * from "./tools";
+export * from "./node";

package/dist/index.js

@@ -176,7 +176,7 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
     graph && typeof graph === "object" && !Array.isArray(graph) ? graph : void 0
   );
   const errors = [];
-  const addError = (code, message, path2) => errors.push({ code, message, ...path2 ? { path: path2 } : {} });
+  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 };
@@ -253,19 +253,19 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
   }
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  const path = [];
+  const path2 = [];
   let cycleMessage = "";
   const visit = (id) => {
     if (cycleMessage) return;
     if (visiting.has(id)) {
-      cycleMessage = [...path.slice(path.indexOf(id)), id].join(" -> ");
+      cycleMessage = [...path2.slice(path2.indexOf(id)), id].join(" -> ");
       return;
     }
     if (visited.has(id)) return;
     visiting.add(id);
-    path.push(id);
+    path2.push(id);
     for (const next of adjacency.get(id) || []) visit(next);
-    path.pop();
+    path2.pop();
     visiting.delete(id);
     visited.add(id);
   };
@@ -315,15 +315,15 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
       }
       continue;
     }
-    const checkString = (target, subject, id, match, path2) => {
+    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}`, path2);
+        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}`, path2);
+        addError("rejected_string", `${target} ${id} field ${match.field} must not include string: ${match.value}`, path3);
       }
     };
     for (const match of rule.graph || []) checkString("graph", normalized, "<root>", match, fieldPath(match.field));
@@ -1025,6 +1025,298 @@ var createUnsupportedRuntimeAdapter = (id) => ({
     throw new Error(`Circuitry runtime adapter is not configured: ${String(id)}`);
   }
 });
+
+// src/tools.ts
+import { z } from "zod";
+var standardSchema = z.object({
+  version: z.string().optional(),
+  requireSpecVersion: z.boolean().optional(),
+  executableKinds: z.array(z.string()).optional(),
+  rules: z.array(
+    z.union([z.string(), z.object({ rule: z.string() }).passthrough()])
+  ).optional()
+}).passthrough().optional();
+var createCircuitryReadGraphTool = (host) => ({
+  name: "circuitry_read_graph",
+  description: "Read the current Circuitry graph. In the App this reads the canvas and includes latest node run outputs.",
+  parameters: z.object({
+    filename: z.string().optional().describe("Optional filename when in standalone mode.")
+  }),
+  execute: (input) => host.readGraph(input)
+});
+var createCircuitryWriteGraphTool = (host) => ({
+  name: "circuitry_write_graph",
+  description: "Replace a Circuitry graph. In the App this applies the graph to the canvas; standalone writes a file.",
+  parameters: z.object({
+    text: z.string().optional().describe("YAML graph text."),
+    filename: z.string().optional().describe("Optional filename."),
+    graph: z.any().optional().describe("Parsed graph object."),
+    standard: standardSchema
+  }),
+  execute: (input) => host.writeGraph(input)
+});
+var createCircuitryRunGraphTool = (host) => ({
+  name: "circuitry_run_graph",
+  description: "Run the current Circuitry graph. After running, call circuitry_read_graph to inspect updated per-node outputs and errors.",
+  parameters: z.object({
+    source: z.enum(["current", "text"]).optional().describe(
+      "Whether to run the 'current' canvas/file or provided 'text'."
+    ),
+    text: z.string().optional().describe("YAML graph text if source is 'text'."),
+    filename: z.string().optional().describe("Optional filename."),
+    selectedNodeId: z.string().optional().describe("Optional specific node to run."),
+    standard: standardSchema,
+    hostModel: z.string().optional().describe("Optional model to use when a node is set to 'inherit'.")
+  }),
+  execute: (input) => host.runGraph(input)
+});
+var createCircuitryValidateGraphTool = (host) => ({
+  name: "circuitry_validate_graph",
+  description: "Validate Circuitry YAML or JSON graph text. Returns structured validation issues.",
+  parameters: z.object({
+    text: z.string().describe("YAML or JSON graph text to validate."),
+    filename: z.string().optional().describe("Optional filename context."),
+    standard: standardSchema
+  }),
+  execute: (input) => host.validateGraph(input)
+});
+var createCircuitryTools = (host) => [
+  createCircuitryReadGraphTool(host),
+  createCircuitryWriteGraphTool(host),
+  createCircuitryRunGraphTool(host),
+  createCircuitryValidateGraphTool(host)
+];
+
+// 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";
+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);
+    }
+  }
+  return await import("@earendil-works/pi-coding-agent");
+};
+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 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 = [],
+  thinkingLevel = "off"
+}) => {
+  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, createAgentSession } = sdk;
+  const authStorage = AuthStorage.create();
+  const modelRegistry = ModelRegistry.create(authStorage);
+  const [provider, ...modelParts] = String(model || "").split("/");
+  const modelId = modelParts.join("/");
+  const available = await modelRegistry.getAvailable();
+  const selectedModel = (provider && modelId ? modelRegistry.find(provider, modelId) : void 0) || available.find((entry) => {
+    if (!modelId) return false;
+    return `${entry.provider}/${entry.id}` === `${provider}/${modelId}` || entry.id === modelId;
+  }) || available[0];
+  if (!selectedModel) {
+    throw new Error("No Pi SDK models are available. Configure ~/.pi/agent/auth.json");
+  }
+  const { session } = await createAgentSession({
+    model: selectedModel,
+    thinkingLevel,
+    sessionManager: SessionManager.inMemory(),
+    authStorage,
+    modelRegistry
+  });
+  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);
+    return { output: output.trim() };
+  } finally {
+    unsubscribe();
+    session.dispose();
+  }
+};
+var defaultFilename = "graph.circuitry.yaml";
+var NodeCircuitryHost = class {
+  resolveGraphFile(filename) {
+    return path.resolve(
+      process.cwd(),
+      filename || process.env.CIRCUITRY_GRAPH || defaultFilename
+    );
+  }
+  runFileFor(filename) {
+    return `${filename}.run.json`;
+  }
+  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]
+    };
+  }
+  parseGraphForValidation(text, filename, standard) {
+    try {
+      return {
+        graph: parseCircuitryText(text || "", filename, standard, {
+          validate: false
+        })
+      };
+    } catch (error) {
+      return { error: this.parseIssue(error, filename) };
+    }
+  }
+  async readGraphFile(filename) {
+    const graphFile = this.resolveGraphFile(filename);
+    const text = await readFile(graphFile, "utf8");
+    const graph = parseCircuitryText(text, graphFile);
+    return { graphFile, text, graph };
+  }
+  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;
+    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.parseGraphForValidation(input.text, filename, input.standard);
+    if (parsed.error) {
+      return {
+        ok: false,
+        errors: [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.parseGraphForValidation(
+      input.text,
+      input.filename || graphFile,
+      input.standard
+    );
+    if (!parsed.graph)
+      throw new Error(`Invalid Circuitry graph:
+${parsed.error?.message}`);
+    const validation = await this.validateGraph({
+      graph: parsed.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(parsed.graph, graphFile),
+      "utf8"
+    );
+    return {
+      filename: graphFile,
+      graph: parsed.graph,
+      mode: "replace"
+    };
+  }
+  async runGraph(input = {}) {
+    const source = input.source || (input.text ? "text" : "current");
+    const graphFile = this.resolveGraphFile(input.filename);
+    const parsed = source === "text" ? this.parseGraphForValidation(
+      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 validation = await this.validateGraph({
+      graph: parsed.graph,
+      standard: 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: parsed.graph,
+      selectedNodeId: input.selectedNodeId,
+      executeNode: (req) => runNodeWithPiSDK(req)
+    });
+    const result = { completedAt: (/* @__PURE__ */ new Date()).toISOString(), runItems };
+    if (source !== "text")
+      await writeFile(
+        this.runFileFor(graphFile),
+        JSON.stringify(result, null, 2),
+        "utf8"
+      );
+    return result;
+  }
+};
 export {
   BUNDLE_MIME,
   CIRCUITRY_AGENT_PRESET_DIRS,
@@ -1035,11 +1327,17 @@ export {
   DEFAULT_CIRCUITRY_VALIDATION_RULES,
   DEFAULT_CIRCUITRY_VALIDATION_STANDARD,
   DEFAULT_MAX_PARALLEL_RUNS,
+  NodeCircuitryHost,
   applyAgentPresets,
   buildCircuitryExecutionGraph,
   buildSimulationGraph,
   createBundleFromSelection,
+  createCircuitryReadGraphTool,
+  createCircuitryRunGraphTool,
+  createCircuitryTools,
+  createCircuitryValidateGraphTool,
   createCircuitryValidationStandard,
+  createCircuitryWriteGraphTool,
   createDefaultNodeData,
   createUnsupportedRuntimeAdapter,
   hasCircuitryNodeData,
@@ -1055,6 +1353,8 @@ export {
   runCircuitryGraphExecution,
   runDependencySimulation,
   runGraphExecution,
+  runNodeWithPiSDK,
+  standardSchema,
   stringifyCircuitryJson,
   stringifyCircuitryText,
   stringifyCircuitryYaml,

package/dist/node.d.ts

@@ -0,0 +1,48 @@
+import type { CircuitryHost } from "./host";
+import type { CircuitryGraph, CircuitryValidationStandard } from "./graph";
+import type { NodeExecutionRequest, NodeExecutionResult, SimulationRunItem } from "./simulation";
+export declare const runNodeWithPiSDK: ({ model, prompt, images, tools, thinkingLevel, }: NodeExecutionRequest) => Promise<NodeExecutionResult>;
+export declare class NodeCircuitryHost implements CircuitryHost {
+    private resolveGraphFile;
+    private runFileFor;
+    private exists;
+    private parseIssue;
+    private parseGraphForValidation;
+    private readGraphFile;
+    readGraph(input?: {
+        filename?: string;
+    }): Promise<{
+        filename: string;
+        graph: CircuitryGraph;
+        text: string;
+        lastRun: any;
+    }>;
+    validateGraph(input: {
+        text?: string;
+        filename?: string;
+        graph?: CircuitryGraph;
+        standard?: CircuitryValidationStandard;
+    }): Promise<import("./graph").CircuitryValidationResult>;
+    writeGraph(input: {
+        text?: string;
+        filename?: string;
+        graph?: CircuitryGraph;
+        mode?: "replace";
+        standard?: CircuitryValidationStandard;
+    }): Promise<{
+        filename: string;
+        graph: CircuitryGraph;
+        mode: "replace";
+    }>;
+    runGraph(input?: {
+        source?: "current" | "text";
+        text?: string;
+        filename?: string;
+        selectedNodeId?: string;
+        standard?: CircuitryValidationStandard;
+        hostModel?: string;
+    }): Promise<{
+        completedAt: string;
+        runItems: SimulationRunItem[];
+    }>;
+}

package/dist/tools.d.ts

@@ -0,0 +1,547 @@
+import { z } from "zod";
+import type { CircuitryHost } from "./host";
+export declare const standardSchema: z.ZodOptional<z.ZodObject<{
+    version: z.ZodOptional<z.ZodString>;
+    requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+    executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        rule: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        rule: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        rule: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    version: z.ZodOptional<z.ZodString>;
+    requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+    executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        rule: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        rule: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        rule: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    version: z.ZodOptional<z.ZodString>;
+    requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+    executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        rule: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        rule: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        rule: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+}, z.ZodTypeAny, "passthrough">>>;
+export declare const createCircuitryReadGraphTool: (host: CircuitryHost) => {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        filename: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        filename?: string | undefined;
+    }, {
+        filename?: string | undefined;
+    }>;
+    execute: (input: {
+        filename?: string;
+    }) => Promise<{
+        filename: string;
+        graph: import("./graph").CircuitryGraph;
+        text: string;
+        lastRun?: any;
+    }>;
+};
+export declare const createCircuitryWriteGraphTool: (host: CircuitryHost) => {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        text: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+        graph: z.ZodOptional<z.ZodAny>;
+        standard: z.ZodOptional<z.ZodObject<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        text?: string | undefined;
+        graph?: any;
+        filename?: string | undefined;
+        standard?: z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        text?: string | undefined;
+        graph?: any;
+        filename?: string | undefined;
+        standard?: z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>;
+    execute: (input: any) => Promise<{
+        filename: string;
+        graph: import("./graph").CircuitryGraph;
+        mode: "replace";
+    }>;
+};
+export declare const createCircuitryRunGraphTool: (host: CircuitryHost) => {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        source: z.ZodOptional<z.ZodEnum<["current", "text"]>>;
+        text: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+        selectedNodeId: z.ZodOptional<z.ZodString>;
+        standard: z.ZodOptional<z.ZodObject<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        hostModel: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        text?: string | undefined;
+        selectedNodeId?: string | undefined;
+        filename?: string | undefined;
+        standard?: z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        source?: "text" | "current" | undefined;
+        hostModel?: string | undefined;
+    }, {
+        text?: string | undefined;
+        selectedNodeId?: string | undefined;
+        filename?: string | undefined;
+        standard?: z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        source?: "text" | "current" | undefined;
+        hostModel?: string | undefined;
+    }>;
+    execute: (input: any) => Promise<{
+        completedAt: string;
+        runItems: import("./simulation").SimulationRunItem[];
+    }>;
+};
+export declare const createCircuitryValidateGraphTool: (host: CircuitryHost) => {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        text: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        standard: z.ZodOptional<z.ZodObject<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        filename?: string | undefined;
+        standard?: z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        text: string;
+        filename?: string | undefined;
+        standard?: z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>;
+    execute: (input: any) => Promise<import("./graph").CircuitryValidationResult>;
+};
+export declare const createCircuitryTools: (host: CircuitryHost) => ({
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        filename: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        filename?: string | undefined;
+    }, {
+        filename?: string | undefined;
+    }>;
+    execute: (input: {
+        filename?: string;
+    }) => Promise<{
+        filename: string;
+        graph: import("./graph").CircuitryGraph;
+        text: string;
+        lastRun?: any;
+    }>;
+} | {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        text: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+        graph: z.ZodOptional<z.ZodAny>;
+        standard: z.ZodOptional<z.ZodObject<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        text?: string | undefined;
+        graph?: any;
+        filename?: string | undefined;
+        standard?: z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        text?: string | undefined;
+        graph?: any;
+        filename?: string | undefined;
+        standard?: z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>;
+    execute: (input: any) => Promise<{
+        filename: string;
+        graph: import("./graph").CircuitryGraph;
+        mode: "replace";
+    }>;
+} | {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        source: z.ZodOptional<z.ZodEnum<["current", "text"]>>;
+        text: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+        selectedNodeId: z.ZodOptional<z.ZodString>;
+        standard: z.ZodOptional<z.ZodObject<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        hostModel: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        text?: string | undefined;
+        selectedNodeId?: string | undefined;
+        filename?: string | undefined;
+        standard?: z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        source?: "text" | "current" | undefined;
+        hostModel?: string | undefined;
+    }, {
+        text?: string | undefined;
+        selectedNodeId?: string | undefined;
+        filename?: string | undefined;
+        standard?: z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        source?: "text" | "current" | undefined;
+        hostModel?: string | undefined;
+    }>;
+    execute: (input: any) => Promise<{
+        completedAt: string;
+        runItems: import("./simulation").SimulationRunItem[];
+    }>;
+} | {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        text: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        standard: z.ZodOptional<z.ZodObject<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        filename?: string | undefined;
+        standard?: z.objectOutputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        text: string;
+        filename?: string | undefined;
+        standard?: z.objectInputType<{
+            version: z.ZodOptional<z.ZodString>;
+            requireSpecVersion: z.ZodOptional<z.ZodBoolean>;
+            executableKinds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                rule: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                rule: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>;
+    execute: (input: any) => Promise<import("./graph").CircuitryValidationResult>;
+})[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkhorseprojects/circuitry",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",