@ai-setting/roy-agent-core 1.7.52 → 1.7.53

package/dist/env/workflow/types/workflow.d.ts

@@ -0,0 +1,654 @@
+import { z } from 'zod';
+export declare const DependsOnSchema: z.ZodArray<z.ZodString, "many">;
+export type DependsOn = z.infer<typeof DependsOnSchema>;
+export declare const RetryConfigSchema: z.ZodObject<{
+    max_attempts: z.ZodDefault<z.ZodNumber>;
+    backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+    initial_delay: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    max_attempts: number;
+    backoff: "fixed" | "exponential";
+    initial_delay: number;
+}, {
+    max_attempts?: number | undefined;
+    backoff?: "fixed" | "exponential" | undefined;
+    initial_delay?: number | undefined;
+}>;
+export type RetryConfig = z.infer<typeof RetryConfigSchema>;
+export declare const LoopGuardConfigSchema: z.ZodObject<{
+    /** Detection type — only `value_unchanged` is supported. */
+    type: z.ZodLiteral<"value_unchanged">;
+    /**
+     * Previous progress signal — any TemplateResolver path.
+     * Examples:
+     *   "{{nodes.tdd-implement.commits[-1]}}"
+     *   "{{nodes.code-review.severity.blocking.length}}"
+     *   "{{nodes.bug-fix.test_count_passing}}"
+     */
+    previous_signal: z.ZodString;
+    /**
+     * Current progress signal — any shell command. The stdout (trimmed) is
+     * compared to the resolved `previous_signal` via JSON.stringify equality.
+     * Examples:
+     *   "git rev-parse HEAD"
+     *   "pytest --collect-only -q 2>/dev/null | wc -l"
+     *   "ls -1 tests/test_*.py | wc -l"
+     */
+    current_signal_command: z.ZodString;
+    /** Optional working directory for `current_signal_command`. */
+    cwd: z.ZodOptional<z.ZodString>;
+    /** Consecutive no-progress re-entries before the engine forces FAIL (default 1). */
+    max_consecutive_no_progress: z.ZodDefault<z.ZodNumber>;
+    /** Custom fail message injected when the guard trips. */
+    fail_message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "value_unchanged";
+    previous_signal: string;
+    current_signal_command: string;
+    max_consecutive_no_progress: number;
+    cwd?: string | undefined;
+    fail_message?: string | undefined;
+}, {
+    type: "value_unchanged";
+    previous_signal: string;
+    current_signal_command: string;
+    cwd?: string | undefined;
+    max_consecutive_no_progress?: number | undefined;
+    fail_message?: string | undefined;
+}>;
+export type LoopGuardConfig = z.infer<typeof LoopGuardConfigSchema>;
+export declare const NodeDefinitionSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    config: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    depends_on: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    condition: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodDefault<z.ZodNumber>;
+        backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+        initial_delay: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        max_attempts: number;
+        backoff: "fixed" | "exponential";
+        initial_delay: number;
+    }, {
+        max_attempts?: number | undefined;
+        backoff?: "fixed" | "exponential" | undefined;
+        initial_delay?: number | undefined;
+    }>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    config: Record<string, unknown>;
+    id: string;
+    name?: string | undefined;
+    timeout?: number | undefined;
+    depends_on?: string[] | undefined;
+    condition?: string | undefined;
+    retry?: {
+        max_attempts: number;
+        backoff: "fixed" | "exponential";
+        initial_delay: number;
+    } | undefined;
+}, {
+    type: string;
+    id: string;
+    name?: string | undefined;
+    config?: Record<string, unknown> | undefined;
+    timeout?: number | undefined;
+    depends_on?: string[] | undefined;
+    condition?: string | undefined;
+    retry?: {
+        max_attempts?: number | undefined;
+        backoff?: "fixed" | "exponential" | undefined;
+        initial_delay?: number | undefined;
+    } | undefined;
+}>, {
+    type: string;
+    config: Record<string, unknown>;
+    id: string;
+    name?: string | undefined;
+    timeout?: number | undefined;
+    depends_on?: string[] | undefined;
+    condition?: string | undefined;
+    retry?: {
+        max_attempts: number;
+        backoff: "fixed" | "exponential";
+        initial_delay: number;
+    } | undefined;
+}, {
+    type: string;
+    id: string;
+    name?: string | undefined;
+    config?: Record<string, unknown> | undefined;
+    timeout?: number | undefined;
+    depends_on?: string[] | undefined;
+    condition?: string | undefined;
+    retry?: {
+        max_attempts?: number | undefined;
+        backoff?: "fixed" | "exponential" | undefined;
+        initial_delay?: number | undefined;
+    } | undefined;
+}>, {
+    type: string;
+    config: Record<string, unknown>;
+    id: string;
+    name?: string | undefined;
+    timeout?: number | undefined;
+    depends_on?: string[] | undefined;
+    condition?: string | undefined;
+    retry?: {
+        max_attempts: number;
+        backoff: "fixed" | "exponential";
+        initial_delay: number;
+    } | undefined;
+}, {
+    type: string;
+    id: string;
+    name?: string | undefined;
+    config?: Record<string, unknown> | undefined;
+    timeout?: number | undefined;
+    depends_on?: string[] | undefined;
+    condition?: string | undefined;
+    retry?: {
+        max_attempts?: number | undefined;
+        backoff?: "fixed" | "exponential" | undefined;
+        initial_delay?: number | undefined;
+    } | undefined;
+}>;
+export type NodeDefinition = z.infer<typeof NodeDefinitionSchema>;
+/**
+ * Node interface - base interface for all workflow nodes
+ */
+export interface Node {
+    /** Node type identifier */
+    readonly type: string;
+    /** Node unique identifier */
+    readonly id: string;
+    /** Execute the node with the given context */
+    execute(context: NodeExecutionContext): Promise<NodeExecutionResult>;
+}
+import type { NodeExecutionContext, NodeExecutionResult } from './run';
+export declare const WorkflowConfigSchema: z.ZodObject<{
+    parallel_limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    retry: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodDefault<z.ZodNumber>;
+        backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+        initial_delay: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        max_attempts: number;
+        backoff: "fixed" | "exponential";
+        initial_delay: number;
+    }, {
+        max_attempts?: number | undefined;
+        backoff?: "fixed" | "exponential" | undefined;
+        initial_delay?: number | undefined;
+    }>>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    /** Strict mode: fail on unresolved templates instead of warning */
+    strict: z.ZodOptional<z.ZodBoolean>;
+    /** Maximum iterations for loop detection */
+    maxIterations: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /** Enable loop mode to allow re-entry of completed nodes (for workflow cycles) */
+    loopEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    maxIterations: number;
+    loopEnabled: boolean;
+    strict?: boolean | undefined;
+    timeout?: number | null | undefined;
+    retry?: {
+        max_attempts: number;
+        backoff: "fixed" | "exponential";
+        initial_delay: number;
+    } | undefined;
+    parallel_limit?: number | null | undefined;
+    debug?: boolean | undefined;
+}, {
+    strict?: boolean | undefined;
+    timeout?: number | null | undefined;
+    maxIterations?: number | undefined;
+    retry?: {
+        max_attempts?: number | undefined;
+        backoff?: "fixed" | "exponential" | undefined;
+        initial_delay?: number | undefined;
+    } | undefined;
+    parallel_limit?: number | null | undefined;
+    debug?: boolean | undefined;
+    loopEnabled?: boolean | undefined;
+}>;
+export type WorkflowConfig = z.infer<typeof WorkflowConfigSchema>;
+export declare const OutputDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    source: z.ZodString;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    source: string;
+}, {
+    path: string;
+    name: string;
+    source: string;
+}>;
+export type OutputDefinition = z.infer<typeof OutputDefinitionSchema>;
+/**
+ * Single input parameter definition
+ */
+export declare const InputParameterSchema: z.ZodObject<{
+    type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
+    description: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    required: boolean;
+    description?: string | undefined;
+    default?: unknown;
+}, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    description?: string | undefined;
+    required?: boolean | undefined;
+    default?: unknown;
+}>;
+export type InputParameter = z.infer<typeof InputParameterSchema>;
+/**
+ * Input parameters schema for workflow definition
+ * Maps parameter names to their definitions
+ */
+export declare const WorkflowInputsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
+    description: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    required: boolean;
+    description?: string | undefined;
+    default?: unknown;
+}, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    description?: string | undefined;
+    required?: boolean | undefined;
+    default?: unknown;
+}>>;
+export type WorkflowInputs = z.infer<typeof WorkflowInputsSchema>;
+export declare const WorkflowMetadataSchema: z.ZodObject<{
+    author: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    tags: string[];
+    author?: string | undefined;
+    taskId?: number | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+}, {
+    tags?: string[] | undefined;
+    author?: string | undefined;
+    taskId?: number | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+}>;
+export type WorkflowMetadata = z.infer<typeof WorkflowMetadataSchema>;
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    config: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        parallel_limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            max_attempts: z.ZodDefault<z.ZodNumber>;
+            backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+            initial_delay: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            max_attempts: number;
+            backoff: "fixed" | "exponential";
+            initial_delay: number;
+        }, {
+            max_attempts?: number | undefined;
+            backoff?: "fixed" | "exponential" | undefined;
+            initial_delay?: number | undefined;
+        }>>;
+        debug: z.ZodOptional<z.ZodBoolean>;
+        /** Strict mode: fail on unresolved templates instead of warning */
+        strict: z.ZodOptional<z.ZodBoolean>;
+        /** Maximum iterations for loop detection */
+        maxIterations: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /** Enable loop mode to allow re-entry of completed nodes (for workflow cycles) */
+        loopEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        maxIterations: number;
+        loopEnabled: boolean;
+        strict?: boolean | undefined;
+        timeout?: number | null | undefined;
+        retry?: {
+            max_attempts: number;
+            backoff: "fixed" | "exponential";
+            initial_delay: number;
+        } | undefined;
+        parallel_limit?: number | null | undefined;
+        debug?: boolean | undefined;
+    }, {
+        strict?: boolean | undefined;
+        timeout?: number | null | undefined;
+        maxIterations?: number | undefined;
+        retry?: {
+            max_attempts?: number | undefined;
+            backoff?: "fixed" | "exponential" | undefined;
+            initial_delay?: number | undefined;
+        } | undefined;
+        parallel_limit?: number | null | undefined;
+        debug?: boolean | undefined;
+        loopEnabled?: boolean | undefined;
+    }>>>;
+    nodes: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        config: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        depends_on: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        condition: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            max_attempts: z.ZodDefault<z.ZodNumber>;
+            backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+            initial_delay: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            max_attempts: number;
+            backoff: "fixed" | "exponential";
+            initial_delay: number;
+        }, {
+            max_attempts?: number | undefined;
+            backoff?: "fixed" | "exponential" | undefined;
+            initial_delay?: number | undefined;
+        }>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        config: Record<string, unknown>;
+        id: string;
+        name?: string | undefined;
+        timeout?: number | undefined;
+        depends_on?: string[] | undefined;
+        condition?: string | undefined;
+        retry?: {
+            max_attempts: number;
+            backoff: "fixed" | "exponential";
+            initial_delay: number;
+        } | undefined;
+    }, {
+        type: string;
+        id: string;
+        name?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        timeout?: number | undefined;
+        depends_on?: string[] | undefined;
+        condition?: string | undefined;
+        retry?: {
+            max_attempts?: number | undefined;
+            backoff?: "fixed" | "exponential" | undefined;
+            initial_delay?: number | undefined;
+        } | undefined;
+    }>, {
+        type: string;
+        config: Record<string, unknown>;
+        id: string;
+        name?: string | undefined;
+        timeout?: number | undefined;
+        depends_on?: string[] | undefined;
+        condition?: string | undefined;
+        retry?: {
+            max_attempts: number;
+            backoff: "fixed" | "exponential";
+            initial_delay: number;
+        } | undefined;
+    }, {
+        type: string;
+        id: string;
+        name?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        timeout?: number | undefined;
+        depends_on?: string[] | undefined;
+        condition?: string | undefined;
+        retry?: {
+            max_attempts?: number | undefined;
+            backoff?: "fixed" | "exponential" | undefined;
+            initial_delay?: number | undefined;
+        } | undefined;
+    }>, {
+        type: string;
+        config: Record<string, unknown>;
+        id: string;
+        name?: string | undefined;
+        timeout?: number | undefined;
+        depends_on?: string[] | undefined;
+        condition?: string | undefined;
+        retry?: {
+            max_attempts: number;
+            backoff: "fixed" | "exponential";
+            initial_delay: number;
+        } | undefined;
+    }, {
+        type: string;
+        id: string;
+        name?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        timeout?: number | undefined;
+        depends_on?: string[] | undefined;
+        condition?: string | undefined;
+        retry?: {
+            max_attempts?: number | undefined;
+            backoff?: "fixed" | "exponential" | undefined;
+            initial_delay?: number | undefined;
+        } | undefined;
+    }>, "many">;
+    entry: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    outputs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        source: z.ZodString;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        name: string;
+        source: string;
+    }, {
+        path: string;
+        name: string;
+        source: string;
+    }>, "many">>>;
+    inputs: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
+        description: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        required: boolean;
+        description?: string | undefined;
+        default?: unknown;
+    }, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        description?: string | undefined;
+        required?: boolean | undefined;
+        default?: unknown;
+    }>>>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        author: z.ZodOptional<z.ZodString>;
+        taskId: z.ZodOptional<z.ZodNumber>;
+        tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        tags: string[];
+        author?: string | undefined;
+        taskId?: number | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    }, {
+        tags?: string[] | undefined;
+        author?: string | undefined;
+        taskId?: number | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    }>>>;
+    edges: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        when: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+        when?: string | undefined;
+    }, {
+        from: string;
+        to: string;
+        when?: string | undefined;
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    config: {
+        maxIterations: number;
+        loopEnabled: boolean;
+        strict?: boolean | undefined;
+        timeout?: number | null | undefined;
+        retry?: {
+            max_attempts: number;
+            backoff: "fixed" | "exponential";
+            initial_delay: number;
+        } | undefined;
+        parallel_limit?: number | null | undefined;
+        debug?: boolean | undefined;
+    };
+    version: string;
+    nodes: {
+        type: string;
+        config: Record<string, unknown>;
+        id: string;
+        name?: string | undefined;
+        timeout?: number | undefined;
+        depends_on?: string[] | undefined;
+        condition?: string | undefined;
+        retry?: {
+            max_attempts: number;
+            backoff: "fixed" | "exponential";
+            initial_delay: number;
+        } | undefined;
+    }[];
+    entry: string | string[];
+    outputs: {
+        path: string;
+        name: string;
+        source: string;
+    }[];
+    inputs: Record<string, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        required: boolean;
+        description?: string | undefined;
+        default?: unknown;
+    }>;
+    metadata: {
+        tags: string[];
+        author?: string | undefined;
+        taskId?: number | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    };
+    edges: {
+        from: string;
+        to: string;
+        when?: string | undefined;
+    }[];
+    description?: string | undefined;
+}, {
+    name: string;
+    nodes: {
+        type: string;
+        id: string;
+        name?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        timeout?: number | undefined;
+        depends_on?: string[] | undefined;
+        condition?: string | undefined;
+        retry?: {
+            max_attempts?: number | undefined;
+            backoff?: "fixed" | "exponential" | undefined;
+            initial_delay?: number | undefined;
+        } | undefined;
+    }[];
+    description?: string | undefined;
+    config?: {
+        strict?: boolean | undefined;
+        timeout?: number | null | undefined;
+        maxIterations?: number | undefined;
+        retry?: {
+            max_attempts?: number | undefined;
+            backoff?: "fixed" | "exponential" | undefined;
+            initial_delay?: number | undefined;
+        } | undefined;
+        parallel_limit?: number | null | undefined;
+        debug?: boolean | undefined;
+        loopEnabled?: boolean | undefined;
+    } | undefined;
+    version?: string | undefined;
+    entry?: string | string[] | undefined;
+    outputs?: {
+        path: string;
+        name: string;
+        source: string;
+    }[] | undefined;
+    inputs?: Record<string, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        description?: string | undefined;
+        required?: boolean | undefined;
+        default?: unknown;
+    }> | undefined;
+    metadata?: {
+        tags?: string[] | undefined;
+        author?: string | undefined;
+        taskId?: number | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    } | undefined;
+    edges?: {
+        from: string;
+        to: string;
+        when?: string | undefined;
+    }[] | undefined;
+}>;
+export type WorkflowDefinition = z.infer<typeof WorkflowDefinitionSchema>;
+export interface WorkflowDefinitionExtended extends WorkflowDefinition {
+    computedEntry: string[];
+    nodeMap: Map<string, NodeDefinition>;
+    topologicalOrder: string[];
+}
+export interface Workflow {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    definition: WorkflowDefinition;
+    config: WorkflowConfig;
+    metadata: WorkflowMetadata;
+    tags: string[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ParsedWorkflow {
+    format: 'yaml' | 'json';
+    definition: WorkflowDefinition;
+}
+/**
+ * 解析 Workflow 文件
+ * @param content 文件内容
+ * @param filename 文件名，用于自动检测格式
+ */
+export declare function parseWorkflowFile(content: string, filename: string): Promise<ParsedWorkflow>;
+/**
+ * Synchronous version of parseWorkflowFile
+ * Uses JSON parsing only for auto-detection
+ */
+export declare function parseWorkflowFileSync(content: string, filename: string): ParsedWorkflow;

package/dist/env/workflow/types_compat.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Workflow types compatibility layer
+ * Re-exports all types from types/index.ts for backward compatibility
+ */
+export type { Workflow, WorkflowDefinition, WorkflowDefinitionExtended, WorkflowConfig, WorkflowMetadata, RetryConfig, Node, NodeDefinition, NodeDefinitionSchema, DependsOn, DependsOnSchema, OutputDefinition, TemplateResolver, ParsedWorkflow, } from './types';
+export { WorkflowDefinitionSchema, RetryConfigSchema, WorkflowConfigSchema, WorkflowMetadataSchema, parseWorkflowFile, parseWorkflowFileSync, } from './types/workflow';
+export { OutputDefinitionSchema } from './types/workflow';
+export type { RunStatus, RunOptions, RunResult, WorkflowRun, NodeRun, NodeStatus, NodeExecutionContext, NodeExecutionResult, } from './types';
+export { createNodeExecutionContext } from './types';
+export type { AgentSessionInfo } from './types';

package/dist/env/workflow/utils/agent-session-metadata.d.ts

@@ -0,0 +1,35 @@
+import type { AgentSessionRef } from '../types/workflow-message';
+/**
+ * Update a single agent session's status by nodeId.
+ * Returns a new array; does not mutate input. Returns empty array if input is undefined/empty.
+ */
+export declare function updateAgentSessionStatus(agentSessions: AgentSessionRef[] | undefined, nodeId: string, status: AgentSessionRef['status']): AgentSessionRef[];
+/**
+ * Mark a single node's agent session as 'completed'.
+ * Convenience wrapper over updateAgentSessionStatus for symmetry with Failed/Stopped.
+ */
+export declare function markAgentSessionCompleted(agentSessions: AgentSessionRef[] | undefined, nodeId: string): AgentSessionRef[];
+/**
+ * Mark a single node's agent session as 'failed'.
+ */
+export declare function markAgentSessionFailed(agentSessions: AgentSessionRef[] | undefined, nodeId: string): AgentSessionRef[];
+/**
+ * Mark a single node's agent session as 'stopped'.
+ */
+export declare function markAgentSessionStopped(agentSessions: AgentSessionRef[] | undefined, nodeId: string): AgentSessionRef[];
+/**
+ * Mark ALL non-terminal (active/paused) agent sessions as 'completed'.
+ * Already-terminal sessions (completed/failed/stopped) are preserved.
+ * Used by WorkflowEngine.completeWorkflow().
+ */
+export declare function markAllAgentSessionsCompleted(agentSessions: AgentSessionRef[] | undefined): AgentSessionRef[];
+/**
+ * Mark ALL non-terminal (active/paused) agent sessions as 'stopped'.
+ * Used by WorkflowEngine.stop() — distinguishes a graceful stop from a failure.
+ */
+export declare function markAllAgentSessionsStopped(agentSessions: AgentSessionRef[] | undefined): AgentSessionRef[];
+/**
+ * Mark ALL non-terminal (active/paused) agent sessions as 'failed'.
+ * Used by WorkflowEngine.failWorkflow().
+ */
+export declare function markAllAgentSessionsFailed(agentSessions: AgentSessionRef[] | undefined): AgentSessionRef[];