plugin-agent-orchestrator 1.0.13 → 1.0.15

package/dist/server/migrations/20260503000000-add-orchestrator-trace-fields.js

@@ -0,0 +1,57 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var add_orchestrator_trace_fields_exports = {};
+__export(add_orchestrator_trace_fields_exports, {
+  default: () => AddOrchestratorTraceFieldsToSkillExecutions
+});
+module.exports = __toCommonJS(add_orchestrator_trace_fields_exports);
+var import_server = require("@nocobase/server");
+class AddOrchestratorTraceFieldsToSkillExecutions extends import_server.Migration {
+  on = "afterLoad";
+  appVersion = ">=0.1.0";
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tablePrefix = this.db.options.tablePrefix || "";
+    const tableName = `${tablePrefix}skillExecutions`;
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    const addIfMissing = async (name) => {
+      if (tableDesc[name]) return;
+      await queryInterface.addColumn(tableName, name, {
+        type: "VARCHAR(100)",
+        allowNull: true
+      });
+    };
+    await addIfMissing("orchestratorRootRunId");
+    await addIfMissing("orchestratorSpanId");
+    await addIfMissing("orchestratorParentSpanId");
+    await addIfMissing("orchestratorToolCallId");
+  }
+  async down() {
+  }
+}

package/dist/server/plugin.d.ts

@@ -1,5 +1,7 @@
 import { Plugin } from '@nocobase/server';
+import SkillHubSubFeature from './skill-hub/plugin';
 export declare class PluginAgentOrchestratorServer extends Plugin {
+    skillHub: SkillHubSubFeature;
     afterAdd(): Promise<void>;
     beforeLoad(): Promise<void>;
     load(): Promise<void>;
@@ -7,5 +9,6 @@ export declare class PluginAgentOrchestratorServer extends Plugin {
     afterEnable(): Promise<void>;
     afterDisable(): Promise<void>;
     remove(): Promise<void>;
+    beforeStop(): Promise<void>;
 }
 export default PluginAgentOrchestratorServer;

package/dist/server/plugin.js

@@ -44,22 +44,55 @@ var import_server = require("@nocobase/server");
 var import_path = __toESM(require("path"));
 var import_delegate_task = require("./tools/delegate-task");
 var import_tracing = require("./resources/tracing");
+var import_plugin = __toESM(require("./skill-hub/plugin"));
 class PluginAgentOrchestratorServer extends import_server.Plugin {
+  skillHub;
   async afterAdd() {
+    this.skillHub = new import_plugin.default(this);
   }
   async beforeLoad() {
     this.db.import({ directory: import_path.default.resolve(__dirname, "collections") });
+    this.db.addMigrations({
+      namespace: this.name,
+      directory: import_path.default.resolve(__dirname, "migrations"),
+      context: { plugin: this }
+    });
   }
   async load() {
+    await this.skillHub.load();
     this.app.acl.registerSnippet({
       name: `pm.${this.name}`,
-      actions: ["orchestratorConfig:*"]
+      actions: ["orchestratorConfig:*", "orchestratorTracing:*", "agentExecutionSpans:*", "skillDefinitions:*", "skillExecutions:*", "skillHub:*", "skillWorkerConfigs:*"]
     });
     const toolsManager = this.app.aiManager.toolsManager;
     toolsManager.registerDynamicTools((0, import_delegate_task.createDelegateToolsProvider)(this));
     (0, import_tracing.registerTracingResource)(this);
+    this.app.cronJobManager.addJob({
+      cronTime: "0 30 2 * * *",
+      onTick: async () => {
+        try {
+          const days = Number(process.env.ORCHESTRATOR_LOG_RETENTION_DAYS || 30);
+          if (!Number.isFinite(days) || days <= 0) return;
+          const cutoff = new Date(Date.now() - days * 864e5);
+          const repo = this.db.getRepository("orchestratorLogs");
+          const spansRepo = this.db.getRepository("agentExecutionSpans");
+          const deletedLogs = repo ? await repo.destroy({
+            filter: { createdAt: { $lt: cutoff.toISOString() } }
+          }) : 0;
+          const deletedSpans = spansRepo ? await spansRepo.destroy({
+            filter: { createdAt: { $lt: cutoff.toISOString() } }
+          }) : 0;
+          this.app.log.info(
+            `[AgentOrchestrator] Pruned ${deletedLogs} orchestratorLogs and ${deletedSpans} agentExecutionSpans rows older than ${days} day(s).`
+          );
+        } catch (e) {
+          this.app.log.error("[AgentOrchestrator] Log retention job failed", e);
+        }
+      }
+    });
   }
   async install() {
+    await this.skillHub.install();
   }
   async afterEnable() {
   }
@@ -67,6 +100,9 @@ class PluginAgentOrchestratorServer extends import_server.Plugin {
   }
   async remove() {
   }
+  async beforeStop() {
+    await this.skillHub.beforeStop();
+  }
 }
 var plugin_default = PluginAgentOrchestratorServer;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/resources/tracing.js

@@ -29,6 +29,94 @@ __export(tracing_exports, {
   registerTracingResource: () => registerTracingResource
 });
 module.exports = __toCommonJS(tracing_exports);
+function toPlain(row) {
+  var _a;
+  return ((_a = row == null ? void 0 : row.toJSON) == null ? void 0 : _a.call(row)) || row;
+}
+function normalizeSpanFilter(filter = {}) {
+  const next = { ...filter };
+  if (next.subAgentUsername) {
+    next.employeeUsername = next.subAgentUsername;
+    delete next.subAgentUsername;
+  }
+  return next;
+}
+function spanTitle(row) {
+  if (row.title) return row.title;
+  if (row.type === "sub_agent") return `${row.leaderUsername || "-"} -> ${row.employeeUsername || "-"}`;
+  return row.toolName || row.type || "span";
+}
+function formatSpanListRow(raw) {
+  const row = toPlain(raw);
+  const metadata = row.metadata || {};
+  const input = row.input || {};
+  return {
+    id: row.id,
+    rootRunId: row.rootRunId,
+    parentSpanId: row.parentSpanId,
+    type: row.type,
+    leaderUsername: row.leaderUsername,
+    subAgentUsername: row.employeeUsername,
+    employeeUsername: row.employeeUsername,
+    toolName: row.toolName,
+    task: input.task || metadata.task || row.title || "",
+    context: input.context || "",
+    result: row.output,
+    status: row.status,
+    depth: metadata.depth ?? 0,
+    durationMs: row.durationMs,
+    error: row.error,
+    userId: row.userId,
+    createdAt: row.createdAt || row.startedAt,
+    traceCount: metadata.traceCount || 0,
+    messageCount: Array.isArray(metadata.messages) ? metadata.messages.length : metadata.messageCount || 0,
+    hasUnifiedTrace: true
+  };
+}
+function buildSpanTree(rows) {
+  const plainRows = rows.map(toPlain);
+  const byId = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const row of plainRows) {
+    const node = { ...row, children: [] };
+    byId.set(String(row.id), node);
+  }
+  for (const row of byId.values()) {
+    if (row.parentSpanId && byId.has(String(row.parentSpanId))) {
+      byId.get(String(row.parentSpanId)).children.push(row);
+    } else {
+      roots.push(row);
+    }
+  }
+  const sortTree = (items) => {
+    items.sort(
+      (a, b) => new Date(a.startedAt || a.createdAt || 0).getTime() - new Date(b.startedAt || b.createdAt || 0).getTime()
+    );
+    for (const item of items) sortTree(item.children || []);
+  };
+  sortTree(roots);
+  return roots;
+}
+function flattenSpanTimeline(rows) {
+  return rows.map(toPlain).sort(
+    (a, b) => new Date(a.startedAt || a.createdAt || 0).getTime() - new Date(b.startedAt || b.createdAt || 0).getTime()
+  ).map((row) => {
+    const input = row.input || {};
+    const metadata = row.metadata || {};
+    return {
+      type: row.type,
+      at: row.startedAt || row.createdAt,
+      title: spanTitle(row),
+      toolName: row.toolName,
+      args: row.type === "tool" || row.type === "skill" ? input : void 0,
+      status: row.status,
+      content: row.output || row.error || input.task || metadata.summary || "",
+      spanId: row.id,
+      parentSpanId: row.parentSpanId,
+      skillExecutionId: row.skillExecutionId
+    };
+  });
+}
 function registerTracingResource(plugin) {
   const app = plugin.app;
   app.resource({
@@ -38,9 +126,36 @@ function registerTracingResource(plugin) {
        * List all delegation execution logs.
        */
       async list(ctx, next) {
-        const repo = ctx.db.getRepository("orchestratorLogs");
         const { page = 1, pageSize = 50, sort = ["-createdAt"], filter = {} } = ctx.action.params;
         try {
+          const spanRepo = ctx.db.getRepository("agentExecutionSpans");
+          if (spanRepo) {
+            const spanFilter = {
+              ...normalizeSpanFilter(filter),
+              parentSpanId: null,
+              type: "sub_agent"
+            };
+            const [spanRows, spanCount] = await spanRepo.findAndCount({
+              filter: spanFilter,
+              sort,
+              offset: (Number(page) - 1) * Number(pageSize),
+              limit: Number(pageSize)
+            });
+            if (spanCount > 0) {
+              ctx.body = {
+                data: spanRows.map(formatSpanListRow),
+                meta: {
+                  count: spanCount,
+                  page: Number(page),
+                  pageSize: Number(pageSize),
+                  totalPage: Math.ceil(spanCount / Number(pageSize))
+                }
+              };
+              await next();
+              return;
+            }
+          }
+          const repo = ctx.db.getRepository("orchestratorLogs");
           const [rows, count] = await repo.findAndCount({
             filter,
             sort,
@@ -63,7 +178,8 @@ function registerTracingResource(plugin) {
               userId: row.userId,
               createdAt: row.createdAt,
               traceCount: Array.isArray(row.trace) ? row.trace.length : 0,
-              messageCount: Array.isArray(row.messages) ? row.messages.length : 0
+              messageCount: Array.isArray(row.messages) ? row.messages.length : 0,
+              hasUnifiedTrace: false
             })),
             meta: {
               count,
@@ -74,7 +190,7 @@ function registerTracingResource(plugin) {
           };
         } catch (e) {
           ctx.log.error("[AgentOrchestrator] Tracing list error", e);
-          ctx.body = { data: [], meta: { count: 0 } };
+          ctx.throw(500, (e == null ? void 0 : e.message) || "Failed to load tracing logs");
         }
         await next();
       },
@@ -83,29 +199,56 @@ function registerTracingResource(plugin) {
        */
       async get(ctx, next) {
         var _a;
-        const { filterByTk } = ctx.action.params;
+        const { filterByTk, source } = ctx.action.params;
         if (!filterByTk) {
           ctx.throw(400, "id is required");
           return;
         }
         try {
+          const spanRepo = ctx.db.getRepository("agentExecutionSpans");
+          if (spanRepo && source !== "log") {
+            const span = await spanRepo.findOne({
+              filter: { id: filterByTk }
+            });
+            if (span) {
+              const plainSpan = toPlain(span);
+              const rows = await spanRepo.find({
+                filter: { rootRunId: plainSpan.rootRunId },
+                sort: ["createdAt"]
+              });
+              const tree = buildSpanTree(rows);
+              const timeline = flattenSpanTimeline(rows);
+              const rootRow = formatSpanListRow(plainSpan);
+              const metadata = plainSpan.metadata || {};
+              ctx.body = {
+                data: {
+                  ...rootRow,
+                  input: plainSpan.input,
+                  output: plainSpan.output,
+                  metadata,
+                  trace: timeline,
+                  messages: metadata.messages || [],
+                  children: tree
+                }
+              };
+              await next();
+              return;
+            }
+          }
           const repo = ctx.db.getRepository("orchestratorLogs");
-          const log = await repo.findOne({
+          const log = source === "span" ? null : await repo.findOne({
             filter: { id: filterByTk }
           });
-          ctx.body = { data: ((_a = log == null ? void 0 : log.toJSON) == null ? void 0 : _a.call(log)) || log || null };
+          const plainLog = ((_a = log == null ? void 0 : log.toJSON) == null ? void 0 : _a.call(log)) || log;
+          ctx.body = { data: plainLog ? { ...plainLog, hasUnifiedTrace: false } : null };
         } catch (e) {
           ctx.log.error("[AgentOrchestrator] Tracing get error", e);
-          ctx.body = { data: null };
+          ctx.throw(500, (e == null ? void 0 : e.message) || "Failed to load tracing log");
         }
         await next();
       }
     }
   });
-  app.acl.registerSnippet({
-    name: `pm.${plugin.name}.tracing`,
-    actions: ["orchestratorTracing:list", "orchestratorTracing:get"]
-  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/server/services/CodeValidator.d.ts

@@ -0,0 +1,32 @@
+export declare class CodeValidator {
+    /**
+     * Check code against forbidden patterns (dangerous modules/functions).
+     * @throws CodeValidationError if a forbidden pattern is found.
+     */
+    validate(code: string, language: 'node' | 'python'): void;
+    /**
+     * Validate that code only imports packages in the whitelist.
+     * Called after the basic forbidden pattern check.
+     * Skips validation if whitelist is empty (env not initialized yet).
+     *
+     * @param code - The code to validate
+     * @param language - 'node' or 'python'
+     * @param whitelist - Array of allowed package names (from skillWorkerConfigs.packageWhitelist)
+     */
+    validateImports(code: string, language: 'node' | 'python', whitelist: string[]): void;
+    /**
+     * Check Node.js require() calls against the whitelist.
+     * Built-in modules (fs, path, etc.) are always allowed.
+     */
+    private validateNodeImports;
+    /**
+     * Check Python import/from statements against the whitelist.
+     * Built-in modules (os, sys, json, etc.) are always allowed.
+     * Handles PyPI→import name mapping (e.g., python-docx → docx, Pillow → PIL).
+     */
+    private validatePythonImports;
+}
+export declare class CodeValidationError extends Error {
+    matchedPattern: string;
+    constructor(message: string, matchedPattern: string);
+}

package/dist/server/services/CodeValidator.js

@@ -0,0 +1,206 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CodeValidator_exports = {};
+__export(CodeValidator_exports, {
+  CodeValidationError: () => CodeValidationError,
+  CodeValidator: () => CodeValidator
+});
+module.exports = __toCommonJS(CodeValidator_exports);
+const DANGEROUS_NODE_PATTERNS = [
+  { pattern: /require\s*\(\s*['"]child_process['"]\s*\)/, reason: "child_process module not allowed" },
+  { pattern: /require\s*\(\s*['"]cluster['"]\s*\)/, reason: "cluster module not allowed" },
+  { pattern: /require\s*\(\s*['"]dgram['"]\s*\)/, reason: "dgram module not allowed" },
+  { pattern: /require\s*\(\s*['"]net['"]\s*\)/, reason: "net module not allowed" },
+  { pattern: /require\s*\(\s*['"]http['"]\s*\)/, reason: "http module not allowed" },
+  { pattern: /require\s*\(\s*['"]https['"]\s*\)/, reason: "https module not allowed" },
+  { pattern: /require\s*\(\s*['"]vm['"]\s*\)/, reason: "vm module not allowed" },
+  { pattern: /process\.exit/, reason: "process.exit not allowed" },
+  { pattern: /process\.env(?!\s*\.OUTPUT_DIR)/, reason: "process.env access not allowed (use OUTPUT_DIR only)" },
+  { pattern: /process\.kill/, reason: "process.kill not allowed" }
+];
+const DANGEROUS_PYTHON_PATTERNS = [
+  { pattern: /import\s+subprocess/, reason: "subprocess module not allowed" },
+  { pattern: /from\s+subprocess\s+import/, reason: "subprocess module not allowed" },
+  { pattern: /import\s+shutil/, reason: "shutil module not allowed" },
+  { pattern: /__import__\s*\(/, reason: "__import__ not allowed" },
+  { pattern: /os\.system\s*\(/, reason: "os.system not allowed" },
+  { pattern: /os\.popen\s*\(/, reason: "os.popen not allowed" },
+  { pattern: /os\.exec\w*\s*\(/, reason: "os.exec* not allowed" },
+  { pattern: /os\.spawn\w*\s*\(/, reason: "os.spawn* not allowed" },
+  { pattern: /\beval\s*\(/, reason: "eval not allowed" },
+  { pattern: /\bexec\s*\(/, reason: "exec not allowed" },
+  { pattern: /\bcompile\s*\(/, reason: "compile not allowed" }
+];
+const NODE_BUILTINS = [
+  "fs",
+  "path",
+  "os",
+  "crypto",
+  "util",
+  "stream",
+  "buffer",
+  "querystring",
+  "url",
+  "assert",
+  "events",
+  "string_decoder",
+  "zlib"
+];
+const PYTHON_BUILTINS = [
+  "os",
+  "sys",
+  "json",
+  "math",
+  "datetime",
+  "collections",
+  "itertools",
+  "functools",
+  "pathlib",
+  "typing",
+  "io",
+  "csv",
+  "re",
+  "string",
+  "textwrap",
+  "decimal",
+  "fractions",
+  "random",
+  "statistics",
+  "copy",
+  "enum",
+  "dataclasses",
+  "abc",
+  "contextlib",
+  "operator",
+  "time",
+  "calendar",
+  "locale",
+  "struct",
+  "hashlib",
+  "base64",
+  "binascii",
+  "codecs",
+  "unicodedata",
+  "pprint",
+  "warnings",
+  "traceback",
+  "logging",
+  "unittest",
+  "argparse",
+  "ast",
+  "tempfile",
+  "xml",
+  "zipfile",
+  // Pre-installed local packages (trusted, bundled with plugin)
+  "svg_to_pptx"
+];
+const PYTHON_IMPORT_NAME_MAP = {
+  "python-docx": "docx",
+  "python-pptx": "pptx",
+  "Pillow": "PIL",
+  "pyyaml": "yaml"
+};
+class CodeValidator {
+  /**
+   * Check code against forbidden patterns (dangerous modules/functions).
+   * @throws CodeValidationError if a forbidden pattern is found.
+   */
+  validate(code, language) {
+    const patterns = language === "node" ? DANGEROUS_NODE_PATTERNS : DANGEROUS_PYTHON_PATTERNS;
+    for (const { pattern, reason } of patterns) {
+      if (pattern.test(code)) {
+        throw new CodeValidationError(reason, pattern.source);
+      }
+    }
+  }
+  /**
+   * Validate that code only imports packages in the whitelist.
+   * Called after the basic forbidden pattern check.
+   * Skips validation if whitelist is empty (env not initialized yet).
+   *
+   * @param code - The code to validate
+   * @param language - 'node' or 'python'
+   * @param whitelist - Array of allowed package names (from skillWorkerConfigs.packageWhitelist)
+   */
+  validateImports(code, language, whitelist) {
+    if (!(whitelist == null ? void 0 : whitelist.length)) return;
+    if (language === "node") {
+      this.validateNodeImports(code, whitelist);
+    } else if (language === "python") {
+      this.validatePythonImports(code, whitelist);
+    }
+  }
+  /**
+   * Check Node.js require() calls against the whitelist.
+   * Built-in modules (fs, path, etc.) are always allowed.
+   */
+  validateNodeImports(code, whitelist) {
+    const requires = [...code.matchAll(/require\s*\(\s*['"]([^'"./][^'"]*)['"]\s*\)/g)];
+    for (const match of requires) {
+      const raw = match[1];
+      const pkgName = raw.startsWith("@") ? raw.split("/").slice(0, 2).join("/") : raw.split("/")[0];
+      if (NODE_BUILTINS.includes(pkgName)) continue;
+      if (whitelist.includes(pkgName)) continue;
+      throw new CodeValidationError(
+        `Package "${pkgName}" is not in the allowed whitelist. Allowed: ${whitelist.join(", ")}`,
+        `require('${pkgName}')`
+      );
+    }
+  }
+  /**
+   * Check Python import/from statements against the whitelist.
+   * Built-in modules (os, sys, json, etc.) are always allowed.
+   * Handles PyPI→import name mapping (e.g., python-docx → docx, Pillow → PIL).
+   */
+  validatePythonImports(code, whitelist) {
+    const imports = [...code.matchAll(/(?:^|\n)\s*(?:import|from)\s+([a-zA-Z_][a-zA-Z0-9_]*)/g)];
+    const allowedImports = /* @__PURE__ */ new Set([
+      ...PYTHON_BUILTINS,
+      ...whitelist.map((p) => PYTHON_IMPORT_NAME_MAP[p] || p)
+    ]);
+    for (const match of imports) {
+      const pkg = match[1];
+      if (allowedImports.has(pkg)) continue;
+      throw new CodeValidationError(
+        `Module "${pkg}" is not in the allowed whitelist. Allowed: ${[...allowedImports].join(", ")}`,
+        `import ${pkg}`
+      );
+    }
+  }
+}
+class CodeValidationError extends Error {
+  constructor(message, matchedPattern) {
+    super(`Code validation failed: ${message}`);
+    this.matchedPattern = matchedPattern;
+    this.name = "CodeValidationError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CodeValidationError,
+  CodeValidator
+});

package/dist/server/services/ExecutionSpanService.d.ts

@@ -0,0 +1,44 @@
+export declare const ORCHESTRATOR_TRACE_CONTEXT_KEY = "__orchestratorTraceContext";
+export type OrchestratorTraceContext = {
+    rootRunId: string;
+    spanId?: string;
+    parentSpanId?: string;
+    toolCallId?: string;
+    leaderUsername?: string;
+    employeeUsername?: string;
+    toolName?: string;
+};
+type SpanValues = {
+    rootRunId: string;
+    parentSpanId?: string;
+    type: string;
+    status: string;
+    leaderUsername?: string;
+    employeeUsername?: string;
+    toolName?: string;
+    title?: string;
+    input?: any;
+    output?: string;
+    error?: string;
+    durationMs?: number;
+    startedAt?: Date;
+    endedAt?: Date;
+    orchestratorLogId?: string | number;
+    skillExecutionId?: string | number;
+    metadata?: any;
+    userId?: string | number;
+};
+export declare class ExecutionSpanService {
+    private readonly plugin;
+    constructor(plugin: any);
+    create(values: SpanValues): Promise<any>;
+    update(spanId: string | number | undefined, values: Record<string, any>): Promise<{
+        id: string | number;
+    }>;
+    finish(spanId: string | number | undefined, status: 'success' | 'error' | 'canceled' | 'timeout', startedAt: number, values?: Record<string, any>): Promise<{
+        id: string | number;
+    }>;
+}
+export declare function getOrchestratorTraceContext(ctx: any): OrchestratorTraceContext | null;
+export declare function setOrchestratorTraceContext(ctx: any, traceContext: OrchestratorTraceContext): any;
+export {};