@evandu/super-pi 0.1.1 → 0.1.3

package/dist/client/index.html

@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="theme-color" content="#101828" />
     <title>Super Pi</title>
-    <script type="module" crossorigin src="/assets/index-BMQsEdio.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CsbZzuMy.css">
+    <script type="module" crossorigin src="/assets/index-D_VwFuME.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BhFeQ1E-.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/agents.d.ts

@@ -146,7 +146,26 @@ export type AgentModeFilter = "primary" | "subagent";
  * so the split is a filter on the parsed field, never a second directory or a second parser. A caller
  * with no argument gets exactly what it always got.
  */
-export declare function readAgents(directory: string, options?: {
+/**
+ * Expands a leading tilde (`~` or `~/...` or `~\...`) to the user's home directory.
+ */
+export declare function expandTilde(filepath: string): string;
+export interface ResolveAgentDirectoriesOptions {
+    customDirs?: readonly string[];
+    env?: NodeJS.ProcessEnv;
+    rootDir?: string;
+}
+/**
+ * Resolves the ordered list of directories to discover agents from:
+ * 1. Custom directories configured by the user in app settings (or options)
+ * 2. SUPER_PI_AGENTS_DIR environment variable if set
+ * 3. User global agent directories (~/.super_pi/agents, ~/.super-pi/agents, ~/.pi/agents)
+ * 4. Built-in repository/package agents directory (<rootDir>/agents)
+ *
+ * Duplicate paths are preserved in order of first appearance.
+ */
+export declare function resolveAgentDirectories(options?: ResolveAgentDirectoriesOptions): string[];
+export declare function readAgents(directory: string | readonly string[], options?: {
     mode?: AgentModeFilter;
 }): Promise<AgentScan>;
 /** Parses one definition file, or returns the reason it is not a usable agent. */

package/dist/server/agents.js

@@ -1,5 +1,6 @@
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 /**
  * A guard rather than a cast: it is the only thing that lets `tools:` be checked once and then used as
  * a map everywhere without the compiler complaining. It narrows to the index-signature shape that
@@ -332,32 +333,105 @@ export function parseAgentModel(model) {
  * so the split is a filter on the parsed field, never a second directory or a second parser. A caller
  * with no argument gets exactly what it always got.
  */
-export async function readAgents(directory, options = {}) {
-    const mode = options.mode ?? "primary";
-    let entries;
-    try {
-        entries = await readdir(directory);
+/**
+ * Expands a leading tilde (`~` or `~/...` or `~\...`) to the user's home directory.
+ */
+export function expandTilde(filepath) {
+    if (filepath === "~")
+        return homedir();
+    if (filepath.startsWith("~/") || filepath.startsWith("~\\")) {
+        return join(homedir(), filepath.slice(2));
     }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return { agents: [], problems: [] };
-        throw error;
+    return filepath;
+}
+/**
+ * Resolves the ordered list of directories to discover agents from:
+ * 1. Custom directories configured by the user in app settings (or options)
+ * 2. SUPER_PI_AGENTS_DIR environment variable if set
+ * 3. User global agent directories (~/.super_pi/agents, ~/.super-pi/agents, ~/.pi/agents)
+ * 4. Built-in repository/package agents directory (<rootDir>/agents)
+ *
+ * Duplicate paths are preserved in order of first appearance.
+ */
+export function resolveAgentDirectories(options = {}) {
+    const dirs = [];
+    const add = (dir) => {
+        if (!dir)
+            return;
+        const trimmed = dir.trim();
+        if (!trimmed)
+            return;
+        const expanded = expandTilde(trimmed);
+        const resolved = resolve(expanded);
+        if (!dirs.includes(resolved)) {
+            dirs.push(resolved);
+        }
+    };
+    if (options.customDirs) {
+        for (const d of options.customDirs)
+            add(d);
     }
+    const env = options.env ?? process.env;
+    if (env.SUPER_PI_AGENTS_DIR) {
+        add(env.SUPER_PI_AGENTS_DIR);
+    }
+    else {
+        try {
+            const home = homedir();
+            add(join(home, ".super_pi", "agents"));
+            add(join(home, ".super-pi", "agents"));
+            add(join(home, ".pi", "agents"));
+        }
+        catch {
+            // homedir() might throw in restricted sandbox environments
+        }
+        const root = options.rootDir ?? resolve(import.meta.dirname, "../..");
+        add(join(root, "agents"));
+    }
+    return dirs;
+}
+export async function readAgents(directory, options = {}) {
+    const mode = options.mode ?? "primary";
+    const rawDirs = Array.isArray(directory) ? directory : [directory];
+    const dirs = rawDirs.filter(Boolean);
     const agents = [];
     const problems = [];
-    for (const file of entries.filter((name) => name.toLowerCase().endsWith(".md")).sort()) {
-        const source = await readFile(join(directory, file), "utf8");
-        const parsed = parseDefinition(file, source);
-        if ("message" in parsed)
-            problems.push({ file, message: parsed.message });
-        else
-            agents.push(parsed);
+    const seenIds = new Set();
+    for (const dir of dirs) {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                continue;
+            throw error;
+        }
+        for (const file of entries.filter((name) => name.toLowerCase().endsWith(".md")).sort()) {
+            const source = await readFile(join(dir, file), "utf8");
+            const parsed = parseDefinition(file, source);
+            if ("message" in parsed) {
+                const fileId = file.replace(/\.md$/i, "");
+                if (!seenIds.has(fileId)) {
+                    problems.push({ file, message: parsed.message });
+                }
+            }
+            else {
+                if (!seenIds.has(parsed.id)) {
+                    seenIds.add(parsed.id);
+                    agents.push({ ...parsed, sourceDir: dir });
+                }
+            }
+        }
     }
     // The half that was NOT asked for is filtered out here rather than marked in the UI: sub-agents are
     // invoked BY an agent and never chosen by a human, so listing one in the picker would promise a role
     // the runtime cannot honour. The remainder is alphabetical by id, so either roster reads as a list
     // rather than as a directory listing.
-    return { agents: agents.filter((agent) => agent.mode === mode).sort((a, b) => a.id.localeCompare(b.id)), problems };
+    return {
+        agents: agents.filter((agent) => agent.mode === mode).sort((a, b) => a.id.localeCompare(b.id)),
+        problems,
+    };
 }
 /** Only `#rgb` and `#rrggbb`. A `color:` frontmatter value is rendered as a CSS background, so it has to
  *  be a colour and nothing else - accepting an arbitrary string would put author-controlled text into a

package/dist/server/application/catalog-service.d.ts

@@ -1,14 +1,34 @@
 import type { AgentRuntime } from "../runtime.js";
 import type { AgentCatalog, ModelCatalog, ModelSelection } from "../types.js";
 import type { EventBroadcaster } from "../server-context.js";
+import type { Store } from "../store.js";
 /**
  * Service managing model catalogs and agent definitions (primary and subagents).
  */
 export declare class CatalogService {
     private readonly runtime;
     private readonly broadcaster;
-    private readonly agentsDir;
-    constructor(runtime: AgentRuntime, broadcaster: EventBroadcaster, agentsDir: string);
+    private readonly store?;
+    private readonly rootDir?;
+    private readonly onDirsChanged?;
+    private agentDirs;
+    constructor(runtime: AgentRuntime, broadcaster: EventBroadcaster, agentsDir: string | readonly string[], store?: Store | undefined, rootDir?: string | undefined, onDirsChanged?: ((dirs: string[]) => void) | undefined);
+    /**
+     * Returns current active agent discovery directories.
+     */
+    getAgentDirs(): string[];
+    /**
+     * Updates agent discovery directories and notifies subscribers.
+     */
+    setAgentDirs(dirs: string[]): void;
+    /**
+     * Updates user-configured custom agent directories in store and triggers rescan.
+     */
+    setCustomDirs(dirs: string[]): Promise<void>;
+    /**
+     * Immediately re-reads agent definitions from disk and broadcasts catalogs.
+     */
+    rescan(): Promise<void>;
     /**
      * Fetches the model catalog from runtime, optionally tailored to a selected model.
      */

package/dist/server/application/catalog-service.js

@@ -1,4 +1,4 @@
-import { readAgents } from "../agents.js";
+import { readAgents, resolveAgentDirectories } from "../agents.js";
 function summarize(agent) {
     const { prompt, toolFlags, ...summary } = agent;
     const toolSummary = toolFlags.includes("--no-tools")
@@ -16,11 +16,54 @@ function summarize(agent) {
 export class CatalogService {
     runtime;
     broadcaster;
-    agentsDir;
-    constructor(runtime, broadcaster, agentsDir) {
+    store;
+    rootDir;
+    onDirsChanged;
+    agentDirs;
+    constructor(runtime, broadcaster, agentsDir, store, rootDir, onDirsChanged) {
         this.runtime = runtime;
         this.broadcaster = broadcaster;
-        this.agentsDir = agentsDir;
+        this.store = store;
+        this.rootDir = rootDir;
+        this.onDirsChanged = onDirsChanged;
+        this.agentDirs = Array.isArray(agentsDir) ? [...agentsDir] : [agentsDir];
+    }
+    /**
+     * Returns current active agent discovery directories.
+     */
+    getAgentDirs() {
+        return [...this.agentDirs];
+    }
+    /**
+     * Updates agent discovery directories and notifies subscribers.
+     */
+    setAgentDirs(dirs) {
+        this.agentDirs = [...dirs];
+        this.onDirsChanged?.(this.agentDirs);
+    }
+    /**
+     * Updates user-configured custom agent directories in store and triggers rescan.
+     */
+    async setCustomDirs(dirs) {
+        if (this.store) {
+            await this.store.setCustomAgentDirs(dirs);
+            this.broadcaster.broadcastState();
+        }
+        const resolved = resolveAgentDirectories({
+            customDirs: dirs,
+            rootDir: this.rootDir,
+        });
+        this.setAgentDirs(resolved);
+        await this.rescan();
+    }
+    /**
+     * Immediately re-reads agent definitions from disk and broadcasts catalogs.
+     */
+    async rescan() {
+        await Promise.all([
+            this.broadcastAgents(),
+            this.broadcastSubagents(),
+        ]);
     }
     /**
      * Fetches the model catalog from runtime, optionally tailored to a selected model.
@@ -39,23 +82,32 @@ export class CatalogService {
      * Reads one catalog filtered by mode at source.
      */
     async readAgentCatalog(mode) {
+        const primaryDir = this.agentDirs[0] ?? "";
         try {
-            const scan = await readAgents(this.agentsDir, { mode });
+            const scan = await readAgents(this.agentDirs, { mode });
             for (const problem of scan.problems) {
-                console.warn(`Super Pi: ${this.agentsDir}/${problem.file} is not a usable agent - ${problem.message}`);
+                console.warn(`Super Pi: ${problem.file} is not a usable agent - ${problem.message}`);
             }
             const agents = scan.agents.filter((agent) => !agent.hidden).map(summarize);
             if (!agents.length) {
-                console.warn(`Super Pi: no ${mode} agents found in ${this.agentsDir} (${scan.problems.length} file(s) rejected).`);
+                console.warn(`Super Pi: no ${mode} agents found in [${this.agentDirs.join(", ")}] (${scan.problems.length} file(s) rejected).`);
             }
-            return { source: "directory", agents, problems: scan.problems, directory: this.agentsDir, fetchedAt: new Date().toISOString() };
+            return {
+                source: "directory",
+                agents,
+                problems: scan.problems,
+                directory: primaryDir,
+                directories: [...this.agentDirs],
+                fetchedAt: new Date().toISOString(),
+            };
         }
         catch (error) {
             return {
                 source: "unavailable",
                 agents: [],
                 problems: [],
-                directory: this.agentsDir,
+                directory: primaryDir,
+                directories: [...this.agentDirs],
                 fetchedAt: new Date().toISOString(),
                 error: error instanceof Error ? error.message : "unknown error",
             };

package/dist/server/application/conversation-service.d.ts

@@ -27,8 +27,9 @@ export declare class ConversationService {
     private readonly catalogService;
     private readonly runService;
     private readonly extensionUiService;
-    private readonly agentsDir;
-    constructor(store: Store, runtime: AgentRuntime, subagents: SubagentRunRecorder, broadcaster: EventBroadcaster, catalogService: CatalogService, runService: RunService, extensionUiService: ExtensionUiService, agentsDir: string);
+    private agentsDir;
+    constructor(store: Store, runtime: AgentRuntime, subagents: SubagentRunRecorder, broadcaster: EventBroadcaster, catalogService: CatalogService, runService: RunService, extensionUiService: ExtensionUiService, agentsDir: string | string[]);
+    setAgentsDir(dir: string | string[]): void;
     /**
      * Creates a new conversation in a workspace.
      */

package/dist/server/application/conversation-service.js

@@ -22,6 +22,9 @@ export class ConversationService {
         this.extensionUiService = extensionUiService;
         this.agentsDir = agentsDir;
     }
+    setAgentsDir(dir) {
+        this.agentsDir = dir;
+    }
     /**
      * Creates a new conversation in a workspace.
      */
@@ -101,7 +104,8 @@ export class ConversationService {
         }
         const agent = await this.runtime.agentFor?.({ id: conversation.id, agentId });
         if (!agent) {
-            throw new Error(`Agent ${JSON.stringify(agentId)} 不存在或不是可用的 primary agent（目录：${this.agentsDir}）`);
+            const dirsLabel = Array.isArray(this.agentsDir) ? this.agentsDir.join(", ") : this.agentsDir;
+            throw new Error(`Agent ${JSON.stringify(agentId)} 不存在或不是可用的 primary agent（目录：${dirsLabel}）`);
         }
         if (agent.model) {
             const catalog = await this.runtime.catalog();

package/dist/server/application/run-service.d.ts

@@ -4,6 +4,7 @@ import type { SubagentRunRecorder } from "../subagent-runs.js";
 import type { Conversation, Message, MessageImage, PiQueueSnapshot, Workspace } from "../types.js";
 import type { EventBroadcaster } from "../server-context.js";
 import type { ExtensionUiService } from "./extension-ui-service.js";
+import type { WorkflowEngine } from "../workflow-engine.js";
 export interface SubagentDispatchRequestBody {
     conversationId?: string;
     subagent_type?: string;
@@ -14,6 +15,23 @@ export interface SubagentDispatchRequestBody {
     description?: string;
     loopId?: string;
     role?: string;
+    /** The per-turn dispatch capability, presented by the primary agent's extension. See `capability.ts`. */
+    capability?: string;
+}
+/**
+ * A whole orchestrated plan, as it arrives over the wire.
+ *
+ * Deliberately NOT a `WorkflowPlan`: the plan type is what validation PRODUces, and accepting it as an
+ * input would let a caller assert that its steps were already checked. This is the untrusted shape, and
+ * `validateWorkflowPlan` is what turns one into a plan.
+ */
+export interface WorkflowRunRequestBody {
+    conversationId?: string;
+    summary?: string;
+    onFailure?: string;
+    steps?: unknown;
+    /** The per-turn dispatch capability, presented by the primary agent's extension. See `capability.ts`. */
+    capability?: string;
 }
 /**
  * Service managing execution of conversation turns, message queueing,
@@ -25,8 +43,11 @@ export declare class RunService {
     private readonly subagents;
     private readonly broadcaster;
     private readonly extensionUiService;
+    private agentsDir;
+    private readonly workflows;
     private readonly activeRuns;
-    constructor(store: Store, runtime: AgentRuntime, subagents: SubagentRunRecorder, broadcaster: EventBroadcaster, extensionUiService: ExtensionUiService);
+    constructor(store: Store, runtime: AgentRuntime, subagents: SubagentRunRecorder, broadcaster: EventBroadcaster, extensionUiService: ExtensionUiService, agentsDir: string | string[], workflows: WorkflowEngine);
+    setAgentsDir(dir: string | string[]): void;
     /**
      * Resolves the conversation and workspace synchronously for a run.
      */
@@ -104,10 +125,37 @@ export declare class RunService {
         status: number;
         body: unknown;
     }>;
+    /**
+     * Validates and executes one orchestrated plan to its end.
+     *
+     * BLOCKS, unlike `dispatchTask`'s background path, and that asymmetry is the whole design. A background
+     * dispatch returns immediately because the model is expected to keep working meanwhile; a plan is the
+     * model handing the work over and wanting the chain back, so the request stays open until the last step
+     * settles. The cost is a long-held connection - a three-step pipeline is minutes - which is the same
+     * cost `task` already carries, and is bounded by the same AbortSignal the extension already forwards,
+     * plus the wall-clock cap below.
+     *
+     * 200 FOR A PLAN THAT RAN, 422 FOR ONE THAT SETTLED AS SOMETHING ELSE - `completed` including deliberate
+     * skips, and anything else the terminal status can be. Same rule `dispatchTask` applies to a single run,
+     * applied to a whole plan: the transport reports whether the work concluded, and the body says how.
+     */
+    runWorkflow(body: WorkflowRunRequestBody): Promise<{
+        status: number;
+        body: unknown;
+    }>;
     /**
      * Stops a specific subagent run by runId.
      */
     stopSubagent(runId: string): void;
+    /**
+     * Stops one orchestrated plan, and says whether there was anything to stop.
+     *
+     * REACHES THE CHILD, not just the loop: the engine dispatches every step under one controller's signal,
+     * so aborting it reaches the child Pi and `killTree`s it exactly as the run recorder's stop does. A stop
+     * that only ended the loop would leave the sub-agent still running and still holding the workspace
+     * directory, which is the precise gap the run card's own stop button was added to close.
+     */
+    stopWorkflow(workflowId: string): boolean;
     /**
      * Stops all subagent runs belonging to a conversation.
      */

package/dist/server/application/run-service.js

@@ -1,5 +1,8 @@
-import { checkSubagentDepth, parentDeniedTools } from "../task-tool.js";
+import { checkSubagentDepth, parentDeniedTools, subagentRoster } from "../task-tool.js";
 import { newSubagentRunId } from "../subagents.js";
+import { readAgents } from "../agents.js";
+import { verifyCapability } from "../capability.js";
+import { validateWorkflowPlan, workflowSummary } from "../workflow.js";
 /**
  * Service managing execution of conversation turns, message queueing,
  * follow-ups, and sub-agent dispatching.
@@ -10,13 +13,20 @@ export class RunService {
     subagents;
     broadcaster;
     extensionUiService;
+    agentsDir;
+    workflows;
     activeRuns = new Map();
-    constructor(store, runtime, subagents, broadcaster, extensionUiService) {
+    constructor(store, runtime, subagents, broadcaster, extensionUiService, agentsDir, workflows) {
         this.store = store;
         this.runtime = runtime;
         this.subagents = subagents;
         this.broadcaster = broadcaster;
         this.extensionUiService = extensionUiService;
+        this.agentsDir = agentsDir;
+        this.workflows = workflows;
+    }
+    setAgentsDir(dir) {
+        this.agentsDir = dir;
     }
     /**
      * Resolves the conversation and workspace synchronously for a run.
@@ -63,6 +73,12 @@ export class RunService {
         if (this.subagents.stopConversation(conversationId)) {
             console.log(`Super Pi: stopped the sub-agent runs of conversation ${conversationId}.`);
         }
+        // Plans too, and separately: a plan's own loop holds the signal that reaches its current child, so
+        // stopping only the runs would let it dispatch the NEXT step a moment later. Reported on its own line
+        // because a person who pressed stop wants to know a plan was still marching, not just a card.
+        if (this.workflows.stopConversation(conversationId)) {
+            console.log(`Super Pi: stopped the running orchestration plans of conversation ${conversationId}.`);
+        }
         this.broadcaster.broadcastState();
     }
     /**
@@ -258,6 +274,12 @@ export class RunService {
         if (!conversationId || !subagentType || !task) {
             throw new Error("task requires conversationId, subagent_type and prompt");
         }
+        // BEFORE anything else, including before the conversation is looked up: a request that cannot prove it
+        // came from this server's primary agent gets no answer about what exists. Everything below this line
+        // is about shaping a dispatch; this line is about whether the caller may have one at all.
+        const capability = verifyCapability(conversationId, body.capability);
+        if (!capability.ok)
+            throw new Error(capability.message);
         if (body.depth !== undefined)
             checkSubagentDepth(body.depth);
         const { conversation, cwd } = this.dispatchContext(conversationId);
@@ -326,12 +348,69 @@ export class RunService {
             },
         };
     }
+    /**
+     * Validates and executes one orchestrated plan to its end.
+     *
+     * BLOCKS, unlike `dispatchTask`'s background path, and that asymmetry is the whole design. A background
+     * dispatch returns immediately because the model is expected to keep working meanwhile; a plan is the
+     * model handing the work over and wanting the chain back, so the request stays open until the last step
+     * settles. The cost is a long-held connection - a three-step pipeline is minutes - which is the same
+     * cost `task` already carries, and is bounded by the same AbortSignal the extension already forwards,
+     * plus the wall-clock cap below.
+     *
+     * 200 FOR A PLAN THAT RAN, 422 FOR ONE THAT SETTLED AS SOMETHING ELSE - `completed` including deliberate
+     * skips, and anything else the terminal status can be. Same rule `dispatchTask` applies to a single run,
+     * applied to a whole plan: the transport reports whether the work concluded, and the body says how.
+     */
+    async runWorkflow(body) {
+        const conversationId = body.conversationId?.trim();
+        if (!conversationId)
+            throw new Error("workflow requires conversationId");
+        // Same rule as `dispatchTask`, and for a larger reason: this endpoint triggers a SEQUENCE of
+        // dispatches, so a caller that cannot prove it is the primary agent would get an unattended pipeline
+        // of sub-agents writing to the workspace rather than one delegation.
+        const capability = verifyCapability(conversationId, body.capability);
+        if (!capability.ok)
+            throw new Error(capability.message);
+        const { conversation, cwd } = this.dispatchContext(conversationId);
+        // Validated against the roster THIS CALL reads from disk, for the same freshness reason the task tool
+        // builds its roster per turn: a sub-agent added while the server is running is dispatchable on the next
+        // message with no restart, because a person edits `agents/*.md` while the server runs.
+        const { agents } = await readAgents(this.agentsDir, { mode: "subagent" });
+        const validated = validateWorkflowPlan(body, subagentRoster(agents));
+        if (!validated.plan)
+            throw new Error(validated.refusal);
+        const { workflow } = await this.workflows.run({
+            conversationId: conversation.id,
+            cwd,
+            plan: validated.plan,
+            ...(conversation.model ? { model: conversation.model } : {}),
+            // The same inheritance a single dispatch applies: a parent's DENY reaches its children, its
+            // allowlist does not. Every step gets the primary's denials, exactly as one dispatch would.
+            denyTools: parentDeniedTools(await this.runtime.agentFor?.(conversation)),
+        });
+        return {
+            status: workflow.status === "completed" ? 200 : 422,
+            body: { workflow: workflowSummary(workflow) },
+        };
+    }
     /**
      * Stops a specific subagent run by runId.
      */
     stopSubagent(runId) {
         this.subagents.stop(runId);
     }
+    /**
+     * Stops one orchestrated plan, and says whether there was anything to stop.
+     *
+     * REACHES THE CHILD, not just the loop: the engine dispatches every step under one controller's signal,
+     * so aborting it reaches the child Pi and `killTree`s it exactly as the run recorder's stop does. A stop
+     * that only ended the loop would leave the sub-agent still running and still holding the workspace
+     * directory, which is the precise gap the run card's own stop button was added to close.
+     */
+    stopWorkflow(workflowId) {
+        return this.workflows.stop(workflowId);
+    }
     /**
      * Stops all subagent runs belonging to a conversation.
      */

package/dist/server/application/workspace-service.d.ts

@@ -23,8 +23,9 @@ export declare class WorkspaceService {
     private readonly runService;
     private readonly extensionUiService;
     private readonly uploadsDir;
-    private readonly agentsDir;
-    constructor(store: Store, runtime: AgentRuntime, broadcaster: EventBroadcaster, catalogService: CatalogService, runService: RunService, extensionUiService: ExtensionUiService, uploadsDir: string, agentsDir: string);
+    private agentsDir;
+    constructor(store: Store, runtime: AgentRuntime, broadcaster: EventBroadcaster, catalogService: CatalogService, runService: RunService, extensionUiService: ExtensionUiService, uploadsDir: string, agentsDir: string | string[]);
+    setAgentsDir(dir: string | string[]): void;
     /**
      * Creates a new workspace.
      */

package/dist/server/application/workspace-service.js

@@ -21,6 +21,9 @@ export class WorkspaceService {
         this.uploadsDir = uploadsDir;
         this.agentsDir = agentsDir;
     }
+    setAgentsDir(dir) {
+        this.agentsDir = dir;
+    }
     /**
      * Creates a new workspace.
      */
@@ -91,7 +94,8 @@ export class WorkspaceService {
                 }
                 const agent = await this.runtime.agentFor({ id: workspaceId, agentId: settings.agentId });
                 if (!agent) {
-                    throw new Error(`Agent ${JSON.stringify(settings.agentId)} 不存在或不是可用的 primary agent（目录：${this.agentsDir}）`);
+                    const dirsLabel = Array.isArray(this.agentsDir) ? this.agentsDir.join(", ") : this.agentsDir;
+                    throw new Error(`Agent ${JSON.stringify(settings.agentId)} 不存在或不是可用的 primary agent（目录：${dirsLabel}）`);
                 }
                 agentToStore = agent.id;
             }