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

package/dist/shared/@ai-setting/roy-agent-core-rr9p1g43.js

@@ -0,0 +1,205 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-8dvbn7tw.js";
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/workflow/nodes/agent-component-adapter.ts
+class AgentComponentAdapter {
+  agentComponent;
+  options;
+  _sessionComponent;
+  agentSessionPrefix = "agent";
+  _currentAgentSessionId;
+  pendingSessions = new Map;
+  runSessionToAgentSessions = new Map;
+  constructor(agentComponent, options = {}, _sessionComponent) {
+    this.agentComponent = agentComponent;
+    this.options = options;
+    this._sessionComponent = _sessionComponent;
+  }
+  setSessionComponent(sessionComponent) {
+    this._sessionComponent = sessionComponent;
+  }
+  getCurrentAgentSessionId() {
+    return this._currentAgentSessionId;
+  }
+  registerAgent(name, config) {
+    this.agentComponent.registerAgent(name, {
+      type: config.type || "general",
+      model: config.model,
+      systemPrompt: config.systemPrompt,
+      maxIterations: config.maxIterations,
+      allowedTools: config.allowedTools,
+      deniedTools: config.deniedTools,
+      timeout: config.timeout,
+      maxErrorRetries: config.maxErrorRetries
+    });
+    if (config.sessionIdPrefix) {
+      this.agentSessionPrefixes.set(name, config.sessionIdPrefix);
+    }
+  }
+  async run(config, resumeOptions) {
+    const startTime = Date.now();
+    const nodeId = config.nodeId || "unknown";
+    const runId = config.runId || "unknown";
+    const workflowSessionId = config.workflowSessionId;
+    const existingAgentSessionId = config.agentSessionId;
+    const resumeAgentSessionId = resumeOptions?.agentSessionId;
+    const isResume = !!resumeOptions?.userResponse || !!existingAgentSessionId || !!resumeAgentSessionId;
+    let agentSessionId;
+    if (isResume && (this._currentAgentSessionId || existingAgentSessionId || resumeAgentSessionId)) {
+      agentSessionId = resumeAgentSessionId || existingAgentSessionId || this._currentAgentSessionId;
+      if (resumeOptions?.userResponse && this._sessionComponent && agentSessionId) {
+        try {
+          await this._sessionComponent.addMessage(agentSessionId, {
+            role: "user",
+            content: resumeOptions.userResponse,
+            metadata: {
+              type: "user_intent",
+              intent: "workflow.resume",
+              workflowNodeId: nodeId
+            }
+          });
+        } catch (error) {
+          console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
+        }
+      }
+    } else {
+      if (this._sessionComponent) {
+        agentSessionId = `${this.agentSessionPrefix}_${runId}_${nodeId}_${Date.now()}`;
+        try {
+          await this._sessionComponent.create({
+            title: `Agent Session: ${config.type} (${agentSessionId})`,
+            metadata: {
+              type: "agent",
+              workflowRunId: runId,
+              workflowNodeId: nodeId
+            }
+          });
+          this._currentAgentSessionId = agentSessionId;
+          if (workflowSessionId) {
+            const mapping = this.runSessionToAgentSessions.get(workflowSessionId) || [];
+            mapping.push(agentSessionId);
+            this.runSessionToAgentSessions.set(workflowSessionId, mapping);
+          }
+          this.pendingSessions.set(agentSessionId, {
+            agentSessionId,
+            nodeId,
+            runId,
+            createdAt: Date.now()
+          });
+        } catch (error) {
+          console.warn(`Failed to create agent session ${agentSessionId}:`, error);
+        }
+      }
+    }
+    try {
+      const context = {};
+      if (config.options?.timeout) {
+        context.abort = new AbortController;
+      }
+      if (agentSessionId) {
+        context.sessionId = agentSessionId;
+      }
+      if (config.options?.allowedTools) {
+        context.allowedTools = config.options.allowedTools;
+      }
+      if (config.options?.deniedTools) {
+        context.deniedTools = config.options.deniedTools;
+      }
+      if (config.workflowHistory) {
+        context.workflowHistory = config.workflowHistory;
+      }
+      const result = await this.agentComponent.run(config.type || "general", config.prompt, context);
+      if (result.error?.startsWith("__ASK_USER_ERROR__:")) {
+        const jsonStr = result.error.substring("__ASK_USER_ERROR__:".length);
+        const errorInfo = JSON.parse(jsonStr);
+        throw new AskUserError(runId, errorInfo.sessionId, errorInfo.nodeId, errorInfo.nodeType || "agent", errorInfo.query);
+      }
+      const duration = Date.now() - startTime;
+      if (agentSessionId) {
+        this.pendingSessions.delete(agentSessionId);
+      }
+      const messages = result._messages || [];
+      return {
+        output: result.finalText || result.output,
+        metadata: {
+          duration,
+          iterations: result.iterations,
+          toolCalls: result.toolCalls?.length,
+          agentSessionId
+        },
+        messages
+      };
+    } catch (error) {
+      const isAskUserError = error instanceof Error && error.name === "AskUserError";
+      if (isAskUserError) {
+        throw error;
+      }
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (agentSessionId) {
+        this.pendingSessions.delete(agentSessionId);
+      }
+      return {
+        output: undefined,
+        metadata: {
+          duration,
+          error: errorMessage,
+          agentSessionId
+        }
+      };
+    } finally {
+      if (!isResume) {
+        this._currentAgentSessionId = undefined;
+      }
+    }
+  }
+  async resumeAgent(agentSessionId, userResponse, config) {
+    if (this._sessionComponent) {
+      try {
+        await this._sessionComponent.addMessage(agentSessionId, {
+          role: "user",
+          content: userResponse,
+          metadata: {
+            type: "user_intent",
+            intent: "workflow.resume"
+          }
+        });
+        this.pendingSessions.delete(agentSessionId);
+        this._currentAgentSessionId = agentSessionId;
+      } catch (error) {
+        console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
+      }
+    }
+    config.agentSessionId = agentSessionId;
+    return this.run(config, { userResponse });
+  }
+  getPendingSession(agentSessionId) {
+    return this.pendingSessions.get(agentSessionId);
+  }
+  getPendingSessionsForRun(runId) {
+    return Array.from(this.pendingSessions.values()).filter((session) => session.runId === runId);
+  }
+  getAgentSessionsForWorkflowSession(workflowSessionId) {
+    return this.runSessionToAgentSessions.get(workflowSessionId) || [];
+  }
+  hasAgent(name) {
+    return this.agentComponent.getAgent(name) !== undefined;
+  }
+  listAgents() {
+    return this.agentComponent.listAgents().map((a) => a.name);
+  }
+  getAgentComponent() {
+    return this.agentComponent;
+  }
+  agentSessionPrefixes = new Map;
+}
+var init_agent_component_adapter = __esm(() => {
+  init_workflow_hil();
+});
+
+export { AgentComponentAdapter, init_agent_component_adapter };

package/dist/{env/workflow/decorators/index.js → shared/@ai-setting/roy-agent-core-sbzvpfn7.js}

@@ -1,164 +1,6 @@
-// @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/decorators/decorator-node.ts
-class DecoratorNode {
-  type = "decorator";
-  id;
-  methodName;
-  instance;
-  dependsOn;
-  timeout;
-  retryConfig;
-  constructor(definition) {
-    const config = definition.config;
-    this.id = definition.id;
-    this.methodName = config._methodName;
-    this.instance = config._instance;
-    this.dependsOn = definition.depends_on || [];
-    this.timeout = definition.timeout;
-    this.retryConfig = definition.retry;
-  }
-  async execute(context) {
-    const startTime = Date.now();
-    const method = this.instance[this.methodName];
-    if (typeof method !== "function") {
-      return {
-        success: false,
-        error: `Method '${this.methodName}' is not a function`,
-        duration: Date.now() - startTime
-      };
-    }
-    const input = this.prepareInput(context);
-    const result = await this.executeWithRetry(input, context.abort);
-    return {
-      success: !result.error,
-      output: result.output,
-      error: result.error,
-      duration: Date.now() - startTime,
-      metadata: {
-        methodName: this.methodName
-      }
-    };
-  }
-  prepareInput(context) {
-    const nodeOutputs = context.nodeOutputs;
-    if (this.dependsOn.length === 0) {
-      return context.input || {};
-    }
-    const input = {};
-    for (const depId of this.dependsOn) {
-      const depOutput = nodeOutputs instanceof Map ? nodeOutputs.get(depId) : nodeOutputs?.[depId];
-      if (depOutput && typeof depOutput === "object") {
-        if ("output" in depOutput) {
-          input[depId] = depOutput.output;
-        } else {
-          input[depId] = depOutput;
-        }
-      }
-    }
-    return input;
-  }
-  async executeWithRetry(input, abort) {
-    const maxAttempts = this.retryConfig?.max_attempts ?? 1;
-    const backoff = this.retryConfig?.backoff ?? "exponential";
-    const initialDelay = this.retryConfig?.initial_delay ?? 1000;
-    let lastError;
-    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
-      if (abort?.aborted) {
-        return { error: "Execution aborted" };
-      }
-      try {
-        const output = await this.executeWithTimeout(input, abort);
-        return { output };
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        if (attempt < maxAttempts) {
-          const delay = this.calculateBackoff(backoff, initialDelay, attempt - 1);
-          await this.sleep(delay, abort);
-        }
-      }
-    }
-    return { error: lastError?.message || "Unknown error" };
-  }
-  async executeWithTimeout(input, abort) {
-    if (!this.timeout) {
-      return this.instance[this.methodName](input);
-    }
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`Execution timeout after ${this.timeout}ms`));
-      }, this.timeout);
-    });
-    return Promise.race([
-      this.instance[this.methodName](input),
-      timeoutPromise
-    ]);
-  }
-  calculateBackoff(backoff, initialDelay, attempt) {
-    if (backoff === "exponential") {
-      return initialDelay * Math.pow(2, attempt);
-    }
-    return initialDelay;
-  }
-  sleep(ms, abort) {
-    return new Promise((resolve) => {
-      const timeout = setTimeout(resolve, ms);
-      abort?.addEventListener("abort", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-    });
-  }
-}
+import {
+  init_decorator_node
+} from "./roy-agent-core-3tnb2005.js";
 
 // packages/core/src/env/workflow/decorators/workflow.ts
 import"reflect-metadata";
@@ -249,6 +91,10 @@ function WorkflowEdges(edges) {
 function getEdgeMetadatas(target) {
   return Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
 }
+
+// packages/core/src/env/workflow/decorators/index.ts
+init_decorator_node();
+
 // packages/core/src/env/workflow/extractor/workflow-converter.ts
 import"reflect-metadata";
 class WorkflowConverter {
@@ -435,15 +281,4 @@ function createWorkflowFromClass(targetClass, options) {
   const instance = options?.instance ?? new targetClass(...options?.constructorArgs ?? []);
   return WorkflowConverter.fromClass(targetClass, instance);
 }
-export {
-  getWorkflowMetadata,
-  getNodeMetadatas,
-  getEdgeMetadatas,
-  createWorkflowFromClass,
-  WorkflowEdges,
-  WorkflowConverter,
-  Workflow,
-  NodeAs,
-  Edge,
-  DecoratorNode
-};
+export { Workflow, getWorkflowMetadata, NodeAs, getNodeMetadatas, Edge, WorkflowEdges, getEdgeMetadatas, WorkflowConverter, createWorkflowFromClass };