openbot 0.4.5 → 0.4.6

package/src/plugins/plugin-manager/index.ts

@@ -67,10 +67,9 @@ export const pluginManagerPlugin: Plugin = {
           const {
             channelId: instanceId,
             name: templateName,
-            participants: customParticipants,
             initialState: customInitialState,
           } = event.data;
-          const { agents: marketplaceAgents, channels } = await resolveMarketplaceRegistry();
+          const { channels } = await resolveMarketplaceRegistry();
 
           // Try to find the template by ID or Name
           const channelListing =
@@ -78,64 +77,17 @@ export const pluginManagerPlugin: Plugin = {
             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}`;

package/src/plugins/storage/index.ts

@@ -48,20 +48,13 @@ const storageToolDefinitions = {
             '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: {
@@ -155,7 +148,7 @@ export const storagePlugin: Plugin = {
     });
 
     builder.on('action:create_channel', async function* (event, context) {
-      const { channelId, spec, initialState, cwd, participants } = (event as any).data;
+      const { channelId, spec, initialState, cwd } = (event as any).data;
       const rawChannelId = (channelId || '').trim();
       const channelSpec = typeof spec === 'string' ? spec : '';
 
@@ -173,15 +166,6 @@ export const storagePlugin: Plugin = {
       const channelUrl = `/channels/${rawChannelId}`;
 
       const mergedInitial: Record<string, unknown> = { ...(initialState || {}) };
-      if (participants !== undefined) {
-        const normalized = Array.isArray(participants)
-          ? participants
-            .filter((x: unknown): x is string => typeof x === 'string')
-            .map((s: string) => s.trim())
-            .filter(Boolean)
-          : [];
-        mergedInitial.participants = normalized;
-      }
 
       try {
         await storage.createChannel({
@@ -254,7 +238,6 @@ export const storagePlugin: Plugin = {
         channelId?: string;
         name?: string;
         cwd?: string;
-        participants?: string[];
       };
       const targetChannelId = (data.channelId || context.state.channelId || '').trim();
       const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
@@ -279,17 +262,6 @@ export const storagePlugin: Plugin = {
         patch.cwd = data.cwd.trim();
         updatedFields.push('cwd');
       }
-      if (data.participants !== undefined) {
-        if (Array.isArray(data.participants)) {
-          patch.participants = data.participants
-            .filter((x): x is string => typeof x === 'string')
-            .map((s) => s.trim())
-            .filter(Boolean);
-        } else {
-          patch.participants = [];
-        }
-        updatedFields.push('participants');
-      }
 
       try {
         if (updatedFields.length > 0) {
@@ -317,13 +289,12 @@ export const storagePlugin: Plugin = {
     });
 
     builder.on('action:patch_channel_details', async function* (event, context) {
-      const updatedFields: ('state' | 'spec' | 'cwd' | 'participants')[] = [];
+      const updatedFields: ('state' | 'spec' | 'cwd')[] = [];
       const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
       const data = (event.data || {}) as {
         state?: Record<string, unknown>;
         spec?: string;
         cwd?: string;
-        participants?: string[];
       };
       try {
         if (data.state !== undefined) {
@@ -347,19 +318,6 @@ export const storagePlugin: Plugin = {
           });
           updatedFields.push('cwd');
         }
-        if (data.participants !== undefined) {
-          const normalized = Array.isArray(data.participants)
-            ? data.participants
-              .filter((x): x is string => 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/src/plugins/storage/service.ts

@@ -418,20 +418,20 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
 /** Display-oriented fields persisted in a channel's `state.json`. */
 const readChannelStateFileFields = (
   parsed: unknown,
-): { name?: string; cwd?: string; participants: string[] } => {
+): { name?: string; cwd?: string } => {
   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: string[] = [];
-  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: string): Promise<boolean> => {
+  const statePath = `${getConversationDir(channelId)}/state.json`;
+  const state = await readJsonFile(statePath, {});
+  return !!readChannelStateFileFields(state).cwd;
 };
 
 /**
@@ -507,24 +507,25 @@ export const storageService = {
         const statePath = path.join(channelDir, 'state.json');
         let cwd: string | undefined;
         let displayName = name;
-        let participants: string[] = [];
 
         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: Channel = {
           id: name,
           name: displayName,
           description: '',
           cwd,
-          participants,
           createdAt: stats.birthtime,
           updatedAt: stats.mtime,
         };
@@ -554,7 +555,9 @@ export const storageService = {
       }),
     );
 
-    return channels.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return channels
+      .filter((channel): channel is Channel => channel !== null)
+      .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
   },
   createChannel: async ({
     channelId,
@@ -606,6 +609,64 @@ export const storageService = {
     );
     await writeJsonFileAtomically(statePath, finalState);
   },
+  ensureChannel: async ({
+    channelId,
+    spec,
+    initialState,
+    cwd,
+  }: {
+    channelId: string;
+    spec?: string;
+    initialState?: Record<string, unknown>;
+    cwd?: string;
+  }): Promise<void> => {
+    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<Record<string, unknown>>(statePath, {});
+    const existingFields = readChannelStateFileFields(existingState);
+    if (existingFields.cwd) {
+      await fs.mkdir(resolvePath(existingFields.cwd), { recursive: true });
+      return;
+    }
+
+    const finalState: Record<string, unknown> = {
+      ...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: unknown) {
+      if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') {
+        await fs.writeFile(
+          specPath,
+          spec?.trim() || `# ${normalizedChannelId}\n\n`,
+        );
+      } else {
+        throw error;
+      }
+    }
+
+    await writeJsonFileAtomically(statePath, finalState);
+  },
   deleteChannel: async ({ channelId }: { channelId: string }): Promise<void> => {
     const normalizedChannelId = channelId.trim();
     if (!normalizedChannelId) {
@@ -808,7 +869,6 @@ export const storageService = {
       spec,
       state,
       cwd,
-      participants: diskFields.participants,
     };
 
     details.threads = await storageService.getThreads({ channelId });
@@ -1290,6 +1350,10 @@ export const storageService = {
     event: OpenBotEvent;
   }): Promise<void> => {
     try {
+      if (!(await isChannelProvisioned(channelId))) {
+        return;
+      }
+
       const threadDir = getConversationDir(channelId, threadId);
       if (threadId) {
         let exists = false;

package/src/services/plugins/domain.ts

@@ -64,8 +64,6 @@ export type Channel = {
   name: string;
   description: string;
   cwd?: string;
-  /** Agent ids associated with this channel (from `state.json`). */
-  participants: string[];
   createdAt: Date;
   updatedAt: Date;
   hasUnseenMessages?: boolean;
@@ -108,8 +106,6 @@ export type ChannelDetails = {
   spec: string;
   state: unknown;
   cwd?: string;
-  /** Agent ids for this channel (from `state.json`). */
-  participants: string[];
   threads?: Thread[];
 };
 
@@ -121,6 +117,13 @@ export interface Storage {
     initialState?: Record<string, unknown>;
     cwd?: string;
   }) => Promise<void>;
+  /** Idempotent channel setup; repairs partial dirs missing cwd/state. */
+  ensureChannel: (args: {
+    channelId: string;
+    spec?: string;
+    initialState?: Record<string, unknown>;
+    cwd?: string;
+  }) => Promise<void>;
   /** Removes the channel directory and cleans up `_meta/last-read.json`. */
   deleteChannel: (args: { channelId: string }) => Promise<void>;
   createThread: (args: {

package/src/services/plugins/service.ts

@@ -49,8 +49,6 @@ export type MarketplaceChannelListing = {
   image?: string;
   spec?: string;
   initialState?: Record<string, unknown>;
-  /** List of agent IDs that should be participants in the channel. */
-  participants: string[];
   /** Starter prompts for the channel. */
   starterPrompts?: StarterPrompt[];
 };
@@ -133,21 +131,17 @@ export function parseMarketplaceRegistryJson(data: unknown): MarketplaceRegistry
       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: MarketplaceChannelListing = {
         id,
         name,
         description,
-        participants: participants.filter((p): p is string => typeof p === 'string'),
       };
 
       if (typeof item.image === 'string') listing.image = item.image;

package/dist/plugins/thread-naming/generate-title.js

@@ -1,44 +0,0 @@
-import { generateText } from 'ai';
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-const THREAD_TITLE_MAX_LENGTH = 80;
-function resolveModel(modelString) {
-    const [provider, ...rest] = modelString.split('/');
-    const modelId = rest.join('/');
-    if (!modelId) {
-        throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
-    }
-    switch (provider) {
-        case 'openai':
-            return openai(modelId);
-        case 'anthropic':
-            return anthropic(modelId);
-        default:
-            throw new Error(`Unsupported AI provider: "${provider}"`);
-    }
-}
-function normalizeTitle(raw) {
-    let title = raw
-        .replace(/^["'`]+|["'`]+$/g, '')
-        .replace(/[.!?]+$/g, '')
-        .replace(/\s+/g, ' ')
-        .trim();
-    if (!title)
-        return '';
-    if (title.length > THREAD_TITLE_MAX_LENGTH) {
-        title = `${title.slice(0, THREAD_TITLE_MAX_LENGTH).trimEnd()}...`;
-    }
-    return title;
-}
-export async function generateThreadTitle(content, modelString) {
-    const normalized = content.replace(/\s+/g, ' ').trim();
-    if (!normalized)
-        return undefined;
-    const result = await generateText({
-        model: resolveModel(modelString),
-        system: 'You name chat threads. Reply with ONLY a short title (3-6 words). No quotes, no trailing punctuation.',
-        prompt: normalized.slice(0, 500),
-        maxOutputTokens: 20,
-    });
-    return normalizeTitle(result.text) || undefined;
-}

package/dist/plugins/thread-naming/index.js

@@ -1,103 +0,0 @@
-import { ORCHESTRATOR_AGENT_ID } from '../../app/agent-ids.js';
-import { loadConfig } from '../../app/config.js';
-import { generateThreadTitle } from './generate-title.js';
-const namingInFlight = new Set();
-function resolveNamingModel(pluginConfig, agentPluginRefs) {
-    const fromPlugin = typeof pluginConfig.model === 'string' ? pluginConfig.model.trim() : '';
-    if (fromPlugin)
-        return fromPlugin;
-    const openbotRef = agentPluginRefs?.find((ref) => ref.id === 'openbot');
-    const fromOpenbot = typeof openbotRef?.config?.model === 'string' ? openbotRef.config.model.trim() : '';
-    if (fromOpenbot)
-        return fromOpenbot;
-    return loadConfig().model || 'openai/gpt-4o-mini';
-}
-async function maybeGenerateThreadName(args) {
-    const details = await args.storage.getThreadDetails({
-        channelId: args.channelId,
-        threadId: args.threadId,
-    });
-    const state = details.state || {};
-    if (state.nameStatus === 'llm' || state.nameStatus === 'manual')
-        return;
-    const title = await generateThreadTitle(args.content, args.model);
-    if (!title)
-        return;
-    await args.storage.patchThreadState({
-        channelId: args.channelId,
-        threadId: args.threadId,
-        state: { generatedName: title, nameStatus: 'llm' },
-    });
-    if (!args.emitEvent)
-        return;
-    await args.emitEvent({
-        type: 'client:ui:thread:updated',
-        data: {
-            channelId: args.channelId,
-            threadId: args.threadId,
-            name: title,
-        },
-        meta: {
-            agentId: ORCHESTRATOR_AGENT_ID,
-            channelId: args.channelId,
-            threadId: args.threadId,
-        },
-    });
-}
-/**
- * `thread-naming` — generates short LLM titles for new threads on the system agent.
- * Runs in the background on the first user message so the main turn is not blocked.
- */
-export const threadNamingPlugin = {
-    id: 'thread-naming',
-    name: 'Thread naming',
-    description: 'Automatically generates short LLM titles for new conversation threads.',
-    configSchema: {
-        type: 'object',
-        properties: {
-            model: {
-                type: 'string',
-                description: 'Provider model string for title generation. Defaults to the openbot plugin model, then workspace config.',
-            },
-        },
-    },
-    factory: ({ agentId, agentDetails, config, storage, emitEvent }) => {
-        if (agentId !== ORCHESTRATOR_AGENT_ID) {
-            return () => { };
-        }
-        const model = resolveNamingModel(config, agentDetails.pluginRefs);
-        return (builder) => {
-            builder.on('agent:invoke', async function* (event, context) {
-                const invoke = event;
-                if (invoke.data?.role && invoke.data.role !== 'user')
-                    return;
-                const threadId = context.state.threadId;
-                const channelId = context.state.channelId;
-                if (!threadId || !channelId)
-                    return;
-                const content = typeof invoke.data?.content === 'string' ? invoke.data.content : '';
-                if (!content.trim())
-                    return;
-                const key = `${channelId}:${threadId}`;
-                if (namingInFlight.has(key))
-                    return;
-                namingInFlight.add(key);
-                void maybeGenerateThreadName({
-                    storage,
-                    channelId,
-                    threadId,
-                    content,
-                    model,
-                    emitEvent,
-                })
-                    .catch((error) => {
-                    console.warn('[thread-naming] Failed to generate thread name:', error);
-                })
-                    .finally(() => {
-                    namingInFlight.delete(key);
-                });
-            });
-        };
-    },
-};
-export default threadNamingPlugin;

package/dist/services/thread-naming.js

@@ -1,81 +0,0 @@
-import { generateText } from 'ai';
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { loadConfig } from '../app/config.js';
-import { storageService } from '../plugins/storage/service.js';
-const THREAD_TITLE_MAX_LENGTH = 80;
-const namingInFlight = new Set();
-function resolveModel(modelString) {
-    const [provider, ...rest] = modelString.split('/');
-    const modelId = rest.join('/');
-    if (!modelId) {
-        throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
-    }
-    switch (provider) {
-        case 'openai':
-            return openai(modelId);
-        case 'anthropic':
-            return anthropic(modelId);
-        default:
-            throw new Error(`Unsupported AI provider: "${provider}"`);
-    }
-}
-function normalizeTitle(raw) {
-    let title = raw
-        .replace(/^["'`]+|["'`]+$/g, '')
-        .replace(/[.!?]+$/g, '')
-        .replace(/\s+/g, ' ')
-        .trim();
-    if (!title)
-        return '';
-    if (title.length > THREAD_TITLE_MAX_LENGTH) {
-        title = `${title.slice(0, THREAD_TITLE_MAX_LENGTH).trimEnd()}...`;
-    }
-    return title;
-}
-export async function generateThreadTitle(content, modelString) {
-    const normalized = content.replace(/\s+/g, ' ').trim();
-    if (!normalized)
-        return undefined;
-    const config = loadConfig();
-    const model = resolveModel(modelString || config.model || 'openai/gpt-4o-mini');
-    const result = await generateText({
-        model,
-        system: 'You name chat threads. Reply with ONLY a short title (3-6 words). No quotes, no trailing punctuation.',
-        prompt: normalized.slice(0, 500),
-        maxOutputTokens: 20,
-    });
-    return normalizeTitle(result.text) || undefined;
-}
-export async function maybeGenerateThreadName(args) {
-    const key = `${args.channelId}:${args.threadId}`;
-    if (namingInFlight.has(key))
-        return;
-    namingInFlight.add(key);
-    try {
-        const details = await storageService.getThreadDetails({
-            channelId: args.channelId,
-            threadId: args.threadId,
-        });
-        const state = details.state || {};
-        if (state.nameStatus === 'llm' || state.nameStatus === 'manual')
-            return;
-        if (state.nameStatus !== 'provisional')
-            return;
-        const title = await generateThreadTitle(args.content);
-        if (!title)
-            return;
-        await storageService.patchThreadState({
-            channelId: args.channelId,
-            threadId: args.threadId,
-            state: { generatedName: title, nameStatus: 'llm' },
-        });
-        await args.onUpdated?.(title);
-    }
-    catch (error) {
-        console.warn('[thread-naming] Failed to generate thread name:', error);
-    }
-    finally {
-        namingInFlight.delete(key);
-    }
-}