@ai-setting/roy-agent-core 1.4.10 → 1.4.12

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

@@ -0,0 +1,262 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/workflow/service/workflow-service.ts
+class WorkflowService {
+  workflowRepository;
+  engineFactory;
+  sessionComponent;
+  constructor(workflowRepository, engineFactory, sessionComponent) {
+    this.workflowRepository = workflowRepository;
+    this.engineFactory = engineFactory;
+    this.sessionComponent = sessionComponent;
+  }
+  async createWorkflow(definition, options) {
+    const existing = this.workflowRepository.getByName(definition.name);
+    if (existing) {
+      if (options?.force !== true) {
+        throw new Error(`Workflow already exists: ${definition.name}`);
+      }
+      return this.workflowRepository.update(existing.id, {
+        name: definition.name,
+        version: definition.version,
+        description: definition.description || existing.description,
+        definition,
+        config: definition.config || {},
+        metadata: {
+          ...options.metadata || definition.metadata || existing.metadata || {},
+          taskId: options.taskId || definition.metadata?.taskId || existing.metadata?.taskId
+        },
+        tags: options.tags || definition.metadata?.tags || []
+      });
+    }
+    const workflow = {
+      name: definition.name,
+      version: definition.version,
+      description: definition.description,
+      definition,
+      config: definition.config || {},
+      metadata: {
+        ...options?.metadata || definition.metadata || {},
+        taskId: options?.taskId || definition.metadata?.taskId
+      },
+      tags: options?.tags || definition.metadata?.tags || []
+    };
+    return this.workflowRepository.create(workflow);
+  }
+  getWorkflow(idOrName) {
+    let workflow = this.workflowRepository.getById(idOrName);
+    if (workflow)
+      return workflow;
+    return this.workflowRepository.getByName(idOrName);
+  }
+  getWorkflowById(id) {
+    return this.workflowRepository.getById(id);
+  }
+  getWorkflowByName(name) {
+    return this.workflowRepository.getByName(name);
+  }
+  listWorkflows(options) {
+    return this.workflowRepository.list(options);
+  }
+  async updateWorkflow(idOrName, updates, options) {
+    let workflow = this.workflowRepository.getByName(idOrName);
+    if (!workflow) {
+      workflow = this.workflowRepository.getById(idOrName);
+    }
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${idOrName}`);
+    }
+    const updateData = {
+      ...updates
+    };
+    if (options?.tags !== undefined) {
+      updateData.tags = options.tags;
+    }
+    const updated = this.workflowRepository.update(workflow.id, updateData);
+    if (!updated) {
+      throw new Error(`Failed to update workflow: ${idOrName}`);
+    }
+    return updated;
+  }
+  async deleteWorkflow(idOrName) {
+    let workflow = this.workflowRepository.getByName(idOrName);
+    if (!workflow) {
+      workflow = this.workflowRepository.getById(idOrName);
+    }
+    if (!workflow) {
+      return false;
+    }
+    return this.workflowRepository.delete(workflow.id);
+  }
+  async runWorkflow(idOrNameOrDefinition, input, options) {
+    let workflow = null;
+    let definition = null;
+    if (typeof idOrNameOrDefinition === "string") {
+      workflow = this.getWorkflow(idOrNameOrDefinition);
+      if (!workflow) {
+        throw new Error(`Workflow not found: ${idOrNameOrDefinition}`);
+      }
+      definition = workflow.definition;
+    } else {
+      definition = idOrNameOrDefinition;
+      workflow = this.getWorkflowByName(definition.name);
+      if (!workflow) {
+        workflow = {
+          id: `wf_inline_${definition.name}`,
+          name: definition.name,
+          version: definition.version,
+          description: definition.description,
+          definition,
+          config: definition.config || {},
+          metadata: definition.metadata || {},
+          tags: definition.metadata?.tags || [],
+          createdAt: new Date,
+          updatedAt: new Date
+        };
+      }
+    }
+    const engine = this.engineFactory(workflow, {
+      ...options,
+      input
+    });
+    const result = await engine.runWorkflow(workflow, {
+      ...options,
+      input
+    });
+    return {
+      ...result,
+      runId: result.runId || result.sessionId || "",
+      sessionId: result.sessionId || result.runId || ""
+    };
+  }
+  async runWorkflowByName(name, input, options) {
+    const workflow = this.getWorkflowByName(name);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${name}`);
+    }
+    return this.runWorkflow(name, input, options);
+  }
+  async stopRun(sessionId, reason) {
+    const session = await this.sessionComponent?.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const metadata = session.metadata;
+    if (metadata.type !== "workflow") {
+      throw new Error(`Session is not a workflow session: ${sessionId}`);
+    }
+    const workflow = this.getWorkflowByName(metadata.workflowName);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${metadata.workflowName}`);
+    }
+    const engine = this.engineFactory(workflow);
+    await engine.stop(sessionId, reason);
+  }
+  async getSession(sessionId) {
+    if (!this.sessionComponent) {
+      return null;
+    }
+    const session = await this.sessionComponent.get(sessionId);
+    return session ?? null;
+  }
+  async listSessions(options) {
+    if (!this.sessionComponent?.list) {
+      return [];
+    }
+    return this.sessionComponent.list(options);
+  }
+  async getSessionMessages(sessionId) {
+    if (!this.sessionComponent) {
+      return [];
+    }
+    return this.sessionComponent.getMessages(sessionId);
+  }
+}
+// packages/core/src/env/workflow/service/registry.ts
+class WorkflowServiceRegistry {
+  static instance;
+  service = null;
+  constructor() {}
+  static getInstance() {
+    if (!WorkflowServiceRegistry.instance) {
+      WorkflowServiceRegistry.instance = new WorkflowServiceRegistry;
+    }
+    return WorkflowServiceRegistry.instance;
+  }
+  register(service) {
+    this.service = service;
+  }
+  get() {
+    if (!this.service) {
+      throw new Error("WorkflowService is not registered. Call register() first.");
+    }
+    return this.service;
+  }
+  isRegistered() {
+    return this.service !== null;
+  }
+  reset() {
+    this.service = null;
+  }
+}
+function getWorkflowService() {
+  return WorkflowServiceRegistry.getInstance().get();
+}
+function registerWorkflowService(service) {
+  WorkflowServiceRegistry.getInstance().register(service);
+}
+export {
+  registerWorkflowService,
+  getWorkflowService,
+  WorkflowServiceRegistry,
+  WorkflowService
+};