pi-loop-graph-sdk 0.2.0

package/dist/core/schema.d.ts

@@ -0,0 +1,8 @@
+import type { TSchema } from "typebox";
+import { type JsonValue } from "./json.js";
+export interface SchemaCheckResult {
+    readonly valid: boolean;
+    readonly value?: JsonValue;
+    readonly message?: string;
+}
+export declare function checkJsonSchemaValue(schema: TSchema, value: unknown): SchemaCheckResult;

package/dist/core/schema.js

@@ -0,0 +1,23 @@
+import { Compile } from "typebox/compile";
+import { isJsonValue } from "./json.js";
+const validators = new WeakMap();
+export function checkJsonSchemaValue(schema, value) {
+    if (!isJsonValue(value)) {
+        return Object.freeze({ valid: false, message: "Value is not JSON-compatible" });
+    }
+    const validator = getValidator(schema);
+    if (validator.Check(value))
+        return Object.freeze({ valid: true, value });
+    const first = validator.Errors(value)[0];
+    const location = first?.instancePath ? ` at ${first.instancePath}` : "";
+    const detail = first?.message ? `: ${first.message}` : "";
+    return Object.freeze({ valid: false, message: `Schema validation failed${location}${detail}` });
+}
+function getValidator(schema) {
+    const cached = validators.get(schema);
+    if (cached)
+        return cached;
+    const validator = Compile(schema);
+    validators.set(schema, validator);
+    return validator;
+}

package/dist/core/skill.d.ts

@@ -0,0 +1,12 @@
+export interface SkillRef {
+    readonly name: string;
+    readonly version?: string;
+    readonly required: boolean;
+}
+export interface ResolvedSkillView {
+    readonly name: string;
+    readonly version?: string;
+    readonly source: string;
+    readonly fingerprint: string;
+    readonly content: string;
+}

package/dist/core/skill.js

@@ -0,0 +1 @@
+export {};

package/dist/host/baseline.d.ts

@@ -0,0 +1,11 @@
+export type HostBaseline = {
+    readonly kind: "isolated";
+} | {
+    readonly kind: "inherit";
+    readonly fingerprint?: string;
+} | {
+    readonly kind: "custom";
+    readonly id: string;
+};
+export declare const DEFAULT_HOST_BASELINE: HostBaseline;
+export declare function resolveHostBaseline(baseline?: HostBaseline): HostBaseline;

package/dist/host/baseline.js

@@ -0,0 +1,4 @@
+export const DEFAULT_HOST_BASELINE = Object.freeze({ kind: "isolated" });
+export function resolveHostBaseline(baseline) {
+    return Object.freeze({ ...(baseline ?? DEFAULT_HOST_BASELINE) });
+}

package/dist/host/graph-catalog.d.ts

@@ -0,0 +1,8 @@
+import type { Graph, GraphRef } from "../core/graph.js";
+export declare class GraphCatalog {
+    private readonly graphs;
+    register(graph: Graph): void;
+    resolve(ref: GraphRef): Graph | undefined;
+    has(ref: GraphRef): boolean;
+    get values(): readonly Graph[];
+}

package/dist/host/graph-catalog.js

@@ -0,0 +1,24 @@
+export class GraphCatalog {
+    graphs = new Map();
+    register(graph) {
+        const key = graphKey(graph);
+        if (this.graphs.has(key))
+            throw new Error(`Graph already registered: ${key}`);
+        this.graphs.set(key, graph);
+    }
+    resolve(ref) {
+        return this.graphs.get(refKey(ref));
+    }
+    has(ref) {
+        return this.graphs.has(refKey(ref));
+    }
+    get values() {
+        return Object.freeze([...this.graphs.values()]);
+    }
+}
+function graphKey(graph) {
+    return `${graph.id}@${graph.version}`;
+}
+function refKey(ref) {
+    return `${ref.id}@${ref.version}`;
+}

package/dist/host/graph-host.d.ts

@@ -0,0 +1,53 @@
+import type { TSchema } from "typebox";
+import type { Graph, SchemaValue } from "../core/graph.js";
+import type { InvocationLimits } from "../core/limits.js";
+import type { GraphRunResult } from "../core/result.js";
+import type { RecordingMode } from "../core/result.js";
+import { type GraphRuntimeHost } from "../runtime/graph-runtime.js";
+import { type RunStore, type CheckpointStore } from "../replay/store.js";
+import type { PricingResolver } from "../replay/events.js";
+export interface GraphHostRunOptions {
+    readonly signal?: AbortSignal;
+    readonly limits?: Partial<InvocationLimits>;
+    readonly maxSteps?: number;
+    readonly recording?: RecordingMode;
+    readonly recordingRequired?: boolean;
+}
+export interface GraphHostResumeOptions {
+    readonly runId: string;
+    readonly signal?: AbortSignal;
+    readonly maxSteps?: number;
+    readonly checkpointMigrator?: (saved: {
+        readonly id: string;
+        readonly version: string;
+    }) => {
+        readonly id: string;
+        readonly version: string;
+    };
+    readonly recording?: RecordingMode;
+    readonly recordingRequired?: boolean;
+}
+export interface GraphHost {
+    execute<TInputSchema extends TSchema, TOutputSchema extends TSchema>(graph: Graph<TInputSchema, TOutputSchema>, input: SchemaValue<TInputSchema>, options?: GraphHostRunOptions): Promise<GraphRunResult<SchemaValue<TOutputSchema>>>;
+    resume<TInputSchema extends TSchema, TOutputSchema extends TSchema>(graph: Graph<TInputSchema, TOutputSchema>, options: GraphHostResumeOptions): Promise<GraphRunResult<SchemaValue<TOutputSchema>>>;
+    dispose(): Promise<void>;
+}
+export interface CreateGraphHostOptions {
+    readonly runtime?: GraphRuntimeHost;
+    readonly limits?: InvocationLimits;
+    readonly dispose?: () => void | Promise<void>;
+    readonly recording?: RecordingMode;
+    readonly recordingRequired?: boolean;
+    readonly runStore?: RunStore;
+    readonly checkpointStore?: CheckpointStore;
+    readonly artifactThresholdBytes?: number;
+    readonly pricingResolver?: PricingResolver;
+}
+/** Owns one Core Runtime execution lane. Concurrent roots require separate hosts. */
+export declare function createGraphHost(options?: CreateGraphHostOptions): GraphHost;
+export interface ExecuteIsolatedGraphOptions<TInput> extends GraphHostRunOptions {
+    readonly input: TInput;
+    readonly createHost: () => GraphHost | Promise<GraphHost>;
+}
+/** Creates, runs and always disposes a one-shot host. */
+export declare function executeIsolatedGraph<TInputSchema extends TSchema, TOutputSchema extends TSchema>(graph: Graph<TInputSchema, TOutputSchema>, options: ExecuteIsolatedGraphOptions<SchemaValue<TInputSchema>>): Promise<GraphRunResult<SchemaValue<TOutputSchema>>>;

package/dist/host/graph-host.js

@@ -0,0 +1,181 @@
+import { GraphRuntime } from "../runtime/graph-runtime.js";
+import { RuntimeEventBus } from "../runtime/event-bus.js";
+import { FileRunStore } from "../replay/store.js";
+import { Recorder } from "../replay/recorder.js";
+/** Owns one Core Runtime execution lane. Concurrent roots require separate hosts. */
+export function createGraphHost(options = {}) {
+    const eventBus = options.runtime?.eventBus ?? new RuntimeEventBus();
+    const runStore = options.runStore ?? new FileRunStore();
+    const checkpointStore = options.checkpointStore ?? runStore;
+    const runtime = new GraphRuntime({ ...options.runtime, eventBus, checkpointStore, limits: options.limits ?? options.runtime?.limits });
+    let running = false;
+    let activeRun;
+    let activeController;
+    let disposed = false;
+    let disposing;
+    return {
+        async execute(graph, input, runOptions = {}) {
+            if (disposed)
+                throw new Error("GraphHost 已释放");
+            if (running)
+                throw new Error("GraphHost 已有 Root Run 正在执行；并发运行必须创建独立 Host");
+            running = true;
+            const controller = new AbortController();
+            activeController = controller;
+            const onAbort = () => controller.abort(runOptions.signal?.reason);
+            if (runOptions.signal?.aborted)
+                onAbort();
+            else
+                runOptions.signal?.addEventListener("abort", onAbort, { once: true });
+            const recording = runOptions.recording ?? options.recording ?? "replay";
+            const recordingRequired = runOptions.recordingRequired ?? options.recordingRequired ?? false;
+            const recorder = recording === "off" ? undefined : new Recorder({
+                mode: recording,
+                store: runStore,
+                artifactThresholdBytes: options.artifactThresholdBytes,
+                pricingResolver: options.pricingResolver,
+            });
+            recorder?.attach(eventBus);
+            const execution = (async () => {
+                try {
+                    const result = await runtime.execute(graph, input, { ...runOptions, signal: controller.signal });
+                    if (!recorder)
+                        return { ...result, replay: Object.freeze({ mode: "off", status: "off" }) };
+                    const finalized = await recorder.finalize(result);
+                    if (recordingRequired && finalized.replay.status !== "complete") {
+                        return {
+                            rootRunId: result.rootRunId,
+                            graphId: result.graphId,
+                            graphVersion: result.graphVersion,
+                            steps: result.steps,
+                            durationMs: result.durationMs,
+                            replay: finalized.replay,
+                            status: "failed",
+                            failure: {
+                                code: "persistence-failed",
+                                phase: "host",
+                                message: finalized.replay.issues?.join("; ") ?? "Replay recording failed",
+                                retryable: true,
+                            },
+                        };
+                    }
+                    return { ...result, replay: finalized.replay };
+                }
+                finally {
+                    runOptions.signal?.removeEventListener("abort", onAbort);
+                    running = false;
+                    activeController = undefined;
+                }
+            })();
+            activeRun = execution;
+            try {
+                return await execution;
+            }
+            finally {
+                if (activeRun === execution)
+                    activeRun = undefined;
+            }
+        },
+        async resume(graph, resumeOptions = { runId: "" }) {
+            if (disposed)
+                throw new Error("GraphHost 已释放");
+            if (running)
+                throw new Error("GraphHost 已有 Root Run 正在执行；并发运行必须创建独立 Host");
+            running = true;
+            const controller = new AbortController();
+            activeController = controller;
+            const onAbort = () => controller.abort(resumeOptions.signal?.reason);
+            if (resumeOptions.signal?.aborted)
+                onAbort();
+            else
+                resumeOptions.signal?.addEventListener("abort", onAbort, { once: true });
+            const recording = resumeOptions.recording ?? options.recording ?? "replay";
+            const recordingRequired = resumeOptions.recordingRequired ?? options.recordingRequired ?? false;
+            const recorder = recording === "off" ? undefined : new Recorder({
+                mode: recording,
+                store: runStore,
+                artifactThresholdBytes: options.artifactThresholdBytes,
+                pricingResolver: options.pricingResolver,
+            });
+            recorder?.attach(eventBus);
+            const execution = (async () => {
+                try {
+                    const result = await runtime.resume(graph, {
+                        runId: resumeOptions.runId,
+                        signal: controller.signal,
+                        maxSteps: resumeOptions.maxSteps,
+                        checkpointMigrator: resumeOptions.checkpointMigrator,
+                    });
+                    if (!recorder)
+                        return { ...result, replay: Object.freeze({ mode: "off", status: "off" }) };
+                    const finalized = await recorder.finalize(result);
+                    if (recordingRequired && finalized.replay.status !== "complete") {
+                        return {
+                            rootRunId: result.rootRunId,
+                            graphId: result.graphId,
+                            graphVersion: result.graphVersion,
+                            steps: result.steps,
+                            durationMs: result.durationMs,
+                            replay: finalized.replay,
+                            status: "failed",
+                            failure: {
+                                code: "persistence-failed",
+                                phase: "host",
+                                message: finalized.replay.issues?.join("; ") ?? "Replay recording failed",
+                                retryable: true,
+                            },
+                        };
+                    }
+                    return { ...result, replay: finalized.replay };
+                }
+                finally {
+                    resumeOptions.signal?.removeEventListener("abort", onAbort);
+                    running = false;
+                    activeController = undefined;
+                }
+            })();
+            activeRun = execution;
+            try {
+                return await execution;
+            }
+            finally {
+                if (activeRun === execution)
+                    activeRun = undefined;
+            }
+        },
+        async dispose() {
+            if (disposing)
+                return disposing;
+            disposed = true;
+            activeController?.abort(new Error("GraphHost disposed"));
+            disposing = (async () => {
+                await activeRun?.catch(() => undefined);
+                await options.dispose?.();
+            })();
+            return disposing;
+        },
+    };
+}
+/** Creates, runs and always disposes a one-shot host. */
+export async function executeIsolatedGraph(graph, options) {
+    const host = await options.createHost();
+    let runError;
+    try {
+        return await host.execute(graph, options.input, options);
+    }
+    catch (error) {
+        runError = error;
+        throw error;
+    }
+    finally {
+        try {
+            await host.dispose();
+        }
+        catch (disposeError) {
+            if (runError && typeof runError === "object")
+                runError.suppressed = disposeError;
+            else
+                throw disposeError;
+        }
+    }
+}

package/dist/host/preflight.d.ts

@@ -0,0 +1,17 @@
+import type { Graph, NodeDefinition } from "../core/graph.js";
+import type { SkillCatalog } from "./skill-catalog.js";
+import { type ToolCatalog, type UnsafeToolResolver } from "./tool-catalog.js";
+export type CapabilityPreflightCode = "invalid-graph" | "tool-unavailable" | "host-unavailable";
+export declare class CapabilityPreflightError extends Error {
+    readonly code: CapabilityPreflightCode;
+    readonly phase: "graph" | "host";
+    readonly stageId?: string | undefined;
+    constructor(code: CapabilityPreflightCode, phase: "graph" | "host", message: string, stageId?: string | undefined);
+}
+export interface CapabilityPreflightHost {
+    readonly toolCatalog?: ToolCatalog;
+    readonly skillCatalog?: SkillCatalog;
+    readonly unsafeToolResolver?: UnsafeToolResolver;
+}
+export declare function preflightGraphCapabilities(graph: Graph, host: CapabilityPreflightHost): void;
+export declare function resolveNodeToolNames(graph: Graph, stageId: string, node: NodeDefinition, host: Pick<CapabilityPreflightHost, "toolCatalog" | "unsafeToolResolver">): readonly string[];

package/dist/host/preflight.js

@@ -0,0 +1,81 @@
+import { RUNTIME_PROTOCOL_TOOL_NAME, selectNodeToolNames, } from "./tool-catalog.js";
+export class CapabilityPreflightError extends Error {
+    code;
+    phase;
+    stageId;
+    constructor(code, phase, message, stageId) {
+        super(message);
+        this.code = code;
+        this.phase = phase;
+        this.stageId = stageId;
+        this.name = "CapabilityPreflightError";
+    }
+}
+export function preflightGraphCapabilities(graph, host) {
+    const policy = graph.tools ?? [];
+    if (new Set(policy).size !== policy.length) {
+        throw new CapabilityPreflightError("invalid-graph", "graph", `Graph Tool Policy contains duplicate names: ${graph.id}@${graph.version}`);
+    }
+    if (policy.includes(RUNTIME_PROTOCOL_TOOL_NAME)) {
+        throw new CapabilityPreflightError("invalid-graph", "graph", `Graph Tool Policy cannot declare Runtime protocol tool: ${RUNTIME_PROTOCOL_TOOL_NAME}`);
+    }
+    if (policy.length > 0 && !host.toolCatalog) {
+        throw new CapabilityPreflightError("tool-unavailable", "host", `Graph requires business tools but Host has no Tool Catalog: ${graph.id}@${graph.version}`);
+    }
+    for (const name of policy)
+        assertToolAvailable(host.toolCatalog, name);
+    assertSkillsAvailable(graph.skills, host.skillCatalog);
+    for (const [stageId, stage] of Object.entries(graph.stages)) {
+        const selected = resolveNodeToolNames(graph, stageId, stage.node, host);
+        for (const name of selected) {
+            if (name !== RUNTIME_PROTOCOL_TOOL_NAME)
+                assertToolAvailable(host.toolCatalog, name, stageId);
+        }
+        assertSkillsAvailable(stage.node.skills, host.skillCatalog, stageId);
+    }
+}
+export function resolveNodeToolNames(graph, stageId, node, host) {
+    const policy = graph.tools ?? [];
+    const nodeTools = node.kind === "graph" ? undefined : node.tools;
+    const requested = nodeTools === "all" ? policy : (nodeTools ?? []);
+    if (!host.unsafeToolResolver) {
+        try {
+            return selectNodeToolNames(graph, node);
+        }
+        catch (error) {
+            throw new CapabilityPreflightError("invalid-graph", "graph", error instanceof Error ? error.message : String(error), stageId);
+        }
+    }
+    const names = host.unsafeToolResolver(Object.freeze({
+        graph,
+        stageId,
+        node,
+        selected: Object.freeze([...requested]),
+        hostTools: host.toolCatalog?.names ?? [],
+    }));
+    if (!Array.isArray(names) || names.some((name) => typeof name !== "string" || name.length === 0)) {
+        throw new CapabilityPreflightError("invalid-graph", "host", "UnsafeToolResolver must return non-empty tool names", stageId);
+    }
+    return Object.freeze([...new Set(names)]);
+}
+function assertToolAvailable(catalog, name, stageId) {
+    if (!catalog?.has(name)) {
+        throw new CapabilityPreflightError("tool-unavailable", "host", `Host tool unavailable: ${name}`, stageId);
+    }
+}
+function assertSkillsAvailable(refs, catalog, stageId) {
+    for (const ref of refs ?? []) {
+        let resolved;
+        try {
+            resolved = catalog?.resolve(ref);
+        }
+        catch (error) {
+            if (!ref.required)
+                continue;
+            throw new CapabilityPreflightError("host-unavailable", "host", `Required Skill resolution failed: ${ref.name}${ref.version ? `@${ref.version}` : ""}: ${error instanceof Error ? error.message : String(error)}`, stageId);
+        }
+        if (!ref.required || resolved)
+            continue;
+        throw new CapabilityPreflightError("host-unavailable", "host", `Required Skill unavailable: ${ref.name}${ref.version ? `@${ref.version}` : ""}`, stageId);
+    }
+}

package/dist/host/skill-catalog.d.ts

@@ -0,0 +1,24 @@
+import type { ResolvedSkillView, SkillRef } from "../core/skill.js";
+export interface SkillRegistration {
+    readonly name: string;
+    readonly version?: string;
+    readonly source: string;
+    readonly content: string;
+}
+export interface SkillResolver {
+    resolve(ref: SkillRef): SkillRegistration | undefined;
+}
+export type SkillResolverFunction = (ref: SkillRef) => SkillRegistration | undefined;
+export interface SkillCatalogOptions {
+    readonly resolver?: SkillResolver | SkillResolverFunction;
+}
+export declare class SkillCatalog implements SkillResolver {
+    private readonly options;
+    private readonly skills;
+    private readonly misses;
+    constructor(options?: SkillCatalogOptions);
+    register(skill: SkillRegistration): void;
+    resolve(ref: SkillRef): ResolvedSkillView | undefined;
+    loadPaths(paths: readonly string[]): Promise<void>;
+    private loadPath;
+}

package/dist/host/skill-catalog.js

@@ -0,0 +1,92 @@
+import { createHash } from "node:crypto";
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+export class SkillCatalog {
+    options;
+    skills = new Map();
+    misses = new Set();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    register(skill) {
+        const key = skillKey(skill.name, skill.version);
+        if (this.skills.has(key))
+            throw new Error(`Skill already registered: ${key}`);
+        this.misses.delete(key);
+        this.skills.set(key, resolveRegistration(skill));
+    }
+    resolve(ref) {
+        const key = skillKey(ref.name, ref.version);
+        const registered = this.skills.get(key);
+        if (registered)
+            return registered;
+        if (this.misses.has(key))
+            return undefined;
+        const resolver = this.options.resolver;
+        if (!resolver)
+            return undefined;
+        const candidate = typeof resolver === "function" ? resolver(ref) : resolver.resolve(ref);
+        if (!candidate) {
+            this.misses.add(key);
+            return undefined;
+        }
+        if (candidate.name !== ref.name || candidate.version !== ref.version) {
+            throw new Error(`Skill resolver returned ${skillKey(candidate.name, candidate.version)} for ${key}`);
+        }
+        const resolved = resolveRegistration(candidate);
+        this.skills.set(key, resolved);
+        return resolved;
+    }
+    async loadPaths(paths) {
+        for (const basePath of paths)
+            await this.loadPath(basePath);
+    }
+    async loadPath(basePath) {
+        for (const entry of await safeDirectories(basePath)) {
+            const skillRoot = join(basePath, entry);
+            const direct = await safeRead(join(skillRoot, "SKILL.md"));
+            if (direct != null) {
+                this.register({ name: entry, source: join(skillRoot, "SKILL.md"), content: direct });
+            }
+            for (const version of await safeDirectories(skillRoot)) {
+                const versionPath = join(skillRoot, version, "SKILL.md");
+                const content = await safeRead(versionPath);
+                if (content != null)
+                    this.register({ name: entry, version, source: versionPath, content });
+            }
+        }
+    }
+}
+async function safeDirectories(path) {
+    try {
+        return (await readdir(path, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function safeRead(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function skillKey(name, version) {
+    return `${name}@${version ?? ""}`;
+}
+function resolveRegistration(skill) {
+    if (!skill.name || !skill.source)
+        throw new Error("Skill registration requires name and source");
+    return Object.freeze({
+        ...skill,
+        fingerprint: createHash("sha256").update(skill.content).digest("hex"),
+    });
+}

package/dist/host/tool-catalog.d.ts

@@ -0,0 +1,27 @@
+import type { Graph, NodeDefinition } from "../core/graph.js";
+import type { TSchema } from "typebox";
+export declare const RUNTIME_PROTOCOL_TOOL_NAME: "__graph_complete__";
+export interface ToolImplementation {
+    readonly name: string;
+    readonly label?: string;
+    readonly description?: string;
+    readonly parameters?: TSchema;
+    readonly execute?: (...args: readonly unknown[]) => unknown | Promise<unknown>;
+    readonly protocol?: boolean;
+}
+export interface UnsafeToolResolverInput {
+    readonly graph: Graph;
+    readonly stageId: string;
+    readonly node: NodeDefinition;
+    readonly selected: readonly string[];
+    readonly hostTools: readonly string[];
+}
+export type UnsafeToolResolver = (input: UnsafeToolResolverInput) => readonly string[];
+export declare class ToolCatalog {
+    private readonly tools;
+    register(tool: ToolImplementation): void;
+    has(name: string): boolean;
+    resolve(name: string): ToolImplementation | undefined;
+    get names(): readonly string[];
+}
+export declare function selectNodeToolNames(graph: Graph, node: NodeDefinition): readonly string[];

package/dist/host/tool-catalog.js

@@ -0,0 +1,33 @@
+export const RUNTIME_PROTOCOL_TOOL_NAME = "__graph_complete__";
+export class ToolCatalog {
+    tools = new Map();
+    register(tool) {
+        if (!tool.name || tool.name === RUNTIME_PROTOCOL_TOOL_NAME) {
+            throw new Error(`Invalid business tool name: ${tool.name}`);
+        }
+        if (this.tools.has(tool.name))
+            throw new Error(`Tool already registered: ${tool.name}`);
+        this.tools.set(tool.name, Object.freeze({ ...tool }));
+    }
+    has(name) {
+        return this.tools.has(name);
+    }
+    resolve(name) {
+        return this.tools.get(name);
+    }
+    get names() {
+        return Object.freeze([...this.tools.keys()]);
+    }
+}
+export function selectNodeToolNames(graph, node) {
+    const policy = graph.tools ?? [];
+    const nodeTools = node.kind === "graph" ? undefined : node.tools;
+    const selected = nodeTools === "all" ? policy : (nodeTools ?? []);
+    const allowed = new Set(policy);
+    for (const name of selected) {
+        if (!allowed.has(name)) {
+            throw new Error(`Node selects tool outside Graph policy: ${name}`);
+        }
+    }
+    return Object.freeze([...new Set(selected)]);
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { createLoopGraphExtension } from "./adapter/loop-graph-extension.js";
+export type { LoopGraphExtension, LoopGraphExtensionOptions, LoopGraphLimits, LoopGraphExecutionOptions, GraphExposure, } from "./adapter/loop-graph-extension.js";
+export { Type } from "typebox";
+export type { AgentNodeDefinition, AgentRunRequest, CodeNodeDefinition, Connection, ContextContent, ContextFrame, Entry, Graph, GraphDefinition, GraphNodeDefinition, GraphRef, NodeDefinition, NodeDefinition as Node, Route, Stage, Transition, } from "./core/graph.js";
+export type { JsonValue, JsonSchema } from "./core/json.js";
+export type { ResolvedSkillView, SkillRef } from "./core/skill.js";
+export { defineMechanism } from "./core/mechanism.js";
+export type { Mechanism, MechanismContext, MechanismContextApi, MechanismDecisionTrace, MechanismExec, MechanismExecResult, MechanismFailurePolicy, MechanismInstallation, MechanismScope, MechanismCompletionDecision, } from "./core/mechanism.js";
+export type { NodeCompletion } from "./core/graph.js";
+export type { ToolSet } from "./builders/refs.js";
+export type { InvocationLimits } from "./core/limits.js";
+export { createGraphHost, executeIsolatedGraph } from "./host/graph-host.js";
+export { createPiGraphHost } from "./adapter/isolated-graph-session.js";
+export type { IsolatedGraphSessionFactoryOptions as CreatePiGraphHostOptions } from "./adapter/isolated-graph-session.js";
+export type { GraphHost, GraphHostRunOptions, CreateGraphHostOptions, ExecuteIsolatedGraphOptions, } from "./host/graph-host.js";
+export type { GraphFailure, GraphFailureCode, GraphRunResult, RecordingMode, ReplayReference, } from "./core/result.js";
+export { defineGraph, defineLinearGraph, defineSingleAgentGraph } from "./builders/graph.js";
+export { agentNode, codeNode, graphNode } from "./builders/node.js";
+export { connect, defineTransition, entry, finish, firstMatch } from "./builders/route.js";
+export { graphRef } from "./core/graph.js";
+export { skillRef, toolSet } from "./builders/refs.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+export { createLoopGraphExtension } from "./adapter/loop-graph-extension.js";
+export { Type } from "typebox";
+export { defineMechanism } from "./core/mechanism.js";
+export { createGraphHost, executeIsolatedGraph } from "./host/graph-host.js";
+export { createPiGraphHost } from "./adapter/isolated-graph-session.js";
+export { defineGraph, defineLinearGraph, defineSingleAgentGraph } from "./builders/graph.js";
+export { agentNode, codeNode, graphNode } from "./builders/node.js";
+export { connect, defineTransition, entry, finish, firstMatch } from "./builders/route.js";
+export { graphRef } from "./core/graph.js";
+export { skillRef, toolSet } from "./builders/refs.js";