openbot 0.2.13 → 0.3.0

package/src/bus/types.ts

@@ -0,0 +1,147 @@
+import type { OpenBotEvent } from '../app/types.js';
+import type { PluginRef } from './plugin.js';
+
+/**
+ * Public data types exposed by the OpenBot bus.
+ *
+ * The bus is the platform layer that owns channels, threads, the agent registry,
+ * and the event stream. Agents are composed entirely of Plugins (see
+ * `bus/plugin.ts`); their internal implementation is opaque to the bus.
+ */
+
+export type Agent = {
+  id: string;
+  name: string;
+  description: string;
+  image?: string;
+  /** Plugin ids that compose this agent (mirrors AGENT.md `plugins[].id`). */
+  plugins: string[];
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+export type AgentDetails = Agent & {
+  instructions: string;
+  /** Full plugin refs from AGENT.md (with per-plugin config). */
+  pluginRefs: PluginRef[];
+};
+
+export type PluginDescriptor = {
+  id: string;
+  name: string;
+  description: string;
+  /** True when bundled with the core server (`src/registry/plugins`); false for ~/.openbot/plugins installs. */
+  builtIn: boolean;
+  image?: string;
+  defaultInstructions?: string;
+  configSchema?: ConfigSchema;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+export type ConfigSchema = {
+  type: 'object';
+  properties: {
+    [key: string]: {
+      type: 'string' | 'number' | 'boolean' | 'integer';
+      description?: string;
+      default?: unknown;
+      enum?: unknown[];
+      minimum?: number;
+      maximum?: number;
+      format?: 'password' | 'url' | 'email';
+    };
+  };
+  required?: string[];
+};
+
+export type Channel = {
+  id: string;
+  name: string;
+  description: string;
+  cwd?: string;
+  createdAt: Date;
+  updatedAt: Date;
+  hasUnseenMessages?: boolean;
+  recentThreads?: Thread[];
+};
+
+export type Thread = {
+  id: string;
+  name: string;
+  channelId: string;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+export type ThreadDetails = {
+  id: string;
+  name: string;
+  channelId: string;
+  spec: string;
+  state: unknown;
+};
+
+export type ChannelDetails = {
+  id: string;
+  name: string;
+  spec: string;
+  state: unknown;
+  cwd?: string;
+  threads?: Thread[];
+};
+
+export interface Storage {
+  getChannels: () => Promise<Channel[]>;
+  createChannel: (args: {
+    channelId: string;
+    spec?: string;
+    initialState?: Record<string, unknown>;
+    cwd?: string;
+  }) => Promise<void>;
+  createThread: (args: {
+    channelId: string;
+    threadId: string;
+    threadTitle?: string;
+    spec?: string;
+    initialState?: Record<string, unknown>;
+  }) => Promise<void>;
+  getThreads: (args: { channelId: string }) => Promise<Thread[]>;
+  getThreadDetails: (args: { channelId: string; threadId: string }) => Promise<ThreadDetails>;
+  getAgents: () => Promise<Agent[]>;
+  getPlugins: () => Promise<PluginDescriptor[]>;
+  getAgentDetails: (args: { agentId: string }) => Promise<AgentDetails>;
+  createAgent: (args: {
+    agentId: string;
+    name: string;
+    description?: string;
+    instructions: string;
+    plugins: PluginRef[];
+  }) => Promise<void>;
+  updateAgent: (args: {
+    agentId: string;
+    name?: string;
+    description?: string;
+    instructions?: string;
+    plugins?: PluginRef[];
+  }) => Promise<void>;
+  deleteAgent: (args: { agentId: string }) => Promise<void>;
+  getEvents: (args: { channelId: string; threadId?: string }) => Promise<OpenBotEvent[]>;
+  getChannelDetails: (args: { channelId: string }) => Promise<ChannelDetails>;
+  patchChannelState: (args: { channelId: string; state: unknown }) => Promise<void>;
+  patchThreadState: (args: {
+    channelId: string;
+    threadId: string;
+    state: unknown;
+  }) => Promise<void>;
+  patchChannelSpec: (args: { channelId: string; spec: string }) => Promise<void>;
+  patchThreadSpec: (args: { channelId: string; threadId: string; spec: string }) => Promise<void>;
+  getVariables: () => Promise<Record<string, string | { value: string; secret: boolean }>>;
+  createVariable: (args: { key: string; value: string; secret?: boolean }) => Promise<void>;
+  deleteVariable: (args: { key: string }) => Promise<void>;
+  listFiles: (args: {
+    channelId: string;
+    path?: string;
+  }) => Promise<Array<{ name: string; isDirectory: boolean }>>;
+  readFile: (args: { channelId: string; path: string }) => Promise<string>;
+}

package/src/harness/context.ts

@@ -0,0 +1,160 @@
+import { OpenBotState } from '../app/types.js';
+import { Storage } from '../bus/types.js';
+
+/**
+ * Represents a piece of context that can be used in a prompt.
+ */
+export interface ContextItem {
+  id: string;
+  type: string;
+  priority: number;
+  content: string;
+  metadata?: Record<string, any>;
+}
+
+/**
+ * A provider that can fetch or generate context items.
+ */
+export interface ContextProvider {
+  name: string;
+  provide(state: OpenBotState, storage?: Storage): Promise<ContextItem[]>;
+}
+
+/**
+ * A processor that can transform or filter context items (e.g., ranking, truncation).
+ */
+export interface ContextProcessor {
+  name: string;
+  process(items: ContextItem[], state: OpenBotState): Promise<ContextItem[]>;
+}
+
+/**
+ * The core engine that orchestrates context building.
+ */
+export class ContextEngine {
+  private providers: ContextProvider[] = [];
+  private processors: ContextProcessor[] = [];
+
+  registerProvider(provider: ContextProvider) {
+    this.providers.push(provider);
+  }
+
+  registerProcessor(processor: ContextProcessor) {
+    this.processors.push(processor);
+  }
+
+  async buildContext(state: OpenBotState, storage?: Storage): Promise<string> {
+    // 1. Collect context from all providers
+    let items: ContextItem[] = [];
+    for (const provider of this.providers) {
+      try {
+        const providedItems = await provider.provide(state, storage);
+        items.push(...providedItems);
+      } catch (error) {
+        console.warn(`[ContextEngine] Provider ${provider.name} failed:`, error);
+      }
+    }
+
+    // 2. Run through processors
+    for (const processor of this.processors) {
+      try {
+        items = await processor.process(items, state);
+      } catch (error) {
+        console.warn(`[ContextEngine] Processor ${processor.name} failed:`, error);
+      }
+    }
+
+    // 3. Format items into a single string
+    return items
+      .sort((a, b) => b.priority - a.priority)
+      .map(item => item.content)
+      .join('\n\n');
+  }
+}
+
+/**
+ * Default implementation of a Context Engine with basic providers.
+ */
+export function createDefaultContextEngine(): ContextEngine {
+  const engine = new ContextEngine();
+
+  // Basic Providers
+  engine.registerProvider(new AgentDetailsProvider());
+  engine.registerProvider(new ChannelDetailsProvider());
+  engine.registerProvider(new ThreadDetailsProvider());
+  engine.registerProvider(new RecentEventsProvider());
+
+  return engine;
+}
+
+class AgentDetailsProvider implements ContextProvider {
+  name = 'agent-details';
+  async provide(state: OpenBotState): Promise<ContextItem[]> {
+    if (!state.agentDetails) return [];
+    return [{
+      id: 'agent-details',
+      type: 'agent',
+      priority: 100,
+      content: `## AGENT NAME\n${state.agentDetails.name}\n\n## AGENT SPECIFICATION\n${state.agentDetails.instructions}`
+    }];
+  }
+}
+
+class ChannelDetailsProvider implements ContextProvider {
+  name = 'channel-details';
+  async provide(state: OpenBotState): Promise<ContextItem[]> {
+    if (!state.channelDetails) return [];
+    return [{
+      id: 'channel-details',
+      type: 'channel',
+      priority: 80,
+      content: `## CHANNEL NAME\n${state.channelDetails.name}\n\n## CHANNEL SPECIFICATION\n${state.channelDetails.spec}`
+    }];
+  }
+}
+
+class ThreadDetailsProvider implements ContextProvider {
+  name = 'thread-details';
+  async provide(state: OpenBotState): Promise<ContextItem[]> {
+    if (!state.threadDetails) return [];
+    return [{
+      id: 'thread-details',
+      type: 'thread',
+      priority: 90,
+      content: `## THREAD NAME\n${state.threadDetails.name}\n\n## THREAD SPECIFICATION\n${state.threadDetails.spec}`
+    }];
+  }
+}
+
+class RecentEventsProvider implements ContextProvider {
+  name = 'recent-events';
+  async provide(state: OpenBotState, storage?: Storage): Promise<ContextItem[]> {
+    if (!storage) return [];
+    const items: ContextItem[] = [];
+
+    // Fetch channel events if no thread, otherwise fetch thread events
+    const channelId = state.channelId;
+    const threadId = state.threadId;
+
+    try {
+      const events = await storage.getEvents({ channelId, threadId });
+      if (events.length > 0) {
+        const formattedEvents = events
+          .slice(-20)
+          .map((e) => `- ${e.type}: ${JSON.stringify((e as any).data || {})}`)
+          .join('\n');
+        
+        items.push({
+          id: threadId ? 'thread-events' : 'channel-events',
+          type: 'events',
+          priority: 70,
+          content: `## ${threadId ? 'THREAD' : 'CHANNEL'} RECENT ACTIVITIES (events)\n${formattedEvents}`
+        });
+      }
+    } catch (error) {
+      console.warn(`[ContextEngine] Failed to fetch events:`, error);
+    }
+
+    return items;
+  }
+}

package/src/harness/event-normalizer.ts

@@ -0,0 +1,82 @@
+import { AgentInvokeEvent, OpenBotEvent, OpenBotState } from '../app/types.js';
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../services/storage.js';
+
+export interface NormalizedEventResult {
+  finalEvent: OpenBotEvent;
+  finalAgentId: string;
+}
+
+export const EventNormalizer = {
+  /**
+   * Normalizes incoming events, converting raw inputs like user:input to agent:invoke.
+   * Also handles initial state storage and event bus propagation for user inputs.
+   */
+  normalize: async (
+    event: OpenBotEvent,
+    options: {
+      runId: string;
+      agentId?: string;
+      channelId: string;
+      threadId?: string;
+      onEvent: (chunk: OpenBotEvent, state: OpenBotState) => Promise<boolean | void>;
+    }
+  ): Promise<NormalizedEventResult> => {
+    const { runId, agentId, channelId, threadId, onEvent } = options;
+
+    // 0. Ensure the incoming event has a unique ID immediately
+    ensureEventId(event);
+
+    let finalAgentId = agentId || 'system';
+    let finalEvent = event;
+
+    // 1. Convert user:input (or other raw inputs) to agent:invoke
+    const rawContent = (event as any).data?.content || '';
+    if (event.type === 'user:input' || event.type === 'agent:invoke') {
+      const normalizedInvokeEvent: AgentInvokeEvent = {
+        type: 'agent:invoke',
+        id: event.id,
+        data: {
+          content: rawContent,
+          role: 'user',
+        },
+        meta: {
+          agentId: 'system',
+          userId: event.meta?.userId,
+          userName: event.meta?.userName,
+          userAvatarUrl: event.meta?.userAvatarUrl,
+        },
+      };
+      finalEvent = normalizedInvokeEvent;
+
+      // 1. Store the user's input in the current context (main channel or existing thread)
+      const initialState = await storageService.getOpenBotState({
+        runId,
+        agentId: 'system',
+        channelId,
+        threadId: threadId,
+        event: finalEvent,
+      });
+
+      // 2. Propagate the user's input to the event bus
+      await onEvent(finalEvent, initialState);
+
+      // 3. Prepare the event for the target agent
+      finalEvent = {
+        ...event,
+        type: 'agent:invoke',
+        data: {
+          ...((event as any).data || {}),
+          content: rawContent,
+        },
+        meta: {
+          ...(event.meta || {}),
+          // The threadId in meta is the anchor for new threads (Slack-style)
+          threadId: threadId || finalEvent.id,
+        },
+      };
+    }
+
+    return { finalEvent, finalAgentId };
+  },
+};