plugin-agent-orchestrator 1.0.0

package/dist/client/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(plugin_1).default; } });

package/dist/client/locale/en-US.json

@@ -0,0 +1,20 @@
+{
+  "Agent Orchestrator": "Agent Orchestrator",
+  "Orchestration Rules": "Orchestration Rules",
+  "Swarm Tracing": "Swarm Tracing",
+  "Leader (Orchestrator)": "Leader (Orchestrator)",
+  "Sub-Agent": "Sub-Agent",
+  "Max Delegation Depth": "Max Delegation Depth",
+  "Timeout (ms)": "Timeout (ms)",
+  "Enabled": "Enabled",
+  "New Rule": "New Rule",
+  "Edit Orchestration Rule": "Edit Orchestration Rule",
+  "New Orchestration Rule": "New Orchestration Rule",
+  "Rule created": "Rule created",
+  "Rule updated": "Rule updated",
+  "Rule deleted": "Rule deleted",
+  "Sub-Agent Conversation": "Sub-Agent Conversation",
+  "Task Summary": "Task Summary",
+  "Parent Session": "Parent Session",
+  "No sub-agent executions yet": "No sub-agent executions yet"
+}

package/dist/client/locale/vi-VN.json

@@ -0,0 +1,20 @@
+{
+  "Agent Orchestrator": "Điều phối Agent",
+  "Orchestration Rules": "Quy tắc điều phối",
+  "Swarm Tracing": "Truy vết Swarm",
+  "Leader (Orchestrator)": "Leader (Điều phối viên)",
+  "Sub-Agent": "Agent con",
+  "Max Delegation Depth": "Độ sâu ủy quyền tối đa",
+  "Timeout (ms)": "Thời gian chờ (ms)",
+  "Enabled": "Bật",
+  "New Rule": "Quy tắc mới",
+  "Edit Orchestration Rule": "Sửa quy tắc điều phối",
+  "New Orchestration Rule": "Quy tắc điều phối mới",
+  "Rule created": "Đã tạo quy tắc",
+  "Rule updated": "Đã cập nhật quy tắc",
+  "Rule deleted": "Đã xóa quy tắc",
+  "Sub-Agent Conversation": "Hội thoại Agent con",
+  "Task Summary": "Tóm tắt nhiệm vụ",
+  "Parent Session": "Phiên gốc",
+  "No sub-agent executions yet": "Chưa có lượt thực thi agent con nào"
+}

package/dist/client/plugin.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginAgentOrchestratorClient = void 0;
+const client_1 = require("@nocobase/client");
+const OrchestratorSettings_1 = require("./OrchestratorSettings");
+class PluginAgentOrchestratorClient extends client_1.Plugin {
+    async load() {
+        // Register under the "AI" settings group for consistency with other AI plugins
+        this.app.pluginSettingsManager.add('ai.orchestrator', {
+            title: 'Agent Orchestrator',
+            icon: 'ApartmentOutlined',
+            Component: OrchestratorSettings_1.OrchestratorSettings,
+        });
+    }
+}
+exports.PluginAgentOrchestratorClient = PluginAgentOrchestratorClient;
+exports.default = PluginAgentOrchestratorClient;

package/dist/server/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(plugin_1).default; } });

package/dist/server/plugin.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginAgentOrchestratorServer = void 0;
+const server_1 = require("@nocobase/server");
+const path_1 = __importDefault(require("path"));
+const delegate_task_1 = require("./tools/delegate-task");
+const tracing_1 = require("./resources/tracing");
+class PluginAgentOrchestratorServer extends server_1.Plugin {
+    async afterAdd() { }
+    async beforeLoad() {
+        // Import collection definitions
+        this.db.import({ directory: path_1.default.resolve(__dirname, 'collections') });
+    }
+    async load() {
+        // --- ACL ---
+        this.app.acl.registerSnippet({
+            name: `pm.${this.name}`,
+            actions: ['orchestratorConfig:*'],
+        });
+        // --- Register Dynamic Tools ---
+        // Each configured sub-agent becomes a callable tool for its leader.
+        // Uses createReactAgent (LangGraph public API) instead of private AIEmployee class.
+        // Tools are registered via app.aiManager.toolsManager (public API from @nocobase/ai core).
+        const toolsManager = this.app.aiManager.toolsManager;
+        toolsManager.registerDynamicTools((0, delegate_task_1.createDelegateToolsProvider)(this));
+        // --- Register Tracing Resource (Phase 5) ---
+        // Custom read-only resource for the Swarm Tracing admin page.
+        (0, tracing_1.registerTracingResource)(this);
+        // NOTE: The createReactAgent approach does NOT create aiConversation records,
+        // so there is no need for a middleware to hide "headless" conversations.
+        // If future versions need conversation logging, add it here.
+    }
+    async install() {
+        // No seed data needed on first install
+    }
+    async afterEnable() { }
+    async afterDisable() { }
+    async remove() { }
+}
+exports.PluginAgentOrchestratorServer = PluginAgentOrchestratorServer;
+exports.default = PluginAgentOrchestratorServer;

package/dist/server/resources/tracing.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTracingResource = void 0;
+/**
+ * Custom resource for the Swarm Tracing admin UI (Phase 5).
+ * Queries the dedicated orchestratorLogs collection instead of
+ * filtering aiConversations by JSONB (P2 fix: DB-engine agnostic).
+ */
+function registerTracingResource(plugin) {
+    const app = plugin.app;
+    app.resource({
+        name: 'orchestratorTracing',
+        actions: {
+            /**
+             * List all delegation execution logs.
+             */
+            async list(ctx, next) {
+                const repo = ctx.db.getRepository('orchestratorLogs');
+                const { page = 1, pageSize = 50, sort = ['-createdAt'] } = ctx.action.params;
+                try {
+                    const [rows, count] = await repo.findAndCount({
+                        sort,
+                        offset: (Number(page) - 1) * Number(pageSize),
+                        limit: Number(pageSize),
+                    });
+                    ctx.body = {
+                        data: rows.map((row) => ({
+                            id: row.id,
+                            leaderUsername: row.leaderUsername,
+                            subAgentUsername: row.subAgentUsername,
+                            toolName: row.toolName,
+                            task: row.task,
+                            result: row.result,
+                            status: row.status,
+                            depth: row.depth,
+                            durationMs: row.durationMs,
+                            error: row.error,
+                            userId: row.userId,
+                            createdAt: row.createdAt,
+                        })),
+                        meta: {
+                            count,
+                            page: Number(page),
+                            pageSize: Number(pageSize),
+                            totalPage: Math.ceil(count / Number(pageSize)),
+                        },
+                    };
+                }
+                catch (e) {
+                    ctx.log.error('[AgentOrchestrator] Tracing list error', e);
+                    ctx.body = { data: [], meta: { count: 0 } };
+                }
+                await next();
+            },
+            /**
+             * Get a single delegation log by ID.
+             */
+            async get(ctx, next) {
+                const { filterByTk } = ctx.action.params;
+                if (!filterByTk) {
+                    ctx.throw(400, 'id is required');
+                    return;
+                }
+                try {
+                    const repo = ctx.db.getRepository('orchestratorLogs');
+                    const log = await repo.findOne({
+                        filter: { id: filterByTk },
+                    });
+                    ctx.body = { data: log };
+                }
+                catch (e) {
+                    ctx.log.error('[AgentOrchestrator] Tracing get error', e);
+                    ctx.body = { data: null };
+                }
+                await next();
+            },
+        },
+    });
+    // ACL: allow admin access to tracing endpoints
+    app.acl.registerSnippet({
+        name: `pm.${plugin.name}.tracing`,
+        actions: ['orchestratorTracing:list', 'orchestratorTracing:get'],
+    });
+}
+exports.registerTracingResource = registerTracingResource;

package/dist/server/tools/delegate-task.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDelegateToolsProvider = void 0;
+const zod_1 = require("zod");
+// @ts-ignore - subpath export types resolve at build time via NocoBase bundler
+const prebuilt_1 = require("@langchain/langgraph/prebuilt");
+const tools_1 = require("@langchain/core/tools");
+const messages_1 = require("@langchain/core/messages");
+/**
+ * Maximum delegation depth key stored in ctx metadata.
+ * Used to prevent circular/recursive delegation chains.
+ */
+const ORCHESTRATOR_DEPTH_KEY = '__orchestratorDepth';
+/**
+ * Creates one dynamic tool per configured sub-agent for a given leader.
+ * Uses Strategy B (Per-SubAgent Tool): each sub-agent becomes a separate tool
+ * with its own name and description, making LLM tool selection natural.
+ *
+ * Architecture:
+ * - Uses createReactAgent (public LangGraph API) for agent execution
+ * - Uses plugin-ai's getLLMService() for LLM model resolution
+ * - Uses core app.aiManager.toolsManager.listTools() for tool resolution
+ *   (same manager that AIEmployee uses — see ai-employee.ts:1286)
+ * - Depth enforcement via ctx metadata tracking
+ * - Per-leader scoping via invoke-time check (core ToolsOptions has no
+ *   leaderUsername field, so scoping is enforced in the invoke callback)
+ */
+function createDelegateToolsProvider(plugin) {
+    return async (register) => {
+        try {
+            const configRepo = plugin.db.getRepository('orchestratorConfig');
+            if (!configRepo)
+                return;
+            const configs = await configRepo.find({
+                filter: { enabled: true },
+            });
+            if (!configs?.length)
+                return;
+            // Build a lookup: which leaders are allowed to use each delegate tool
+            // Multiple leaders may share the same sub-agent, but each leader must
+            // have an explicit rule.
+            const leadersByTool = new Map();
+            for (const config of configs) {
+                const toolName = `delegate_to_${config.subAgentUsername.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+                if (!leadersByTool.has(toolName)) {
+                    leadersByTool.set(toolName, new Set());
+                }
+                leadersByTool.get(toolName).add(config.leaderUsername);
+            }
+            // De-duplicate: register one tool per sub-agent (not per config row)
+            const seenSubAgents = new Set();
+            for (const config of configs) {
+                const { leaderUsername, subAgentUsername, maxDepth, timeout } = config;
+                // Skip if we already registered this sub-agent's tool
+                if (seenSubAgents.has(subAgentUsername))
+                    continue;
+                seenSubAgents.add(subAgentUsername);
+                // Fetch the sub-agent employee model for its description and LLM config
+                const subAgentEmployee = await plugin.db.getRepository('aiEmployees').findOne({
+                    filter: { username: subAgentUsername },
+                });
+                if (!subAgentEmployee)
+                    continue;
+                const toolName = `delegate_to_${subAgentUsername.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+                const toolDescription = [
+                    `Delegate a task to the AI Employee "${subAgentEmployee.nickname || subAgentUsername}".`,
+                    subAgentEmployee.about ? `Specialist profile: ${subAgentEmployee.about.substring(0, 200)}` : '',
+                    'The sub-agent will execute the task independently and return its final answer.',
+                ].filter(Boolean).join(' ');
+                // Capture the allowed leaders for this tool (for invoke-time scoping)
+                const allowedLeaders = leadersByTool.get(toolName);
+                register.registerTools({
+                    scope: 'CUSTOM',
+                    execution: 'backend',
+                    defaultPermission: 'ALLOW',
+                    silence: false,
+                    introduction: {
+                        title: `[Sub-Agent] ${subAgentEmployee.nickname || subAgentUsername}`,
+                        about: toolDescription,
+                    },
+                    definition: {
+                        name: toolName,
+                        description: toolDescription,
+                        schema: zod_1.z.object({
+                            task: zod_1.z.string().describe('The detailed task description for the sub-agent to execute.'),
+                            context: zod_1.z.string().optional().describe('Optional additional context to help the sub-agent understand the task better.'),
+                        }),
+                    },
+                    invoke: async (ctx, args, id) => {
+                        // --- P2 FIX: Per-leader scoping at invoke time ---
+                        // Core ToolsOptions doesn't support leaderUsername field, so
+                        // we enforce scoping here by checking the calling employee.
+                        const callingEmployee = ctx._currentAIEmployee?.username
+                            || ctx.state?.currentAIEmployee;
+                        if (callingEmployee && !allowedLeaders.has(callingEmployee)) {
+                            return {
+                                status: 'error',
+                                content: `Employee "${callingEmployee}" is not authorized to delegate to "${subAgentUsername}". Configure an orchestration rule first.`,
+                            };
+                        }
+                        return invokeDelegateTask(ctx, plugin, {
+                            leaderUsername: callingEmployee || Array.from(allowedLeaders)[0] || '',
+                            subAgentUsername,
+                            subAgentEmployee,
+                            task: args.task,
+                            context: args.context,
+                            maxDepth: maxDepth ?? 1,
+                            timeout: timeout ?? 120000,
+                            toolCallId: id,
+                        });
+                    },
+                });
+            }
+        }
+        catch (e) {
+            plugin.app.log.error('[AgentOrchestrator] Failed to register delegate tools', e);
+        }
+    };
+}
+exports.createDelegateToolsProvider = createDelegateToolsProvider;
+/**
+ * Core execution logic using createReactAgent (public LangGraph API).
+ *
+ * This approach mirrors plugin-sub-agent's proven pattern:
+ *  1. Get LLM model via aiPlugin.aiManager.getLLMService()
+ *  2. Resolve sub-agent's tools via core app.aiManager.toolsManager.listTools()
+ *  3. Build a standalone createReactAgent with the model + tools
+ *  4. Stream results and extract final AI message
+ *
+ * Tool resolution uses the CORE toolsManager (app.aiManager.toolsManager) —
+ * the same manager that AIEmployee.getToolsMap() uses (see ai-employee.ts:1286).
+ * This ensures tool names in skillSettings.skills[].name match correctly.
+ *
+ * skillSettings.skills shape (verified against ai-employee.ts:1028):
+ *   { name: string, autoCall: boolean }[]
+ */
+async function invokeDelegateTask(ctx, plugin, options) {
+    const { leaderUsername, subAgentUsername, subAgentEmployee, task, context, maxDepth, timeout, toolCallId } = options;
+    // --- P1: Depth enforcement ---
+    const currentDepth = ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0;
+    if (currentDepth >= maxDepth) {
+        return {
+            status: 'error',
+            content: `Delegation depth limit reached (${currentDepth}/${maxDepth}). Sub-agent "${subAgentUsername}" cannot delegate further.`,
+        };
+    }
+    const startTime = Date.now();
+    try {
+        const aiPlugin = ctx.app.pm.get('ai');
+        if (!aiPlugin) {
+            throw new Error('Plugin AI is not installed or enabled');
+        }
+        // --- Step 1: Resolve LLM model from sub-agent's employee config ---
+        const modelSettings = subAgentEmployee.modelSettings;
+        if (!modelSettings?.llmService || !modelSettings?.model) {
+            throw new Error(`Sub-agent "${subAgentUsername}" has no LLM model configured. Please configure a model in the AI Employee settings.`);
+        }
+        const { provider } = await aiPlugin.aiManager.getLLMService({
+            llmService: modelSettings.llmService,
+            model: modelSettings.model,
+        });
+        const chatModel = provider.createModel();
+        // --- Step 2: Resolve tools via CORE toolsManager ---
+        // Uses app.aiManager.toolsManager (same as AIEmployee.getToolsMap at ai-employee.ts:1286)
+        // NOT plugin-ai's local toolManager (which has a different grouped format).
+        const coreToolsManager = ctx.app.aiManager.toolsManager;
+        const allTools = await coreToolsManager.listTools();
+        // skillSettings.skills is { name: string, autoCall: boolean }[]
+        // (verified at ai-employee.ts:1028-1029)
+        const employeeSkills = (subAgentEmployee.skillSettings?.skills ?? [])
+            .map((s) => (typeof s === 'string' ? s : s.name))
+            .filter(Boolean);
+        const langchainTools = [];
+        for (const toolEntry of allTools) {
+            const toolName = toolEntry.definition.name;
+            if (!toolName)
+                continue;
+            // Only include tools that the sub-agent employee is configured to use.
+            // Also skip our own delegate_to_* tools to prevent circular delegation
+            // (belt-and-suspenders with the depth check above).
+            if (!employeeSkills.includes(toolName) || toolName.startsWith('delegate_to_')) {
+                continue;
+            }
+            langchainTools.push(new tools_1.DynamicStructuredTool({
+                name: toolName.replace(/[^a-zA-Z0-9_-]/g, '_'),
+                description: toolEntry.definition.description || toolName,
+                schema: (toolEntry.definition.schema || zod_1.z.object({})),
+                func: async (toolArgs) => {
+                    // Forward the invoke with depth tracking
+                    const invokeCtx = Object.create(ctx);
+                    invokeCtx[ORCHESTRATOR_DEPTH_KEY] = currentDepth + 1;
+                    const res = await toolEntry.invoke(invokeCtx, toolArgs, `orch-${toolCallId}`);
+                    if (res?.status === 'error') {
+                        throw new Error(`Tool <${toolName}> failed: ${res.content}`);
+                    }
+                    return typeof res?.content === 'string' ? res.content : JSON.stringify(res);
+                },
+            }));
+        }
+        // --- Step 3: Build the agent ---
+        const abortController = new AbortController();
+        const executor = (0, prebuilt_1.createReactAgent)({
+            llm: chatModel,
+            tools: langchainTools,
+        });
+        // --- Step 4: Construct messages ---
+        const systemPrompt = subAgentEmployee.chatSettings?.systemPrompt
+            || subAgentEmployee.bio
+            || `You are an AI assistant named "${subAgentEmployee.nickname || subAgentUsername}". ${subAgentEmployee.about || ''}`;
+        const combinedTask = context
+            ? `Task: ${task}\n\nContext Provided:\n${context}`
+            : `Task: ${task}`;
+        // --- Step 5: Execute with timeout + abort ---
+        // P3 FIX: AbortController signal cancels the in-flight stream on timeout,
+        // preventing continued token consumption after the timeout fires.
+        const invokePromise = executeAgent(executor, systemPrompt, combinedTask, abortController.signal);
+        const result = await Promise.race([
+            invokePromise,
+            createTimeout(timeout, subAgentUsername, abortController),
+        ]);
+        const content = result || 'Sub-agent completed the task but produced no output.';
+        // Log successful execution for tracing
+        await logDelegation(ctx, plugin, {
+            leaderUsername,
+            subAgentUsername,
+            task,
+            result: content,
+            status: 'success',
+            depth: currentDepth,
+            durationMs: Date.now() - startTime,
+        });
+        return {
+            status: 'success',
+            content,
+        };
+    }
+    catch (e) {
+        plugin.app.log.error(`[AgentOrchestrator] Sub-agent ${subAgentUsername} failed`, e);
+        // Log failed execution for tracing
+        await logDelegation(ctx, plugin, {
+            leaderUsername,
+            subAgentUsername,
+            task,
+            result: '',
+            status: 'error',
+            depth: currentDepth,
+            durationMs: Date.now() - startTime,
+            error: e.message,
+        }).catch(() => { }); // Don't let logging errors mask the real error
+        return {
+            status: 'error',
+            content: `Sub-agent "${subAgentUsername}" failed: ${e.message}`,
+        };
+    }
+}
+/**
+ * Log a delegation event to the orchestratorLogs collection for observability.
+ */
+async function logDelegation(ctx, plugin, data) {
+    try {
+        const logsRepo = plugin.db.getRepository('orchestratorLogs');
+        if (!logsRepo)
+            return;
+        await logsRepo.create({
+            values: {
+                leaderUsername: data.leaderUsername,
+                subAgentUsername: data.subAgentUsername,
+                toolName: `delegate_to_${data.subAgentUsername}`,
+                task: data.task.substring(0, 2000),
+                result: data.result.substring(0, 5000),
+                status: data.status,
+                depth: data.depth,
+                durationMs: data.durationMs,
+                error: data.error?.substring(0, 2000),
+                userId: ctx.auth?.user?.id || ctx.state?.currentUser?.id,
+            },
+        });
+    }
+    catch (e) {
+        plugin.app.log.warn('[AgentOrchestrator] Failed to log delegation event', e);
+    }
+}
+/**
+ * Execute the agent and extract the final AI message content.
+ * Uses stream mode to collect all chunks, similar to plugin-sub-agent.
+ * Accepts an AbortSignal so the stream can be cancelled on timeout.
+ */
+async function executeAgent(executor, systemPrompt, task, signal) {
+    const streamOptions = { recursionLimit: 50, streamMode: 'messages' };
+    if (signal) {
+        streamOptions.signal = signal;
+    }
+    const stream = await executor.stream({
+        messages: [new messages_1.SystemMessage(systemPrompt), new messages_1.HumanMessage(task)],
+    }, streamOptions);
+    let aiContentCache = '';
+    for await (const chunk of stream) {
+        // Check abort between chunks
+        if (signal?.aborted)
+            break;
+        const [message] = chunk;
+        if (message.getType() === 'ai' && message.content) {
+            aiContentCache += message.content.toString();
+        }
+    }
+    return aiContentCache || '';
+}
+/**
+ * Create a timeout promise that rejects after the specified duration.
+ * P3 FIX: Also triggers AbortController to cancel the in-flight stream.
+ */
+function createTimeout(ms, agentName, abortController) {
+    return new Promise((_, reject) => setTimeout(() => {
+        abortController?.abort();
+        reject(new Error(`Sub-agent "${agentName}" timed out after ${ms / 1000}s`));
+    }, ms));
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "plugin-agent-orchestrator",
+  "displayName": "Agent Orchestrator",
+  "displayName.zh-CN": "代理协调器",
+  "displayName.vi-VN": "Điều phối Agent",
+  "description": "Hierarchical Multi-Agent orchestration for NocoBase AI Employees. Enables Leader agents to delegate tasks to Sub-Agent employees without modifying core plugin-ai.",
+  "version": "1.0.0",
+  "license": "Apache-2.0",
+  "main": "dist/server/index.js",
+  "keywords": [
+    "AI",
+    "Agent",
+    "Orchestrator",
+    "Multi-Agent",
+    "Swarm"
+  ],
+  "files": [
+    "dist",
+    "src",
+    "client.js",
+    "server.js",
+    "client.d.ts",
+    "server.d.ts"
+  ],
+  "nocobase": {
+    "supportedVersions": [
+      "2.x"
+    ],
+    "editionLevel": 0
+  },
+  "dependencies": {
+    "@langchain/core": "^0.3.0",
+    "@langchain/langgraph": "^0.2.0",
+    "zod": "^3.23.0"
+  },
+  "peerDependencies": {
+    "@nocobase/client": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/database": "2.x",
+    "@nocobase/ai": "2.x",
+    "@nocobase/plugin-ai": "2.x"
+  }
+}

package/server.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/server';
+export { default } from './dist/server';

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server');

package/src/client/AIEmployeeSelect.tsx

@@ -0,0 +1,49 @@
+import React from 'react';
+import { Select } from 'antd';
+import { useAIEmployees } from './AIEmployeesContext';
+
+/**
+ * Reusable Select component for AI Employees.
+ * P3 FIX: Uses shared AIEmployeesContext instead of making its own API call.
+ */
+export const AIEmployeeSelect: React.FC<{
+  value?: string;
+  onChange?: (value: string) => void;
+  exclude?: string; // username to exclude (prevent self-reference)
+  placeholder?: string;
+}> = ({ value, onChange, exclude, placeholder = 'Select AI Employee...' }) => {
+  const { employees, loading } = useAIEmployees();
+
+  const options = React.useMemo(() => {
+    return employees
+      .filter((emp) => !exclude || emp.username !== exclude)
+      .map((emp) => ({
+        label: emp.nickname,
+        value: emp.username,
+        description: emp.about,
+      }));
+  }, [employees, exclude]);
+
+  return (
+    <Select
+      loading={loading}
+      options={options}
+      value={value}
+      onChange={onChange}
+      placeholder={placeholder}
+      showSearch
+      filterOption={(input, option) =>
+        (option?.label ?? '').toString().toLowerCase().includes(input.toLowerCase()) ||
+        (option?.value ?? '').toString().toLowerCase().includes(input.toLowerCase())
+      }
+      optionRender={(option) => (
+        <div>
+          <div style={{ fontWeight: 500 }}>{option.label}</div>
+          {option.data.description && (
+            <div style={{ fontSize: 12, color: '#888' }}>{option.data.description}</div>
+          )}
+        </div>
+      )}
+    />
+  );
+};