@darkhorseprojects/circuitry 0.2.12 → 0.2.14

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/presets.d.ts

@@ -0,0 +1,4 @@
+import type { CircuitryAgentPreset, CircuitryGraph } from "./graph";
+export declare const CIRCUITRY_AGENT_PRESET_DIRS: readonly [".agents/agents", ".circuitry/agents", "~/.agents/agents", "~/.circuitry/agents"];
+export declare const parseAgentPresetMarkdown: (text: string, fallbackName: string) => CircuitryAgentPreset;
+export declare const applyAgentPresets: (graph: CircuitryGraph, presets: Record<string, CircuitryAgentPreset>) => CircuitryGraph;

package/dist/runtime.d.ts

@@ -0,0 +1,16 @@
+import type { CircuitryGraph, CircuitryRuntimeProvider } from "./graph";
+import type { NodeExecutionRequest, NodeExecutionResult, SimulationRunItem } from "./simulation";
+export type CircuitryRuntimeModel = {
+    id: string;
+    label?: string;
+};
+export type CircuitryRuntimeAdapter = {
+    id: CircuitryRuntimeProvider;
+    label: string;
+    listModels?: () => Promise<CircuitryRuntimeModel[]> | CircuitryRuntimeModel[];
+    runNode: (request: NodeExecutionRequest) => Promise<NodeExecutionResult>;
+    runGraph?: (graph: CircuitryGraph) => Promise<{
+        runItems: SimulationRunItem[];
+    }>;
+};
+export declare const createUnsupportedRuntimeAdapter: (id: CircuitryRuntimeProvider) => CircuitryRuntimeAdapter;

package/dist/scheduler.d.ts

@@ -0,0 +1,30 @@
+import { type CircuitryGraph, type CircuitryNode } from "./graph";
+import type { NodeContextInput, NodeExecutionRequest, NodeExecutionResult, SimulationRunItem } from "./simulation";
+export type CircuitryExecutionNode = {
+    id: string;
+    node: CircuitryNode;
+    inputNodeIds: string[];
+    outputNodeIds: string[];
+    output?: string;
+    completed?: boolean;
+};
+export type CircuitryExecutionGraph = {
+    nodes: Map<string, CircuitryExecutionNode>;
+};
+export declare const buildCircuitryExecutionGraph: (graph: CircuitryGraph) => CircuitryExecutionGraph;
+export declare const runCircuitryGraphExecution: ({ graph, selectedNodeId, executeNode, resolveContextInputs, onNodeStart, onNodeComplete, maxParallelRuns, }: {
+    graph: CircuitryGraph;
+    selectedNodeId?: string;
+    executeNode: (request: NodeExecutionRequest) => Promise<NodeExecutionResult>;
+    resolveContextInputs?: (args: {
+        nodeId: string;
+        inputNodeIds: Set<string>;
+        graph: CircuitryGraph;
+    }) => Promise<NodeContextInput[]> | NodeContextInput[];
+    onNodeStart?: (nodeId: string, fallbackCycle: boolean) => void;
+    onNodeComplete?: (nodeId: string, result: {
+        output?: string;
+        error?: string;
+    }) => void;
+    maxParallelRuns?: number;
+}) => Promise<SimulationRunItem[]>;

package/dist/simulation.d.ts

@@ -0,0 +1,90 @@
+import { type CircuitryNodeData } from "./types";
+type SceneElement = {
+    id: string;
+    type: string;
+    customData?: Record<string, unknown> | {
+        circuitry?: CircuitryNodeData;
+    };
+};
+export type SimulationNode = {
+    id: string;
+    element: SceneElement;
+    data: CircuitryNodeData;
+    inputNodeIds: string[];
+    outputNodeIds: string[];
+    incomingSourceIds: string[];
+};
+export type SimulationRunItem = {
+    nodeId: string;
+    fallbackCycle: boolean;
+    inputNodeIds: string[];
+    output: string;
+    error?: string;
+};
+export type NodeContextInput = {
+    sourceId: string;
+    kind: "text" | "image" | "element";
+    text?: string;
+    elementType?: string;
+    image?: {
+        mediaType: string;
+        data: string;
+    };
+};
+export type NodeExecutionRequest = {
+    nodeId: string;
+    model: string;
+    tools: string[];
+    thinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    prompt: string;
+    personality: string;
+    instructions: string;
+    context: string;
+    inputs: Array<{
+        nodeId: string;
+        output: string;
+    }>;
+    contextInputs: NodeContextInput[];
+    images: Array<{
+        mediaType: string;
+        data: string;
+    }>;
+};
+export type NodeExecutionResult = {
+    output: string;
+};
+export type SimulationGraph = {
+    nodes: Map<string, SimulationNode>;
+};
+export type GraphRunMode = "dependency" | "single";
+export declare const DEFAULT_MAX_PARALLEL_RUNS = 4;
+export declare const buildSimulationGraph: (elements: readonly SceneElement[]) => SimulationGraph;
+export declare const runGraphExecution: ({ elements, mode, selectedNodeId, executeNode, resolveContextInputs, onNodeStart, onNodeComplete, maxParallelRuns, }: {
+    elements: readonly SceneElement[];
+    mode: GraphRunMode;
+    selectedNodeId?: string;
+    executeNode: (request: NodeExecutionRequest) => Promise<NodeExecutionResult>;
+    resolveContextInputs?: (args: {
+        nodeId: string;
+        inputNodeIds: Set<string>;
+        incomingSourceIds: string[];
+        elements: readonly SceneElement[];
+    }) => Promise<NodeContextInput[]> | NodeContextInput[];
+    onNodeStart?: (nodeId: string, fallbackCycle: boolean) => void;
+    onNodeComplete?: (nodeId: string, result: {
+        output?: string;
+        error?: string;
+    }) => void;
+    maxParallelRuns?: number;
+}) => Promise<SimulationRunItem[]>;
+export declare const runDependencySimulation: ({ elements, executeNode, onNodeStart, onNodeComplete, maxParallelRuns, }: {
+    elements: readonly SceneElement[];
+    executeNode: (request: NodeExecutionRequest) => Promise<NodeExecutionResult>;
+    onNodeStart?: (nodeId: string, fallbackCycle: boolean) => void;
+    onNodeComplete?: (nodeId: string, result: {
+        output?: string;
+        error?: string;
+    }) => void;
+    maxParallelRuns?: number;
+}) => Promise<SimulationRunItem[]>;
+export {};