openbot 0.1.23 → 0.1.25

package/dist/agents/os-agent.js

@@ -1,8 +1,6 @@
 import { llmPlugin } from "../plugins/llm/index.js";
 import { shellPlugin, shellToolDefinitions } from "../plugins/shell/index.js";
-import { shellUIPlugin } from "../plugins/shell/ui.js";
 import { fileSystemPlugin, fileSystemToolDefinitions } from "../plugins/file-system/index.js";
-import { fileSystemUIPlugin } from "../plugins/file-system/ui.js";
 const DEFAULT_SYSTEM_PROMPT = `You are an OS Agent with access to the shell and file system.
 Your job is to help the user with file operations and command execution.
 You can read, write, list, and delete files, as well as execute shell commands.
@@ -12,9 +10,7 @@ export const osAgent = (options) => (builder) => {
     const { model, cwd = process.cwd(), systemPrompt = DEFAULT_SYSTEM_PROMPT } = options;
     builder
         .use(shellPlugin({ cwd }))
-        .use(shellUIPlugin())
         .use(fileSystemPlugin({ baseDir: "/" }))
-        .use(fileSystemUIPlugin())
         .use(llmPlugin({
         model,
         system: systemPrompt,

package/dist/agents/topic-agent.js

@@ -0,0 +1,32 @@
+import { generateText } from "ai";
+export const topicAgent = (options) => (builder) => {
+    builder.on("manager:completion", async function* (event, { state }) {
+        // Only title if it doesn't have one and there's history
+        if (state.title || !state.messages || state.messages.length === 0) {
+            return;
+        }
+        // Don't title if there are too few messages
+        if (state.messages.length < 2) {
+            return;
+        }
+        try {
+            const { text } = await generateText({
+                model: options.model,
+                system: "You are a Topic Agent. Create a very concise (3-5 words) title for the conversation based on the user's intent. Do not use quotes or special characters.",
+                prompt: `Analyze these messages and provide a title: ${JSON.stringify(state.messages.slice(0, 6))}`,
+            });
+            const newTitle = text.replace(/["']/g, "").trim();
+            if (newTitle) {
+                state.title = newTitle;
+                // Notify the client to refresh the sessions list in the sidebar
+                yield {
+                    type: "client:invalidate",
+                    data: { tags: ["sessions"] }
+                };
+            }
+        }
+        catch (error) {
+            console.error("[topic-agent] Failed to generate title:", error);
+        }
+    });
+};

package/dist/cli.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import * as readline from "node:readline/promises";
-import { saveConfig } from "./config.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { saveConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
 import { startServer } from "./server.js";
+import { ensurePluginReady } from "./registry/plugin-loader.js";
 const program = new Command();
 program
     .name("openbot")
@@ -20,13 +25,13 @@ program
     console.log("🍎 OpenBot Configuration");
     console.log("------------------------------------------");
     const models = [
-        { name: "GPT-5 Nano (OpenAI)", value: "openai:gpt-5-nano" },
-        { name: "GPT-4o (OpenAI)", value: "openai:gpt-4o" },
-        { name: "GPT-4o-mini (OpenAI)", value: "openai:gpt-4o-mini" },
-        { name: "Claude Opus 4.5 (Anthropic)", value: "anthropic:claude-opus-4-5-20251101" },
-        { name: "Claude Sonnet 4.5 (Anthropic)", value: "anthropic:claude-sonnet-4-5-20250929" },
-        { name: "Claude 3.7 Sonnet (Anthropic)", value: "anthropic:claude-3-7-sonnet-20250219" },
-        { name: "Claude 3.5 Sonnet (Anthropic)", value: "anthropic:claude-3-5-sonnet-20240620" },
+        { name: "GPT-5 Nano (OpenAI)", value: "openai/gpt-5-nano" },
+        { name: "GPT-4o (OpenAI)", value: "openai/gpt-4o" },
+        { name: "GPT-4o-mini (OpenAI)", value: "openai/gpt-4o-mini" },
+        { name: "Claude Opus 4.5 (Anthropic)", value: "anthropic/claude-opus-4-5-20251101" },
+        { name: "Claude Sonnet 4.5 (Anthropic)", value: "anthropic/claude-sonnet-4-5-20250929" },
+        { name: "Claude 3.7 Sonnet (Anthropic)", value: "anthropic/claude-3-7-sonnet-20250219" },
+        { name: "Claude 3.5 Sonnet (Anthropic)", value: "anthropic/claude-3-5-sonnet-20240620" },
     ];
     console.log("Please choose a model:");
     models.forEach((m, i) => console.log(`${i + 1}) ${m.name}`));
@@ -67,4 +72,105 @@ program
     .action(async (options) => {
     await startServer(options);
 });
+const plugin = program.command("plugin").description("Manage OpenBot plugins");
+plugin
+    .command("install <source>")
+    .description("Install a shared plugin from GitHub (user/repo) or a local path")
+    .action(async (source) => {
+    const isGitHub = source.includes("/") && !source.startsWith("/") && !source.startsWith(".");
+    const repoUrl = isGitHub ? `https://github.com/${source}.git` : source;
+    const tempDir = path.join(tmpdir(), `openbot-plugin-install-${Date.now()}`);
+    try {
+        console.log(`📦 Installing plugin from: ${repoUrl}`);
+        // 1. Clone or copy to temp directory
+        if (isGitHub) {
+            execSync(`git clone --depth 1 ${repoUrl} ${tempDir}`, { stdio: "inherit" });
+        }
+        else {
+            const absoluteSource = path.resolve(source);
+            await fs.mkdir(tempDir, { recursive: true });
+            execSync(`cp -R ${absoluteSource}/. ${tempDir}`, { stdio: "inherit" });
+        }
+        // 2. Identify name from package.json
+        let name = path.basename(source.replace(".git", ""));
+        const pkgPath = path.join(tempDir, "package.json");
+        if (await fs.access(pkgPath).then(() => true).catch(() => false)) {
+            try {
+                const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+                if (pkg.name)
+                    name = pkg.name.split("/").pop(); // Use last part of scoped names
+            }
+            catch {
+                // Fallback to source basename
+            }
+        }
+        const baseDir = resolvePath(DEFAULT_BASE_DIR);
+        const targetDir = path.join(baseDir, "plugins", name);
+        // 3. Move to target directory
+        await fs.mkdir(path.dirname(targetDir), { recursive: true });
+        if (await fs.access(targetDir).then(() => true).catch(() => false)) {
+            console.log(`⚠️  Plugin "${name}" already exists. Overwriting...`);
+            await fs.rm(targetDir, { recursive: true, force: true });
+        }
+        await fs.rename(tempDir, targetDir);
+        console.log(`✅ Moved to: ${targetDir}`);
+        // 4. Prepare
+        console.log(`⚙️  Preparing plugin "${name}"...`);
+        await ensurePluginReady(targetDir);
+        console.log(`\n🎉 Successfully installed plugin: ${name}`);
+        console.log(`This plugin is now available to all agents.`);
+    }
+    catch (err) {
+        console.error("\n❌ Plugin installation failed:", err instanceof Error ? err.message : String(err));
+        try {
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+        process.exit(1);
+    }
+});
+plugin
+    .command("list")
+    .description("List all installed shared plugins")
+    .action(async () => {
+    const baseDir = resolvePath(DEFAULT_BASE_DIR);
+    const pluginsDir = path.join(baseDir, "plugins");
+    try {
+        await fs.access(pluginsDir);
+    }
+    catch {
+        console.log("No shared plugins found.");
+        return;
+    }
+    const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+    const plugins = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+            continue;
+        const pkgPath = path.join(pluginsDir, entry.name, "package.json");
+        let description = "No description";
+        let version = "0.0.0";
+        try {
+            const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+            description = pkg.description || description;
+            version = pkg.version || version;
+        }
+        catch {
+            // Use defaults
+        }
+        plugins.push({ name: entry.name, version, description });
+    }
+    if (plugins.length === 0) {
+        console.log("No shared plugins found.");
+        return;
+    }
+    console.log("\n🔌 Installed Shared Plugins:");
+    console.log("------------------------------------------");
+    for (const p of plugins) {
+        console.log(`${p.name.padEnd(20)} (${p.version}) - ${p.description}`);
+    }
+    console.log("------------------------------------------\n");
+});
 program.parse();

package/dist/handlers/settings.js

@@ -0,0 +1,29 @@
+import { saveConfig } from "../config.js";
+import { tabOnlyUI } from "../ui/layout.js";
+/**
+ * Handle settings updates (like API keys)
+ */
+export async function* updateSettingsHandler(event, { state }) {
+    const { openai_api_key, anthropic_api_key, model } = event.data;
+    const updates = {};
+    if (model) {
+        updates.model = model.trim();
+    }
+    if (openai_api_key && openai_api_key !== "••••••••••••••••") {
+        updates.openaiApiKey = openai_api_key.trim();
+    }
+    if (anthropic_api_key && anthropic_api_key !== "••••••••••••••••") {
+        updates.anthropicApiKey = anthropic_api_key.trim();
+    }
+    if (Object.keys(updates).length > 0) {
+        saveConfig(updates);
+        // Refresh the settings UI to show the "saved" state (masking the keys)
+        yield {
+            type: "ui",
+            meta: {
+                type: "content",
+            },
+            data: await tabOnlyUI({ tab: "settings" })
+        };
+    }
+}

package/dist/models.js

@@ -3,16 +3,9 @@ import { anthropic } from "@ai-sdk/anthropic";
 import { loadConfig } from "./config.js";
 /**
  * Parse model string to extract provider and model ID
- * Supports formats: "provider:model", "provider/model", or just "model" (defaults to openai)
+ * Supports formats: "provider/model" or just "model" (defaults to openai)
  */
 export function parseModelString(modelString) {
-    // Check for provider:model format
-    if (modelString.includes(":")) {
-        const [provider, modelId] = modelString.split(":");
-        if (provider === "openai" || provider === "anthropic") {
-            return { provider: provider, modelId };
-        }
-    }
     // Check for provider/model format
     if (modelString.includes("/")) {
         const [provider, modelId] = modelString.split("/");

package/dist/open-bot.js

@@ -1,25 +1,21 @@
 import { melony } from "melony";
 import { osAgent } from "./agents/os-agent.js";
-import { browserAgent } from "./agents/browser-agent.js";
-import { browserUIPlugin } from "./plugins/browser/ui.js";
+import { topicAgent } from "./agents/topic-agent.js";
 import { brainPlugin, brainToolDefinitions, createBrainPromptBuilder } from "./plugins/brain/index.js";
-import { brainUIPlugin } from "./plugins/brain/ui.js";
 import { llmPlugin } from "./plugins/llm/index.js";
 import { initHandler } from "./handlers/init.js";
 import { sessionChangeHandler } from "./handlers/session-change.js";
 import { tabChangeHandler } from "./handlers/tab-change.js";
+import { updateSettingsHandler } from "./handlers/settings.js";
 import { loadConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
 import { createModel } from "./models.js";
 import path from "node:path";
 import { z } from "zod";
 // Plugin imports for the registry
 import { shellPlugin, shellToolDefinitions } from "./plugins/shell/index.js";
-import { shellUIPlugin } from "./plugins/shell/ui.js";
 import { fileSystemPlugin, fileSystemToolDefinitions } from "./plugins/file-system/index.js";
-import { fileSystemUIPlugin } from "./plugins/file-system/ui.js";
-import { browserPlugin, browserToolDefinitions } from "./plugins/browser/index.js";
 // Registry
-import { PluginRegistry, AgentRegistry, discoverYamlAgents } from "./registry/index.js";
+import { PluginRegistry, AgentRegistry, discoverYamlAgents, loadPluginsFromDir } from "./registry/index.js";
 /**
  * Create the OpenBot manager agent.
  *
@@ -43,44 +39,40 @@ export async function createOpenBot(options) {
         description: "Execute shell commands",
         toolDefinitions: shellToolDefinitions,
         factory: () => shellPlugin({ cwd: process.cwd() }),
-        uiFactory: () => shellUIPlugin(),
     });
     pluginRegistry.register({
         name: "file-system",
         description: "Read, write, list, and delete files",
         toolDefinitions: fileSystemToolDefinitions,
         factory: () => fileSystemPlugin({ baseDir: "/" }),
-        uiFactory: () => fileSystemUIPlugin(),
-    });
-    pluginRegistry.register({
-        name: "browser",
-        description: "Browse the web and interact with pages",
-        toolDefinitions: browserToolDefinitions,
-        factory: () => browserPlugin({
-            headless: true,
-            userDataDir,
-            channel: "chrome",
-            model: model,
-        }),
-        uiFactory: () => browserUIPlugin(),
     });
+    // ─── Shared Plugins ──────────────────────────────────────────────
+    // Load community/user plugins from ~/.openbot/plugins/
+    const sharedPlugins = await loadPluginsFromDir(path.join(resolvedBaseDir, "plugins"));
+    for (const p of sharedPlugins) {
+        pluginRegistry.register(p);
+        console.log(`[plugins] Loaded shared plugin: ${p.name}`);
+    }
     // ─── Agent Registry ──────────────────────────────────────────────
     // Register built-in agents, then discover YAML agents from ~/.openbot/agents/.
     const agentRegistry = new AgentRegistry();
     agentRegistry.register({
         name: "os",
         description: "Handles shell commands and file system operations",
+        capabilities: {
+            ...Object.fromEntries(Object.entries(shellToolDefinitions).map(([k, v]) => [k, v.description])),
+            ...Object.fromEntries(Object.entries(fileSystemToolDefinitions).map(([k, v]) => [
+                k,
+                v.description,
+            ])),
+        },
         plugin: osAgent({ model: model }),
     });
     agentRegistry.register({
-        name: "browser",
-        description: "Browses the web, extracts data, and interacts with pages",
-        plugin: browserAgent({
-            model: model,
-            headless: true,
-            userDataDir,
-            channel: "chrome",
-        }),
+        name: "topic",
+        description: "Automatically titles threads",
+        plugin: topicAgent({ model: model }),
+        subscribe: ["manager:completion"],
     });
     // Discover community / user agents from ~/.openbot/agents/
     const yamlAgents = await discoverYamlAgents(path.join(resolvedBaseDir, "agents"), pluginRegistry, model, options);
@@ -94,35 +86,76 @@ export async function createOpenBot(options) {
     // 1. Register all agent plugins
     for (const agent of allAgents) {
         app.use(agent.plugin);
+        // Choreography bridge: Auto-wire subscriptions
+        if (agent.subscribe) {
+            for (const eventType of agent.subscribe) {
+                app.on(eventType, async function* (event, { state }) {
+                    // Avoid self-triggering if the event has agent meta
+                    if (event.meta?.agent === agent.name)
+                        return;
+                    yield {
+                        type: `agent:${agent.name}:input`,
+                        data: {
+                            content: `Event observed: ${event.type}\nData: ${JSON.stringify(event.data)}`,
+                        },
+                        meta: {
+                            background: true,
+                            agent: agent.name
+                        },
+                    };
+                });
+            }
+        }
     }
     // 2. Register global plugins (brain, UI, etc.)
     const buildBrainPrompt = createBrainPromptBuilder(baseDir);
     app
-        .use(browserUIPlugin())
         .use(brainPlugin({
         baseDir: resolvedBaseDir,
         allowSoulModification: false,
-    }))
-        .use(brainUIPlugin());
+    }));
     // 3. Build dynamic delegation tool from the agent registry
     const agentDescriptions = allAgents
-        .map((a) => `- ${a.name}: ${a.description}`)
-        .join("\n");
+        .map((a) => {
+        const tools = a.capabilities
+            ? Object.entries(a.capabilities)
+                .map(([name, desc]) => `    - ${name}: ${desc}`)
+                .join("\n")
+            : "";
+        return `- **${a.name}**: ${a.description}${tools ? `\n  Capabilities:\n${tools}` : ""}`;
+    })
+        .join("\n\n");
     app.use(llmPlugin({
         model: model,
         system: async (context) => {
             const [brainPrompt] = await Promise.all([
                 buildBrainPrompt(context),
             ]);
-            return `${brainPrompt}`;
+            return `${brainPrompt}
+
+## Delegation & Specialized Agents
+You are the **Manager Agent**. Your primary role is to orchestrate tasks by delegating them to specialized agents when appropriate. 
+If a task falls outside your core capabilities (memory and orchestration), you **MUST** use the \`delegateTask\` tool.
+
+### Available Agents:
+${agentDescriptions}
+
+### Delegation Guidelines:
+1. **Choose the Best Expert**: Analyze the user's request and select the agent whose description most closely matches the required expertise.
+2. **Task Description**: When delegating, provide a clear and detailed task description. Include any context the agent might need to succeed.
+3. **No "I Can't"**: If an agent is available that can handle a request, do not tell the user you cannot do it. Simply delegate.
+4. **Summary**: Once an agent returns a result, summarize the findings or actions for the user.
+
+Example: If the user asks to "check the weather", and you see a 'browser' agent, delegate the task to it.`;
         },
+        completionEventType: "manager:completion",
         toolDefinitions: {
             ...brainToolDefinitions,
             delegateTask: {
-                description: `Delegate a task to a specialized agent.\n\nAvailable agents:\n${agentDescriptions}`,
+                description: `Delegate a specialized task to another agent. Use this whenever a task matches the capabilities of one of the available agents.`,
                 inputSchema: z.object({
                     agent: z.enum(agentNames).describe("The specialized agent to use"),
-                    task: z.string().describe("The task description"),
+                    task: z.string().describe("The detailed task description for the agent"),
                 }),
             },
         },
@@ -161,6 +194,7 @@ export async function createOpenBot(options) {
     app
         .on("init", initHandler)
         .on("sessionChange", sessionChangeHandler)
-        .on("tabChange", tabChangeHandler);
+        .on("tabChange", tabChangeHandler)
+        .on("action:updateSettings", updateSettingsHandler);
     return app;
 }

package/dist/plugins/brain/identity.js

@@ -17,17 +17,18 @@ const DEFAULT_SOUL = `# Soul
 `;
 const DEFAULT_IDENTITY = `# Identity
 
-I am OpenBot, a self-evolving AI assistant built on the OpenBot framework.
+I am the Manager Agent and central orchestrator of this AI system. My name and specific personality are defined by the user in this IDENTITY.md file.
 
 ## Personality
 - Friendly and approachable
 - Technically competent
 - Eager to learn and adapt
+- Professional manager and delegator
 
 ## Capabilities
-- Shell command execution
-- File system operations
-- Skill-based task execution
+- Task Orchestration & Delegation
+- Long-term Memory & Knowledge Management
+- Executing specialized tasks via expert agents (Web, OS, etc.)
 - Self-modification and learning
 `;
 // --- Factory ---

package/dist/plugins/brain/index.js

@@ -1,3 +1,4 @@
+import { ui } from "@melony/ui-kit/server";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { createIdentityModule } from "./identity.js";
@@ -6,7 +7,6 @@ import { buildBrainPrompt } from "./prompt.js";
 // Re-exports
 export { brainToolDefinitions } from "./types.js";
 export { buildBrainPrompt } from "./prompt.js";
-// --- Helpers ---
 function expandPath(p) {
     if (p.startsWith("~/")) {
         return path.join(process.env.HOME || "", p.slice(2));
@@ -265,5 +265,8 @@ export const brainPlugin = (options) => (builder) => {
             };
         }
     });
+    builder.on("brain:status", async function* (event) {
+        yield ui.event(ui.status(event.data.message, event.data.severity));
+    });
 };
 export default brainPlugin;

package/dist/plugins/brain/prompt.js

@@ -18,26 +18,26 @@ export async function buildBrainPrompt(baseDir, modules, context) {
     // 1. Environment context
     const now = new Date();
     parts.push(`## Environment
-You are running as a global system agent.
+You are the **Manager Agent**, the central orchestrator of this system.
 - **Current Time**: ${now.toLocaleString()} (${Intl.DateTimeFormat().resolvedOptions().timeZone})
 - **Current Working Directory (CWD)**: ${currentCwd}
 - **System Access**: You have access to the entire file system (root: /).
 - **Bot Home (Internal State)**: ${baseDir}
 
+### Delegation Policy:
+You are designed to delegate specialized tasks to expert agents. Analyze the "Available Agents" list provided in your instructions and delegate whenever a user request matches an agent's expertise. You should not claim you cannot perform a task if a suitable agent is available.
+
 ### Path Rules:
 1. **Shell Commands**: All commands (executeCommand) run in the CWD: ${currentCwd}.
 2. **File Operations**: Relative paths in readFile, writeFile, listFiles, etc. resolve against the CWD.
-3. **Changing Directory**: Use \`cd <path>\` in executeCommand to move. Your CWD is persisted across turns.
-4. **Skills/Memory**: To access your own skills and memory, use absolute paths starting with "${baseDir}/".
-
-When you want to execute skill scripts, always use the full path to the skill directory.`);
+3. **Changing Directory**: Use \`cd <path>\` in executeCommand to move. Your CWD is persisted across turns.`);
     // 2. Identity (small, always included)
     const soul = await modules.identity.getSoul();
     if (soul)
-        parts.push(soul);
+        parts.push(`<soul>\n${soul}\n</soul>`);
     const identity = await modules.identity.getIdentity();
     if (identity)
-        parts.push(identity);
+        parts.push(`<identity>\n${identity}\n</identity>`);
     // 3. Recent memories (lean — just a few to keep context fresh)
     const recentFacts = await modules.memory.getRecentFacts(3);
     if (recentFacts.length > 0) {

package/dist/plugins/brain/types.js

@@ -44,7 +44,7 @@ export const brainToolDefinitions = {
     },
     // Identity tools
     updateIdentity: {
-        description: "Update your identity file to refine your personality and traits.",
+        description: "Update your identity file to refine your personality and traits. Start it with # Identity.",
         inputSchema: z.object({
             content: z.string().describe("New content for IDENTITY.md"),
         }),

package/dist/plugins/file-system/index.js

@@ -1,3 +1,4 @@
+import { ui } from "@melony/ui-kit/server";
 import { z } from "zod";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -163,4 +164,7 @@ export const fileSystemPlugin = (options = {}) => (builder) => {
             };
         }
     });
+    builder.on("file-system:status", async function* (event) {
+        yield ui.event(ui.status(event.data.message, event.data.severity));
+    });
 };

package/dist/plugins/llm/index.js

@@ -1,5 +1,4 @@
 import { streamText } from "ai";
-import { ui } from "@melony/ui-kit";
 /**
  * Builds a simple history summary from recent messages.
  * Keeps the last N messages as simple role/content pairs.
@@ -53,7 +52,16 @@ export const llmPlugin = (options) => (builder) => {
             }
         }
         const usage = await result.usage;
-        yield ui.event(ui.status(`Usage: ${usage.totalTokens} tokens`, "info"));
+        if (!state.usage) {
+            state.usage = {
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0,
+            };
+        }
+        state.usage.inputTokens += usage.inputTokens ?? 0;
+        state.usage.outputTokens += usage.outputTokens ?? 0;
+        state.usage.totalTokens += usage.totalTokens ?? 0;
         // Emit tool call events
         for (const call of toolCalls) {
             yield {

package/dist/plugins/shell/index.js

@@ -1,3 +1,4 @@
+import { ui } from "@melony/ui-kit/server";
 import { z } from "zod";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
@@ -92,4 +93,7 @@ export const shellPlugin = (options = {}) => (builder) => {
             };
         }
     });
+    builder.on("shell:status", async function* (event) {
+        yield ui.event(ui.status(event.data.message, event.data.severity));
+    });
 };

package/dist/plugins/skills/index.js

@@ -1,3 +1,4 @@
+import { ui } from "@melony/ui-kit/server";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import matter from "gray-matter";
@@ -271,5 +272,13 @@ export const skillsPlugin = (options) => (builder) => {
             };
         }
     });
+    builder.on("skills:status", async function* (event) {
+        yield ui.event(ui.status(event.data.message, event.data.severity));
+    });
+    builder.on("skills:loaded", async function* (event) {
+        yield ui.event(ui.resourceCard(event.data.title, "", [
+            ui.text(event.data.instructions),
+        ]));
+    });
 };
 export default skillsPlugin;

package/dist/registry/index.js

@@ -1,3 +1,4 @@
 export { PluginRegistry } from "./plugin-registry.js";
 export { AgentRegistry } from "./agent-registry.js";
 export { discoverYamlAgents } from "./yaml-agent-loader.js";
+export { loadPluginsFromDir } from "./plugin-loader.js";