plugin-agent-orchestrator 1.0.28 → 1.0.32

package/dist/server/services/AgentMemoryContextService.js

@@ -0,0 +1,216 @@
+/**
+ * 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 AgentMemoryContextService_exports = {};
+__export(AgentMemoryContextService_exports, {
+  AgentMemoryContextService: () => AgentMemoryContextService
+});
+module.exports = __toCommonJS(AgentMemoryContextService_exports);
+var import_ctx_utils = require("../utils/ctx-utils");
+const DEFAULT_MEMORY_SCOPES = ["public", "user", "agent_user"];
+const DEFAULT_MAX_CONTEXT_CHARS = 6e3;
+function readModelValue(record, key) {
+  const model = record;
+  return typeof (model == null ? void 0 : model.get) === "function" ? model.get(key) : model == null ? void 0 : model[key];
+}
+function normalizeScopes(value) {
+  if (!Array.isArray(value)) return DEFAULT_MEMORY_SCOPES;
+  const scopes = value.filter(
+    (item) => item === "public" || item === "user" || item === "agent_user"
+  );
+  return scopes.length ? scopes : DEFAULT_MEMORY_SCOPES;
+}
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function formatRecordSection(record) {
+  const content = normalizeText(record.contentMd);
+  const graph = normalizeText(record.graphMd);
+  return [content, graph ? `## Graph
+${graph}` : ""].filter(Boolean).join("\n\n").trim();
+}
+class AgentMemoryContextService {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  async resolvePolicySettings(task) {
+    var _a, _b, _c;
+    const directSettings = (0, import_ctx_utils.asObject)(task == null ? void 0 : task.skillSettings);
+    const employeeSettings = (0, import_ctx_utils.asObject)(readModelValue(task == null ? void 0 : task.employee, "skillSettings"));
+    const values = (0, import_ctx_utils.asObject)((_c = (_b = (_a = task == null ? void 0 : task.ctx) == null ? void 0 : _a.action) == null ? void 0 : _b.params) == null ? void 0 : _c.values);
+    const tag = normalizeText(values.harnessTag) || normalizeText(values.orchestratorHarnessTag) || normalizeText(directSettings.harnessTag) || normalizeText(directSettings.orchestratorHarnessTag) || normalizeText(employeeSettings.harnessTag) || normalizeText(employeeSettings.orchestratorHarnessTag) || "default";
+    const profile = await this.findHarnessProfile(tag);
+    const fallbackProfile = profile || (tag === "default" ? null : await this.findHarnessProfile("default"));
+    const profileSettings = (0, import_ctx_utils.asObject)(fallbackProfile ? readModelValue(fallbackProfile, "settings") : {});
+    return {
+      ...profileSettings,
+      harnessTag: tag
+    };
+  }
+  async buildContext(options) {
+    const { userId, aiEmployeeUsername } = options;
+    const settings = options.settings || {};
+    if (!userId || settings.memoryInjectionEnabled === false) {
+      return {
+        context: "",
+        appliedScopes: [],
+        chars: 0
+      };
+    }
+    const sections = [];
+    const scopes = normalizeScopes(settings.memoryScopes);
+    if (scopes.includes("public")) {
+      sections.push(...await this.loadStoredSections("public", userId, aiEmployeeUsername));
+    }
+    if (scopes.includes("user")) {
+      const userMemory = await this.loadUserMemory(userId);
+      if (userMemory) {
+        sections.push({
+          scope: "user-memory",
+          title: "User Memory",
+          body: userMemory
+        });
+      }
+      sections.push(...await this.loadStoredSections("user", userId, aiEmployeeUsername));
+    }
+    if (scopes.includes("agent_user")) {
+      sections.push(...await this.loadStoredSections("agent_user", userId, aiEmployeeUsername));
+    }
+    if (!sections.length) {
+      return {
+        context: "",
+        appliedScopes: [],
+        chars: 0
+      };
+    }
+    const body = sections.map((section) => `### ${section.title}
+${section.body}`).join("\n\n").trim();
+    const maxChars = Number(settings.maxMemoryContextChars || settings.maxContextChars || DEFAULT_MAX_CONTEXT_CHARS);
+    const context = `<agent_memory_context>
+${(0, import_ctx_utils.trimText)(
+      body,
+      Number.isFinite(maxChars) ? maxChars : DEFAULT_MAX_CONTEXT_CHARS
+    )}
+</agent_memory_context>`;
+    return {
+      context,
+      appliedScopes: Array.from(new Set(sections.map((section) => section.scope))),
+      chars: context.length
+    };
+  }
+  async findHarnessProfile(tag) {
+    var _a, _b;
+    try {
+      const repo = this.plugin.db.getRepository("agentHarnessProfiles");
+      if (!repo) return null;
+      return repo.findOne({
+        filter: {
+          tag,
+          enabled: true
+        }
+      });
+    } catch (error) {
+      (_b = (_a = this.plugin.app.logger) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "[AgentOrchestrator] Failed to load policy profile", error);
+      return null;
+    }
+  }
+  async loadStoredSections(scope, userId, aiEmployeeUsername) {
+    var _a, _b;
+    try {
+      const repo = this.plugin.db.getRepository("agentMemoryContexts");
+      if (!repo) return [];
+      const filter = {
+        scope,
+        enabled: true
+      };
+      if (scope === "public") {
+        filter.userId = null;
+      } else if (userId) {
+        filter.userId = userId;
+      }
+      const records = await repo.find({
+        filter,
+        sort: ["scope", "aiEmployeeUsername", "updatedAt"]
+      });
+      return records.map((record) => (0, import_ctx_utils.toPlain)(record)).filter((record) => {
+        if (scope === "agent_user") {
+          return String(record.userId || "") === String(userId || "") && normalizeText(record.aiEmployeeUsername) === normalizeText(aiEmployeeUsername);
+        }
+        const username = normalizeText(record.aiEmployeeUsername);
+        return !username || username === normalizeText(aiEmployeeUsername);
+      }).map((record) => ({
+        scope,
+        title: this.sectionTitle(scope, record.aiEmployeeUsername),
+        body: formatRecordSection(record)
+      })).filter((section) => section.body);
+    } catch (error) {
+      (_b = (_a = this.plugin.app.logger) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, `[AgentOrchestrator] Failed to load ${scope} memory context`, error);
+      return [];
+    }
+  }
+  async loadUserMemory(userId) {
+    var _a, _b, _c, _d, _e;
+    try {
+      const pluginManager = this.plugin.app.pm;
+      const candidates = ["plugin-user-memory", "@nocobase/plugin-user-memory", "user-memory"];
+      let userMemoryPlugin = null;
+      for (const name of candidates) {
+        try {
+          const candidate = (_a = pluginManager == null ? void 0 : pluginManager.get) == null ? void 0 : _a.call(pluginManager, name);
+          if ((_b = candidate == null ? void 0 : candidate.memoryInjector) == null ? void 0 : _b.getMemoryPromptSection) {
+            userMemoryPlugin = candidate;
+            break;
+          }
+        } catch {
+        }
+      }
+      if (!userMemoryPlugin && typeof (pluginManager == null ? void 0 : pluginManager.getPlugins) === "function") {
+        for (const [, candidate] of pluginManager.getPlugins()) {
+          if ((_c = candidate == null ? void 0 : candidate.memoryInjector) == null ? void 0 : _c.getMemoryPromptSection) {
+            userMemoryPlugin = candidate;
+            break;
+          }
+        }
+      }
+      const injector = userMemoryPlugin == null ? void 0 : userMemoryPlugin.memoryInjector;
+      if (!(injector == null ? void 0 : injector.getMemoryPromptSection)) return "";
+      return normalizeText(await injector.getMemoryPromptSection(Number(userId)));
+    } catch (error) {
+      (_e = (_d = this.plugin.app.logger) == null ? void 0 : _d.warn) == null ? void 0 : _e.call(_d, "[AgentOrchestrator] Failed to read plugin-user-memory context", error);
+      return "";
+    }
+  }
+  sectionTitle(scope, aiEmployeeUsername) {
+    const suffix = aiEmployeeUsername ? ` (${aiEmployeeUsername})` : "";
+    if (scope === "public") return `Public Agent Knowledge${suffix}`;
+    if (scope === "user") return `User Context${suffix}`;
+    return `Private Agent/User Context${suffix}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentMemoryContextService
+});

package/dist/server/services/ExecutionSpanService.js

@@ -52,7 +52,7 @@ class ExecutionSpanService {
       });
       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);
+      (_b = (_a = this.plugin.app.logger) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "[AgentOrchestrator] Failed to create execution span", error);
       return null;
     }
   }
@@ -71,7 +71,7 @@ class ExecutionSpanService {
       });
       return { id: spanId };
     } catch (error) {
-      (_b = (_a = this.plugin.app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, `[AgentOrchestrator] Failed to update execution span ${spanId}`, error);
+      (_b = (_a = this.plugin.app.logger) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, `[AgentOrchestrator] Failed to update execution span ${spanId}`, error);
       return null;
     }
   }

package/dist/server/services/NativeSubAgentObserver.js

@@ -0,0 +1,413 @@
+/**
+ * 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 NativeSubAgentObserver_exports = {};
+__export(NativeSubAgentObserver_exports, {
+  NATIVE_SOURCE: () => NATIVE_SOURCE,
+  NativeSubAgentObserver: () => NativeSubAgentObserver,
+  makeNativeRunId: () => makeNativeRunId
+});
+module.exports = __toCommonJS(NativeSubAgentObserver_exports);
+var import_crypto = require("crypto");
+var import_ExecutionSpanService = require("./ExecutionSpanService");
+var import_AgentMemoryContextService = require("./AgentMemoryContextService");
+var import_ctx_utils = require("../utils/ctx-utils");
+const WRAP_STATE_KEY = Symbol.for("plugin-agent-orchestrator.nativeSubAgentObserver");
+const NATIVE_SOURCE = "native-plugin-ai";
+function readValue(record, key) {
+  const model = record;
+  return typeof (model == null ? void 0 : model.get) === "function" ? model.get(key) : model == null ? void 0 : model[key];
+}
+function normalizeString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function modelUsername(model) {
+  return normalizeString(readValue(model, "username")) || normalizeString(readValue(model, "aiEmployeeUsername")) || normalizeString(readValue(model, "name")) || void 0;
+}
+function makeNativeRunId(parts) {
+  const source = parts.map((part) => String(part || "")).join("|");
+  return `native_${(0, import_crypto.createHash)("sha1").update(source || String(Date.now())).digest("hex").slice(0, 24)}`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error || "Unknown error");
+}
+function chunkBody(chunk) {
+  return (0, import_ctx_utils.asObject)(chunk.body);
+}
+function chunkCurrentConversation(chunk) {
+  return (0, import_ctx_utils.asObject)(chunk.currentConversation);
+}
+class NativeSubAgentObserver {
+  constructor(plugin) {
+    this.plugin = plugin;
+    this.spanService = new import_ExecutionSpanService.ExecutionSpanService(plugin);
+    this.memoryService = new import_AgentMemoryContextService.AgentMemoryContextService(plugin);
+  }
+  spanService;
+  memoryService;
+  install() {
+    var _a, _b, _c, _d, _e, _f;
+    const aiPlugin = (_b = (_a = this.plugin.app.pm) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, "ai");
+    const dispatcher = aiPlugin == null ? void 0 : aiPlugin.subAgentsDispatcher;
+    if (!(dispatcher == null ? void 0 : dispatcher.run)) {
+      (_d = (_c = this.plugin.app.logger) == null ? void 0 : _c.warn) == null ? void 0 : _d.call(
+        _c,
+        "[AgentOrchestrator] plugin-ai subAgentsDispatcher not available; observer skipped."
+      );
+      return false;
+    }
+    const existing = dispatcher[WRAP_STATE_KEY];
+    if ((existing == null ? void 0 : existing.wrappedRun) === dispatcher.run) {
+      return false;
+    }
+    const originalRun = (existing == null ? void 0 : existing.originalRun) || dispatcher.run.bind(dispatcher);
+    const observer = this;
+    const wrappedRun = async function wrappedNativeSubAgentRun(task) {
+      return observer.runObserved(originalRun, task);
+    };
+    dispatcher.run = wrappedRun;
+    dispatcher[WRAP_STATE_KEY] = {
+      originalRun,
+      wrappedRun
+    };
+    (_f = (_e = this.plugin.app.logger) == null ? void 0 : _e.info) == null ? void 0 : _f.call(_e, "[AgentOrchestrator] Native plugin-ai sub-agent observer installed.");
+    return true;
+  }
+  uninstall() {
+    var _a, _b, _c, _d;
+    const aiPlugin = (_b = (_a = this.plugin.app.pm) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, "ai");
+    const dispatcher = aiPlugin == null ? void 0 : aiPlugin.subAgentsDispatcher;
+    const existing = dispatcher == null ? void 0 : dispatcher[WRAP_STATE_KEY];
+    if (!(dispatcher == null ? void 0 : dispatcher.run) || !existing || existing.wrappedRun !== dispatcher.run) {
+      return false;
+    }
+    dispatcher.run = existing.originalRun;
+    delete dispatcher[WRAP_STATE_KEY];
+    (_d = (_c = this.plugin.app.logger) == null ? void 0 : _c.info) == null ? void 0 : _d.call(_c, "[AgentOrchestrator] Native plugin-ai sub-agent observer uninstalled.");
+    return true;
+  }
+  async runObserved(originalRun, task) {
+    var _a, _b, _c;
+    const settings = await this.safeResolvePolicy(task);
+    if (settings.nativeObserverEnabled === false) {
+      return originalRun(task);
+    }
+    const parentSessionId = this.resolveParentSessionId(task) || void 0;
+    const subSessionId = normalizeString(task.sessionId) || void 0;
+    const employeeUsername = modelUsername(task.employee);
+    const userId = (0, import_ctx_utils.currentUserId)(task.ctx) || ((_c = (_b = (_a = task.ctx) == null ? void 0 : _a.auth) == null ? void 0 : _b.user) == null ? void 0 : _c.id);
+    const dispatchToolMessage = await this.resolveDispatchToolMessage(task.ctx, parentSessionId, subSessionId);
+    const toolCallId = dispatchToolMessage == null ? void 0 : dispatchToolMessage.toolCallId;
+    const leaderUsername = await this.resolveLeaderUsername(task.ctx, parentSessionId);
+    const rootRunId = makeNativeRunId([parentSessionId, subSessionId, toolCallId, employeeUsername]);
+    const memory = await this.safeBuildMemoryContext({
+      userId,
+      aiEmployeeUsername: employeeUsername,
+      settings
+    });
+    const observedTask = memory.context ? {
+      ...task,
+      question: `${task.question}
+
+${memory.context}`
+    } : task;
+    const state = {
+      rootRunId,
+      rootStartedAt: Date.now(),
+      rootMetadata: {
+        source: NATIVE_SOURCE,
+        parentSessionId,
+        subSessionId,
+        toolCallId,
+        dispatchToolMessageId: dispatchToolMessage == null ? void 0 : dispatchToolMessage.id,
+        dispatchMessageId: dispatchToolMessage == null ? void 0 : dispatchToolMessage.messageId,
+        memoryContextApplied: Boolean(memory.context),
+        memoryScopes: memory.appliedScopes,
+        memoryContextChars: memory.chars,
+        harnessTag: settings.harnessTag || "default"
+      },
+      parentSessionId,
+      subSessionId,
+      toolCallId,
+      leaderUsername,
+      employeeUsername,
+      userId,
+      toolSpans: /* @__PURE__ */ new Map(),
+      pending: /* @__PURE__ */ new Set()
+    };
+    await this.safeCreateRootSpan(state, task.question);
+    const originalWriter = task.writer;
+    observedTask.writer = (chunk) => {
+      const pending = this.handleWriterChunk(state, chunk).catch((error) => {
+        var _a2, _b2;
+        (_b2 = (_a2 = this.plugin.app.logger) == null ? void 0 : _a2.warn) == null ? void 0 : _b2.call(_a2, "[AgentOrchestrator] Native writer observer failed", error);
+      });
+      state.pending.add(pending);
+      return originalWriter == null ? void 0 : originalWriter(chunk);
+    };
+    try {
+      const result = await originalRun(observedTask);
+      await this.flushPending(state);
+      await this.spanService.finish(state.rootSpanId, "success", state.rootStartedAt, {
+        output: (0, import_ctx_utils.trimText)(result, 2e4),
+        metadata: {
+          ...state.rootMetadata,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      return result;
+    } catch (error) {
+      await this.flushPending(state);
+      await this.spanService.finish(state.rootSpanId, "error", state.rootStartedAt, {
+        error: (0, import_ctx_utils.trimText)(errorMessage(error), 1e4),
+        metadata: {
+          ...state.rootMetadata,
+          failedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      throw error;
+    }
+  }
+  async safeResolvePolicy(task) {
+    var _a, _b;
+    try {
+      return await this.memoryService.resolvePolicySettings(task);
+    } catch (error) {
+      (_b = (_a = this.plugin.app.logger) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "[AgentOrchestrator] Failed to resolve native observer policy", error);
+      return { harnessTag: "default" };
+    }
+  }
+  async safeBuildMemoryContext(options) {
+    var _a, _b;
+    try {
+      return await this.memoryService.buildContext(options);
+    } catch (error) {
+      (_b = (_a = this.plugin.app.logger) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "[AgentOrchestrator] Failed to build agent memory context", error);
+      return { context: "", appliedScopes: [], chars: 0 };
+    }
+  }
+  async safeCreateRootSpan(state, question) {
+    const span = await this.spanService.create({
+      rootRunId: state.rootRunId,
+      parentSpanId: void 0,
+      source: NATIVE_SOURCE,
+      parentSessionId: state.parentSessionId,
+      subSessionId: state.subSessionId,
+      toolCallId: state.toolCallId,
+      type: "sub_agent",
+      status: "running",
+      leaderUsername: state.leaderUsername,
+      employeeUsername: state.employeeUsername,
+      toolName: "dispatch-sub-agent-task",
+      title: `${state.leaderUsername || "main"} -> ${state.employeeUsername || "sub-agent"}`,
+      input: {
+        question,
+        parentSessionId: state.parentSessionId,
+        subSessionId: state.subSessionId
+      },
+      metadata: state.rootMetadata,
+      userId: state.userId
+    });
+    state.rootSpanId = span == null ? void 0 : span.id;
+  }
+  async handleWriterChunk(state, chunk) {
+    const action = chunk.action;
+    if (action === "beforeToolCall") {
+      await this.handleBeforeToolCall(state, chunk);
+      return;
+    }
+    if (action === "afterToolCall") {
+      await this.handleAfterToolCall(state, chunk, false);
+      return;
+    }
+    if (action === "afterToolCallError") {
+      await this.handleAfterToolCall(state, chunk, true);
+      return;
+    }
+    if (action === "afterSubAgentInvoke") {
+      state.rootMetadata = {
+        ...state.rootMetadata,
+        afterSubAgentInvokeAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.spanService.update(state.rootSpanId, { metadata: state.rootMetadata });
+    }
+  }
+  async handleBeforeToolCall(state, chunk) {
+    const body = chunkBody(chunk);
+    const toolCall = (0, import_ctx_utils.asObject)(body.toolCall);
+    const toolCallId = normalizeString(toolCall.id);
+    if (!toolCallId || state.toolSpans.has(toolCallId)) return;
+    const conversation = chunkCurrentConversation(chunk);
+    const startedAt = Date.now();
+    const toolSpan = {
+      startedAt,
+      ready: Promise.resolve()
+    };
+    state.toolSpans.set(toolCallId, toolSpan);
+    toolSpan.ready = this.spanService.create({
+      rootRunId: state.rootRunId,
+      parentSpanId: state.rootSpanId ? String(state.rootSpanId) : void 0,
+      source: NATIVE_SOURCE,
+      parentSessionId: state.parentSessionId || void 0,
+      subSessionId: normalizeString(conversation.sessionId) || state.subSessionId || void 0,
+      toolCallId,
+      type: normalizeString(toolCall.name) === "dispatch-sub-agent-task" ? "dispatch" : "tool",
+      status: "running",
+      leaderUsername: state.leaderUsername,
+      employeeUsername: normalizeString(conversation.username) || state.employeeUsername,
+      toolName: normalizeString(toolCall.name),
+      title: normalizeString(toolCall.name) || "tool call",
+      input: (0, import_ctx_utils.asObject)(toolCall.args),
+      metadata: {
+        source: NATIVE_SOURCE,
+        currentConversation: conversation,
+        messageId: toolCall.messageId
+      },
+      userId: state.userId
+    }).then((span) => {
+      toolSpan.spanId = span == null ? void 0 : span.id;
+    });
+    await toolSpan.ready;
+  }
+  async handleAfterToolCall(state, chunk, forceError) {
+    const body = chunkBody(chunk);
+    const toolCall = (0, import_ctx_utils.asObject)(body.toolCall);
+    const toolCallId = normalizeString(toolCall.id);
+    const existing = toolCallId ? state.toolSpans.get(toolCallId) : void 0;
+    if (!existing) return;
+    await existing.ready;
+    const result = (0, import_ctx_utils.asObject)((0, import_ctx_utils.toPlain)(body.toolCallResult));
+    const error = body.error;
+    const status = forceError || result.status === "error" ? "error" : "success";
+    const output = result.content ?? result.result ?? result;
+    const invokeStart = Number(result.invokeStartTime);
+    const invokeEnd = Number(result.invokeEndTime);
+    const durationMs = Number.isFinite(invokeStart) && Number.isFinite(invokeEnd) && invokeEnd >= invokeStart ? invokeEnd - invokeStart : Date.now() - existing.startedAt;
+    await this.spanService.update(existing.spanId, {
+      status,
+      endedAt: /* @__PURE__ */ new Date(),
+      durationMs,
+      output: forceError ? void 0 : (0, import_ctx_utils.trimText)(output, 2e4),
+      error: forceError ? (0, import_ctx_utils.trimText)(errorMessage(error), 1e4) : void 0,
+      metadata: {
+        source: NATIVE_SOURCE,
+        toolCallResultStatus: result.status,
+        invokeStatus: result.invokeStatus,
+        messageId: toolCall.messageId
+      }
+    });
+  }
+  resolveParentSessionId(task) {
+    var _a, _b, _c;
+    const values = ((_c = (_b = (_a = task.ctx) == null ? void 0 : _a.action) == null ? void 0 : _b.params) == null ? void 0 : _c.values) || {};
+    return normalizeString(values.sessionId) || void 0;
+  }
+  async resolveLeaderUsername(ctx, parentSessionId) {
+    var _a, _b, _c, _d, _e;
+    const values = ((_b = (_a = ctx == null ? void 0 : ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) || {};
+    const direct = normalizeString(values.aiEmployeeUsername) || normalizeString((0, import_ctx_utils.asObject)(values.aiEmployee).username);
+    if (direct) return direct;
+    if (!parentSessionId) return void 0;
+    try {
+      const repo = (_d = (_c = ctx.db) == null ? void 0 : _c.getRepository) == null ? void 0 : _d.call(_c, "aiConversations");
+      const conversation = await ((_e = repo == null ? void 0 : repo.findOne) == null ? void 0 : _e.call(repo, {
+        filter: { sessionId: parentSessionId }
+      }));
+      return normalizeString(readValue(conversation, "aiEmployeeUsername")) || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async resolveDispatchToolMessage(ctx, parentSessionId, subSessionId) {
+    var _a, _b, _c;
+    if (!parentSessionId) return null;
+    try {
+      const fromMetadata = await this.resolveDispatchToolMessageFromMetadata(ctx, parentSessionId, subSessionId);
+      if (fromMetadata) {
+        return fromMetadata;
+      }
+      const repo = (_b = (_a = ctx.db) == null ? void 0 : _a.getRepository) == null ? void 0 : _b.call(_a, "aiToolMessages");
+      const record = await ((_c = repo == null ? void 0 : repo.findOne) == null ? void 0 : _c.call(repo, {
+        filter: {
+          sessionId: parentSessionId,
+          toolName: "dispatch-sub-agent-task",
+          invokeStatus: {
+            $ne: "confirmed"
+          }
+        },
+        sort: ["-id"]
+      }));
+      return (0, import_ctx_utils.toPlain)(record);
+    } catch {
+      return null;
+    }
+  }
+  async resolveDispatchToolMessageFromMetadata(ctx, parentSessionId, subSessionId) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!parentSessionId || !subSessionId) return null;
+    const messageRepo = (_b = (_a = ctx.db) == null ? void 0 : _a.getRepository) == null ? void 0 : _b.call(_a, "aiMessages");
+    const toolRepo = (_d = (_c = ctx.db) == null ? void 0 : _c.getRepository) == null ? void 0 : _d.call(_c, "aiToolMessages");
+    const messages = await ((_e = messageRepo == null ? void 0 : messageRepo.find) == null ? void 0 : _e.call(messageRepo, {
+      filter: { sessionId: parentSessionId },
+      sort: ["-messageId"],
+      limit: 20
+    }));
+    if (!Array.isArray(messages)) return null;
+    for (const rawMessage of messages) {
+      const message = (0, import_ctx_utils.toPlain)(rawMessage);
+      const conversations = (0, import_ctx_utils.asObject)(message == null ? void 0 : message.metadata).subAgentConversations;
+      if (!Array.isArray(conversations)) continue;
+      const matched = conversations.find((item) => normalizeString(item == null ? void 0 : item.sessionId) === subSessionId);
+      const toolCallId = normalizeString(matched == null ? void 0 : matched.toolCallId);
+      if (!toolCallId) continue;
+      const toolMessage = await ((_f = toolRepo == null ? void 0 : toolRepo.findOne) == null ? void 0 : _f.call(toolRepo, {
+        filter: {
+          sessionId: parentSessionId,
+          toolCallId
+        }
+      }));
+      return {
+        ...(0, import_ctx_utils.toPlain)(toolMessage) || {},
+        toolCallId,
+        messageId: readValue(toolMessage, "messageId") || (message == null ? void 0 : message.messageId),
+        sessionId: parentSessionId,
+        status: matched == null ? void 0 : matched.status
+      };
+    }
+    return null;
+  }
+  async flushPending(state) {
+    const pending = Array.from(state.pending);
+    if (!pending.length) return;
+    await Promise.allSettled(pending);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NATIVE_SOURCE,
+  NativeSubAgentObserver,
+  makeNativeRunId
+});