plugin-agent-orchestrator 1.0.28 → 1.0.32

package/src/server/services/AgentMemoryContextService.ts

@@ -0,0 +1,256 @@
+import { asObject, toPlain, trimText } from '../utils/ctx-utils';
+
+type MemoryScope = 'public' | 'user' | 'agent_user';
+
+type PolicySettings = {
+  nativeObserverEnabled?: boolean;
+  memoryInjectionEnabled?: boolean;
+  memoryScopes?: string[];
+  maxMemoryContextChars?: number;
+  maxContextChars?: number;
+  harnessTag?: string;
+};
+
+type ContextRecord = {
+  scope?: string;
+  userId?: string | number | null;
+  aiEmployeeUsername?: string | null;
+  contentMd?: string | null;
+  graphMd?: string | null;
+  enabled?: boolean;
+};
+
+type BuildContextOptions = {
+  userId?: string | number;
+  aiEmployeeUsername?: string;
+  settings?: PolicySettings;
+};
+
+type ContextSection = {
+  scope: string;
+  title: string;
+  body: string;
+};
+
+const DEFAULT_MEMORY_SCOPES: MemoryScope[] = ['public', 'user', 'agent_user'];
+const DEFAULT_MAX_CONTEXT_CHARS = 6000;
+
+function readModelValue(record: unknown, key: string) {
+  const model = record as { get?: (name: string) => unknown; [key: string]: unknown };
+  return typeof model?.get === 'function' ? model.get(key) : model?.[key];
+}
+
+function normalizeScopes(value: unknown): MemoryScope[] {
+  if (!Array.isArray(value)) return DEFAULT_MEMORY_SCOPES;
+  const scopes = value.filter(
+    (item): item is MemoryScope => item === 'public' || item === 'user' || item === 'agent_user',
+  );
+  return scopes.length ? scopes : DEFAULT_MEMORY_SCOPES;
+}
+
+function normalizeText(value: unknown) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function formatRecordSection(record: ContextRecord) {
+  const content = normalizeText(record.contentMd);
+  const graph = normalizeText(record.graphMd);
+  return [content, graph ? `## Graph\n${graph}` : ''].filter(Boolean).join('\n\n').trim();
+}
+
+export class AgentMemoryContextService {
+  constructor(private readonly plugin: { app: any; db: any }) {}
+
+  async resolvePolicySettings(task?: {
+    ctx?: unknown;
+    employee?: unknown;
+    skillSettings?: unknown;
+  }): Promise<PolicySettings> {
+    const directSettings = asObject(task?.skillSettings);
+    const employeeSettings = asObject(readModelValue(task?.employee, 'skillSettings'));
+    const values = asObject((task?.ctx as { action?: { params?: { values?: unknown } } })?.action?.params?.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 = asObject(fallbackProfile ? readModelValue(fallbackProfile, 'settings') : {});
+
+    return {
+      ...profileSettings,
+      harnessTag: tag,
+    };
+  }
+
+  async buildContext(options: BuildContextOptions) {
+    const { userId, aiEmployeeUsername } = options;
+    const settings = options.settings || {};
+    if (!userId || settings.memoryInjectionEnabled === false) {
+      return {
+        context: '',
+        appliedScopes: [] as string[],
+        chars: 0,
+      };
+    }
+
+    const sections: ContextSection[] = [];
+    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: [] as string[],
+        chars: 0,
+      };
+    }
+
+    const body = sections
+      .map((section) => `### ${section.title}\n${section.body}`)
+      .join('\n\n')
+      .trim();
+    const maxChars = Number(settings.maxMemoryContextChars || settings.maxContextChars || DEFAULT_MAX_CONTEXT_CHARS);
+    const context = `<agent_memory_context>\n${trimText(
+      body,
+      Number.isFinite(maxChars) ? maxChars : DEFAULT_MAX_CONTEXT_CHARS,
+    )}\n</agent_memory_context>`;
+
+    return {
+      context,
+      appliedScopes: Array.from(new Set(sections.map((section) => section.scope))),
+      chars: context.length,
+    };
+  }
+
+  private async findHarnessProfile(tag: string) {
+    try {
+      const repo = this.plugin.db.getRepository('agentHarnessProfiles');
+      if (!repo) return null;
+      return repo.findOne({
+        filter: {
+          tag,
+          enabled: true,
+        },
+      });
+    } catch (error) {
+      this.plugin.app.logger?.warn?.('[AgentOrchestrator] Failed to load policy profile', error);
+      return null;
+    }
+  }
+
+  private async loadStoredSections(scope: MemoryScope, userId?: string | number, aiEmployeeUsername?: string) {
+    try {
+      const repo = this.plugin.db.getRepository('agentMemoryContexts');
+      if (!repo) return [];
+
+      const filter: Record<string, unknown> = {
+        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: unknown) => toPlain(record) as ContextRecord)
+        .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) {
+      this.plugin.app.logger?.warn?.(`[AgentOrchestrator] Failed to load ${scope} memory context`, error);
+      return [];
+    }
+  }
+
+  private async loadUserMemory(userId: string | number) {
+    try {
+      const pluginManager = this.plugin.app.pm;
+      const candidates = ['plugin-user-memory', '@nocobase/plugin-user-memory', 'user-memory'];
+      let userMemoryPlugin: {
+        memoryInjector?: { getMemoryPromptSection?: (userId: number) => Promise<string> };
+      } | null = null;
+
+      for (const name of candidates) {
+        try {
+          const candidate = pluginManager?.get?.(name);
+          if (candidate?.memoryInjector?.getMemoryPromptSection) {
+            userMemoryPlugin = candidate;
+            break;
+          }
+        } catch {
+          // Missing plugin aliases are expected in installations without user memory.
+        }
+      }
+
+      if (!userMemoryPlugin && typeof pluginManager?.getPlugins === 'function') {
+        for (const [, candidate] of pluginManager.getPlugins()) {
+          if (candidate?.memoryInjector?.getMemoryPromptSection) {
+            userMemoryPlugin = candidate;
+            break;
+          }
+        }
+      }
+
+      const injector = userMemoryPlugin?.memoryInjector;
+      if (!injector?.getMemoryPromptSection) return '';
+      return normalizeText(await injector.getMemoryPromptSection(Number(userId)));
+    } catch (error) {
+      this.plugin.app.logger?.warn?.('[AgentOrchestrator] Failed to read plugin-user-memory context', error);
+      return '';
+    }
+  }
+
+  private sectionTitle(scope: MemoryScope, aiEmployeeUsername?: string | null) {
+    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}`;
+  }
+}

package/src/server/services/AgentPlanValidator.ts

@@ -1,73 +1,73 @@
-import { AgentLoopPlanStepInput } from './AgentLoopService';
-
-function normalizeStepType(value: any) {
-  return ['reasoning', 'skill', 'tool', 'sub_agent', 'verification'].includes(value) ? value : 'tool';
-}
-
-function normalizePlanKey(step: any, index: number) {
-  return String(step.planKey || step.key || step.id || `step_${index + 1}`);
-}
-
-function asArray(value: any): any[] {
-  return Array.isArray(value) ? value : [];
-}
-
-const ORCHESTRATOR_CONTROLLER_MAX_STEPS = 100;
-
-export class AgentPlanValidator {
-  validate(plan: AgentLoopPlanStepInput[]) {
-    if (!Array.isArray(plan) || plan.length === 0) {
-      throw new Error('Plan must include at least one step.');
-    }
-    if (plan.length > ORCHESTRATOR_CONTROLLER_MAX_STEPS) {
-      throw new Error(`Plan cannot exceed ${ORCHESTRATOR_CONTROLLER_MAX_STEPS} steps.`);
-    }
-
-    const keys = new Set<string>();
-    const graph = new Map<string, string[]>();
-    for (let i = 0; i < plan.length; i++) {
-      const key = normalizePlanKey(plan[i], i).trim();
-      if (!key) {
-        throw new Error(`Plan step ${i + 1} has an empty planKey.`);
-      }
-      if (keys.has(key)) {
-        throw new Error(`Duplicate planKey "${key}" in plan.`);
-      }
-      const type = normalizeStepType(plan[i].type);
-      if (['tool', 'skill', 'sub_agent'].includes(type) && !plan[i].target) {
-        throw new Error(`Step "${key}" of type "${type}" must include a target.`);
-      }
-      keys.add(key);
-      graph.set(key, asArray(plan[i].dependsOn).map(String));
-    }
-
-    for (const [key, dependencies] of graph.entries()) {
-      for (const dependency of dependencies) {
-        if (!keys.has(dependency)) {
-          throw new Error(`Step "${key}" depends on unknown step "${dependency}".`);
-        }
-        if (dependency === key) {
-          throw new Error(`Step "${key}" cannot depend on itself.`);
-        }
-      }
-    }
-
-    const visiting = new Set<string>();
-    const visited = new Set<string>();
-    const visit = (key: string) => {
-      if (visited.has(key)) return;
-      if (visiting.has(key)) {
-        throw new Error(`Plan has a dependency cycle at "${key}".`);
-      }
-      visiting.add(key);
-      for (const dependency of graph.get(key) || []) {
-        visit(dependency);
-      }
-      visiting.delete(key);
-      visited.add(key);
-    };
-    for (const key of graph.keys()) {
-      visit(key);
-    }
-  }
-}
+import { AgentLoopPlanStepInput } from './AgentLoopService';
+
+function normalizeStepType(value: any) {
+  return ['reasoning', 'skill', 'tool', 'sub_agent', 'verification'].includes(value) ? value : 'tool';
+}
+
+function normalizePlanKey(step: any, index: number) {
+  return String(step.planKey || step.key || step.id || `step_${index + 1}`);
+}
+
+function asArray(value: any): any[] {
+  return Array.isArray(value) ? value : [];
+}
+
+const ORCHESTRATOR_CONTROLLER_MAX_STEPS = 100;
+
+export class AgentPlanValidator {
+  validate(plan: AgentLoopPlanStepInput[]) {
+    if (!Array.isArray(plan) || plan.length === 0) {
+      throw new Error('Plan must include at least one step.');
+    }
+    if (plan.length > ORCHESTRATOR_CONTROLLER_MAX_STEPS) {
+      throw new Error(`Plan cannot exceed ${ORCHESTRATOR_CONTROLLER_MAX_STEPS} steps.`);
+    }
+
+    const keys = new Set<string>();
+    const graph = new Map<string, string[]>();
+    for (let i = 0; i < plan.length; i++) {
+      const key = normalizePlanKey(plan[i], i).trim();
+      if (!key) {
+        throw new Error(`Plan step ${i + 1} has an empty planKey.`);
+      }
+      if (keys.has(key)) {
+        throw new Error(`Duplicate planKey "${key}" in plan.`);
+      }
+      const type = normalizeStepType(plan[i].type);
+      if (['tool', 'skill', 'sub_agent'].includes(type) && !plan[i].target) {
+        throw new Error(`Step "${key}" of type "${type}" must include a target.`);
+      }
+      keys.add(key);
+      graph.set(key, asArray(plan[i].dependsOn).map(String));
+    }
+
+    for (const [key, dependencies] of graph.entries()) {
+      for (const dependency of dependencies) {
+        if (!keys.has(dependency)) {
+          throw new Error(`Step "${key}" depends on unknown step "${dependency}".`);
+        }
+        if (dependency === key) {
+          throw new Error(`Step "${key}" cannot depend on itself.`);
+        }
+      }
+    }
+
+    const visiting = new Set<string>();
+    const visited = new Set<string>();
+    const visit = (key: string) => {
+      if (visited.has(key)) return;
+      if (visiting.has(key)) {
+        throw new Error(`Plan has a dependency cycle at "${key}".`);
+      }
+      visiting.add(key);
+      for (const dependency of graph.get(key) || []) {
+        visit(dependency);
+      }
+      visiting.delete(key);
+      visited.add(key);
+    };
+    for (const key of graph.keys()) {
+      visit(key);
+    }
+  }
+}

package/src/server/services/ExecutionSpanService.ts

@@ -17,6 +17,10 @@ export type OrchestratorTraceContext = {
 type SpanValues = {
   rootRunId: string;
   parentSpanId?: string;
+  source?: string;
+  parentSessionId?: string;
+  subSessionId?: string;
+  toolCallId?: string;
   type: string;
   status: string;
   leaderUsername?: string;
@@ -52,7 +56,7 @@ export class ExecutionSpanService {
       });
       return toPlain(record);
     } catch (error) {
-      this.plugin.app.log?.warn?.('[AgentOrchestrator] Failed to create execution span', error);
+      this.plugin.app.logger?.warn?.('[AgentOrchestrator] Failed to create execution span', error);
       return null;
     }
   }
@@ -71,7 +75,7 @@ export class ExecutionSpanService {
       });
       return { id: spanId };
     } catch (error) {
-      this.plugin.app.log?.warn?.(`[AgentOrchestrator] Failed to update execution span ${spanId}`, error);
+      this.plugin.app.logger?.warn?.(`[AgentOrchestrator] Failed to update execution span ${spanId}`, error);
       return null;
     }
   }