@ghchinoy/litflow 0.3.0 → 0.4.1

package/dist/breadboard/engine/inspector/graph/node.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { GraphIdentifier, InputValues, InspectableEdge, InspectableNode, InspectableNodePorts, InspectableNodeType, MutableGraph, NodeConfiguration, NodeDescriberResult, NodeDescriptor, NodeMetadata, OutputValues } from "@breadboard-ai/types";
+export declare class Node implements InspectableNode {
+    #private;
+    descriptor: NodeDescriptor;
+    constructor(descriptor: NodeDescriptor, graph: MutableGraph, graphId: GraphIdentifier);
+    title(): string;
+    description(): string;
+    incoming(): InspectableEdge[];
+    outgoing(): InspectableEdge[];
+    isEntry(): boolean;
+    isExit(): boolean;
+    isStart(): boolean;
+    type(): InspectableNodeType;
+    configuration(): NodeConfiguration;
+    metadata(): NodeMetadata;
+    describe(): Promise<NodeDescriberResult>;
+    currentDescribe(): NodeDescriberResult;
+    currentPorts(inputValues?: InputValues, outputValues?: OutputValues): InspectableNodePorts;
+    ports(inputValues?: InputValues, outputValues?: OutputValues): Promise<InspectableNodePorts>;
+    setDeleted(): void;
+    deleted(): boolean;
+}

package/dist/breadboard/engine/inspector/graph/port-cache.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { GraphIdentifier, InspectableNodePorts, NodeIdentifier, NodePortChanges } from "@breadboard-ai/types";
+export { PortCache };
+type PortsUpdate = {
+    updated: InspectableNodePorts;
+    changes: NodePortChanges;
+};
+declare class PortCache {
+    #private;
+    reconcilePorts(incoming: InspectableNodePorts, existing?: InspectableNodePorts): PortsUpdate;
+    createNewSnapshot(incoming: InspectableNodePorts): PortsUpdate;
+    current(graphId: GraphIdentifier, nodeId: NodeIdentifier): InspectableNodePorts | undefined;
+    getChanges(graphId: GraphIdentifier, nodeId: NodeIdentifier, ports: InspectableNodePorts): NodePortChanges;
+}

package/dist/breadboard/engine/inspector/graph/ports.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { BehaviorSchema, InputValues, InspectableEdge, InspectableNode, InspectableNodePorts, InspectablePort, InspectablePortType, NodeConfiguration, NodeDescriberResult, NodeHandler, NodeTypeIdentifier, OutputValues, Schema } from "@breadboard-ai/types";
+import { EdgeType } from "./schemas.js";
+export { describerResultToPorts };
+export declare const collectPorts: (type: EdgeType, edges: InspectableEdge[], schema: Schema, addErrorPort: boolean, allowRequired: boolean, values?: NodeConfiguration) => InspectablePort[];
+export declare class PortType implements InspectablePortType {
+    schema: Schema;
+    constructor(schema: Schema);
+    hasBehavior(behavior: BehaviorSchema): boolean;
+}
+declare function describerResultToPorts(node: InspectableNode, described: NodeDescriberResult, updating: boolean, inputValues?: InputValues, outputValues?: OutputValues): InspectableNodePorts;
+export declare const portsFromHandler: (type: NodeTypeIdentifier, handler: NodeHandler | undefined) => Promise<InspectableNodePorts>;

package/dist/breadboard/engine/inspector/graph/schemas.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { InspectableEdge, NodeDescriberResult, NodeTypeDescriberOptions, Schema } from "@breadboard-ai/types";
+export declare enum EdgeType {
+    In = 0,
+    Out = 1
+}
+export declare const DEFAULT_SCHEMA: Schema;
+export declare const edgesToSchema: (edgeType: EdgeType, edges?: InspectableEdge[], keepStar?: boolean) => Schema;
+/**
+ * Constructs a Schema for an input node.
+ * @param options
+ * @returns
+ */
+export declare const describeInput: (options: NodeTypeDescriberOptions) => NodeDescriberResult;
+/**
+ * Constructs a Schema for an output node.
+ * @param options
+ * @returns
+ */
+export declare const describeOutput: (options: NodeTypeDescriberOptions) => NodeDescriberResult;

package/dist/breadboard/engine/inspector/graph/virtual-node.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { InputValues, InspectableEdge, InspectableNode, InspectableNodePorts, InspectableNodeType, NodeConfiguration, NodeDescriberResult, NodeDescriptor, NodeMetadata, OutputValues } from "@breadboard-ai/types";
+export { VirtualNode };
+/**
+ * A virtual node represents a node in a virtual graph. Virtual
+ * Graphs aren't actually graphs, but rather code that
+ * behaves as in a "graph-like" way: it may invoke components,
+ * but its topology is entirely imperative.
+ * For example, the runModule code is a virtual graph, and
+ * every capability it invokes shows up as a virtual node.
+ */
+declare class VirtualNode implements InspectableNode {
+    #private;
+    descriptor: NodeDescriptor;
+    constructor(descriptor: Partial<NodeDescriptor>);
+    title(): string;
+    description(): string;
+    incoming(): InspectableEdge[];
+    outgoing(): InspectableEdge[];
+    isEntry(): boolean;
+    isExit(): boolean;
+    isStart(): boolean;
+    type(): InspectableNodeType;
+    describe(): Promise<NodeDescriberResult>;
+    currentDescribe(): NodeDescriberResult;
+    configuration(): NodeConfiguration;
+    metadata(): NodeMetadata;
+    ports(inputs?: InputValues, outputs?: OutputValues): Promise<InspectableNodePorts>;
+    currentPorts(inputs?: InputValues, outputs?: OutputValues): InspectableNodePorts;
+    deleted(): boolean;
+}

package/dist/breadboard/engine/inspector/graph-store.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AddResult, EditableGraph, EditableGraphOptions, FileSystem, GraphDescriptor, GraphIdentifier, GraphLoader, GraphLoaderContext, GraphLoaderResult, GraphStoreArgs, GraphStoreEntry, GraphStoreEventTarget, InspectableDescriberResultTypeCache, InspectableGraph, InspectableGraphOptions, Kit, MainGraphIdentifier, MainGraphStoreEntry, MutableGraph, MutableGraphStore, NodeHandlerContext, Result, RuntimeFlagManager } from "@breadboard-ai/types";
+import { RunnableModuleFactory } from "@breadboard-ai/types/sandbox.js";
+export { contextFromMutableGraph, contextFromMutableGraphStore, GraphStore, makeTerribleOptions, };
+declare function contextFromMutableGraph(mutable: MutableGraph): NodeHandlerContext;
+declare function contextFromMutableGraphStore(store: MutableGraphStore): NodeHandlerContext;
+declare function makeTerribleOptions(options?: InspectableGraphOptions): Required<InspectableGraphOptions>;
+declare const GraphStore_base: GraphStoreEventTarget;
+declare class GraphStore extends GraphStore_base implements MutableGraphStore {
+    #private;
+    readonly kits: readonly Kit[];
+    readonly sandbox: RunnableModuleFactory;
+    readonly loader: GraphLoader;
+    readonly fileSystem: FileSystem;
+    readonly flags: RuntimeFlagManager;
+    /**
+     * The cache of type describer results. These are currently
+     * entirely static: they are only loaded once and exist
+     * for the lifetime of the GraphStore. At the moment, this
+     * is ok, since the only graph that ever changes is the main
+     * graph, and we don't need its type. This will change
+     * probably, so we need to be on look out for when.
+     */
+    readonly types: InspectableDescriberResultTypeCache;
+    constructor(args: GraphStoreArgs);
+    getEntryByDescriptor(descriptor: GraphDescriptor, graphId: GraphIdentifier): GraphStoreEntry | undefined;
+    mainGraphs(): MainGraphStoreEntry[];
+    graphs(): GraphStoreEntry[];
+    load(path: string, context: GraphLoaderContext): Promise<GraphLoaderResult>;
+    registerKit(kit: Kit, dependences: MainGraphIdentifier[]): void;
+    addByDescriptor(graph: GraphDescriptor): Result<MainGraphIdentifier>;
+    getByDescriptor(graph: GraphDescriptor): Result<MainGraphIdentifier>;
+    editByDescriptor(graph: GraphDescriptor, options?: EditableGraphOptions): EditableGraph | undefined;
+    edit(id: MainGraphIdentifier, options?: EditableGraphOptions): EditableGraph | undefined;
+    inspect(id: MainGraphIdentifier, graphId: GraphIdentifier): InspectableGraph | undefined;
+    inspectSnapshot(graph: GraphDescriptor, graphId: GraphIdentifier): InspectableGraph | undefined;
+    addByURL(path: string, dependencies: MainGraphIdentifier[], context?: GraphLoaderContext): AddResult;
+    getLatest(mutable: MutableGraph): Promise<MutableGraph>;
+    getOrAdd(graph: GraphDescriptor): Result<MutableGraph>;
+    get(id: MainGraphIdentifier): MutableGraph | undefined;
+}

package/dist/breadboard/engine/inspector/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { GraphStoreArgs, MutableGraphStore } from "@breadboard-ai/types";
+export declare function createGraphStore(args: GraphStoreArgs): MutableGraphStore;

package/dist/breadboard/engine/inspector/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GraphIdentifier } from "@breadboard-ai/types";
+export { isModule, getModuleId };
+declare function isModule(graphId: GraphIdentifier): boolean;
+declare function getModuleId(graphId: GraphIdentifier): string;

package/dist/breadboard/engine/loader/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GraphLoader, BoardServer } from "@breadboard-ai/types";
+export declare const createLoader: (boardServers?: BoardServer[]) => GraphLoader;

package/dist/breadboard/engine/runtime/harness/diagnostics.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Probe, ProbeMessage } from "@breadboard-ai/types";
+export type DiagnosticsCallback = (message: ProbeMessage) => Promise<void>;
+export declare class Diagnostics implements Probe {
+    #private;
+    constructor(callback: DiagnosticsCallback);
+    report(message: ProbeMessage): Promise<void>;
+}

package/dist/breadboard/engine/runtime/harness/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { HarnessRunner, RunConfig } from "@breadboard-ai/types";
+export { RunnerErrorEvent } from "./events.js";
+export declare function createPlanRunner(config: RunConfig): HarnessRunner;

package/dist/breadboard/engine/runtime/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export { createPlanRunner, RunnerErrorEvent } from "./harness/index.js";

package/dist/breadboard/engine/runtime/legacy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export { describerResultToNodeHandlerMetadata } from "./graph-based-node-handler.js";
+export { getGraphHandlerFromMutableGraph, getHandler, getGraphHandler, } from "./handler.js";
+export { invokeGraph } from "./run/invoke-graph.js";
+export { CapabilitiesManagerImpl } from "./sandbox/capabilities-manager.js";
+export { invokeDescriber, invokeMainDescriber, } from "./sandbox/invoke-describer.js";
+export { GraphRepresentationImpl } from "./traversal/representation.js";

package/dist/breadboard/engine/runtime/static/condense.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GraphDescriptor } from "@breadboard-ai/types";
+export { condense };
+/**
+ * Given a GraphDescriptor, creates another GraphDescriptor that is a
+ * condensed graph representation of it.
+ * All strongly connected components (SCC) of the graph are replaced with nodes
+ * whose types point at subgraphs, like this "#<id of subgraph>".
+ * The subgraph is created as follows:
+ * - a node of type "input" is created, and this node acts as a way to
+ *   capture all incoming edge ports (the "in" values), so that they
+ *   are correctly routed to inside of the subgraph
+ * - a node of type "output" is created, and this node acts as a way to
+ *   capture all outgoing edge ports (the "out" values), so that they
+ *   are correctly routed from the subgraph to.
+ * In effect, the input/output nodes in a subgraph act as a
+ * "function signature" of the subgraph.
+ * See https://en.wikipedia.org/wiki/Strongly_connected_component for
+ * discussion and definitions.
+ */
+declare function condense(graph: GraphDescriptor): GraphDescriptor;

package/dist/breadboard/engine/runtime/static/nodes-to-subgraph.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GraphDescriptor, GraphIdentifier, NodeIdentifier } from "@breadboard-ai/types";
+export { nodesToSubgraph };
+/**
+ * Moves a group of nodes within a graph into a subgraph, mutating
+ * the supplied graph.
+ *
+ * @param graph - The graph where the subgraph will be created.
+ * @param nodeGroup - The group of nodes to include in the subgraph.
+ * @param subgraphId - The unique identifier for the subgraph.
+ * @param title - An optional title for the subgraph.
+ * @param description - An optional description for the subgraph.
+ */
+declare function nodesToSubgraph(graph: GraphDescriptor, nodeGroup: NodeIdentifier[], subgraphId: GraphIdentifier, title?: string, description?: string): void;

package/dist/breadboard/engine/runtime/static/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { NodeIdentifier, Outcome } from "@breadboard-ai/types";
+/**
+ * Very WIP, sketching out reactive Model + Controller
+ * that replaces the current HarnessRunner
+ */
+export type OrchestrationController = {
+    /**
+     * Run the graph from start to finish or the next breakpoint.
+     * Always restarts, resetting current state.
+     * Promise resolves when the run completes.
+     */
+    run(): Promise<Outcome<void>>;
+    /**
+     * Run all incomplete stages to finish or the next breakpoint.
+     * Promise resolves when the run completes.
+     */
+    continue(): Promise<Outcome<void>>;
+    /**
+     * Invoke the next "ready" node in the orchestration.
+     * Promise resolves when the node invocation completes.
+     * If the node reports failure, this is not an error that affects outcome.
+     */
+    stepThroughNode(): Promise<Outcome<void>>;
+    /**
+     * Step through the next incomplete stage in the orchestration.
+     * Promise resolves when the stage completes.
+     */
+    stepThroughStage(): Promise<Outcome<void>>;
+    /**
+     * Provides a way to manage breakpoints.
+     */
+    breakpoints: BreakpointsController;
+};
+export type BreakpointsController = {
+    /**
+     * All current breakpoints.
+     */
+    readonly breakpoints: ReadonlyMap<NodeIdentifier, Breakpoint>;
+    /**
+     * Creates a breakpoint. Can be called multiple times on the same node.
+     * @param node - the node at which to set the breakpoint
+     */
+    create(node: NodeIdentifier): void;
+    /**
+     * Removes a breakpoint. Can be called multiple times on the same node.
+     * @param node - the node at which to remove the breakpoint
+     */
+    delete(node: NodeIdentifier): void;
+    /**
+     * Clears all breakpoints.
+     */
+    clear(): void;
+};
+export type Breakpoint = {
+    /**
+     * The node at which the breakpoint is set.
+     */
+    readonly id: NodeIdentifier;
+    /**
+     * Disables the breakpoint.
+     */
+    disable(): void;
+    /**
+     * Enables the breakpoint.
+     */
+    enable(): void;
+};

package/dist/breadboard/engine/telemetry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { InputValues, NodeMetadata, OutputValues, Probe } from "@breadboard-ai/types";
+import { RunnableModuleTelemetry } from "@breadboard-ai/types/sandbox.js";
+export { Telemetry };
+type Context = {
+    probe?: Probe;
+    invocationPath?: number[];
+};
+declare class Telemetry implements RunnableModuleTelemetry {
+    #private;
+    readonly probe: Probe;
+    readonly path: number[];
+    index: number;
+    static create(context: Context): Telemetry | undefined;
+    constructor(probe: Probe, path: number[]);
+    startModule(): Promise<void>;
+    startCapability(type: string, inputs: InputValues, metadata?: NodeMetadata): Promise<number>;
+    endCapability(type: string, path: number, inputs: InputValues, outputs: OutputValues): Promise<void>;
+    endModule(): Promise<void>;
+    invocationPath(path: number): number[];
+}

package/dist/breadboard/engine/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export type { Capability, CommentNode, Edge, GraphDescriptor, GraphIdentifier, GraphInlineMetadata, InputIdentifier, InputResponse, InputValues, KitDescriptor, KitReference, NodeConfiguration, NodeDescriptor, NodeIdentifier, NodeTypeIdentifier, NodeValue, OutputIdentifier, OutputResponse, OutputValues, SubGraphs, } from "@breadboard-ai/types";
+export type * from "@breadboard-ai/types/legacy.js";
+export type * from "@breadboard-ai/types/node-handler.js";
+export type * from "@breadboard-ai/types/schema.js";

package/dist/lit-flow.d.ts

@@ -23,6 +23,8 @@ export declare class LitFlow extends LitFlow_base {
     zoomOnDoubleClick: boolean;
     promptOnDrop: boolean;
     selectionMode: 'pan' | 'select';
+    layoutEnabled: boolean;
+    layoutPadding: number;
     private _selectionRect;
     private _selectionStart;
     private _width;
@@ -31,6 +33,7 @@ export declare class LitFlow extends LitFlow_base {
     get nodes(): NodeBase[];
     private _notifyChange;
     private _discoverNodes;
+    private _performLayout;
     set edges(edges: any[]);
     get edges(): any[];
     viewport: Viewport;
@@ -54,6 +57,16 @@ export declare class LitFlow extends LitFlow_base {
      * @param padding Optional padding in pixels (default: 50)
      */
     fitView(padding?: number): Promise<void>;
+    /**
+     * Isolates a subgraph by hiding all nodes and edges not connected to the specified node.
+     * @param nodeId The ID of the node to focus on.
+     * @param direction The direction of the traversal ('downstream', 'upstream', or 'both').
+     */
+    isolateSubgraph(nodeId: string, direction?: 'downstream' | 'upstream' | 'both'): void;
+    /**
+     * Clears any subgraph isolation, showing all nodes and edges.
+     */
+    clearIsolation(): void;
     private _updatePanZoom;
     firstUpdated(): void;
     updated(changedProperties: Map<string, any>): void;

package/dist/lit-node.d.ts

@@ -1,6 +1,7 @@
 import { LitElement } from 'lit';
 declare const LitNode_base: typeof LitElement;
 export declare class LitNode extends LitNode_base {
+    static styles: import("lit").CSSResult;
     createRenderRoot(): this;
     label: string;
     type: string;