@ai-setting/roy-agent-cli 1.3.15 → 1.3.16

package/dist/core/src/env/workflow/utils/validation-rules.js

@@ -0,0 +1,44 @@
+/**
+ * Validation Rules for Workflow Recovery
+ *
+ * Defines types for validation errors, results, and recovery plans.
+ */
+// ==================== Validation Error Types ====================
+/**
+ * Validation error types for workflow recovery
+ */
+export var ValidationErrorType;
+(function (ValidationErrorType) {
+    /** Variable referenced by node input is missing */
+    ValidationErrorType["MISSING_VARIABLE"] = "MISSING_VARIABLE";
+    /** Parallel branch is incomplete */
+    ValidationErrorType["INCOMPLETE_PARALLEL"] = "INCOMPLETE_PARALLEL";
+    /** Condition branch cannot be determined */
+    ValidationErrorType["AMBIGUOUS_BRANCH"] = "AMBIGUOUS_BRANCH";
+    /** Loop state is lost */
+    ValidationErrorType["LOOP_STATE_LOST"] = "LOOP_STATE_LOST";
+    /** Nested workflow state is invalid */
+    ValidationErrorType["NESTED_WORKFLOW_INVALID"] = "NESTED_WORKFLOW_INVALID";
+    /** Node execution state is inconsistent */
+    ValidationErrorType["NODE_STATE_INCONSISTENT"] = "NODE_STATE_INCONSISTENT";
+    /** Critical dependency is missing */
+    ValidationErrorType["MISSING_DEPENDENCY"] = "MISSING_DEPENDENCY";
+})(ValidationErrorType || (ValidationErrorType = {}));
+// ==================== Suggested Actions ====================
+/**
+ * Suggested actions for recovery
+ */
+export var SuggestedAction;
+(function (SuggestedAction) {
+    /** Re-run the workflow from the beginning */
+    SuggestedAction["RE_RUN"] = "RE_RUN";
+    /** Confirm with user before proceeding */
+    SuggestedAction["CONFIRM"] = "CONFIRM";
+    /** Skip the problematic node */
+    SuggestedAction["SKIP"] = "SKIP";
+    /** Provide the missing value */
+    SuggestedAction["PROVIDE_VALUE"] = "PROVIDE_VALUE";
+    /** Ignore the warning and proceed */
+    SuggestedAction["IGNORE"] = "IGNORE";
+})(SuggestedAction || (SuggestedAction = {}));
+//# sourceMappingURL=validation-rules.js.map

package/dist/core/src/env/workflow/workflow-component.d.ts

@@ -0,0 +1,135 @@
+/**
+ * @fileoverview WorkflowComponent
+ *
+ * Workflow 组件入口，提供工作流管理和执行能力。
+ *
+ * 功能：
+ * - 工作流 CRUD 操作（通过 WorkflowService）
+ * - 工作流执行（通过 WorkflowEngine）
+ * - Decorator 节点注册
+ *
+ * Note: After session-based refactoring, workflow runs are managed via SessionComponent.
+ * The Session.metadata stores workflow run state (status, input, agentSessions).
+ * Node execution messages are stored in Session.messages with workflow.node.* roles.
+ */
+import 'reflect-metadata';
+import { BaseComponent, type ComponentConfig } from '../component';
+import type { WorkflowDefinition, RunOptions, RunResult } from './types';
+import { WorkflowService } from './service';
+import type { ToolComponent } from '../tool/tool-component';
+import type { LLMComponent } from '../llm';
+import type { LogTraceComponent } from '../log-trace/log-trace-component';
+import type { Environment } from '../interface';
+import type { AgentRunner } from './nodes/agent-node';
+export { EventBus, DAGManager, Scheduler, Executor, WorkflowEngine, } from './engine';
+export type { NodeExecutionContext, RunOptions, RunResult, RunStatus, NodeStatus, DAGAnalysis, SchedulerOptions, SchedulerState, ExecutorOptions, WorkflowEngineConfig, NodeContext, NodeFactory, } from './engine';
+export type { NodeDefinition, RetryConfig, TemplateResolver, } from './types';
+export type { WorkflowDefinition, } from './types/workflow';
+export { WorkflowService, WorkflowServiceRegistry, } from './service';
+export type { WorkflowOptions, NodeAsOptions, EdgeOptions, WorkflowMetadata, NodeMetadata, EdgeMetadata, ValidationResult, ConvertedWorkflowDefinition, ConvertedNodeDefinition, } from './types/decorators-types';
+export { Workflow, NodeAs, Edge, WorkflowEdges, getWorkflowMetadata, getNodeMetadatas, getEdgeMetadatas, DecoratorNode, } from './decorators';
+export type { DecoratorNodeConfig, } from './decorators/decorator-node';
+export { WorkflowConverter, } from './extractor/workflow-converter';
+export { createWorkflowFromClass } from './utils/create-workflow';
+export { registerDecoratorNodeType } from './utils/node-registry-helper';
+export interface WorkflowComponentConfig extends ComponentConfig {
+    /** 自动注册 decorator 节点类型 */
+    autoRegisterDecorators?: boolean;
+}
+export interface WorkflowComponentOptions {
+    /** Tool 组件（可选） */
+    toolComponent?: ToolComponent;
+    /** LLM 组件（可选） */
+    llmComponent?: LLMComponent;
+    /** Log Trace 组件（可选） */
+    logTraceComponent?: LogTraceComponent;
+    /** Environment（包含 AgentComponent 等） */
+    env?: Environment;
+    /** Skill registry（可选） */
+    skillRegistry?: {
+        getSkill(name: string): any;
+        hasSkill(name: string): boolean;
+    };
+    /** Agent runner（可选，用于 agent 节点） */
+    agentRunner?: AgentRunner;
+}
+export declare class WorkflowComponent extends BaseComponent {
+    readonly name = "workflow";
+    readonly version = "1.0.0";
+    workflowService: WorkflowService | null;
+    sessionComponent: any;
+    private nodeRegistry;
+    private decoratorsRegistered;
+    /**
+     * 获取 WorkflowService 实例
+     */
+    getService(): WorkflowService | null;
+    private toolComponent?;
+    private llmComponent?;
+    private logTraceComponent?;
+    private _workflowEnv?;
+    private skillRegistry?;
+    private agentRunner?;
+    /**
+     * 初始化 WorkflowComponent
+     */
+    init(options: any): Promise<void>;
+    /**
+     * 注册 decorator 节点类型
+     */
+    private registerDecorators;
+    /**
+     * 创建 WorkflowService（需要外部传入依赖）
+     *
+     * Note: After session-based refactoring, runRepository is no longer needed.
+     * Workflow runs are managed via SessionComponent.
+     */
+    createService(options: {
+        workflowRepository: any;
+        toolComponent?: ToolComponent;
+        llmComponent?: LLMComponent;
+        env?: Environment;
+        skillRegistry?: {
+            getSkill(name: string): any;
+            hasSkill(name: string): boolean;
+        };
+        sessionComponent?: any;
+    }): WorkflowService;
+    /**
+     * 运行工作流定义
+     */
+    runWorkflow(definition: WorkflowDefinition, input?: Record<string, any>, options?: RunOptions): Promise<RunResult>;
+    /**
+     * 停止组件并清理资源
+     *
+     * 遵循 Component 接口契约，通过 onStop 钩子实现
+     */
+    protected onStop(): Promise<void>;
+    /**
+     * 启动组件 - 初始化持久化的 SQLite WorkflowService
+     */
+    start(): Promise<void>;
+    /**
+     * 注册 ask_user 工具到 ToolComponent
+     *
+     * 这样 Workflow 中的 AgentNode 执行时，Agent 能够找到并调用 ask_user 工具。
+     * ask_user 工具会抛出 AskUserError，触发 workflow pause。
+     */
+    private registerAskUserTool;
+    /**
+     * 初始化 SQLite 持久化的 WorkflowService
+     *
+     * Note: After session-based refactoring, runRepository is no longer needed.
+     * Workflow runs are managed via SessionComponent.
+     */
+    private initSqliteService;
+    /**
+     * 创建内存中的 WorkflowService（用于快速运行或降级）
+     */
+    private createInMemoryService;
+    /**
+     * 停止组件
+     */
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=workflow-component.d.ts.map

package/dist/core/src/env/workflow/workflow-component.js

@@ -0,0 +1,376 @@
+/**
+ * @fileoverview WorkflowComponent
+ *
+ * Workflow 组件入口，提供工作流管理和执行能力。
+ *
+ * 功能：
+ * - 工作流 CRUD 操作（通过 WorkflowService）
+ * - 工作流执行（通过 WorkflowEngine）
+ * - Decorator 节点注册
+ *
+ * Note: After session-based refactoring, workflow runs are managed via SessionComponent.
+ * The Session.metadata stores workflow run state (status, input, agentSessions).
+ * Node execution messages are stored in Session.messages with workflow.node.* roles.
+ */
+import 'reflect-metadata';
+import { BaseComponent } from "../component.js";
+import { WorkflowService } from "./service/index.js";
+import { WorkflowEngine } from "./engine/index.js";
+// Logger - 使用统一的 Logger 系统，支持 quiet 模式
+import { createLogger } from "../log-trace/logger.js";
+const componentLogger = createLogger('workflow');
+// AskUserTool - 供 Workflow 中的 AgentNode 使用
+import { askUserTool } from "./tools/ask-user-tool.js";
+/**
+ * SkillRegistry Adapter
+ *
+ * 将 SkillComponent 适配为 SkillRegistry 接口，供 SkillNode 使用。
+ *
+ * SkillComponent.getSkill() 返回 SkillEntry 对象（包含 content 等属性），
+ * 而 SkillRegistry 接口期望的 Skill.invoke() 方法需要 skill 对象支持。
+ * 这个适配器将两者连接起来。
+ */
+class SkillRegistryAdapter {
+    skillComponent;
+    constructor(skillComponent) {
+        this.skillComponent = skillComponent;
+    }
+    getSkill(name) {
+        const entry = this.skillComponent.getSkill(name);
+        if (!entry)
+            return undefined;
+        // 创建一个适配的 Skill 对象
+        return {
+            name: entry.name,
+            invoke: async (input, context) => {
+                // SkillNode 调用 skill.invoke(input, context)
+                // 这里我们直接返回 skill 的 content，供 SkillNode 使用
+                // 注意：SkillNode 期望返回的是 skill 内容（字符串），而不是执行结果
+                return entry.content;
+            },
+        };
+    }
+    hasSkill(name) {
+        return this.skillComponent.hasSkill(name);
+    }
+}
+// Re-export engine classes and types
+export { EventBus, DAGManager, Scheduler, Executor, WorkflowEngine, } from "./engine/index.js";
+// Re-export service
+export { WorkflowService, WorkflowServiceRegistry, } from "./service/index.js";
+// Re-export decorators
+export { Workflow, NodeAs, Edge, WorkflowEdges, getWorkflowMetadata, getNodeMetadatas, getEdgeMetadatas, DecoratorNode, } from "./decorators/index.js";
+// Re-export converter
+export { WorkflowConverter, } from "./extractor/workflow-converter.js";
+// Re-export utilities
+export { createWorkflowFromClass } from "./utils/create-workflow.js";
+export { registerDecoratorNodeType } from "./utils/node-registry-helper.js";
+// ==================== WorkflowComponent ====================
+export class WorkflowComponent extends BaseComponent {
+    name = "workflow";
+    version = "1.0.0";
+    workflowService = null;
+    sessionComponent = null; // Expose for CLI resume command
+    nodeRegistry = null;
+    decoratorsRegistered = false;
+    /**
+     * 获取 WorkflowService 实例
+     */
+    getService() {
+        return this.workflowService;
+    }
+    toolComponent;
+    llmComponent;
+    logTraceComponent;
+    _workflowEnv;
+    skillRegistry;
+    agentRunner;
+    /**
+     * 初始化 WorkflowComponent
+     */
+    async init(options) {
+        const opts = options;
+        this._status = 'initializing';
+        componentLogger.info('Initializing WorkflowComponent...');
+        // 保存组件引用供后续使用
+        this.toolComponent = opts.toolComponent;
+        this.llmComponent = opts.llmComponent;
+        this.logTraceComponent = opts.logTraceComponent;
+        this._workflowEnv = opts.env;
+        this.skillRegistry = opts.skillRegistry;
+        this.agentRunner = opts.agentRunner;
+        try {
+            // Register decorator node type
+            if (opts.autoRegisterDecorators !== false) {
+                await this.registerDecorators();
+            }
+            // 注意：ask_user 工具不在这里注册
+            // 因为 toolComponent 在 init() 时还未初始化
+            // 将在 initSqliteService() 中注册
+            this._status = 'ready';
+            componentLogger.info('WorkflowComponent initialized successfully');
+        }
+        catch (error) {
+            this._status = 'error';
+            componentLogger.error('Failed to initialize WorkflowComponent:', error);
+            throw error;
+        }
+    }
+    /**
+     * 注册 decorator 节点类型
+     */
+    async registerDecorators() {
+        if (this.decoratorsRegistered)
+            return;
+        try {
+            // 动态导入避免循环依赖
+            const { NodeRegistry } = await import('./engine');
+            const { registerDecoratorNodeType } = await import('./utils/node-registry-helper');
+            this.nodeRegistry = new NodeRegistry();
+            registerDecoratorNodeType(this.nodeRegistry);
+            this.decoratorsRegistered = true;
+            componentLogger.info('Decorator node type registered');
+        }
+        catch (error) {
+            componentLogger.error('Failed to register decorator node type:', error);
+            throw error;
+        }
+    }
+    /**
+     * 创建 WorkflowService（需要外部传入依赖）
+     *
+     * Note: After session-based refactoring, runRepository is no longer needed.
+     * Workflow runs are managed via SessionComponent.
+     */
+    createService(options) {
+        // 创建 SkillRegistry adapter（将 SkillComponent 适配为 SkillRegistry）
+        const skillRegistryAdapter = options.skillRegistry
+            ? new SkillRegistryAdapter(options.skillRegistry)
+            : undefined;
+        // 保存 sessionComponent 引用供 engineFactory 使用
+        const sessionComponentForEngine = options.sessionComponent;
+        // 创建引擎工厂
+        // 传入 workflowRepository 以便在 resume 时能从数据库加载 workflow definition
+        const engineFactory = (workflow, opts) => {
+            const { NodeRegistry, WorkflowEngine } = require('./engine');
+            const registry = new NodeRegistry({
+                toolRegistry: options.toolComponent,
+                agentComponent: options.env?.getComponent('agent'),
+                skillRegistry: skillRegistryAdapter,
+                sessionComponent: sessionComponentForEngine, // Pass sessionComponent for agent session management
+            });
+            // 注册 decorator 节点
+            const { registerDecoratorNodeType } = require('./utils/node-registry-helper');
+            registerDecoratorNodeType(registry);
+            // 传入 sessionComponent 和 workflowRepository 以便在完成时持久化状态和实现 resume
+            // sessionComponent 用于 session-based resume（CLI 无状态场景）
+            // workflowRepository 用于从数据库加载 workflow definition（resume 时需要）
+            return new WorkflowEngine(registry, sessionComponentForEngine, options.workflowRepository);
+        };
+        this.workflowService = new WorkflowService(options.workflowRepository, engineFactory, options.sessionComponent // For session-based resume
+        );
+        return this.workflowService;
+    }
+    /**
+     * 运行工作流定义
+     */
+    async runWorkflow(definition, input, options) {
+        const { NodeRegistry } = await import('./engine');
+        const { registerDecoratorNodeType } = await import('./utils/node-registry-helper');
+        // 获取组件引用（优先使用 env 中的最新引用，因为 env 中注册了所有组件）
+        const toolComponent = this.toolComponent || this._workflowEnv?.getComponent('tool');
+        const skillComponent = this._workflowEnv?.getComponent('skill');
+        // 获取 AgentComponent 并创建 AgentRunner adapter
+        let agentRunner = this.agentRunner;
+        if (!agentRunner && this._workflowEnv) {
+            const agentComponent = this._workflowEnv.getComponent('agent');
+            if (agentComponent) {
+                // 动态导入 AgentComponentAdapter
+                const { AgentComponentAdapter } = await import('./nodes/agent-component-adapter');
+                agentRunner = new AgentComponentAdapter(agentComponent);
+            }
+        }
+        // 创建 NodeRegistry 并注册所有内置节点类型
+        const registry = new NodeRegistry({
+            toolRegistry: toolComponent,
+            skillRegistry: skillComponent,
+            agentRunner,
+        });
+        // 注册 decorator 节点
+        registerDecoratorNodeType(registry);
+        // 创建引擎
+        const engine = new WorkflowEngine(registry);
+        // 直接运行
+        return engine.runWorkflow(definition, { ...options, input });
+    }
+    /**
+     * 停止组件并清理资源
+     *
+     * 遵循 Component 接口契约，通过 onStop 钩子实现
+     */
+    async onStop() {
+        componentLogger.info('[WorkflowComponent] Stopping and cleaning up resources...');
+        // 清理 NodeRegistry（如果已创建）
+        if (this.nodeRegistry) {
+            // NodeRegistry 目前没有清理方法，保留引用供 GC
+            this.nodeRegistry = null;
+        }
+        // 清理 WorkflowService 和数据库连接
+        if (this.workflowService) {
+            this.workflowService = null;
+            // 延迟导入并关闭数据库连接
+            try {
+                const { closeDatabase } = await import('./storage/sqlite');
+                closeDatabase();
+                componentLogger.info('[WorkflowComponent] SQLite database closed');
+            }
+            catch (error) {
+                componentLogger.warn('[WorkflowComponent] Failed to close SQLite database:', error);
+            }
+        }
+        this._status = "stopped";
+        componentLogger.info('[WorkflowComponent] Cleanup completed');
+    }
+    /**
+     * 启动组件 - 初始化持久化的 SQLite WorkflowService
+     */
+    async start() {
+        await super.start();
+        // 初始化持久化的 WorkflowService
+        await this.initSqliteService();
+        // 注册 ask_user 工具到 ToolComponent
+        // 这样 Workflow 中的 AgentNode 执行时，Agent 能够找到并调用 ask_user 工具
+        await this.registerAskUserTool();
+    }
+    /**
+     * 注册 ask_user 工具到 ToolComponent
+     *
+     * 这样 Workflow 中的 AgentNode 执行时，Agent 能够找到并调用 ask_user 工具。
+     * ask_user 工具会抛出 AskUserError，触发 workflow pause。
+     */
+    async registerAskUserTool() {
+        try {
+            const toolComponent = this.toolComponent || this._workflowEnv?.getComponent('tool');
+            if (!toolComponent) {
+                componentLogger.warn('ToolComponent not available, cannot register ask_user tool');
+                return;
+            }
+            // 注册 ask_user 工具（使用 as any 绕过类型检查，因为 parameters 使用 Zod schema）
+            if (typeof toolComponent.register === 'function') {
+                toolComponent.register(askUserTool);
+                componentLogger.info('ask_user tool registered to ToolComponent');
+            }
+            else if (typeof toolComponent.registerMany === 'function') {
+                toolComponent.registerMany([askUserTool]);
+                componentLogger.info('ask_user tool registered to ToolComponent');
+            }
+            else {
+                componentLogger.warn('ToolComponent does not support tool registration');
+            }
+        }
+        catch (error) {
+            componentLogger.warn('Failed to register ask_user tool:', error);
+            // 不抛出错误，只是无法使用 ask_user 功能
+        }
+    }
+    /**
+     * 初始化 SQLite 持久化的 WorkflowService
+     *
+     * Note: After session-based refactoring, runRepository is no longer needed.
+     * Workflow runs are managed via SessionComponent.
+     */
+    async initSqliteService() {
+        try {
+            // 动态导入 SQLite storage 和 repositories
+            const { getDatabase, initializeTables } = await import('./storage/sqlite');
+            const { WorkflowRepository } = await import('./storage/workflow-repo');
+            // 注意：ask_user 工具不在这里注册
+            // 只在 workflow run 运行时，通过 AgentNode 的 allowedTools 机制注册
+            // 这样确保 ask_user 只在 workflow 上下文中可用
+            // 初始化数据库和表
+            const db = getDatabase();
+            initializeTables();
+            // 创建持久化的 repositories（只有 workflowRepository，runRepository 已移除）
+            const workflowRepository = new WorkflowRepository(db);
+            // 获取组件引用（优先使用 env 中的最新引用）
+            const toolComponent = this.toolComponent || this._workflowEnv?.getComponent('tool');
+            const llmComponent = this.llmComponent || this._workflowEnv?.getComponent('llm');
+            const agentComponent = this._workflowEnv?.getComponent('agent');
+            const skillComponent = this.skillRegistry || this._workflowEnv?.getComponent('skill');
+            const sessionComponent = this._workflowEnv?.getComponent('session');
+            componentLogger.info(`initSqliteService - toolComponent: ${!!toolComponent}, llmComponent: ${!!llmComponent}, skillRegistry: ${!!skillComponent}, sessionComponent: ${!!sessionComponent}`);
+            // 创建并设置 WorkflowService（不传 runRepository）
+            this.createService({
+                workflowRepository,
+                toolComponent,
+                llmComponent,
+                env: this._workflowEnv,
+                skillRegistry: skillComponent,
+                sessionComponent, // For session-based resume
+            });
+            // 保存 sessionComponent 引用供 CLI resume 使用
+            this.sessionComponent = sessionComponent;
+            // 动态注册 ask_user 工具到 ToolComponent
+            // 这样 workflow agent 可以使用 ask_user 工具触发工作流暂停
+            await this.registerAskUserTool();
+            componentLogger.info('SQLite WorkflowService initialized successfully');
+        }
+        catch (error) {
+            componentLogger.error('Failed to initialize SQLite WorkflowService:', error);
+            // 不抛出错误，降级到内存模式
+            await this.createInMemoryService();
+        }
+    }
+    /**
+     * 创建内存中的 WorkflowService（用于快速运行或降级）
+     */
+    createInMemoryService() {
+        // In-memory workflow repository
+        const workflows = new Map();
+        const workflowRepository = {
+            create: (wf) => {
+                const id = wf.id || `wf_${Date.now()}`;
+                const record = { ...wf, id, createdAt: new Date(), updatedAt: new Date() };
+                workflows.set(id, record);
+                return record;
+            },
+            getById: (id) => workflows.get(id) || null,
+            getByName: (name) => {
+                for (const wf of workflows.values()) {
+                    if (wf.name === name)
+                        return wf;
+                }
+                return null;
+            },
+            list: () => Array.from(workflows.values()),
+            update: (id, updates) => {
+                const wf = workflows.get(id);
+                if (!wf)
+                    return null;
+                const updated = { ...wf, ...updates, updatedAt: new Date() };
+                workflows.set(id, updated);
+                return updated;
+            },
+            delete: (id) => workflows.delete(id),
+        };
+        // 获取 sessionComponent
+        const sessionComponent = this._workflowEnv?.getComponent('session');
+        return this.createService({
+            workflowRepository,
+            sessionComponent,
+        });
+    }
+    /**
+     * 停止组件
+     */
+    async stop() {
+        componentLogger.info('Stopping WorkflowComponent...');
+        this._status = 'stopping';
+        // 清理资源
+        this.workflowService = null;
+        this.nodeRegistry = null;
+        this._status = 'stopped';
+        componentLogger.info('WorkflowComponent stopped');
+    }
+}
+//# sourceMappingURL=workflow-component.js.map

package/dist/core/src/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @roy-agent/core - Core SDK
+ */
+export { generateId, generateDescendingId } from "./utils/id";
+export { type Environment, BaseEnvironment, } from "./env";
+export type { EnvironmentConfig, BaseEnvironmentConfig, EnvEvent, EnvEventMetadata, EnvEventHandler, Action, Context, } from "./env";
+export { type Component, type ComponentConfig, type ComponentSchema, type ComponentPaths, type ComponentStatus, type ComponentConfigChangeEvent, type ComponentWatchCallback, BaseComponent, } from "./env/component";
+export { globalHookManager, type HookPhase, type HookMeta, type BaseHookContext, // 通用 HookContext
+type BaseHook, // 通用 Hook
+type BaseHookFn, // 通用 HookFn
+type HookManagerOptions, type HookAction, type HookResult, type HookActionType, createHook, createPriorityHook, HookManager, } from "./env/hook";
+export { type XDGPaths, type XDGDirType, XDG_PATHS, getXDGPaths, getXDGPath, } from "./env/paths";
+export { type ConfigSource, type ConfigSourceType, type ConfigChangeEvent, ConfigComponent, } from "./config/config-component";
+export { LLMComponent, type LLMComponentOptions, type LLMMessage, type LLMOutput, type UsageInfo, type ToolCall, type LLMConfig, type LLMProvider, type ProviderConfig, type ProviderType, type LLMInvokeRequest, type LLMInvokeResult, type StreamEvent, invoke, invokeNonStream, parseModelString, createInvokeConfig, type InvokeConfig, type InvokeOptions, type LLMToolContext, type ConvertedUsageInfo, LLMConfigSchema, ProviderConfigSchema, ProviderCapabilitiesSchema, ModelLimitsSchema, LLMDefaultConfigSchema, } from "./env/llm";
+export { ToolComponent, type ToolComponentConfig, type Tool, type ToolInfo, type ToolResult, type ToolResultMetadata, type ToolMetadata, type SandboxConfig, type ValidationResult, ToolRegistry, ToolValidator, getAllBuiltInTools, getBuiltInTool, bashTool, globTool, readFileTool, writeFileTool, editFileTool, grepTool, } from "./env/tool";
+export type { ToolContext } from "./env/tool/types";
+export type { ToolHookContext } from "./env/tool/tool-component";
+export { AgentComponent, type AgentComponentConfig, type AgentContext, AgentComponentConfigSchema, type Plugin, type HookPoint, type HookContext, } from "./env/agent";
+export { LogTraceComponent, type LogTraceConfig, type LogTraceComponentOptions, LogTraceConfigSchema, Traced, TracedAs, TracedLightweight, wrapFunction, type TracedOptions, createLogger, getLogDir, setLogDirOverride, setQuietMode, isQuietMode, getLogLevels, getLogLevel, setLoggerConfigComponent, SQLiteSpanStorage, type SpanContext, type SpanAttributes, type Span, type TraceInfo, type SpanStorage, type LogLevel, type LoggerConfig, type ILogger, SpanKind, SpanStatus, OTelTracerProvider, getTracerProvider, resetTracerProvider, type OTelTracer, type OTelSpan, type SpanOptions, propagation, } from "./env/log-trace";
+export { DebugComponent, TraceFormatter, TreeFormatter, ReplFormatter, type TraceDataSource, type TraceParserOptions, } from "./env/debug";
+export type { TraceEntry, TraceTreeNode, ParserOptions, LogDiscoveryOptions, TraceIdInfo, TraceSummary, TraceAction, LogLevel as DebugLogLevel, FormatOptions, } from "./env/debug";
+export { PromptComponent, type PromptComponentOptions, } from "./env/prompt/prompt-component";
+export type { PromptConfig, PromptPath, PromptEntry, PromptSource, PromptHook, RenderHookContext, PromptHookMap, } from "./env/prompt/types";
+export { SessionComponent, MemorySessionStore, } from "./env/session";
+export type { Session, SessionMessage, SessionConfig, CreateSessionOptions, UpdateSessionOptions, ListSessionsOptions, AddMessageOptions, SessionCheckpoint, CompactOptions, CompactResult, CompactPreview, GetContextOptions, GetContextResult, CheckpointType, SearchMessagesOptions, MessageMatch, SearchResult, } from "./env/session/types";
+export { createMemoryAgentTools, } from "./env/memory/tools/memory-agent-tools";
+export type { SearchSessionsParams, GetSessionParams, WriteMemoryParams, } from "./env/memory/tools/memory-agent-tools";
+export { getBuiltInPrompt, getBuiltInPromptNames, } from "./env/prompt/prompts-index";
+export { TaskComponent, } from "./env/task";
+export type { Task, TaskOperation, TaskStatus, TaskPriority, ActionType, CreateTaskOptions, UpdateTaskOptions, ListTasksOptions, CreateOperationOptions, ListOperationsOptions, TaskConfig, } from "./env/task/types";
+export { TaskPlugin, TaskTagPlugin, type TaskPluginConfig, type TaskPluginHook, } from "./env/task/plugins";
+export { TaskHookPoints, type TaskHookPoint, } from "./env/task/hooks";
+export { SkillComponent, } from "./env/skill";
+export type { SkillEntry, SkillListItem, SkillConfig, SkillPath, SkillSource, SkillToolParams, } from "./env/skill/types";
+export { McpComponent, } from "./env/mcp";
+export type { McpComponentConfig, McpComponentOptions, McpPath, McpServerConfig, McpServerLocalConfig, McpServerRemoteConfig, McpServerStatus, DiscoveredMcpServer, } from "./env/mcp";
+export { MemoryComponent, } from "./env/memory";
+export type { MemoryConfig, MemoryPath, MemorySource, RecordMemoryParams, RecallMemoryParams, RecordMemoryMode, RecordMemoryResult, } from "./env/memory/types";
+export type { MemoryComponentOptions } from "./env/memory";
+export { MemoryPlugin, createMemoryPlugin, } from "./env/memory/plugin";
+export type { MemoryPluginConfig, } from "./env/memory/plugin/types";
+export { CommandsComponent, } from "./env/commands";
+export type { CommandsComponentConfig, CommandIndex, ScanResult, ExecutionResult, DiscoverOptions, AddCommandOptions, RemoveCommandOptions, CommandSource, CommandsComponentOptions, } from "./env/commands";
+export { EventSourceComponent, } from "./env/event-source/event-source-component";
+export { EventSourceAgentHandler, } from "./env/event-source/event-source-agent-handler";
+export type { EventSourceConfig, EventSourceStatus, EventSourceType, EventSourceEvent, EventSourceEventPayload, EventSourceEventHandler, EventSourceStatusChangeEvent, EventSourcePersistenceConfig, EventSourceComponentInterface, EventSourceAgentHandlerConfig, EventMetadata, RecommendedAction, } from "./env/event-source/types";
+export { ErrorCodes, RoyError, AgentError, ToolError, LLMError, ComponentError, ContextError, isRoyError, getErrorCode, } from "./env/errors";
+export type { ErrorCode } from "./env/errors";
+export { WorkflowComponent, type WorkflowComponentConfig, } from "./env/workflow/workflow-component";
+export { Workflow, WorkflowEdges, NodeAs, Edge, } from "./env/workflow/decorators";
+export type { WorkflowOptions, NodeAsOptions, EdgeMetadata, } from "./env/workflow/types/decorators-types";
+export { createWorkflowFromClass, } from "./env/workflow/utils/create-workflow";
+export { registerDecoratorNodeType, } from "./env/workflow/utils/node-registry-helper";
+//# sourceMappingURL=index.d.ts.map