openbot 0.2.2 → 0.2.5

package/dist/plugins/memory/prompt.js

@@ -0,0 +1,55 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+// --- Prompt Builder ---
+/**
+ * Build the memory's section of the system prompt.
+ *
+ * Includes only what the memory owns:
+ * - Environment context
+ * - Agent definition (from AGENT.md)
+ * - A handful of the most recent memories
+ * - Memory capability instructions
+ *
+ * Skills are handled by the separate skills plugin and composed
+ * at the top level in open-bot.ts.
+ */
+export async function buildMemoryPrompt(baseDir, modules, context) {
+    const parts = [];
+    const state = context?.state;
+    const currentCwd = state?.cwd || process.cwd();
+    // 1. Environment context
+    const now = new Date();
+    parts.push(`<environment>
+- Time: ${now.toLocaleString()} (${Intl.DateTimeFormat().resolvedOptions().timeZone})
+- CWD: ${currentCwd}
+- Bot Home: ${baseDir}
+</environment>`);
+    // 2. Agent definition (manual edit only)
+    try {
+        const agentPath = path.join(baseDir, "AGENT.md");
+        const agentMd = await fs.readFile(agentPath, "utf-8");
+        if (agentMd.trim()) {
+            parts.push(`<agent_definition>\n${agentMd.trim()}\n</agent_definition>`);
+        }
+    }
+    catch {
+        // Skip if AGENT.md doesn't exist yet
+    }
+    // 3. Recent memories (lean — just a few to keep context fresh)
+    const recentFacts = await modules.memory.getRecentFacts(5);
+    if (recentFacts.length > 0) {
+        const factsList = recentFacts
+            .map((f) => `- ${f.content}${f.tags.length > 0 ? ` [${f.tags.join(", ")}]` : ""}`)
+            .join("\n");
+        parts.push(`<recent_memories>\n${factsList}\n</recent_memories>`);
+    }
+    // 4. Memory capabilities
+    parts.push(`<memory_tools>
+Use these to manage your persistent state:
+- \`remember(content, tags)\`: Store facts/preferences
+- \`recall(query, tags)\`: Search long-term memory
+- \`forget(memoryId)\`: Remove outdated info
+- \`journal(content)\`: Record session reflections
+</memory_tools>`);
+    return `\n${parts.join("\n\n")}\n`;
+}

package/dist/plugins/memory/types.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+// --- Tool Definitions ---
+export const memoryToolDefinitions = {
+    // Memory tools
+    remember: {
+        description: "Store something important in long-term memory. Use for user preferences, learned facts, project context, etc.",
+        inputSchema: z.object({
+            content: z
+                .string()
+                .describe("The information to remember"),
+            tags: z
+                .array(z.string())
+                .optional()
+                .describe("Tags for categorization (e.g., 'user-preference', 'project', 'learning')"),
+        }),
+    },
+    recall: {
+        description: "Search your memory for relevant information. Use before answering questions that might relate to past interactions.",
+        inputSchema: z.object({
+            query: z.string().describe("What to search for in memory"),
+            tags: z
+                .array(z.string())
+                .optional()
+                .describe("Filter by specific tags"),
+            limit: z
+                .number()
+                .optional()
+                .describe("Max results to return (default: 5)"),
+        }),
+    },
+    forget: {
+        description: "Remove a specific memory entry by ID.",
+        inputSchema: z.object({
+            memoryId: z
+                .string()
+                .describe("The ID of the memory entry to remove"),
+        }),
+    },
+    journal: {
+        description: "Add a journal entry for today. Use for session notes, learnings, and reflections.",
+        inputSchema: z.object({
+            content: z.string().describe("Journal entry content"),
+        }),
+    },
+};

package/dist/plugins/shell/index.js

@@ -42,7 +42,7 @@ export const shellPlugin = (options = {}) => (builder) => {
                 data: { message: `Directory changed to ${newCwd}`, severity: "success" }
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "executeCommand",
                     toolCallId,
@@ -62,7 +62,7 @@ export const shellPlugin = (options = {}) => (builder) => {
                 data: { message: `Command executed successfully`, severity: "success" }
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "executeCommand",
                     toolCallId,
@@ -76,7 +76,7 @@ export const shellPlugin = (options = {}) => (builder) => {
         }
         catch (error) {
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "executeCommand",
                     toolCallId,

package/dist/plugins/skills/index.js

@@ -116,7 +116,7 @@ You have no skills yet. When you learn reusable patterns, create skills using \`
 // --- Prompt Builder ---
 /**
  * Create a prompt builder that generates the skills section
- * of the system prompt. Use alongside the brain prompt builder.
+ * of the system prompt. Use alongside the memory prompt builder.
  */
 export function createSkillsPromptBuilder(baseDir) {
     const expandedBase = expandPath(baseDir);
@@ -128,7 +128,7 @@ export function createSkillsPromptBuilder(baseDir) {
  * Skills Plugin for Melony
  *
  * Manages reusable skill definitions: load, create, update, list.
- * Fully independent from the brain plugin.
+ * Fully independent from the memory plugin.
  */
 export const skillsPlugin = (options) => (builder) => {
     const expandedBase = expandPath(options.baseDir);
@@ -155,7 +155,7 @@ export const skillsPlugin = (options) => (builder) => {
                 },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "loadSkill",
                     toolCallId,
@@ -165,7 +165,7 @@ export const skillsPlugin = (options) => (builder) => {
         }
         catch {
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "loadSkill",
                     toolCallId,
@@ -179,7 +179,7 @@ export const skillsPlugin = (options) => (builder) => {
         const { toolCallId } = event.data;
         const skillsList = await skills.list();
         yield {
-            type: "action:taskResult",
+            type: "action:result",
             data: {
                 action: "listSkills",
                 toolCallId,
@@ -197,7 +197,7 @@ export const skillsPlugin = (options) => (builder) => {
                 data: { message: `Skill "${title}" created`, severity: "success" },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "createSkill",
                     toolCallId,
@@ -218,7 +218,7 @@ export const skillsPlugin = (options) => (builder) => {
                 },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "createSkill",
                     toolCallId,
@@ -240,7 +240,7 @@ export const skillsPlugin = (options) => (builder) => {
                 },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "updateSkill",
                     toolCallId,
@@ -265,7 +265,7 @@ export const skillsPlugin = (options) => (builder) => {
                 },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "updateSkill",
                     toolCallId,

package/dist/registry/index.js

@@ -1,5 +1,2 @@
 export { PluginRegistry } from "./plugin-registry.js";
-export { AgentRegistry } from "./agent-registry.js";
-export { discoverYamlAgents, listYamlAgents } from "./yaml-agent-loader.js";
-export { discoverTsAgents } from "./ts-agent-loader.js";
-export { loadPluginsFromDir } from "./plugin-loader.js";
+export { discoverPlugins, listPlugins, readAgentConfig, getPluginMetadata, ensurePluginReady, } from "./plugin-loader.js";

package/dist/registry/plugin-loader.js

@@ -2,13 +2,42 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import { execSync } from "node:child_process";
-/**
- * Get metadata (name, description, version) from a plugin directory.
- */
+import matter from "gray-matter";
+import { PluginRegistry } from "./plugin-registry.js";
+import { llmPlugin } from "../plugins/llm/index.js";
+import { createModel } from "../models.js";
+import { resolvePath, DEFAULT_AGENT_MD } from "../config.js";
+// ── Helpers ──────────────────────────────────────────────────────────
+async function fileExists(filePath) {
+    return fs.access(filePath).then(() => true).catch(() => false);
+}
+async function findIndexFile(dir) {
+    for (const file of ["dist/index.js", "index.js", "index.ts"]) {
+        if (await fileExists(path.join(dir, file))) {
+            return path.join(dir, file);
+        }
+    }
+    return undefined;
+}
+function resolveConfigPaths(config) {
+    if (typeof config === "string")
+        return resolvePath(config);
+    if (Array.isArray(config))
+        return config.map(resolveConfigPaths);
+    if (config !== null && typeof config === "object") {
+        const resolved = {};
+        for (const [key, value] of Object.entries(config)) {
+            resolved[key] = resolveConfigPaths(value);
+        }
+        return resolved;
+    }
+    return config;
+}
+// ── Metadata ─────────────────────────────────────────────────────────
 export async function getPluginMetadata(pluginDir) {
     const pkgPath = path.join(pluginDir, "package.json");
-    const hasPackageJson = await fs.access(pkgPath).then(() => true).catch(() => false);
-    let name = path.basename(pluginDir);
+    const hasPackageJson = await fileExists(pkgPath);
+    let name = "Unnamed Plugin";
     let description = "No description";
     let version = "0.0.0";
     if (hasPackageJson) {
@@ -18,33 +47,23 @@ export async function getPluginMetadata(pluginDir) {
             description = pkg.description || description;
             version = pkg.version || version;
         }
-        catch {
-            // Fallback to defaults
-        }
+        catch { /* fallback to defaults */ }
     }
     return { name, description, version };
 }
-/**
- * Ensure a plugin is ready to run by installing dependencies and building if necessary.
- */
 export async function ensurePluginReady(pluginDir) {
     try {
         const pkgPath = path.join(pluginDir, "package.json");
-        const hasPackageJson = await fs.access(pkgPath).then(() => true).catch(() => false);
-        if (!hasPackageJson)
+        if (!(await fileExists(pkgPath)))
             return;
         const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
         const nodeModulesPath = path.join(pluginDir, "node_modules");
-        const hasNodeModules = await fs.access(nodeModulesPath).then(() => true).catch(() => false);
-        // 1. Install dependencies if node_modules is missing
-        if (!hasNodeModules) {
+        if (!(await fileExists(nodeModulesPath))) {
             console.log(`[plugins] Installing dependencies for ${path.basename(pluginDir)}...`);
             execSync("npm install", { cwd: pluginDir, stdio: "inherit" });
         }
-        // 2. Run build if dist is missing but build script exists
         const distPath = path.join(pluginDir, "dist");
-        const hasDist = await fs.access(distPath).then(() => true).catch(() => false);
-        if (!hasDist && pkg.scripts?.build) {
+        if (!(await fileExists(distPath)) && pkg.scripts?.build) {
             console.log(`[plugins] Building ${path.basename(pluginDir)}...`);
             execSync("npm run build", { cwd: pluginDir, stdio: "inherit" });
         }
@@ -53,57 +72,81 @@ export async function ensurePluginReady(pluginDir) {
         console.error(`[plugins] Failed to prepare plugin in ${pluginDir}:`, err);
     }
 }
-/**
- * Dynamically load plugins from a directory.
- * Scans each subdirectory for an index.js (or index.ts if running via tsx).
- */
-export async function loadPluginsFromDir(dir) {
-    const plugins = [];
+export async function readAgentConfig(agentDir) {
+    const mdPath = path.join(agentDir, "AGENT.md");
+    let mdContent = "";
     try {
-        await fs.access(dir);
+        mdContent = await fs.readFile(mdPath, "utf-8");
     }
     catch {
-        // Directory doesn't exist
-        return plugins;
+        mdContent = DEFAULT_AGENT_MD;
     }
+    const parsed = matter(mdContent);
+    const config = (parsed.data || {});
+    return {
+        name: typeof config.name === "string" ? config.name : "",
+        description: typeof config.description === "string" ? config.description : "",
+        model: config.model,
+        image: config.image,
+        plugins: config.plugins || [],
+        instructions: parsed.content.trim() || "",
+        subscribe: config.subscribe,
+    };
+}
+// ── Agent composition (declarative AGENT.md agents) ──────────────────
+function composeAgentFromConfig(config, toolRegistry, model) {
+    const allToolDefinitions = {};
+    const pluginFactories = [];
+    for (const pluginItem of config.plugins) {
+        const isString = typeof pluginItem === "string";
+        const pluginName = isString ? pluginItem : pluginItem.name;
+        const pluginConfig = isString ? {} : (pluginItem.config || {});
+        const resolvedConfig = resolveConfigPaths(pluginConfig);
+        const entry = toolRegistry.get(pluginName);
+        if (!entry || entry.type !== "tool") {
+            console.warn(`[plugins] "${config.name}": tool "${pluginName}" not found — skipping`);
+            continue;
+        }
+        pluginFactories.push({ plugin: entry.plugin, config: resolvedConfig });
+        Object.assign(allToolDefinitions, entry.toolDefinitions);
+    }
+    const plugin = (builder) => {
+        for (const { plugin: toolPlugin, config: resolvedConfig } of pluginFactories) {
+            builder.use(toolPlugin({ ...resolvedConfig, model }));
+        }
+        builder.use(llmPlugin({
+            model,
+            system: config.instructions,
+            toolDefinitions: allToolDefinitions,
+        }));
+    };
+    return { plugin, toolDefinitions: allToolDefinitions };
+}
+// ── Load tool plugins from a subdirectory (used for agent-local tools) ─
+async function loadToolPluginsFromDir(dir) {
+    const plugins = [];
+    if (!(await fileExists(dir)))
+        return plugins;
     try {
         const entries = await fs.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+            if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_"))
                 continue;
             const pluginDir = path.join(dir, entry.name);
-            // Ensure plugin is ready (dependencies, build)
             await ensurePluginReady(pluginDir);
-            // Try to find index.js or index.ts, prioritizing dist/index.js for pre-built bundles
-            let indexPath;
-            const possibleIndices = ["dist/index.js", "index.js", "index.ts"];
-            for (const file of possibleIndices) {
-                try {
-                    const fullPath = path.join(pluginDir, file);
-                    await fs.access(fullPath);
-                    indexPath = fullPath;
-                    break;
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (!indexPath) {
-                console.warn(`[plugins] No index.js or index.ts found in ${pluginDir}`);
+            const indexPath = await findIndexFile(pluginDir);
+            if (!indexPath)
                 continue;
-            }
             try {
-                // Use pathToFileURL for compatibility with import() on all OSs
-                const moduleUrl = pathToFileURL(indexPath).href;
-                const module = await import(moduleUrl);
-                // The plugin can be exported as 'plugin', 'default', or 'entry'
+                const module = await import(pathToFileURL(indexPath).href);
                 const entryData = module.plugin || module.default || module.entry;
                 if (entryData && typeof entryData.factory === "function") {
                     plugins.push({
-                        ...entryData,
-                        name: entryData.name || entry.name, // Fallback to folder name
+                        name: entryData.name || entry.name,
+                        description: entryData.description || `Tool plugin ${entry.name}`,
+                        type: "tool",
+                        plugin: entryData.factory,
+                        toolDefinitions: entryData.toolDefinitions || {},
                     });
                 }
                 else {
@@ -111,7 +154,7 @@ export async function loadPluginsFromDir(dir) {
                 }
             }
             catch (err) {
-                console.error(`[plugins] Failed to load plugin "${entry.name}":`, err);
+                console.error(`[plugins] Failed to load tool plugin "${entry.name}":`, err);
             }
         }
     }
@@ -120,3 +163,243 @@ export async function loadPluginsFromDir(dir) {
     }
     return plugins;
 }
+// ── Main unified discovery ───────────────────────────────────────────
+/**
+ * Discover all plugins (tools + agents) from a directory.
+ *
+ * Pass 1: Load code plugins in folders without AGENT.md.
+ *   - module.agent export → code-only agent
+ *   - plugin/default/entry export → tool plugin
+ * Pass 2: Load agent-type plugins (folders WITH AGENT.md).
+ *   - AGENT.md only → declarative agent (auto-wrapped with llmPlugin)
+ *   - AGENT.md + index.ts → TS agent (user controls logic, AGENT.md for UI editing)
+ *
+ * Discovered entries are registered directly into the provided registry.
+ */
+export async function discoverPlugins(dir, registry, defaultModel, options) {
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    catch { /* best effort */ }
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    // Classify each subdirectory
+    const codeDirs = [];
+    const agentDirs = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_"))
+            continue;
+        const pluginDir = path.join(dir, entry.name);
+        const hasAgentMd = await fileExists(path.join(pluginDir, "AGENT.md"));
+        const hasIndex = !!(await findIndexFile(pluginDir));
+        const hasPkg = await fileExists(path.join(pluginDir, "package.json"));
+        if (hasAgentMd) {
+            agentDirs.push({ dir: pluginDir, hasIndex: hasIndex || hasPkg });
+        }
+        else if (hasIndex || hasPkg) {
+            codeDirs.push(pluginDir);
+        }
+    }
+    // Pass 1: code-only agents and tool plugins
+    for (const pluginDir of codeDirs) {
+        await ensurePluginReady(pluginDir);
+        const indexPath = await findIndexFile(pluginDir);
+        if (!indexPath)
+            continue;
+        try {
+            const module = await import(pathToFileURL(indexPath).href);
+            const codeAgentDef = module.agent;
+            const entryData = module.plugin || module.default || module.entry;
+            if (codeAgentDef && typeof codeAgentDef.factory === "function") {
+                const meta = await getPluginMetadata(pluginDir);
+                const name = codeAgentDef.name || meta.name || "Unnamed Agent";
+                const description = codeAgentDef.description || meta.description || "Code Agent";
+                registry.register({
+                    name,
+                    description,
+                    type: "agent",
+                    plugin: codeAgentDef.factory({ ...options, model: defaultModel }),
+                    capabilities: codeAgentDef.capabilities,
+                    subscribe: codeAgentDef.subscribe,
+                    folder: pluginDir,
+                });
+                console.log(`[plugins] Loaded code-only agent: ${name} — ${description}`);
+            }
+            else if (entryData && typeof entryData.factory === "function") {
+                const meta = await getPluginMetadata(pluginDir);
+                const pluginEntry = {
+                    name: entryData.name || meta.name || "Unnamed Tool",
+                    description: entryData.description || meta.description || "Tool plugin",
+                    type: "tool",
+                    plugin: entryData.factory,
+                    toolDefinitions: entryData.toolDefinitions || {},
+                    folder: pluginDir,
+                };
+                registry.register(pluginEntry);
+                console.log(`[plugins] Loaded tool: ${pluginEntry.name}`);
+            }
+            else {
+                console.warn(`[plugins] "${path.basename(pluginDir)}" does not export a valid plugin (missing factory)`);
+            }
+        }
+        catch (err) {
+            console.error(`[plugins] Failed to load "${path.basename(pluginDir)}":`, err);
+        }
+    }
+    // Pass 2: agent plugins
+    for (const { dir: agentDir, hasIndex } of agentDirs) {
+        const folderName = path.basename(agentDir);
+        try {
+            if (hasIndex) {
+                // TS Agent — has AGENT.md + code. User controls logic; AGENT.md is for UI editing.
+                await ensurePluginReady(agentDir);
+                const indexPath = await findIndexFile(agentDir);
+                if (!indexPath)
+                    continue;
+                const module = await import(pathToFileURL(indexPath).href);
+                const definition = module.agent || module.plugin || module.default || module.entry;
+                if (definition && typeof definition.factory === "function") {
+                    const config = await readAgentConfig(agentDir);
+                    const meta = await getPluginMetadata(agentDir);
+                    const name = config.name || definition.name || meta.name || "Unnamed Agent";
+                    const description = definition.description || config.description || "TS Agent";
+                    registry.register({
+                        name,
+                        description,
+                        type: "agent",
+                        plugin: definition.factory({ ...options, model: defaultModel }),
+                        capabilities: definition.capabilities,
+                        subscribe: definition.subscribe || config.subscribe,
+                        folder: agentDir,
+                    });
+                    console.log(`[plugins] Loaded TS agent: ${name} — ${description}`);
+                }
+            }
+            else {
+                // Declarative Agent — AGENT.md only, auto-wrapped with llmPlugin.
+                const config = await readAgentConfig(agentDir);
+                const meta = await getPluginMetadata(agentDir);
+                const resolvedName = config.name || meta.name || "Unnamed Agent";
+                const resolvedDescription = config.description || meta.description || "No description";
+                const agentModel = config.model
+                    ? createModel({ ...options, model: config.model })
+                    : defaultModel;
+                // Load agent-local tool plugins
+                const localPlugins = await loadToolPluginsFromDir(path.join(agentDir, "plugins"));
+                // Scoped registry: global tools + local tools
+                const scopedRegistry = new PluginRegistry();
+                for (const p of registry.getTools()) {
+                    scopedRegistry.register(p);
+                }
+                for (const p of localPlugins) {
+                    scopedRegistry.register(p);
+                }
+                // Initialize AGENT.md if missing
+                const agentMdPath = path.join(agentDir, "AGENT.md");
+                if (!(await fileExists(agentMdPath))) {
+                    const content = DEFAULT_AGENT_MD.replace("name: Agent", `name: ${resolvedName}`);
+                    await fs.writeFile(agentMdPath, content, "utf-8");
+                    console.log(`[plugins] Initialized ${resolvedName}/AGENT.md`);
+                }
+                const { plugin, toolDefinitions } = composeAgentFromConfig(config, scopedRegistry, agentModel);
+                registry.register({
+                    name: resolvedName,
+                    description: resolvedDescription,
+                    type: "agent",
+                    plugin,
+                    capabilities: Object.fromEntries(Object.entries(toolDefinitions).map(([name, def]) => [name, def.description])),
+                    subscribe: config.subscribe,
+                    folder: agentDir,
+                });
+                console.log(`[plugins] Loaded agent: ${resolvedName} — ${resolvedDescription}${config.model ? ` (model: ${config.model})` : ""}`);
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                console.warn(`[plugins] Error loading "${folderName}":`, err);
+            }
+        }
+    }
+}
+// ── Lightweight listing (for API) ────────────────────────────────────
+export async function listPlugins(dir) {
+    const plugins = [];
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_"))
+                continue;
+            const pluginDir = path.join(dir, entry.name);
+            const hasAgentMd = await fileExists(path.join(pluginDir, "AGENT.md"));
+            const hasCode = await fileExists(path.join(pluginDir, "package.json"))
+                || !!(await findIndexFile(pluginDir));
+            if (hasAgentMd) {
+                const config = await readAgentConfig(pluginDir);
+                const { name: fallbackName, description: fallbackDescription } = await getPluginMetadata(pluginDir);
+                plugins.push({
+                    name: config.name || fallbackName || "Unnamed Agent",
+                    description: config.description || fallbackDescription || "No description",
+                    folder: pluginDir,
+                    type: "agent",
+                    hasAgentMd: true,
+                    image: config.image,
+                });
+            }
+            else if (hasCode) {
+                await ensurePluginReady(pluginDir);
+                const indexPath = await findIndexFile(pluginDir);
+                const { name: fallbackName, description: fallbackDescription } = await getPluginMetadata(pluginDir);
+                if (!indexPath) {
+                    plugins.push({
+                        name: fallbackName,
+                        description: fallbackDescription,
+                        folder: pluginDir,
+                        type: "tool",
+                        hasAgentMd: false,
+                    });
+                    continue;
+                }
+                try {
+                    const module = await import(pathToFileURL(indexPath).href);
+                    const codeAgentDef = module.agent;
+                    const toolEntry = module.plugin || module.default || module.entry;
+                    if (codeAgentDef && typeof codeAgentDef.factory === "function") {
+                        plugins.push({
+                            name: codeAgentDef.name || fallbackName || "Unnamed Agent",
+                            description: codeAgentDef.description || fallbackDescription || "Code Agent",
+                            folder: pluginDir,
+                            type: "agent",
+                            hasAgentMd: false,
+                            image: codeAgentDef.image,
+                        });
+                    }
+                    else if (toolEntry && typeof toolEntry.factory === "function") {
+                        plugins.push({
+                            name: toolEntry.name || fallbackName,
+                            description: toolEntry.description || fallbackDescription,
+                            folder: pluginDir,
+                            type: "tool",
+                            hasAgentMd: false,
+                        });
+                    }
+                }
+                catch {
+                    plugins.push({
+                        name: fallbackName,
+                        description: fallbackDescription,
+                        folder: pluginDir,
+                        type: "tool",
+                        hasAgentMd: false,
+                    });
+                }
+            }
+        }
+    }
+    catch { /* directory doesn't exist */ }
+    return plugins;
+}