plugin-agent-orchestrator 1.0.20 → 1.0.21

package/dist/server/services/ContextAggregator.js

@@ -0,0 +1,201 @@
+/**
+ * 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 ContextAggregator_exports = {};
+__export(ContextAggregator_exports, {
+  ContextAggregator: () => ContextAggregator
+});
+module.exports = __toCommonJS(ContextAggregator_exports);
+function trimText(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n...[truncated]";
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+class ContextAggregator {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  get db() {
+    return this.plugin.db;
+  }
+  get app() {
+    return this.plugin.app;
+  }
+  /**
+   * Build a structured context string from completed steps of a run.
+   *
+   * @param runId - agentLoopRuns.id
+   * @param maxTokens - Maximum tokens for the context output (default 4000)
+   * @param options - Strategy options
+   */
+  async buildStepContext(runId, maxTokens, options) {
+    var _a;
+    const effectiveMaxTokens = maxTokens || 4e3;
+    let steps;
+    try {
+      const repo = this.db.getRepository("agentLoopSteps");
+      if (!repo) return "";
+      steps = await repo.find({
+        filter: { runId },
+        sort: ["index", "createdAt"],
+        pageSize: 500
+      });
+    } catch {
+      return "";
+    }
+    if (!steps || steps.length === 0) return "";
+    const completedSteps = steps.filter((s) => s.status === "succeeded" || s.status === "failed");
+    if (completedSteps.length === 0) return "";
+    const config = {
+      strategy: (options == null ? void 0 : options.strategy) || "all",
+      includeToolResults: (options == null ? void 0 : options.includeToolResults) ?? false,
+      includeStepOutputs: (options == null ? void 0 : options.includeStepOutputs) ?? true
+    };
+    let candidates = completedSteps;
+    if (config.strategy === "last_n") {
+      const n = Math.min(10, completedSteps.length);
+      candidates = completedSteps.slice(-n);
+    }
+    const parts = [];
+    for (const step of candidates) {
+      const key = step.planKey || `step_${step.index || 0}`;
+      const type = step.type || "unknown";
+      const target = step.target || "";
+      const title = step.title || key;
+      const status = step.status || "unknown";
+      const lines = [];
+      lines.push(`<step key="${key}" type="${type}" target="${target}" status="${status}">`);
+      lines.push(`  <title>${this.escapeXml(title)}</title>`);
+      if (step.description) {
+        lines.push(`  <description>${this.escapeXml(trimText(step.description, 500))}</description>`);
+      }
+      if (config.includeStepOutputs && step.output) {
+        const outputStr = typeof step.output === "string" ? step.output : this.safeStringify(step.output);
+        lines.push(`  <output>${this.escapeXml(trimText(outputStr, 2e3))}</output>`);
+      }
+      if (config.includeToolResults && ((_a = step.metadata) == null ? void 0 : _a.toolResults)) {
+        const toolStr = this.safeStringify(step.metadata.toolResults);
+        lines.push(`  <tool_results>${this.escapeXml(trimText(toolStr, 1500))}</tool_results>`);
+      }
+      if (step.error) {
+        lines.push(`  <error>${this.escapeXml(trimText(step.error, 1e3))}</error>`);
+      }
+      lines.push("</step>");
+      parts.push(lines.join("\n"));
+    }
+    let context = `<previous_steps>
+${parts.join("\n\n")}
+</previous_steps>`;
+    if (estimateTokens(context) > effectiveMaxTokens) {
+      context = this.truncateToTokenLimit(context, effectiveMaxTokens);
+    }
+    return context;
+  }
+  /**
+   * Enrich a base system prompt with step context from the run.
+   * Fetches the run from DB to access policy settings (maxContextTokens, etc.).
+   *
+   * @param basePrompt - The original system prompt to enrich
+   * @param runId - agentLoopRuns.id
+   * @param _stepId - agentLoopSteps.id (reserved for future per-step context)
+   */
+  async enrichSystemPrompt(basePrompt, runId, _stepId, options) {
+    let run;
+    try {
+      const repo = this.db.getRepository("agentLoopRuns");
+      if (!repo) return basePrompt;
+      run = await repo.findOne({ filter: { id: runId } });
+      if (!run) return basePrompt;
+    } catch {
+      return basePrompt;
+    }
+    const policy = run.policy || {};
+    const maxCtxTokens = (options == null ? void 0 : options.maxContextTokens) ?? policy.maxContextTokens ?? 4e3;
+    const strategy = (options == null ? void 0 : options.contextSummaryStrategy) ?? policy.contextSummaryStrategy ?? "all";
+    const includeToolResults = (options == null ? void 0 : options.includeToolResults) ?? policy.includeToolResults ?? false;
+    const includeStepOutputs = (options == null ? void 0 : options.includeStepOutputs) ?? policy.includeStepOutputs ?? true;
+    const stepContext = await this.buildStepContext(runId, maxCtxTokens, {
+      strategy,
+      includeToolResults,
+      includeStepOutputs
+    });
+    if (!stepContext) return basePrompt;
+    return `${basePrompt}
+
+<previous_steps_context>
+${stepContext}
+</previous_steps_context>`;
+  }
+  truncateToTokenLimit(text, maxTokens) {
+    const outerMatch = text.match(/<previous_steps>\n([\s\S]*)\n<\/previous_steps>/);
+    if (!outerMatch) return text;
+    const inner = outerMatch[1];
+    const stepBlocks = this.splitStepBlocks(inner);
+    if (stepBlocks.length <= 2) {
+      const maxChars2 = maxTokens * 4;
+      if (text.length <= maxChars2) return text;
+      return text.slice(0, maxChars2) + "\n...[truncated]\n</previous_steps>";
+    }
+    const keepFirst = stepBlocks.slice(0, 2);
+    const keepLast = stepBlocks.slice(-2);
+    const removed = stepBlocks.length - keepFirst.length - keepLast.length;
+    const rebuilt = [
+      "<previous_steps>",
+      ...keepFirst,
+      `  <!-- ... ${removed} intermediate step(s) omitted due to context limit ... -->`,
+      ...keepLast,
+      "</previous_steps>"
+    ].join("\n");
+    const maxChars = maxTokens * 4;
+    if (rebuilt.length <= maxChars) return rebuilt;
+    return rebuilt.slice(0, maxChars) + "\n...[truncated]\n</previous_steps>";
+  }
+  splitStepBlocks(text) {
+    const blocks = [];
+    const regex = /<step[\s\S]*?<\/step>/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+      blocks.push(match[0]);
+    }
+    return blocks;
+  }
+  escapeXml(value) {
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  safeStringify(value) {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextAggregator
+});

package/dist/server/services/ExecutionSpanService.js

@@ -32,11 +32,8 @@ __export(ExecutionSpanService_exports, {
   setOrchestratorTraceContext: () => setOrchestratorTraceContext
 });
 module.exports = __toCommonJS(ExecutionSpanService_exports);
+var import_ctx_utils = require("../utils/ctx-utils");
 const ORCHESTRATOR_TRACE_CONTEXT_KEY = "__orchestratorTraceContext";
-function toPlain(record) {
-  var _a;
-  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
-}
 class ExecutionSpanService {
   constructor(plugin) {
     this.plugin = plugin;
@@ -53,7 +50,7 @@ class ExecutionSpanService {
           createdAt: /* @__PURE__ */ new Date()
         }
       });
-      return toPlain(record);
+      return (0, import_ctx_utils.toPlain)(record);
     } catch (error) {
       (_b = (_a = this.plugin.app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "[AgentOrchestrator] Failed to create execution span", error);
       return null;

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

@@ -0,0 +1,9 @@
+type EventCallback = (event: any) => void;
+declare class RunEventBusImpl {
+    private listeners;
+    subscribe(runId: string | number, callback: EventCallback): () => void;
+    emit(runId: string | number, event: any): void;
+    listenerCount(runId: string | number): number;
+}
+export declare function getRunEventBus(): RunEventBusImpl;
+export {};

package/dist/server/services/RunEventBus.js

@@ -0,0 +1,73 @@
+/**
+ * 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 RunEventBus_exports = {};
+__export(RunEventBus_exports, {
+  getRunEventBus: () => getRunEventBus
+});
+module.exports = __toCommonJS(RunEventBus_exports);
+class RunEventBusImpl {
+  listeners = /* @__PURE__ */ new Map();
+  subscribe(runId, callback) {
+    let set = this.listeners.get(runId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(runId, set);
+    }
+    set.add(callback);
+    return () => {
+      set == null ? void 0 : set.delete(callback);
+      if ((set == null ? void 0 : set.size) === 0) {
+        this.listeners.delete(runId);
+      }
+    };
+  }
+  emit(runId, event) {
+    const set = this.listeners.get(runId);
+    if (!set) return;
+    for (const callback of set) {
+      try {
+        callback(event);
+      } catch {
+      }
+    }
+  }
+  listenerCount(runId) {
+    var _a;
+    return ((_a = this.listeners.get(runId)) == null ? void 0 : _a.size) || 0;
+  }
+}
+let instance = null;
+function getRunEventBus() {
+  if (!instance) {
+    instance = new RunEventBusImpl();
+  }
+  return instance;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRunEventBus
+});

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

@@ -0,0 +1,62 @@
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cost: number;
+}
+export interface BudgetConfig {
+    budgetMaxTokens?: number;
+    budgetMaxCost?: number;
+}
+export interface BudgetCheckResult {
+    allowed: boolean;
+    reason?: string;
+}
+/**
+ * Extract usage_metadata from the final state returned by createReactAgent.invoke().
+ *
+ * LangChain's createReactAgent returns a final state object with a `messages` array.
+ * The last AIMessage in that array carries `usage_metadata` populated by the
+ * LLM provider after the final generation step. This is the standard LangChain
+ * approach — no private API access needed.
+ *
+ * Expected shape (from @langchain/core/messages/ai):
+ *   AIMessage.usage_metadata = {
+ *     input_tokens: number,
+ *     output_tokens: number,
+ *     total_tokens: number,
+ *   }
+ */
+export declare function extractTokenUsage(finalState: any): TokenUsage | null;
+/**
+ * Service for tracking token consumption across agent runs and spans.
+ *
+ * Responsibilities:
+ * 1. Parse token usage from LangGraph execution results
+ * 2. Persist token counts to agentExecutionSpans
+ * 3. Accumulate totals at the agentLoopRuns level
+ * 4. Enforce budget limits (max tokens / max cost per run)
+ */
+export declare class TokenTracker {
+    private readonly plugin;
+    constructor(plugin: any);
+    get db(): any;
+    get app(): any;
+    /**
+     * Track token usage for a single execution span.
+     * Updates the span record and accumulates into the parent run.
+     *
+     * @param spanId - The agentExecutionSpans.id to update
+     * @param usage - Parsed token usage from extractTokenUsage()
+     * @param runId - Optional agentLoopRuns.id to accumulate totals
+     */
+    trackSpan(spanId: string | number | undefined, usage: TokenUsage, runId?: string | number): Promise<void>;
+    /**
+     * Recalculate total token/cost for a run by summing all its spans.
+     */
+    accumulateToRun(runId: string | number): Promise<void>;
+    /**
+     * Check if a run has exceeded its budget limits.
+     */
+    checkBudget(runId: string | number): Promise<BudgetCheckResult>;
+}

package/dist/server/services/TokenTracker.js

@@ -0,0 +1,173 @@
+/**
+ * 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 TokenTracker_exports = {};
+__export(TokenTracker_exports, {
+  TokenTracker: () => TokenTracker,
+  extractTokenUsage: () => extractTokenUsage
+});
+module.exports = __toCommonJS(TokenTracker_exports);
+const PRICE_PER_1K_INPUT = Number(process.env.ORCHESTRATOR_PRICE_PER_1K_INPUT || 3e-3);
+const PRICE_PER_1K_OUTPUT = Number(process.env.ORCHESTRATOR_PRICE_PER_1K_OUTPUT || 0.015);
+function estimateCost(inputTokens, outputTokens) {
+  return inputTokens / 1e3 * PRICE_PER_1K_INPUT + outputTokens / 1e3 * PRICE_PER_1K_OUTPUT;
+}
+function extractTokenUsage(finalState) {
+  if (!(finalState == null ? void 0 : finalState.messages) || !Array.isArray(finalState.messages)) return null;
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalAll = 0;
+  for (const msg of finalState.messages) {
+    if (msg == null ? void 0 : msg.usage_metadata) {
+      const um = msg.usage_metadata;
+      totalInput += um.input_tokens || 0;
+      totalOutput += um.output_tokens || 0;
+      totalAll += um.total_tokens || 0;
+    }
+  }
+  if (totalAll === 0) return null;
+  return {
+    inputTokens: totalInput,
+    outputTokens: totalOutput,
+    totalTokens: totalAll,
+    cost: estimateCost(totalInput, totalOutput)
+  };
+}
+class TokenTracker {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  get db() {
+    return this.plugin.db;
+  }
+  get app() {
+    return this.plugin.app;
+  }
+  /**
+   * Track token usage for a single execution span.
+   * Updates the span record and accumulates into the parent run.
+   *
+   * @param spanId - The agentExecutionSpans.id to update
+   * @param usage - Parsed token usage from extractTokenUsage()
+   * @param runId - Optional agentLoopRuns.id to accumulate totals
+   */
+  async trackSpan(spanId, usage, runId) {
+    var _a, _b;
+    if (!spanId) return;
+    try {
+      const repo = this.db.getRepository("agentExecutionSpans");
+      if (!repo) return;
+      await repo.update({
+        filterByTk: spanId,
+        values: {
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          totalTokens: usage.totalTokens,
+          cost: usage.cost
+        }
+      });
+      if (runId != null) {
+        await this.accumulateToRun(runId);
+      }
+    } catch (e) {
+      (_b = (_a = this.app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "[TokenTracker] Failed to track span tokens", e);
+    }
+  }
+  /**
+   * Recalculate total token/cost for a run by summing all its spans.
+   */
+  async accumulateToRun(runId) {
+    var _a, _b, _c, _d, _e;
+    try {
+      const spansRepo = this.db.getRepository("agentExecutionSpans");
+      if (!spansRepo) return;
+      const spans = await spansRepo.find({
+        filter: { "metadata.agentLoopRunId": String(runId) }
+      });
+      let totalInput = 0;
+      let totalOutput = 0;
+      let totalCost = 0;
+      for (const span of spans) {
+        totalInput += Number(((_a = span.get) == null ? void 0 : _a.call(span, "inputTokens")) || span.inputTokens || 0);
+        totalOutput += Number(((_b = span.get) == null ? void 0 : _b.call(span, "outputTokens")) || span.outputTokens || 0);
+        totalCost += Number(((_c = span.get) == null ? void 0 : _c.call(span, "cost")) || span.cost || 0);
+      }
+      const runsRepo = this.db.getRepository("agentLoopRuns");
+      if (!runsRepo) return;
+      await runsRepo.update({
+        filterByTk: runId,
+        values: {
+          totalInputTokens: totalInput,
+          totalOutputTokens: totalOutput,
+          totalTokens: totalInput + totalOutput,
+          totalCost
+        }
+      });
+    } catch (e) {
+      (_e = (_d = this.app.log) == null ? void 0 : _d.warn) == null ? void 0 : _e.call(_d, "[TokenTracker] Failed to accumulate run totals", e);
+    }
+  }
+  /**
+   * Check if a run has exceeded its budget limits.
+   */
+  async checkBudget(runId) {
+    var _a, _b, _c, _d, _e, _f;
+    try {
+      const repo = this.db.getRepository("agentLoopRuns");
+      if (!repo) return { allowed: true };
+      const run = await repo.findOne({ filter: { id: runId } });
+      if (!run) return { allowed: true };
+      const budgetMaxTokens = Number(((_a = run.get) == null ? void 0 : _a.call(run, "budgetMaxTokens")) ?? 0);
+      const budgetMaxCost = Number(((_b = run.get) == null ? void 0 : _b.call(run, "budgetMaxCost")) ?? 0);
+      if (budgetMaxTokens <= 0 && budgetMaxCost <= 0) return { allowed: true };
+      const totalTokens = Number(((_c = run.get) == null ? void 0 : _c.call(run, "totalTokens")) || 0);
+      const totalCost = Number(((_d = run.get) == null ? void 0 : _d.call(run, "totalCost")) || 0);
+      if (budgetMaxTokens > 0 && totalTokens >= budgetMaxTokens) {
+        return {
+          allowed: false,
+          reason: `Budget exceeded: ${totalTokens}/${budgetMaxTokens} tokens used. Maximum allowed tokens for this run: ${budgetMaxTokens}.`
+        };
+      }
+      if (budgetMaxCost > 0 && totalCost >= budgetMaxCost) {
+        return {
+          allowed: false,
+          reason: `Budget exceeded: $${totalCost.toFixed(4)}/$${budgetMaxCost.toFixed(
+            4
+          )} spent. Maximum allowed cost for this run: $${budgetMaxCost}.`
+        };
+      }
+      return { allowed: true };
+    } catch (e) {
+      (_f = (_e = this.app.log) == null ? void 0 : _e.warn) == null ? void 0 : _f.call(_e, "[TokenTracker] Budget check failed, allowing", e);
+      return { allowed: true };
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TokenTracker,
+  extractTokenUsage
+});

package/dist/server/tools/agent-loop.d.ts

@@ -56,10 +56,10 @@ export declare function createAgentLoopTools(plugin: any, service: AgentLoopServ
                 description?: string;
                 metadata?: any;
                 input?: any;
+                id?: string;
                 planKey?: string;
                 target?: string;
                 dependsOn?: string[];
-                id?: string;
                 parentStepId?: string | number;
                 maxAttempts?: number;
             }, {
@@ -69,10 +69,10 @@ export declare function createAgentLoopTools(plugin: any, service: AgentLoopServ
                 description?: string;
                 metadata?: any;
                 input?: any;
+                id?: string;
                 planKey?: string;
                 target?: string;
                 dependsOn?: string[];
-                id?: string;
                 parentStepId?: string | number;
                 maxAttempts?: number;
             }>, "many">>;
@@ -96,10 +96,10 @@ export declare function createAgentLoopTools(plugin: any, service: AgentLoopServ
                 description?: string;
                 metadata?: any;
                 input?: any;
+                id?: string;
                 planKey?: string;
                 target?: string;
                 dependsOn?: string[];
-                id?: string;
                 parentStepId?: string | number;
                 maxAttempts?: number;
             }[];
@@ -123,10 +123,10 @@ export declare function createAgentLoopTools(plugin: any, service: AgentLoopServ
                 description?: string;
                 metadata?: any;
                 input?: any;
+                id?: string;
                 planKey?: string;
                 target?: string;
                 dependsOn?: string[];
-                id?: string;
                 parentStepId?: string | number;
                 maxAttempts?: number;
             }[];
@@ -181,20 +181,20 @@ export declare function createAgentLoopTools(plugin: any, service: AgentLoopServ
             metadata: z.ZodOptional<z.ZodAny>;
         }, "strip", z.ZodTypeAny, {
             error?: string;
-            status?: "running" | "succeeded" | "failed" | "skipped";
+            status?: "succeeded" | "failed" | "running" | "skipped";
+            reason?: string;
             metadata?: any;
             output?: any;
             skillExecutionId?: string | number;
-            reason?: string;
             stepId?: string | number;
             agentExecutionSpanId?: string | number;
         }, {
             error?: string;
-            status?: "running" | "succeeded" | "failed" | "skipped";
+            status?: "succeeded" | "failed" | "running" | "skipped";
+            reason?: string;
             metadata?: any;
             output?: any;
             skillExecutionId?: string | number;
-            reason?: string;
             stepId?: string | number;
             agentExecutionSpanId?: string | number;
         }>;