openbot 0.4.4 → 0.4.6

package/src/plugins/storage/service.ts

@@ -24,6 +24,7 @@ import {
   PluginDescriptor,
   Thread,
   ThreadDetails,
+  ThreadState,
 } from '../../services/plugins/domain.js';
 import type { PluginRef } from '../../services/plugins/types.js';
 import { openbotPlugin } from '../openbot/index.js';
@@ -417,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;
 };
 
 /**
@@ -506,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,
         };
@@ -553,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,
@@ -605,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) {
@@ -771,7 +833,7 @@ export const storageService = {
       id: threadId,
       name: threadName || threadId,
       channelId,
-      state,
+      state: (isRecord(state) ? state : {}) as ThreadState,
     };
   },
   getChannelDetails: async ({ channelId }: { channelId: string }): Promise<ChannelDetails> => {
@@ -807,7 +869,6 @@ export const storageService = {
       spec,
       state,
       cwd,
-      participants: diskFields.participants,
     };
 
     details.threads = await storageService.getThreads({ channelId });
@@ -1289,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;
@@ -81,11 +79,25 @@ export type Thread = {
   hasUnseenMessages?: boolean;
 };
 
+/** Persisted thread `state.json` fields (additional keys are allowed). */
+export type ThreadState = {
+  name?: string;
+  /** Sticky agent id for this thread (`system` = orchestrator). Set once, then enforced on publish. */
+  respondingAgentId?: string;
+  pendingToolCallIds?: string[];
+  usage?: {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+  };
+  [key: string]: unknown;
+};
+
 export type ThreadDetails = {
   id: string;
   name: string;
   channelId: string;
-  state: unknown;
+  state: ThreadState;
 };
 
 export type ChannelDetails = {
@@ -94,8 +106,6 @@ export type ChannelDetails = {
   spec: string;
   state: unknown;
   cwd?: string;
-  /** Agent ids for this channel (from `state.json`). */
-  participants: string[];
   threads?: Thread[];
 };
 
@@ -107,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);
-    }
-}