openbot 0.4.4 → 0.4.6

package/dist/plugins/plugin-manager/index.js

@@ -54,64 +54,22 @@ export const pluginManagerPlugin = {
             });
             builder.on('action:channel:install', async function* (event) {
                 try {
-                    const { channelId: instanceId, name: templateName, participants: customParticipants, initialState: customInitialState, } = event.data;
-                    const { agents: marketplaceAgents, channels } = await resolveMarketplaceRegistry();
+                    const { channelId: instanceId, name: templateName, initialState: customInitialState, } = event.data;
+                    const { channels } = await resolveMarketplaceRegistry();
                     // Try to find the template by ID or Name
                     const channelListing = channels.find((c) => c.id === instanceId) ||
                         channels.find((c) => c.name === templateName);
                     const channelId = instanceId;
-                    const participants = customParticipants || channelListing?.participants || [];
                     const initialState = {
                         ...(channelListing?.initialState || {}),
                         ...(customInitialState || {}),
                     };
                     const spec = channelListing?.spec || '';
-                    // 1. Auto-install participant agents if missing
-                    for (const agentId of participants) {
-                        const existingAgents = await storage.getAgents();
-                        if (existingAgents.some((a) => a.id === agentId)) {
-                            continue;
-                        }
-                        // Not found locally, look in marketplace
-                        const agentListing = marketplaceAgents.find((a) => a.id === agentId);
-                        if (agentListing) {
-                            console.log(`[plugin-manager] Auto-installing agent ${agentId} for channel ${channelId}`);
-                            // Install plugins for this agent
-                            for (const ref of agentListing.plugins) {
-                                const installed = await pluginService.isInstalled(ref.id);
-                                if (!installed &&
-                                    ref.id.includes('/') === false &&
-                                    ref.id.includes('-plugin-') === false) {
-                                    continue;
-                                }
-                                if (!installed) {
-                                    try {
-                                        await pluginService.install({ packageName: ref.id });
-                                    }
-                                    catch (err) {
-                                        console.warn(`[plugins] Failed to pre-install plugin ${ref.id}`, err);
-                                    }
-                                }
-                            }
-                            // Create the agent
-                            await storage.createAgent({
-                                agentId: agentListing.id,
-                                name: agentListing.name,
-                                description: agentListing.description,
-                                image: agentListing.image,
-                                instructions: agentListing.instructions,
-                                plugins: agentListing.plugins,
-                            });
-                        }
-                    }
                     // 2. Create the channel
                     await storage.createChannel({
                         channelId,
                         spec,
-                        initialState: {
-                            ...initialState,
-                            participants,
-                        },
+                        initialState,
                     });
                     const channelUrl = `/channels/${channelId}`;
                     yield {

package/dist/plugins/storage/index.js

@@ -38,15 +38,10 @@ const storageToolDefinitions = {
                 .optional()
                 .describe('Markdown content for the channel specification (SPEC.md). Use for goals and rules.'),
             cwd: z.string().optional().describe('Current working directory for the channel.'),
-            participants: z
-                .array(z.string())
-                .optional()
-                .describe('List of agent IDs that are participants in this channel. When a user tags an agent (e.g. @agent-id), you should ensure they are added to this list if they are not already there.'),
         })
             .refine((value) => value.state !== undefined ||
             value.spec !== undefined ||
-            value.cwd !== undefined ||
-            value.participants !== undefined, { message: 'Provide at least one of state, spec, cwd, or participants.' }),
+            value.cwd !== undefined, { message: 'Provide at least one of state, spec, or cwd.' }),
     },
     patch_thread_details: {
         description: 'Patch current thread details (state).',
@@ -125,7 +120,7 @@ export const storagePlugin = {
             };
         });
         builder.on('action:create_channel', async function* (event, context) {
-            const { channelId, spec, initialState, cwd, participants } = event.data;
+            const { channelId, spec, initialState, cwd } = event.data;
             const rawChannelId = (channelId || '').trim();
             const channelSpec = typeof spec === 'string' ? spec : '';
             const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
@@ -139,15 +134,6 @@ export const storagePlugin = {
             }
             const channelUrl = `/channels/${rawChannelId}`;
             const mergedInitial = { ...(initialState || {}) };
-            if (participants !== undefined) {
-                const normalized = Array.isArray(participants)
-                    ? participants
-                        .filter((x) => typeof x === 'string')
-                        .map((s) => s.trim())
-                        .filter(Boolean)
-                    : [];
-                mergedInitial.participants = normalized;
-            }
             try {
                 await storage.createChannel({
                     channelId: rawChannelId,
@@ -232,18 +218,6 @@ export const storagePlugin = {
                 patch.cwd = data.cwd.trim();
                 updatedFields.push('cwd');
             }
-            if (data.participants !== undefined) {
-                if (Array.isArray(data.participants)) {
-                    patch.participants = data.participants
-                        .filter((x) => typeof x === 'string')
-                        .map((s) => s.trim())
-                        .filter(Boolean);
-                }
-                else {
-                    patch.participants = [];
-                }
-                updatedFields.push('participants');
-            }
             try {
                 if (updatedFields.length > 0) {
                     await storage.patchChannelState({ channelId: targetChannelId, state: patch });
@@ -293,19 +267,6 @@ export const storagePlugin = {
                     });
                     updatedFields.push('cwd');
                 }
-                if (data.participants !== undefined) {
-                    const normalized = Array.isArray(data.participants)
-                        ? data.participants
-                            .filter((x) => typeof x === 'string')
-                            .map((s) => s.trim())
-                            .filter(Boolean)
-                        : [];
-                    await storage.patchChannelState({
-                        channelId: context.state.channelId,
-                        state: { participants: normalized },
-                    });
-                    updatedFields.push('participants');
-                }
                 context.state.channelDetails = await storage.getChannelDetails({
                     channelId: context.state.channelId,
                 });

package/dist/plugins/storage/service.js

@@ -340,18 +340,16 @@ const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArr
 /** Display-oriented fields persisted in a channel's `state.json`. */
 const readChannelStateFileFields = (parsed) => {
     if (!isRecord(parsed)) {
-        return { participants: [] };
+        return {};
     }
     const name = typeof parsed.name === 'string' && parsed.name.trim() ? parsed.name.trim() : undefined;
     const cwd = typeof parsed.cwd === 'string' ? parsed.cwd : undefined;
-    const participants = [];
-    if (Array.isArray(parsed.participants)) {
-        for (const x of parsed.participants) {
-            if (typeof x === 'string' && x.trim())
-                participants.push(x.trim());
-        }
-    }
-    return { name, cwd, participants };
+    return { name, cwd };
+};
+const isChannelProvisioned = async (channelId) => {
+    const statePath = `${getConversationDir(channelId)}/state.json`;
+    const state = await readJsonFile(statePath, {});
+    return !!readChannelStateFileFields(state).cwd;
 };
 /**
  * Parse the `plugins:` array from AGENT.md frontmatter. Each entry must have an
@@ -412,23 +410,23 @@ export const storageService = {
             const statePath = path.join(channelDir, 'state.json');
             let cwd;
             let displayName = name;
-            let participants = [];
             try {
                 const parsed = await readJsonFile(statePath, {});
                 const fields = readChannelStateFileFields(parsed);
                 cwd = fields.cwd;
                 displayName = fields.name ?? name;
-                participants = fields.participants;
             }
             catch {
                 // ignore
             }
+            if (!cwd) {
+                return null;
+            }
             const channel = {
                 id: name,
                 name: displayName,
                 description: '',
                 cwd,
-                participants,
                 createdAt: stats.birthtime,
                 updatedAt: stats.mtime,
             };
@@ -452,7 +450,9 @@ export const storageService = {
             }
             return channel;
         }));
-        return channels.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return channels
+            .filter((channel) => channel !== null)
+            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     },
     createChannel: async ({ channelId, spec, initialState, cwd, }) => {
         const normalizedChannelId = channelId.trim();
@@ -486,6 +486,44 @@ export const storageService = {
             `# ${normalizedChannelId}\n\n`);
         await writeJsonFileAtomically(statePath, finalState);
     },
+    ensureChannel: async ({ channelId, spec, initialState, cwd, }) => {
+        const normalizedChannelId = channelId.trim();
+        if (!normalizedChannelId) {
+            throw new Error('channelId is required');
+        }
+        const channelDir = getConversationDir(normalizedChannelId);
+        const specPath = `${channelDir}/SPEC.md`;
+        const statePath = `${channelDir}/state.json`;
+        const existingState = await readJsonFile(statePath, {});
+        const existingFields = readChannelStateFileFields(existingState);
+        if (existingFields.cwd) {
+            await fs.mkdir(resolvePath(existingFields.cwd), { recursive: true });
+            return;
+        }
+        const finalState = {
+            ...existingState,
+            ...(initialState || {}),
+        };
+        const rawCwd = (typeof cwd === 'string' && cwd.trim()) ||
+            (typeof finalState.cwd === 'string' && finalState.cwd.trim()) ||
+            getDefaultChannelCwd(normalizedChannelId);
+        const resolvedCwd = resolvePath(rawCwd);
+        finalState.cwd = resolvedCwd;
+        await fs.mkdir(resolvedCwd, { recursive: true });
+        await fs.mkdir(channelDir, { recursive: true });
+        try {
+            await fs.access(specPath);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                await fs.writeFile(specPath, spec?.trim() || `# ${normalizedChannelId}\n\n`);
+            }
+            else {
+                throw error;
+            }
+        }
+        await writeJsonFileAtomically(statePath, finalState);
+    },
     deleteChannel: async ({ channelId }) => {
         const normalizedChannelId = channelId.trim();
         if (!normalizedChannelId) {
@@ -614,7 +652,7 @@ export const storageService = {
             id: threadId,
             name: threadName || threadId,
             channelId,
-            state,
+            state: (isRecord(state) ? state : {}),
         };
     },
     getChannelDetails: async ({ channelId }) => {
@@ -648,7 +686,6 @@ export const storageService = {
             spec,
             state,
             cwd,
-            participants: diskFields.participants,
         };
         details.threads = await storageService.getThreads({ channelId });
         return details;
@@ -1030,6 +1067,9 @@ export const storageService = {
     },
     storeEvent: async ({ channelId, threadId, event, }) => {
         try {
+            if (!(await isChannelProvisioned(channelId))) {
+                return;
+            }
             const threadDir = getConversationDir(channelId, threadId);
             if (threadId) {
                 let exists = false;

package/dist/services/plugins/service.js

@@ -74,20 +74,16 @@ export function parseMarketplaceRegistryJson(data) {
         const id = item.id;
         const name = item.name;
         const description = item.description;
-        const participants = item.participants;
         if (typeof id !== 'string' || !id)
             throw new Error(`channels[${i}].id must be a non-empty string`);
         if (typeof name !== 'string')
             throw new Error(`channels[${i}].name must be a string`);
         if (typeof description !== 'string')
             throw new Error(`channels[${i}].description must be a string`);
-        if (!Array.isArray(participants))
-            throw new Error(`channels[${i}].participants must be an array`);
         const listing = {
             id,
             name,
             description,
-            participants: participants.filter((p) => typeof p === 'string'),
         };
         if (typeof item.image === 'string')
             listing.image = item.image;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "private": false,
   "type": "module",
   "engines": {
@@ -16,6 +16,7 @@
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.33",
+    "@ai-sdk/google": "^3.0.82",
     "@ai-sdk/openai": "^3.0.13",
     "@anthropic-ai/claude-agent-sdk": "^0.2.138",
     "@types/cors": "^2.8.19",

package/src/app/channel-ids.ts

@@ -0,0 +1,5 @@
+/** Default channel when requests omit channelId (general-purpose conversation). */
+export const UNCATEGORIZED_CHANNEL_ID = 'uncategorized';
+
+export const DEFAULT_UNCATEGORIZED_SPEC =
+  '# Uncategorized\n\nGeneral-purpose channel for conversations without a dedicated channel.';

package/src/app/cli.ts

@@ -25,7 +25,7 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.4.4');
+program.name('openbot').description('OpenBot CLI').version('0.4.6');
 
 program
   .command('start')

package/src/app/responding-agent.ts

@@ -0,0 +1,74 @@
+import { ORCHESTRATOR_AGENT_ID } from './agent-ids.js';
+import { storageService } from '../plugins/storage/service.js';
+
+/** Thread `state.json` key for the sticky responding agent id. */
+export const THREAD_RESPONDING_AGENT_ID_KEY = 'respondingAgentId';
+
+export type ResolveRespondingAgentOptions = {
+  channelId: string;
+  threadId?: string;
+  requestedAgentId?: string;
+  /** When true, persist `respondingAgentId` on the first unbound thread touch. */
+  bindIfUnbound?: boolean;
+};
+
+export type ResolveRespondingAgentResult = {
+  agentId: string;
+  /** True when the thread already had or now has a persisted responding agent. */
+  bound: boolean;
+  /** True when the request asked for a different agent than the bound one. */
+  overridden: boolean;
+};
+
+const readBoundAgentId = (state: unknown): string | undefined => {
+  if (!state || typeof state !== 'object') return undefined;
+  const value = (state as Record<string, unknown>)[THREAD_RESPONDING_AGENT_ID_KEY];
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+};
+
+/**
+ * Resolves which agent should handle a thread-scoped publish.
+ * Once `respondingAgentId` is stored on the thread, that value wins over request overrides.
+ */
+export async function resolveRespondingAgentId(
+  options: ResolveRespondingAgentOptions,
+): Promise<ResolveRespondingAgentResult> {
+  const { channelId, threadId, requestedAgentId, bindIfUnbound = false } = options;
+  const requested = requestedAgentId?.trim() || undefined;
+  const fallback = requested || ORCHESTRATOR_AGENT_ID;
+
+  if (!threadId) {
+    return { agentId: fallback, bound: false, overridden: false };
+  }
+
+  const details = await storageService.getThreadDetails({ channelId, threadId });
+  const bound = readBoundAgentId(details.state);
+
+  if (bound) {
+    const overridden = !!requested && requested !== bound;
+    if (overridden) {
+      console.warn('[publish] Ignoring agentId override; thread is bound to responding agent', {
+        threadId,
+        bound,
+        requested,
+      });
+    }
+    return { agentId: bound, bound: true, overridden };
+  }
+
+  if (!bindIfUnbound) {
+    return { agentId: fallback, bound: false, overridden: false };
+  }
+
+  await storageService.getAgentDetails({ agentId: fallback });
+
+  await storageService.patchThreadState({
+    channelId,
+    threadId,
+    state: { [THREAD_RESPONDING_AGENT_ID_KEY]: fallback },
+  });
+
+  return { agentId: fallback, bound: true, overridden: false };
+}

package/src/app/server.ts

@@ -21,6 +21,11 @@ import {
 } from '../plugins/storage/files.js';
 import { ensureEventId, openBotEventFromQuery } from './utils.js';
 import { abortRegistry, abortKey } from '../services/abort.js';
+import { resolveRespondingAgentId } from './responding-agent.js';
+import {
+  DEFAULT_UNCATEGORIZED_SPEC,
+  UNCATEGORIZED_CHANNEL_ID,
+} from './channel-ids.js';
 
 type Bucket = { channelId: string; threadId?: string; activeCount: number; agentIds: Set<string> };
 
@@ -64,9 +69,18 @@ export async function startServer(options: ServerOptions = {}) {
   storageService.getAgents().catch((err) => console.warn('[server] Failed to pre-warm agents cache', err));
   storageService.getPlugins().catch((err) => console.warn('[server] Failed to pre-warm plugins cache', err));
 
+  const getRawChannelId = (req: express.Request): string | undefined => {
+    const raw =
+      req.get('x-openbot-channel-id') ||
+      req.query.channelId ||
+      (req.body && req.body.channelId);
+    if (typeof raw !== 'string') return undefined;
+    const trimmed = raw.trim();
+    return trimmed || undefined;
+  };
+
   const getContext = (req: express.Request) => {
-    const channelId =
-      req.get('x-openbot-channel-id') || req.query.channelId || (req.body && req.body.channelId);
+    const rawChannelId = getRawChannelId(req);
     const threadId =
       req.get('x-openbot-thread-id') || req.query.threadId || (req.body && req.body.threadId);
     const agentId =
@@ -82,7 +96,8 @@ export async function startServer(options: ServerOptions = {}) {
       (req.body && req.body.responseType);
 
     return {
-      channelId: (channelId || (threadId ? 'uncategorized' : 'uncategorized')) as string, // Default to uncategorized if none
+      channelId: (rawChannelId || UNCATEGORIZED_CHANNEL_ID) as string,
+      rawChannelId,
       threadId: threadId as string | undefined,
       agentId: agentId as string | undefined,
       runId: runId as string,
@@ -150,18 +165,71 @@ export async function startServer(options: ServerOptions = {}) {
     };
   };
 
+  const broadcastActiveRunsSnapshot = (): void => {
+    const snapshot = buildActiveRunsSnapshot();
+    ensureEventId(snapshot);
+    sendToClientKey(GLOBAL_CHANNEL_ID, snapshot);
+  };
+
+  const persistLifecycleEvent = (
+    event: OpenBotEvent,
+    targetChannelId: string,
+    targetThreadId?: string,
+  ): void => {
+    ensureEventId(event);
+    storageService
+      .storeEvent({
+        channelId: targetChannelId,
+        threadId: targetThreadId,
+        event,
+      })
+      .catch((error) => {
+        console.error('[server] Failed to persist lifecycle event', {
+          type: event.type,
+          channelId: targetChannelId,
+          threadId: targetThreadId,
+          error,
+        });
+      });
+  };
+
   // Drop every tracked run for a channel/thread. A stop aborts the whole
   // chain (parent + delegated sub-agents), but the sub-agents' `agent:run:end`
   // events can be swallowed when the parent run loop breaks on abort, leaving
-  // orphaned entries that keep a channel falsely "active". Purging by
-  // channel/thread guarantees the snapshot self-heals after a stop.
+  // orphaned entries that keep a channel falsely "active". Emit explicit
+  // `agent:run:end` for each purged run and refresh the global snapshot so
+  // clients stay in sync even when the parent harness stops yielding.
   const purgeActiveRunsForThread = (channelId: string, threadId?: string): void => {
     const target = threadId || undefined;
+    const removed: Array<{
+      runId: string;
+      channelId: string;
+      threadId?: string;
+      agentId: string;
+    }> = [];
+
     for (const [key, run] of activeRuns) {
       if (run.channelId === channelId && (run.threadId || undefined) === target) {
+        removed.push(run);
         activeRuns.delete(key);
       }
     }
+
+    for (const run of removed) {
+      const endEvent: OpenBotEvent = {
+        type: 'agent:run:end',
+        data: {
+          runId: run.runId,
+          agentId: run.agentId,
+          channelId: run.channelId,
+          threadId: run.threadId,
+        },
+      } as OpenBotEvent;
+      ensureEventId(endEvent);
+      persistLifecycleEvent(endEvent, run.channelId, run.threadId);
+      sendToClientKey(getClientKey(run.channelId, run.threadId), endEvent);
+      sendToClientKey(GLOBAL_CHANNEL_ID, endEvent);
+    }
   };
 
   // Support for Chrome's Private Network Access (PNA)
@@ -401,20 +469,38 @@ export async function startServer(options: ServerOptions = {}) {
       };
       const targetChannelId = data.channelId || channelId;
       const targetThreadId = data.threadId || threadId;
+      let resolvedStopAgentId = data.agentId || agentId || ORCHESTRATOR_AGENT_ID;
+      try {
+        const resolved = await resolveRespondingAgentId({
+          channelId: targetChannelId,
+          threadId: targetThreadId,
+          requestedAgentId: data.agentId || agentId,
+        });
+        resolvedStopAgentId = resolved.agentId;
+      } catch (error) {
+        console.warn('[publish] Failed to resolve responding agent for stop request', {
+          channelId: targetChannelId,
+          threadId: targetThreadId,
+          error,
+        });
+      }
       const stopped = abortRegistry.abort(abortKey(targetChannelId, targetThreadId));
       purgeActiveRunsForThread(targetChannelId, targetThreadId);
+      // Resync global clients even when nothing was tracked server-side.
+      broadcastActiveRunsSnapshot();
 
       const stoppedEvent: OpenBotEvent = {
         type: 'agent:run:stopped',
         data: {
           runId: data.runId || runId,
-          agentId: data.agentId || agentId || ORCHESTRATOR_AGENT_ID,
+          agentId: resolvedStopAgentId,
           channelId: targetChannelId,
           threadId: targetThreadId,
           reason: data.reason,
         },
       } as OpenBotEvent;
       ensureEventId(stoppedEvent);
+      persistLifecycleEvent(stoppedEvent, targetChannelId, targetThreadId);
       sendToClientKey(getClientKey(targetChannelId, targetThreadId), stoppedEvent);
       sendToClientKey(GLOBAL_CHANNEL_ID, stoppedEvent);
 
@@ -443,6 +529,7 @@ export async function startServer(options: ServerOptions = {}) {
         );
       } else if (chunk.type === 'agent:run:stopped') {
         purgeActiveRunsForThread(chunk.data.channelId, chunk.data.threadId);
+        broadcastActiveRunsSnapshot();
       }
 
       sendToClientKey(targetClientKey, chunk);
@@ -459,9 +546,31 @@ export async function startServer(options: ServerOptions = {}) {
     try {
       ensureEventId(event);
 
+      const isUserConversationStart =
+        event.type === 'agent:invoke' &&
+        event.data?.role === 'user' &&
+        typeof event.data.content === 'string' &&
+        event.data.content.trim().length > 0;
+
+      if (isUserConversationStart && channelId === UNCATEGORIZED_CHANNEL_ID) {
+        await storageService.ensureChannel({
+          channelId: UNCATEGORIZED_CHANNEL_ID,
+          spec: DEFAULT_UNCATEGORIZED_SPEC,
+          initialState: { name: 'Uncategorized' },
+        });
+      }
+
+      const bindIfUnbound = event.type === 'agent:invoke';
+      const resolved = await resolveRespondingAgentId({
+        channelId,
+        threadId,
+        requestedAgentId: agentId,
+        bindIfUnbound,
+      });
+
       await runAgent({
         runId,
-        agentId: agentId || ORCHESTRATOR_AGENT_ID,
+        agentId: resolved.agentId,
         event,
         channelId,
         threadId,
@@ -470,6 +579,13 @@ export async function startServer(options: ServerOptions = {}) {
       });
       res.sendStatus(200);
     } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const isUnknownAgent =
+        (error instanceof Error &&
+          ((error as Error & { code?: string }).code === 'AGENT_NOT_FOUND' ||
+            error.message.includes('does not exist'))) ||
+        message.includes('does not exist');
+
       console.error('[publish] Failed to dispatch event', {
         runId,
         channelId,
@@ -477,6 +593,12 @@ export async function startServer(options: ServerOptions = {}) {
         eventType: event.type,
         error,
       });
+
+      if (isUnknownAgent) {
+        res.status(400).json({ error: message });
+        return;
+      }
+
       res.status(500).json({ error: 'Failed to process publish event' });
     }
   });
@@ -493,6 +615,14 @@ export async function startServer(options: ServerOptions = {}) {
 
     const { channelId, threadId, agentId, runId } = getContext(req);
 
+    // In-memory active runs (not persisted). Mirrors the initial SSE frame on __global__.
+    if (channelId === GLOBAL_CHANNEL_ID && event.type === 'action:storage:get-active-runs') {
+      const snapshot = buildActiveRunsSnapshot();
+      ensureEventId(snapshot);
+      res.json({ events: [snapshot] });
+      return;
+    }
+
     if (event.type === 'action:storage:serve-file') {
       const filePath = (event.data as { path?: string })?.path;
       if (!channelId?.trim()) {