openbot 0.4.5 → 0.4.7

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) {
@@ -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.5",
+  "version": "0.4.7",
   "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.5');
+program.name('openbot').description('OpenBot CLI').version('0.4.7');
 
 program
   .command('start')

package/src/app/responding-agent.ts

@@ -4,6 +4,9 @@ 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';
 
+/** Publish events that continue a pending UI interaction rather than a new user turn. */
+export const CONTINUATION_EVENT_TYPES = new Set(['client:ui:widget:response']);
+
 export type ResolveRespondingAgentOptions = {
   channelId: string;
   threadId?: string;
@@ -20,6 +23,14 @@ export type ResolveRespondingAgentResult = {
   overridden: boolean;
 };
 
+const readMetaAgentId = (meta: unknown): string | undefined => {
+  if (!meta || typeof meta !== 'object') return undefined;
+  const value = (meta as Record<string, unknown>).agentId;
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+};
+
 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];
@@ -72,3 +83,38 @@ export async function resolveRespondingAgentId(
 
   return { agentId: fallback, bound: true, overridden: false };
 }
+
+export type ResolvePublishTargetAgentOptions = {
+  eventType: string;
+  channelId: string;
+  threadId?: string;
+  requestedAgentId?: string;
+  eventMeta?: unknown;
+  bindIfUnbound?: boolean;
+};
+
+/**
+ * Resolves the agent that should handle a publish event.
+ * UI continuations route to the widget origin agent; everything else uses sticky thread binding.
+ */
+export async function resolvePublishTargetAgentId(
+  options: ResolvePublishTargetAgentOptions,
+): Promise<{ agentId: string } | { error: 'agentId_required' }> {
+  const { eventType, channelId, threadId, requestedAgentId, eventMeta, bindIfUnbound } = options;
+
+  if (CONTINUATION_EVENT_TYPES.has(eventType)) {
+    const originAgentId = readMetaAgentId(eventMeta) || requestedAgentId?.trim();
+    if (!originAgentId) {
+      return { error: 'agentId_required' };
+    }
+    return { agentId: originAgentId };
+  }
+
+  const resolved = await resolveRespondingAgentId({
+    channelId,
+    threadId,
+    requestedAgentId,
+    bindIfUnbound,
+  });
+  return { agentId: resolved.agentId };
+}

package/src/app/server.ts

@@ -21,7 +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 { resolvePublishTargetAgentId, 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> };
 
@@ -65,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 =
@@ -83,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,
@@ -532,17 +546,38 @@ 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({
+      const target = await resolvePublishTargetAgentId({
+        eventType: event.type,
         channelId,
         threadId,
         requestedAgentId: agentId,
+        eventMeta: event.meta,
         bindIfUnbound,
       });
 
+      if ('error' in target) {
+        res.status(400).json({ error: 'agentId is required for widget response' });
+        return;
+      }
+
       await runAgent({
         runId,
-        agentId: resolved.agentId,
+        agentId: target.agentId,
         event,
         channelId,
         threadId,

package/src/app/types.ts

@@ -301,8 +301,6 @@ export type PatchChannelDetailsEvent = BaseEvent & {
     state?: Record<string, unknown>;
     spec?: string;
     cwd?: string;
-    /** When set, replaces `state.json` `participants` (merged after `state` if both are sent). */
-    participants?: string[];
   };
 };
 
@@ -310,7 +308,7 @@ export type PatchChannelDetailsResultEvent = BaseEvent & {
   type: 'action:patch_channel_details:result';
   data: {
     success: boolean;
-    updatedFields: ('state' | 'spec' | 'cwd' | 'participants')[];
+    updatedFields: ('state' | 'spec' | 'cwd')[];
   };
 };
 
@@ -569,8 +567,6 @@ export type CreateChannelEvent = BaseEvent & {
     spec?: string;
     initialState?: Record<string, unknown>;
     cwd?: string;
-    /** Initial channel agent ids; written into `state.json` (overrides `initialState.participants` if both are set). */
-    participants?: string[];
   };
   meta?: {
     toolCallId?: string;
@@ -594,8 +590,6 @@ export type UpdateChannelEvent = BaseEvent & {
     channelId?: string;
     name?: string;
     cwd?: string;
-    /** Replaces the channel participant list when provided. */
-    participants?: string[];
   };
 };
 
@@ -655,7 +649,7 @@ export type UIWidgetAction = {
 export type UIWidgetField = {
   id: string;
   label: string;
-  type: 'text' | 'textarea' | 'number' | 'boolean' | 'select' | 'multiselect' | 'date';
+  type: 'text' | 'textarea' | 'number' | 'boolean' | 'select' | 'multiselect' | 'date' | 'password';
   description?: string;
   placeholder?: string;
   required?: boolean;
@@ -736,6 +730,11 @@ export type UIWidgetResponseEvent = BaseEvent & {
     values?: Record<string, unknown>;
     metadata?: Record<string, unknown>;
   };
+  meta?: {
+    agentId?: string;
+    threadId?: string;
+    [key: string]: unknown;
+  };
 };
 
 export type BashEvent = BaseEvent & {
@@ -851,7 +850,6 @@ export type ListMarketplaceRegistryResultEvent = BaseEvent & {
       image?: string;
       spec?: string;
       initialState?: Record<string, unknown>;
-      participants: string[];
       starterPrompts?: Array<{ label: string; prompt: string }>;
     }>;
     error?: string;
@@ -863,7 +861,6 @@ export type InstallChannelEvent = BaseEvent & {
   data: {
     channelId: string;
     name?: string;
-    participants?: string[];
     initialState?: Record<string, unknown>;
   };
 };

package/src/plugins/openbot/context.ts

@@ -27,20 +27,11 @@ export const getContextBudgetForModel = (modelString: string): number => {
 /** Built-in orchestrator agent id. */
 export const ORCHESTRATOR_AGENT_ID = 'system';
 
-/**
- * Check if a channel is a solo DM (only the agent is present).
- */
-export function isDmSoloChannel(participants: string[], agentId: string): boolean {
-  return participants.length === 0 || (participants.length === 1 && participants[0] === agentId);
-}
-
 /**
  * Simplified context builder for MVP.
  */
 export async function buildContext(state: OpenBotState, storage?: Storage): Promise<string> {
   const { channelId, threadId, channelDetails, agentId, threadDetails, agentDetails } = state;
-  const participants = channelDetails?.participants || [];
-  const isDm = isDmSoloChannel(participants, agentId);
 
   const sections: string[] = [];
 
@@ -54,23 +45,13 @@ export async function buildContext(state: OpenBotState, storage?: Storage): Prom
 
   // 2. Environment
   let env = '## ENVIRONMENT\n';
-  if (isDm) {
-    env += '- Mode: Direct Message (Solo)\n';
-  } else {
-    const channelName = channelDetails?.name || channelId;
-    env += `- Mode: Channel (#${channelName})\n`;
-    if (channelDetails?.cwd) {
-      env += `- Workspace: ${channelDetails.cwd}\n`;
-    }
-    if (threadId) {
-      env += `- Thread: ${threadDetails?.name || threadId}\n`;
-    }
-    const peerIds = participants.filter((id: string) => id !== agentId);
-    const participantLabels = peerIds.map((id) => {
-      const agent = allAgents.find((a) => a.id === id);
-      return agent ? `${agent.name} (${id})` : id;
-    });
-    env += `- Participants: ${participantLabels.length > 0 ? participantLabels.join(', ') : 'None'}\n`;
+  const channelName = channelDetails?.name || channelId;
+  env += `- Mode: Channel (#${channelName})\n`;
+  if (channelDetails?.cwd) {
+    env += `- Workspace: ${channelDetails.cwd}\n`;
+  }
+  if (threadId) {
+    env += `- Thread: ${threadDetails?.name || threadId}\n`;
   }
   sections.push(env);
 

package/src/plugins/openbot/index.ts

@@ -49,7 +49,8 @@ export const openbotPlugin: Plugin = {
     ...memoryPlugin.toolDefinitions,
     ...storagePlugin.toolDefinitions,
     ...delegationPlugin.toolDefinitions,
-    ...uiPlugin.toolDefinitions,
+    // this is the capability to render UI widgets to the user. We dont need it for now.
+    // ...uiPlugin.toolDefinitions,
   },
   factory: (context) => (builder) => {
     const { config, storage, tools, abortSignal } = context;