@ai-setting/roy-agent-core 1.5.15-test → 1.5.17-beta.1

package/dist/env/workflow/nodes/index.js

@@ -0,0 +1,19 @@
+import {
+  SkillNode,
+  ToolNode,
+  WorkflowNode,
+  init_skill_node,
+  init_tool_node,
+  init_workflow_node
+} from "../../../shared/@ai-setting/roy-agent-core-jvatggbb.js";
+import"../../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/nodes/index.ts
+init_tool_node();
+init_skill_node();
+init_workflow_node();
+export {
+  WorkflowNode,
+  ToolNode,
+  SkillNode
+};

package/dist/env/workflow/service/index.d.ts

@@ -0,0 +1,227 @@
+import { z as z5 } from "zod";
+import { z as z4 } from "zod";
+declare const RunStatusSchema: unknown;
+type RunStatus = z4.infer<typeof RunStatusSchema>;
+interface RunOptions {
+	input?: Record<string, any>;
+	debug?: boolean;
+	parallelLimit?: number | null;
+	timeout?: number | null;
+	/** @deprecated No-op: workflow always waits for completion */
+	sync?: boolean;
+}
+interface RunResult {
+	runId: string;
+	/** Session ID (workflow_{runId} format) - useful for CLI resume */
+	sessionId?: string;
+	status: RunStatus;
+	output?: Record<string, any>;
+	error?: string;
+	durationMs?: number;
+	/** Pending node ID (when status is 'paused') */
+	pendingNodeId?: string;
+	/** Query from ask_user (when status is 'paused') */
+	query?: string;
+	/** Agent sub-session ID (for resuming agent nodes) */
+	agentSessionId?: string;
+}
+declare const NodeDefinitionSchema: unknown;
+type NodeDefinition = z5.infer<typeof NodeDefinitionSchema>;
+declare const WorkflowConfigSchema: unknown;
+type WorkflowConfig = z5.infer<typeof WorkflowConfigSchema>;
+declare const WorkflowMetadataSchema: unknown;
+type WorkflowMetadata = z5.infer<typeof WorkflowMetadataSchema>;
+declare const WorkflowDefinitionSchema: unknown;
+type WorkflowDefinition = z5.infer<typeof WorkflowDefinitionSchema>;
+interface Workflow {
+	id: string;
+	name: string;
+	version: string;
+	description?: string;
+	definition: WorkflowDefinition;
+	config: WorkflowConfig;
+	metadata: WorkflowMetadata;
+	tags: string[];
+	createdAt: Date;
+	updatedAt: Date;
+}
+interface WorkflowRepository {
+	create(workflow: Omit<Workflow, "id" | "createdAt" | "updatedAt">): Workflow;
+	getById(id: string): Workflow | null;
+	getByName(name: string): Workflow | null;
+	list(options?: ListOptions): Workflow[];
+	update(id: string, updates: Partial<Workflow>): Workflow | null;
+	delete(id: string): boolean;
+}
+interface CreateOptions {
+	tags?: string[];
+	metadata?: WorkflowMetadata;
+	taskId?: number;
+	force?: boolean;
+}
+interface ListOptions {
+	tag?: string;
+	taskId?: number;
+	search?: string;
+	limit?: number;
+	offset?: number;
+}
+interface WorkflowUpdates {
+	definition?: WorkflowDefinition;
+	config?: WorkflowConfig;
+	tags?: string[];
+	metadata?: WorkflowMetadata;
+}
+interface WorkflowEngine {
+	createSession(workflowId: string, options?: {
+		input?: Record<string, any>;
+		workflowName?: string;
+		workflowVersion?: string;
+	}): Promise<string>;
+	run(sessionId: string, options?: RunOptions): Promise<RunResult>;
+	runWorkflow(workflow: Workflow | WorkflowDefinition, options?: RunOptions): Promise<RunResult>;
+	stop(sessionId: string, reason?: string): Promise<void>;
+	addNode(sessionId: string, nodeDefinition: NodeDefinition): Promise<void>;
+	removeNode(sessionId: string, nodeId: string): Promise<void>;
+}
+type WorkflowEngineFactory = (workflow: Workflow, options?: RunOptions) => Pick<WorkflowEngine, "run" | "stop" | "runWorkflow">;
+interface SessionInfo {
+	id: string;
+	title: string;
+	metadata: WorkflowSessionMetadata3;
+	createdAt: Date;
+	updatedAt: Date;
+}
+interface WorkflowSessionMetadata3 {
+	type: "workflow";
+	runId?: string;
+	workflowId?: string;
+	workflowName: string;
+	workflowVersion?: string;
+	status: "running" | "paused" | "completed" | "failed";
+	input?: any;
+	rootNodeId?: string;
+	agentSessions?: AgentSessionRef3[];
+}
+interface AgentSessionRef3 {
+	nodeId: string;
+	sessionId: string;
+	status: "active" | "paused" | "completed";
+}
+declare class WorkflowService {
+	private workflowRepository;
+	private engineFactory;
+	private sessionComponent?;
+	constructor(workflowRepository: WorkflowRepository, engineFactory: WorkflowEngineFactory, sessionComponent?: {
+		create(options: {
+			id?: string;
+			title: string;
+			metadata: any;
+		}): Promise<{
+			id: string;
+		}>;
+		get(id: string): Promise<SessionInfo | null | undefined>;
+		list?(options?: {
+			limit?: number;
+			offset?: number;
+		}): Promise<SessionInfo[]>;
+		update(id: string, updates: {
+			metadata?: any;
+		}): Promise<boolean>;
+		addMessage(sessionId: string, message: any): Promise<string>;
+		getMessages(sessionId: string): Promise<any[]>;
+	} | undefined);
+	/**
+	* Create a new workflow from definition
+	*/
+	createWorkflow(definition: WorkflowDefinition, options?: CreateOptions): Promise<Workflow>;
+	/**
+	* Get workflow by id or name
+	*/
+	getWorkflow(idOrName: string): Workflow | null;
+	/**
+	* Get workflow by id
+	*/
+	getWorkflowById(id: string): Workflow | null;
+	/**
+	* Get workflow by name
+	*/
+	getWorkflowByName(name: string): Workflow | null;
+	/**
+	* List workflows with optional filters
+	*/
+	listWorkflows(options?: ListOptions): Workflow[];
+	/**
+	* Update an existing workflow
+	*/
+	updateWorkflow(idOrName: string, updates: WorkflowUpdates, options?: {
+		tags?: string[];
+	}): Promise<Workflow>;
+	/**
+	* Delete a workflow by name or id
+	*/
+	deleteWorkflow(idOrName: string): Promise<boolean>;
+	/**
+	* Run a workflow by definition or name
+	* 
+	* This creates a Session that represents the workflow run.
+	* The Session ID is used as the run identifier for pause/resume.
+	*/
+	runWorkflow(idOrNameOrDefinition: string | WorkflowDefinition, input?: Record<string, any>, options?: RunOptions): Promise<RunResult>;
+	/**
+	* Run workflow by name (convenience method)
+	*/
+	runWorkflowByName(name: string, input?: Record<string, any>, options?: RunOptions): Promise<RunResult>;
+	/**
+	* Stop a running workflow session
+	*/
+	stopRun(sessionId: string, reason?: string): Promise<void>;
+	/**
+	* Get workflow session by ID
+	*/
+	getSession(sessionId: string): Promise<SessionInfo | null>;
+	/**
+	* List workflow sessions
+	*/
+	listSessions(options?: {
+		limit?: number;
+		offset?: number;
+	}): Promise<SessionInfo[]>;
+	/**
+	* Get messages from a workflow session
+	*/
+	getSessionMessages(sessionId: string): Promise<any[]>;
+}
+/**
+* Singleton registry for WorkflowService
+* Provides centralized access to the workflow service instance
+*/
+declare class WorkflowServiceRegistry {
+	private static instance;
+	private service;
+	private constructor();
+	/**
+	* Get the singleton registry instance
+	*/
+	static getInstance(): WorkflowServiceRegistry;
+	/**
+	* Register a WorkflowService instance
+	*/
+	register(service: WorkflowService): void;
+	/**
+	* Get the registered WorkflowService instance
+	* @throws Error if no service is registered
+	*/
+	get(): WorkflowService;
+	/**
+	* Check if a service is registered
+	*/
+	isRegistered(): boolean;
+	/**
+	* Reset the registry (primarily for testing)
+	*/
+	reset(): void;
+}
+declare function getWorkflowService(): WorkflowService;
+declare function registerWorkflowService(service: WorkflowService): void;
+export { registerWorkflowService, getWorkflowService, WorkflowUpdates, WorkflowSessionMetadata3 as WorkflowSessionMetadata, WorkflowServiceRegistry, WorkflowService, WorkflowRepository, WorkflowEngineFactory, WorkflowEngine, WorkflowDefinition, SessionInfo, ListOptions, CreateOptions, AgentSessionRef3 as AgentSessionRef };

package/dist/env/workflow/service/index.js

@@ -0,0 +1,13 @@
+import {
+  WorkflowService,
+  WorkflowServiceRegistry,
+  getWorkflowService,
+  registerWorkflowService
+} from "../../../shared/@ai-setting/roy-agent-core-4t40mkpv.js";
+import"../../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
+export {
+  registerWorkflowService,
+  getWorkflowService,
+  WorkflowServiceRegistry,
+  WorkflowService
+};

package/dist/env/workflow/storage/index.d.ts

@@ -0,0 +1,165 @@
+import { z as z5 } from "zod";
+declare const WorkflowConfigSchema: unknown;
+type WorkflowConfig = z5.infer<typeof WorkflowConfigSchema>;
+declare const WorkflowMetadataSchema: unknown;
+type WorkflowMetadata = z5.infer<typeof WorkflowMetadataSchema>;
+declare const WorkflowDefinitionSchema: unknown;
+type WorkflowDefinition = z5.infer<typeof WorkflowDefinitionSchema>;
+interface Workflow {
+	id: string;
+	name: string;
+	version: string;
+	description?: string;
+	definition: WorkflowDefinition;
+	config: WorkflowConfig;
+	metadata: WorkflowMetadata;
+	tags: string[];
+	createdAt: Date;
+	updatedAt: Date;
+}
+/**
+* Get the database file path
+* Default: ~/.local/share/roy-agent/workflows.db
+*/
+declare function getDatabasePath(): string;
+/**
+* Get the singleton database instance
+* @param path - Optional custom database path. If not provided, uses default path.
+*               Use ':memory:' for in-memory database (testing)
+*/
+declare function getDatabase(path?: string): any;
+/**
+* Close the database connection
+*/
+declare function closeDatabase(): void;
+type BunDatabase = {
+	exec(sql: string): void;
+	query<T>(sql: string): {
+		all(): T[];
+		get(...params: any[]): T | null;
+	};
+	run(sql: string, ...params: any[]): {
+		lastInsertRowid: number;
+		changes: number;
+	};
+	close(): void;
+	pragma?: (sql: string) => void;
+};
+/**
+* Initialize all required tables
+* 
+* Note: Only workflows table is created. Workflow runs are managed via SessionComponent
+* using the session/message storage, following the session-based design.
+*/
+declare function initializeTables(): void;
+/**
+* Reset the database instance (for testing purposes)
+* This is useful for tests that need a fresh database
+*/
+declare function resetDatabase(): void;
+/**
+* Initialize tables and return a ready database
+* This is a convenience function that combines getDatabase and initializeTables
+*/
+declare function initDatabase(path?: string): any;
+interface WorkflowRow {
+	id: string;
+	name: string;
+	version: string;
+	description: string | null;
+	definition: string;
+	config: string;
+	metadata: string;
+	tags: string;
+	task_id: number | null;
+	created_at: string;
+	updated_at: string;
+}
+interface ListWorkflowsOptions {
+	limit?: number;
+	offset?: number;
+	orderBy?: "name" | "created_at" | "updated_at";
+	order?: "asc" | "desc";
+	tag?: string;
+	taskId?: number;
+	search?: string;
+}
+interface UpdateWorkflowOptions {
+	name?: string;
+	version?: string;
+	description?: string;
+	definition?: WorkflowDefinition;
+	config?: WorkflowConfig;
+	metadata?: WorkflowMetadata;
+	tags?: string[];
+}
+/**
+* Row to Workflow conversion helper
+*/
+declare function rowToWorkflow(row: WorkflowRow): Workflow;
+/**
+* WorkflowRepository class
+* 
+* Provides CRUD operations for workflows in SQLite.
+*/
+declare class WorkflowRepository {
+	private db;
+	constructor(db?: ReturnType<typeof getDatabase>);
+	/**
+	* Create a new workflow
+	*/
+	create(workflow: Omit<Workflow, "id" | "createdAt" | "updatedAt">): Workflow;
+	/**
+	* Create a workflow from definition only
+	*/
+	createFromDefinition(definition: WorkflowDefinition, options?: {
+		config?: WorkflowConfig;
+		metadata?: WorkflowMetadata;
+		tags?: string[];
+	}): Workflow;
+	/**
+	* Get a workflow by ID
+	*/
+	getById(id: string): Workflow | undefined;
+	/**
+	* Get a workflow by name (returns latest version)
+	*/
+	getByName(name: string): Workflow | undefined;
+	/**
+	* Get a specific version of a workflow by name
+	*/
+	getByNameAndVersion(name: string, version: string): Workflow | undefined;
+	/**
+	* List workflows with optional filtering and pagination
+	*/
+	list(options?: ListWorkflowsOptions): Workflow[];
+	/**
+	* List all versions of a workflow by name
+	*/
+	listVersions(name: string): Workflow[];
+	/**
+	* Update a workflow
+	*/
+	update(id: string, updates: UpdateWorkflowOptions): Workflow | undefined;
+	/**
+	* Delete a workflow
+	*/
+	delete(id: string): boolean;
+	/**
+	* Check if a workflow exists
+	*/
+	exists(id: string): boolean;
+	/**
+	* Check if a workflow with name and version exists
+	*/
+	existsByNameAndVersion(name: string, version: string): boolean;
+	/**
+	* Get total count of workflows
+	*/
+	count(): number;
+	/**
+	* Search workflows by name (partial match)
+	*/
+	search(query: string, limit?: number): Workflow[];
+}
+export { rowToWorkflow, resetDatabase, initializeTables, initDatabase, getDatabasePath, getDatabase, closeDatabase, WorkflowRow, WorkflowRepository, UpdateWorkflowOptions, ListWorkflowsOptions, BunDatabase };

package/dist/env/workflow/storage/index.js

@@ -0,0 +1,27 @@
+import {
+  WorkflowRepository,
+  rowToWorkflow
+} from "../../../shared/@ai-setting/roy-agent-core-3rr5k71j.js";
+import {
+  closeDatabase,
+  getDatabase,
+  getDatabasePath,
+  initDatabase,
+  initializeTables,
+  resetDatabase
+} from "../../../shared/@ai-setting/roy-agent-core-zpn0bqa8.js";
+import"../../../shared/@ai-setting/roy-agent-core-rvxg1wps.js";
+import"../../../shared/@ai-setting/roy-agent-core-44hnfb02.js";
+import"../../../shared/@ai-setting/roy-agent-core-xs5rsgat.js";
+import"../../../shared/@ai-setting/roy-agent-core-psv4v63c.js";
+import"../../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
+export {
+  rowToWorkflow,
+  resetDatabase,
+  initializeTables,
+  initDatabase,
+  getDatabasePath,
+  getDatabase,
+  closeDatabase,
+  WorkflowRepository
+};