@ghchinoy/litflow 0.3.0 → 0.4.1

package/dist/breadboard/engine/file-system/blob-transform.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FileSystemBlobTransform, FileSystemPath, LLMContent, Outcome } from "@breadboard-ai/types";
+export { transformBlobs };
+declare function transformBlobs(path: FileSystemPath, data: LLMContent[], pipeline: FileSystemBlobTransform[]): Promise<Outcome<LLMContent[]>>;

package/dist/breadboard/engine/file-system/composed-peristent-backend.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { PersistentBackend } from "@breadboard-ai/types";
+export { composeFileSystemBackends };
+declare function composeFileSystemBackends(backends: Map<string, PersistentBackend>): PersistentBackend;

package/dist/breadboard/engine/file-system/ephemeral-blob-store.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { EphemeralBlobStore } from "@breadboard-ai/types";
+export { createEphemeralBlobStore };
+declare function createEphemeralBlobStore(): EphemeralBlobStore;

package/dist/breadboard/engine/file-system/in-memory-blob-store.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FileSystemBlobStore, FileSystemBlobTransform, FileSystemPath, Outcome } from "@breadboard-ai/types";
+export { InMemoryBlobStore };
+declare class InMemoryBlobStore implements FileSystemBlobStore {
+    #private;
+    handles: Map<FileSystemPath, string[]>;
+    constructor();
+    delete(): Promise<Outcome<void>>;
+    inflator(): FileSystemBlobTransform;
+    deflator(): FileSystemBlobTransform;
+    copy(): Promise<Outcome<void>>;
+    move(): Promise<Outcome<void>>;
+    close(): Promise<void>;
+}

package/dist/breadboard/engine/file-system/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FileSystem, FileSystemQueryArguments, FileSystemQueryResult, FileSystemReadArguments, FileSystemEntry, FileSystemReadResult, FileSystemWriteArguments, FileSystemWriteResult, OuterFileSystems, Outcome, CreateRunFileSystemArgs, CreateModuleFileSystemArgs, FileSystemWriteStreamArguments } from "@breadboard-ai/types";
+export { FileSystemImpl, createFileSystem };
+declare function createFileSystem(args: Omit<OuterFileSystems, "graphUrl" | "blobs" | "session" | "run" | "assets">): FileSystem;
+declare class FileSystemImpl implements FileSystem {
+    #private;
+    constructor(outer: Partial<OuterFileSystems>);
+    query({ path, }: FileSystemQueryArguments): Promise<FileSystemQueryResult>;
+    read({ path, start, inflate, }: FileSystemReadArguments): Promise<FileSystemReadResult>;
+    write(args: FileSystemWriteArguments): Promise<FileSystemWriteResult>;
+    addStream({ path, stream, }: FileSystemWriteStreamArguments): Promise<Outcome<void>>;
+    close(): Promise<void>;
+    onEndRun(): Promise<void>;
+    env(): FileSystemEntry[];
+    createModuleFileSystem(args: CreateModuleFileSystemArgs): FileSystem;
+    updateRunFileSystem(args: CreateRunFileSystemArgs): FileSystem;
+    createRunFileSystem(args: CreateRunFileSystemArgs): FileSystem;
+}

package/dist/breadboard/engine/file-system/partial-persistent-backend.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FileSystemPath, FileSystemQueryResult, FileSystemWriteResult, LLMContent, Outcome, PersistentBackend } from "@breadboard-ai/types";
+export { PartialPersistentBackend };
+declare class PartialPersistentBackend implements PersistentBackend {
+    private readonly backend;
+    constructor(backend: Partial<PersistentBackend>);
+    query(graphUrl: string, path: FileSystemPath): Promise<FileSystemQueryResult>;
+    read(graphUrl: string, path: FileSystemPath, inflate: boolean): Promise<Outcome<LLMContent[]>>;
+    write(graphUrl: string, path: FileSystemPath, data: LLMContent[]): Promise<FileSystemWriteResult>;
+    append(graphUrl: string, path: FileSystemPath, data: LLMContent[]): Promise<FileSystemWriteResult>;
+    delete(graphUrl: string, path: FileSystemPath, all: boolean): Promise<FileSystemWriteResult>;
+    copy(graphUrl: string, source: FileSystemPath, destination: FileSystemPath): Promise<FileSystemWriteResult>;
+    move(graphUrl: string, source: FileSystemPath, destination: FileSystemPath): Promise<FileSystemWriteResult>;
+    onEndRun(): Promise<void>;
+}

package/dist/breadboard/engine/file-system/path.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FileSystemPath, FileSystemReadWritePath, Outcome } from "@breadboard-ai/types";
+export { Path };
+export declare function writablePathFromString(s: string): Outcome<FileSystemReadWritePath>;
+declare class Path {
+    readonly root: string;
+    readonly path: string[];
+    readonly dir: boolean;
+    static roots: Set<string>;
+    static writableRoots: Set<string>;
+    static persistentRoots: Set<string>;
+    static mountedRoots: Set<string>;
+    readonly writable: boolean;
+    readonly persistent: boolean;
+    readonly mounted: boolean;
+    constructor(root: string, path: string[], dir: boolean);
+    static createRoots(): Path[];
+    static create(path: FileSystemPath): Outcome<Path>;
+}

package/dist/breadboard/engine/file-system/persistent-file.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FileSystemFile, FileSystemPath, FileSystemQueryEntry, FileSystemReadResult, FileSystemWriteResult, LLMContent, Outcome, PersistentBackend } from "@breadboard-ai/types";
+export { PersistentFile };
+declare class PersistentFile implements FileSystemFile {
+    readonly graphUrl: string;
+    readonly path: FileSystemPath;
+    readonly backend: PersistentBackend;
+    constructor(graphUrl: string, path: FileSystemPath, backend: PersistentBackend);
+    read(inflate: boolean, start?: number): Promise<FileSystemReadResult>;
+    append(data: LLMContent[], done: boolean, receipt?: boolean): Promise<FileSystemWriteResult>;
+    copy(): Outcome<FileSystemFile>;
+    queryEntry(_path: FileSystemPath): FileSystemQueryEntry;
+    delete(): Promise<FileSystemWriteResult>;
+    data: LLMContent[];
+}

package/dist/breadboard/engine/file-system/readable-stream-file.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FileSystemFile, FileSystemPath, FileSystemQueryEntry, FileSystemReadResult, FileSystemWriteResult, LLMContent, Outcome } from "@breadboard-ai/types";
+export { ReadableStreamFile };
+declare class ReadableStreamFile implements FileSystemFile {
+    readonly stream: ReadableStream<LLMContent>;
+    readonly data: LLMContent[];
+    constructor(stream: ReadableStream<LLMContent>);
+    read(_inflate: boolean, start?: number): Promise<FileSystemReadResult>;
+    append(): Promise<Outcome<void>>;
+    copy(): Outcome<FileSystemFile>;
+    queryEntry(path: FileSystemPath): FileSystemQueryEntry;
+    delete(): Promise<FileSystemWriteResult>;
+}

package/dist/breadboard/engine/file-system/stub-file-system.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FileSystem, FileSystemEntry, FileSystemQueryResult, FileSystemReadResult, FileSystemWriteResult, Outcome } from "@breadboard-ai/types";
+export { StubFileSystem };
+declare class StubFileSystem implements FileSystem {
+    query(): Promise<FileSystemQueryResult>;
+    read(): Promise<FileSystemReadResult>;
+    write(): Promise<FileSystemWriteResult>;
+    addStream(): Promise<Outcome<void>>;
+    close(): Promise<void>;
+    updateRunFileSystem(): FileSystem;
+    createRunFileSystem(): FileSystem;
+    createModuleFileSystem(): FileSystem;
+    env(): FileSystemEntry[];
+}

package/dist/breadboard/engine/file-system/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FileSystemPath, FileSystemReadResult, FileSystemWriteResult, LLMContent } from "@breadboard-ai/types";
+export { noStreams, readFromStart };
+declare function readFromStart(path: FileSystemPath, data: LLMContent[] | undefined, start: number): FileSystemReadResult;
+declare function noStreams(done: boolean, receipt?: boolean): FileSystemWriteResult;

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

@@ -0,0 +1,34 @@
+/**
+ * @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";
+/**
+ * This is a special kind of an `InspectableNode`, representing a bubbled
+ * node instance. Its key difference is that, when it's type = input,
+ * it will narrow down the ports and values to only the ones that bubbled up.
+ * For instance, the actual input node might have four parameters, but
+ * only one of them bubbled up. This node will make sure that it looks as if
+ * it only has that one parameter.
+ */
+export declare class BubbledInspectableNode implements InspectableNode {
+    #private;
+    descriptor: NodeDescriptor;
+    constructor(actual: InspectableNode);
+    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;
+    ports(inputValues?: InputValues | undefined, outputValues?: OutputValues | undefined): Promise<InspectableNodePorts>;
+    currentPorts(inputValues?: InputValues, outputValues?: OutputValues): InspectableNodePorts;
+    deleted(): boolean;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AffectedNode, DescribeResultCacheArgs, GraphIdentifier, InspectableDescriberResultCache, InspectableDescriberResultCacheEntry, NodeIdentifier } from "@breadboard-ai/types";
+export { DescribeResultCache };
+declare class DescribeResultCache implements InspectableDescriberResultCache {
+    #private;
+    readonly args: DescribeResultCacheArgs;
+    constructor(args: DescribeResultCacheArgs);
+    get(id: NodeIdentifier, graphId: GraphIdentifier): InspectableDescriberResultCacheEntry;
+    update(affectedNodes: AffectedNode[]): void;
+    clear(visualOnly: boolean, affectedNodes: AffectedNode[]): void;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DescribeResultTypeCacheArgs, InspectableDescriberResultCacheEntry, InspectableDescriberResultTypeCache, NodeTypeIdentifier } from "@breadboard-ai/types";
+export { DescribeResultTypeCache };
+declare class DescribeResultTypeCache implements InspectableDescriberResultTypeCache {
+    #private;
+    readonly args: DescribeResultTypeCacheArgs;
+    constructor(args: DescribeResultTypeCacheArgs);
+    get(type: NodeTypeIdentifier): InspectableDescriberResultCacheEntry;
+    update(affectedTypes: NodeTypeIdentifier[]): void;
+    clear(): void;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Edge as EdgeDescriptor, GraphDescriptor, GraphIdentifier, InspectableEdge, InspectableEdgeCache } from "@breadboard-ai/types";
+type EdgeFactory = (edge: EdgeDescriptor, graphId: GraphIdentifier) => InspectableEdge;
+export declare class EdgeCache implements InspectableEdgeCache {
+    #private;
+    constructor(factory: EdgeFactory);
+    rebuild(graph: GraphDescriptor): void;
+    get(edge: EdgeDescriptor, graphId: GraphIdentifier): InspectableEdge | undefined;
+    getOrCreate(edge: EdgeDescriptor, graphId: GraphIdentifier): InspectableEdge;
+    add(edge: EdgeDescriptor, graphId: GraphIdentifier): void;
+    remove(edge: EdgeDescriptor, graphId: GraphIdentifier): void;
+    has(edge: EdgeDescriptor, graphId: GraphIdentifier): boolean;
+    hasByValue(edge: EdgeDescriptor, graphId: GraphIdentifier): boolean;
+    edges(graphId: GraphIdentifier): InspectableEdge[];
+    addSubgraphEdges(subgraph: GraphDescriptor, graphId: GraphIdentifier): void;
+    removeSubgraphEdges(graphId: GraphIdentifier): void;
+}
+export {};

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

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Edge as EdgeDescriptor, EdgeMetadata, GraphIdentifier, InspectableEdge, InspectablePort, MutableGraph } from "@breadboard-ai/types";
+import { InspectableEdgeType } from "@breadboard-ai/types";
+export { Edge };
+/**
+ * This helper is necessary because both "*" and "" are valid representations
+ * of a wildcard edge tail. This function ensures that the edge is always
+ * consistent.
+ * @param edge -- the edge to fix up
+ * @returns
+ */
+export declare const fixUpStarEdge: (edge: EdgeDescriptor) => EdgeDescriptor;
+/**
+ * This is inverse of the helper above, necessary when working with
+ * instances of `InspectableEdge` directly, since they will show "*" on both
+ * sides of the edge.
+ * @param edge -- the edge to un-fix up
+ * @returns
+ */
+export declare const unfixUpStarEdge: (edge: EdgeDescriptor) => EdgeDescriptor;
+export declare const fixupConstantEdge: (edge: EdgeDescriptor) => EdgeDescriptor;
+declare class Edge implements InspectableEdge {
+    #private;
+    constructor(mutable: MutableGraph, edge: EdgeDescriptor, graphId: GraphIdentifier);
+    raw(): EdgeDescriptor;
+    get from(): import("@breadboard-ai/types").InspectableNode;
+    get out(): string;
+    get to(): import("@breadboard-ai/types").InspectableNode;
+    get in(): string;
+    get type(): InspectableEdgeType;
+    metadata(): EdgeMetadata | undefined;
+    outPort(): Promise<InspectablePort>;
+    inPort(): Promise<InspectablePort>;
+    setDeleted(): void;
+    deleted(): boolean;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GraphIdentifier, GraphStoreUpdateEvent, MainGraphIdentifier, NodeIdentifier } from "@breadboard-ai/types";
+export { UpdateEvent };
+declare class UpdateEvent extends Event implements GraphStoreUpdateEvent {
+    readonly mainGraphId: MainGraphIdentifier;
+    readonly graphId: GraphIdentifier;
+    readonly nodeId: NodeIdentifier;
+    readonly affectedGraphs: MainGraphIdentifier[];
+    readonly topologyChange: boolean;
+    static eventName: string;
+    constructor(mainGraphId: MainGraphIdentifier, graphId: GraphIdentifier, nodeId: NodeIdentifier, affectedGraphs: MainGraphIdentifier[], topologyChange: boolean);
+}

package/dist/breadboard/engine/inspector/graph/exports-describer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GraphDescriberFactory, MutableGraph, NodeDescriberResult } from "@breadboard-ai/types";
+export { ExportsDescriber };
+declare class ExportsDescriber {
+    private readonly mutable;
+    private readonly describerFactory;
+    constructor(mutable: MutableGraph, describerFactory: GraphDescriberFactory);
+    transform(result: NodeDescriberResult): Promise<NodeDescriberResult>;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GraphDescriptor, GraphIdentifier, InspectableGraph, InspectableGraphCache, InspectableSubgraphs } from "@breadboard-ai/types";
+export { GraphCache };
+type GraphFactory = (graphId: GraphIdentifier) => InspectableGraph;
+declare class GraphCache implements InspectableGraphCache {
+    #private;
+    constructor(factory: GraphFactory);
+    rebuild(graph: GraphDescriptor): void;
+    get(id: GraphIdentifier): InspectableGraph | undefined;
+    add(id: GraphIdentifier): void;
+    graphs(): InspectableSubgraphs;
+    remove(id: GraphIdentifier): void;
+    clear(): void;
+}

package/dist/breadboard/engine/inspector/graph/graph-describer-manager.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { GraphDescriber, GraphIdentifier, InputValues, MutableGraph, NodeDescriberContext, NodeDescriberResult, Outcome, Schema } from "@breadboard-ai/types";
+import { GraphDescriptorHandle } from "./graph-descriptor-handle.js";
+export { GraphDescriberManager };
+/**
+ * Contains all machinery that allows
+ * describing a node or a graph
+ */
+declare class GraphDescriberManager implements GraphDescriber {
+    #private;
+    readonly handle: GraphDescriptorHandle;
+    readonly mutable: MutableGraph;
+    private readonly exports;
+    private constructor();
+    describe(inputs?: InputValues, _inputSchema?: Schema, _outputSchema?: Schema, context?: NodeDescriberContext): Promise<NodeDescriberResult>;
+    static create(graphId: GraphIdentifier, cache: MutableGraph): Outcome<GraphDescriberManager>;
+}

package/dist/breadboard/engine/inspector/graph/graph-descriptor-handle.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { GraphDescriptor, GraphIdentifier, Result } from "@breadboard-ai/types";
+export { GraphDescriptorHandle };
+declare class GraphDescriptorHandle {
+    #private;
+    readonly graphId: GraphIdentifier;
+    private constructor();
+    main(): string | undefined;
+    url(): URL | undefined;
+    outerGraph(): GraphDescriptor;
+    graph(): GraphDescriptor;
+    static create(graph: GraphDescriptor, graphId: GraphIdentifier): Result<GraphDescriptorHandle>;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { InspectableNodePorts, InspectableNodeType, MutableGraph, NodeHandlerMetadata } from "@breadboard-ai/types";
+export { GraphNodeType };
+declare class GraphNodeType implements InspectableNodeType {
+    #private;
+    constructor(type: string, mutable: MutableGraph);
+    currentMetadata(): NodeHandlerMetadata;
+    metadata(): Promise<NodeHandlerMetadata>;
+    type(): string;
+    ports(): Promise<InspectableNodePorts>;
+}

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

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AssetPath, GraphIdentifier, ImportIdentifier, InspectableAsset, InspectableAssetEdge, InspectableEdge, InspectableGraph, InspectableNode, InspectableNodeType, ModuleIdentifier, MutableGraph, NodeIdentifier, NodeTypeIdentifier, Outcome } from "@breadboard-ai/types";
+import { TemplatePart } from "@breadboard-ai/utils";
+export { GraphQueries };
+/**
+ * Encapsulates common graph operations.
+ */
+declare class GraphQueries {
+    #private;
+    constructor(cache: MutableGraph, graphId: GraphIdentifier);
+    isEntry(id: NodeIdentifier): boolean;
+    isExit(id: NodeIdentifier): boolean;
+    incoming(id: NodeIdentifier): InspectableEdge[];
+    outgoing(id: NodeIdentifier): InspectableEdge[];
+    entries(): InspectableNode[];
+    isStart(id: NodeIdentifier): boolean;
+    nodeById(id: NodeIdentifier): InspectableNode | undefined;
+    typeForNode(id: NodeIdentifier): InspectableNodeType | undefined;
+    typeById(id: NodeTypeIdentifier): InspectableNodeType | undefined;
+    moduleExports(): Set<ModuleIdentifier>;
+    graphExports(): Set<GraphIdentifier>;
+    imports(): Promise<Map<ImportIdentifier, Outcome<InspectableGraph>>>;
+    assets(): Map<AssetPath, InspectableAsset>;
+    assetEdges(): Outcome<InspectableAssetEdge[]>;
+    tools(): TemplatePart[];
+    usesTool(path: string): boolean;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AssetPath, Edge, GraphDescriptor, GraphIdentifier, GraphMetadata, ImportIdentifier, InputValues, InspectableAsset, InspectableAssetEdge, InspectableEdge, InspectableGraph, InspectableModules, InspectableNode, InspectableNodeType, InspectableSubgraphs, ModuleIdentifier, MutableGraph, NodeDescriberContext, NodeDescriberResult, NodeIdentifier, NodeTypeIdentifier, Outcome } from "@breadboard-ai/types";
+export { Graph };
+declare class Graph implements InspectableGraph {
+    #private;
+    constructor(graphId: GraphIdentifier, mutableGraph: MutableGraph);
+    raw(): GraphDescriptor;
+    mainGraphDescriptor(): GraphDescriptor;
+    imperative(): boolean;
+    main(): string | undefined;
+    metadata(): GraphMetadata | undefined;
+    nodesByType(type: NodeTypeIdentifier): InspectableNode[];
+    nodeById(id: NodeIdentifier): InspectableNode | undefined;
+    nodes(): InspectableNode[];
+    moduleById(id: ModuleIdentifier): import("@breadboard-ai/types").InspectableModule | undefined;
+    modules(): InspectableModules;
+    edges(): InspectableEdge[];
+    hasEdge(edge: Edge): boolean;
+    typeForNode(id: NodeIdentifier): InspectableNodeType | undefined;
+    typeById(id: NodeTypeIdentifier): InspectableNodeType | undefined;
+    incomingForNode(id: NodeIdentifier): InspectableEdge[];
+    outgoingForNode(id: NodeIdentifier): InspectableEdge[];
+    entries(): InspectableNode[];
+    describe(inputs?: InputValues, context?: NodeDescriberContext): Promise<NodeDescriberResult>;
+    graphs(): InspectableSubgraphs | undefined;
+    graphId(): GraphIdentifier;
+    moduleExports(): Set<ModuleIdentifier>;
+    graphExports(): Set<GraphIdentifier>;
+    imports(): Promise<Map<ImportIdentifier, Outcome<InspectableGraph>>>;
+    assets(): Map<AssetPath, InspectableAsset>;
+    assetEdges(): Outcome<InspectableAssetEdge[]>;
+    usesTool(path: string): boolean;
+}

package/dist/breadboard/engine/inspector/graph/inspectable-asset.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Asset, AssetPath, AssetType, InspectableAsset, LLMContent } from "@breadboard-ai/types";
+export { InspectableAssetImpl };
+declare class InspectableAssetImpl implements InspectableAsset {
+    readonly title: string;
+    readonly description: string;
+    readonly type: AssetType;
+    readonly subType: string;
+    readonly data: LLMContent[];
+    readonly visual: Record<string, unknown>;
+    readonly managed: boolean;
+    constructor(path: AssetPath, asset: Asset);
+}

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

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { GraphDescriptor, InspectableKitCache, InspectableNodeType, Kit, MutableGraph, NodeTypeIdentifier } from "@breadboard-ai/types";
+export { createBuiltInKit, KitCache };
+declare function createBuiltInKit(): Kit;
+declare class KitCache implements InspectableKitCache {
+    #private;
+    constructor(mutable: MutableGraph);
+    getType(id: NodeTypeIdentifier): InspectableNodeType | undefined;
+    addType(id: NodeTypeIdentifier, type: InspectableNodeType): void;
+    rebuild(graph: GraphDescriptor): void;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { GraphDescriptor, InspectableModule, InspectableModuleCache, InspectableModules, ModuleIdentifier, Module as ModuleType } from "@breadboard-ai/types";
+export declare class ModuleCache implements InspectableModuleCache {
+    #private;
+    get(id: ModuleIdentifier): InspectableModule | undefined;
+    add(id: ModuleIdentifier, module: ModuleType): void;
+    remove(id: ModuleIdentifier): void;
+    modules(): InspectableModules;
+    rebuild(graph: GraphDescriptor): void;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AffectedNode, GraphDescriptor, GraphIdentifier, GraphRepresentation, InspectableDescriberResultCache, InspectableEdgeCache, InspectableGraphCache, InspectableKitCache, InspectableModuleCache, InspectableNodeCache, InspectablePortCache, KitDescriptor, MainGraphIdentifier, ModuleIdentifier, MutableGraph, MutableGraphStore } from "@breadboard-ai/types";
+export { MutableGraphImpl };
+declare class MutableGraphImpl implements MutableGraph {
+    readonly store: MutableGraphStore;
+    readonly id: MainGraphIdentifier;
+    legacyKitMetadata: KitDescriptor | null;
+    graph: GraphDescriptor;
+    graphs: InspectableGraphCache;
+    nodes: InspectableNodeCache;
+    edges: InspectableEdgeCache;
+    modules: InspectableModuleCache;
+    describe: InspectableDescriberResultCache;
+    kits: InspectableKitCache;
+    ports: InspectablePortCache;
+    representation: GraphRepresentation;
+    constructor(graph: GraphDescriptor, store: MutableGraphStore);
+    update(graph: GraphDescriptor, visualOnly: boolean, affectedNodes: AffectedNode[], affectedModules: ModuleIdentifier[], topologyChange: boolean): void;
+    addSubgraph(subgraph: GraphDescriptor, graphId: GraphIdentifier): void;
+    removeSubgraph(graphId: GraphIdentifier): void;
+    rebuild(graph: GraphDescriptor): void;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { GraphDescriptor, GraphIdentifier, InspectableNode, InspectableNodeCache, NodeDescriptor, NodeIdentifier, NodeTypeIdentifier } from "@breadboard-ai/types";
+type NodeFactory = (node: NodeDescriptor, graphId: GraphIdentifier) => InspectableNode;
+export declare class NodeCache implements InspectableNodeCache {
+    #private;
+    constructor(factory: NodeFactory);
+    rebuild(graph: GraphDescriptor): void;
+    addSubgraphNodes(subgraph: GraphDescriptor, graphId: GraphIdentifier): void;
+    removeSubgraphNodes(graphId: GraphIdentifier): void;
+    byType(type: NodeTypeIdentifier, graphId: GraphIdentifier): InspectableNode[];
+    get(id: NodeIdentifier, graphId: GraphIdentifier): InspectableNode | undefined;
+    add(node: NodeDescriptor, graphId: GraphIdentifier): void;
+    remove(id: NodeIdentifier, graphId: GraphIdentifier): void;
+    nodes(graphId: GraphIdentifier): InspectableNode[];
+}
+export {};

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

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DescribeResultCacheArgs, GraphIdentifier, InspectableEdge, MutableGraph, NodeDescriberResult, NodeIdentifier, NodeTypeDescriberOptions, NodeTypeIdentifier } from "@breadboard-ai/types";
+export { emptyResult, NodeDescriberManager };
+declare function emptyResult(): NodeDescriberResult;
+declare class NodeDescriberManager implements DescribeResultCacheArgs {
+    #private;
+    readonly mutable: MutableGraph;
+    constructor(mutable: MutableGraph);
+    initial(graphId: GraphIdentifier, nodeId: NodeIdentifier): NodeDescriberResult;
+    latest(graphId: GraphIdentifier, nodeId: NodeIdentifier): Promise<NodeDescriberResult>;
+    willUpdate(previous: NodeDescriberResult, current: NodeDescriberResult): void;
+    updated(graphId: GraphIdentifier, nodeId: NodeIdentifier): void;
+    getLatestDescription(type: NodeTypeIdentifier, graphId: GraphIdentifier, options?: NodeTypeDescriberOptions): Promise<{
+        inputSchema: import("@breadboard-ai/types").Schema;
+        outputSchema: import("@breadboard-ai/types").Schema;
+    }>;
+    static asWired(incoming?: InspectableEdge[], outgoing?: InspectableEdge[]): {
+        inputSchema: import("@breadboard-ai/types").Schema;
+        outputSchema: import("@breadboard-ai/types").Schema;
+    };
+}

package/dist/breadboard/engine/inspector/graph/node-type-describer-manager.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DescribeResultTypeCacheArgs, MutableGraphStore, NodeDescriberResult, NodeTypeIdentifier } from "@breadboard-ai/types";
+export { NodeTypeDescriberManager };
+declare class NodeTypeDescriberManager implements DescribeResultTypeCacheArgs {
+    #private;
+    readonly store: MutableGraphStore;
+    constructor(store: MutableGraphStore);
+    initial(): NodeDescriberResult;
+    updated(): void;
+    latest(type: NodeTypeIdentifier): Promise<NodeDescriberResult>;
+    getLatestDescription(type: NodeTypeIdentifier): Promise<{
+        inputSchema: import("@breadboard-ai/types").Schema;
+        outputSchema: import("@breadboard-ai/types").Schema;
+    }>;
+}