openbot 0.3.5 → 0.4.0

package/src/plugins/mcp/index.ts

@@ -1,128 +0,0 @@
-import { MelonyPlugin } from 'melony';
-import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
-import { OpenBotEvent, OpenBotState } from '../../app/types.js';
-import { mcpService } from '../../harness/mcp.js';
-
-function stringifyResult(value: unknown): string {
-  if (typeof value === 'string') return value;
-  try {
-    return JSON.stringify(value, null, 2);
-  } catch {
-    return String(value);
-  }
-}
-
-const mcpToolDefinitions = {
-  mcp_list_tools: {
-    description:
-      'List available tools from a configured MCP server. Use this first before calling tools on an unknown server.',
-    inputSchema: z.object({
-      serverId: z.string().describe('Configured MCP server id (e.g. github, notion, linear).'),
-    }),
-  },
-  mcp_call: {
-    description:
-      'Call a tool on a configured MCP server. Provide tool arguments as a JSON object. Use mcp_list_tools first when uncertain.',
-    inputSchema: z.object({
-      serverId: z.string().describe('Configured MCP server id.'),
-      toolName: z.string().describe('Exact MCP tool name from mcp_list_tools.'),
-      args: z
-        .record(z.string(), z.unknown())
-        .default({})
-        .describe('Tool arguments as a JSON object.'),
-    }),
-  },
-};
-
-const mcpPluginRuntime = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
-  builder.on('action:mcp_list_tools', async function* (event, context) {
-    const serverId = (event.data as { serverId?: string })?.serverId as string;
-
-    try {
-      const tools = await mcpService.listTools(serverId);
-      const toolNames = tools.map(
-        (tool) => `- ${tool.name}${tool.description ? `: ${tool.description}` : ''}`,
-      );
-
-      yield {
-        type: 'action:mcp_list_tools:result',
-        data: { success: true, serverId, tools },
-        meta: event.meta,
-      } as OpenBotEvent;
-
-      yield {
-        type: 'agent:output',
-        data: {
-          content:
-            toolNames.length > 0
-              ? `MCP tools available on \`${serverId}\`:\n${toolNames.join('\n')}`
-              : `MCP server \`${serverId}\` has no tools.`,
-        },
-        meta: { ...(event.meta || {}), agentId: context.state.agentId },
-      } as OpenBotEvent;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown MCP error';
-      yield {
-        type: 'action:mcp_list_tools:result',
-        data: { success: false, serverId, tools: [], error: message },
-        meta: event.meta,
-      } as OpenBotEvent;
-      yield {
-        type: 'agent:output',
-        data: { content: `Failed to list MCP tools for \`${serverId}\`: ${message}` },
-        meta: { ...(event.meta || {}), agentId: context.state.agentId },
-      } as OpenBotEvent;
-    }
-  });
-
-  builder.on('action:mcp_call', async function* (event, context) {
-    const data = event.data as {
-      serverId?: string;
-      toolName?: string;
-      args?: Record<string, unknown>;
-    };
-    const serverId = data?.serverId as string;
-    const toolName = data?.toolName as string;
-    const args = (data?.args || {}) as Record<string, unknown>;
-
-    try {
-      const result = await mcpService.callTool(serverId, toolName, args);
-      const rendered = stringifyResult(result);
-
-      yield {
-        type: 'action:mcp_call:result',
-        data: { success: true, serverId, toolName, result },
-        meta: event.meta,
-      } as OpenBotEvent;
-
-      yield {
-        type: 'agent:output',
-        data: { content: `MCP \`${serverId}.${toolName}\` result:\n\n${rendered}` },
-        meta: { ...(event.meta || {}), agentId: context.state.agentId },
-      } as OpenBotEvent;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown MCP error';
-      yield {
-        type: 'action:mcp_call:result',
-        data: { success: false, serverId, toolName, error: message },
-        meta: event.meta,
-      } as OpenBotEvent;
-      yield {
-        type: 'agent:output',
-        data: { content: `MCP call failed for \`${serverId}.${toolName}\`: ${message}` },
-        meta: { ...(event.meta || {}), agentId: context.state.agentId },
-      } as OpenBotEvent;
-    }
-  });
-};
-
-export const mcpPlugin: Plugin = {
-  id: 'mcp',
-  name: 'MCP',
-  description: 'Connect to Model Context Protocol servers and call their tools.',
-  toolDefinitions: mcpToolDefinitions,
-  factory: () => mcpPluginRuntime(),
-};
-
-export default mcpPlugin;

package/src/plugins/storage-tools/index.ts

@@ -1,90 +0,0 @@
-import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
-
-/**
- * `storage-tools` — exposes channel/thread/variable mutation tools to runtime
- * plugins. The actual handlers live in `bus/services.ts` because storage is
- * platform infrastructure, not agent behaviour.
- */
-const storageToolDefinitions = {
-  create_channel: {
-    description:
-      'Create a new channel. Use when the user intent is clearly different from the current channel and should be split. Always confirm before creating. Skip for simple Q&A.',
-    inputSchema: z.object({
-      channelId: z
-        .string()
-        .describe('Unique channel ID (e.g. product-launch, backend-platform, channel_roadmap).'),
-      spec: z
-        .string()
-        .optional()
-        .describe('Optional initial markdown content for the channel spec.'),
-      initialState: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe('Optional initial state object for the channel.'),
-      cwd: z
-        .string()
-        .optional()
-        .describe('Optional initial current working directory for the channel.'),
-    }),
-  },
-  patch_channel_details: {
-    description: 'Patch current channel details (state, spec, cwd).',
-    inputSchema: z
-      .object({
-        state: z
-          .record(z.string(), z.unknown())
-          .optional()
-          .describe(
-            'JSON state object for the channel. Use for structured data like `todos` or metadata.',
-          ),
-        spec: z
-          .string()
-          .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.'),
-      })
-      .refine(
-        (value) => value.state !== undefined || value.spec !== undefined || value.cwd !== undefined,
-        { message: 'Provide at least one of state, spec, or cwd.' },
-      ),
-  },
-  patch_thread_details: {
-    description: 'Patch current thread details (state).',
-    inputSchema: z.object({
-      state: z
-        .record(z.string(), z.unknown())
-        .describe(
-          'JSON state object for the thread. Use for structured data like `todos` or progress.',
-        ),
-    }),
-  },
-  create_variable: {
-    description: 'Create or update a variable in the workspace storage.',
-    inputSchema: z.object({
-      key: z.string().describe('The key of the variable.'),
-      value: z.string().describe('The value of the variable.'),
-      secret: z.boolean().optional().describe('Whether the variable is a secret.'),
-    }),
-  },
-  delete_variable: {
-    description: 'Delete a variable from the workspace storage.',
-    inputSchema: z.object({
-      key: z.string().describe('The key of the variable to delete.'),
-    }),
-  },
-};
-
-export const storageToolsPlugin: Plugin = {
-  id: 'storage-tools',
-  name: 'Storage Tools',
-  description: 'Tools for creating channels, patching state, and managing workspace variables.',
-  toolDefinitions: storageToolDefinitions,
-  factory: () => () => {
-    // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
-  },
-};
-
-export default storageToolsPlugin;

package/src/plugins/todo/index.ts

@@ -1,64 +0,0 @@
-import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
-
-/**
- * `todo` — shared, per-thread task list for autonomous multi-agent flows.
- *
- * Todos live in `threadDetails.state.todos` and are owned by the system
- * (handlers in `bus/services.ts`). Any agent in the thread can read the
- * list via context, and propose mutations through these tools. Each item
- * may carry an `assignee` agent id; combine with `handoff` to drive an
- * autonomous, multi-step plan across agents.
- *
- * Keep the surface minimal: two tools (replace-all, patch-one) cover plan
- * authoring, status transitions, and reassignment.
- */
-const todoStatus = z.enum(['pending', 'in_progress', 'done', 'cancelled']);
-
-const todoToolDefinitions = {
-  todo_write: {
-    description:
-      'Author or rewrite the shared todo plan for the current thread. Pass the full ordered list — missing items are removed. Use at the start of multi-step work, or whenever the plan changes shape. For status flips, prefer `todo_update`.',
-    inputSchema: z.object({
-      todos: z
-        .array(
-          z.object({
-            id: z
-              .string()
-              .optional()
-              .describe('Stable id. Reuse existing ids to preserve history; omit to create.'),
-            content: z.string().min(1).describe('What needs to be done. One concrete step.'),
-            status: todoStatus.optional().describe('Defaults to `pending`.'),
-            assignee: z
-              .string()
-              .optional()
-              .describe('Agent id responsible for this step. Pair with `handoff` to delegate.'),
-          }),
-        )
-        .describe('The complete, ordered plan.'),
-    }),
-  },
-  todo_update: {
-    description:
-      'Patch a single todo by id. Use to mark progress (`in_progress`, `done`, `cancelled`), rephrase, or reassign without rewriting the whole list.',
-    inputSchema: z.object({
-      id: z.string().describe('Todo id from `todo_write` or the rendered list.'),
-      status: todoStatus.optional(),
-      content: z.string().min(1).optional(),
-      assignee: z.string().optional().describe('Use empty string to clear.'),
-    }),
-  },
-};
-
-export const todoPlugin: Plugin = {
-  id: 'todo',
-  name: 'Todo',
-  description:
-    'Shared per-thread task list for coordinating multi-step, multi-agent work.',
-  toolDefinitions: todoToolDefinitions,
-  factory: () => () => {
-    // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
-  },
-};
-
-export default todoPlugin;

package/src/plugins/ui/index.ts

@@ -1,227 +0,0 @@
-import { MelonyPlugin } from 'melony';
-import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
-import {
-  OpenBotEvent,
-  OpenBotState,
-  RenderUIWidgetData,
-  UIWidgetField,
-  UIWidgetListItem,
-  UIWidgetSpec,
-} from '../../app/types.js';
-
-const actionSchema = z.object({
-  id: z.string().describe('Stable action ID returned by client:ui:widget:response.'),
-  label: z.string().describe('Human-readable button label.'),
-  value: z.unknown().optional().describe('Optional machine-readable value for this action.'),
-  variant: z.enum(['primary', 'secondary', 'danger']).optional(),
-  disabled: z.boolean().optional(),
-});
-
-const optionSchema = z.object({
-  label: z.string(),
-  value: z.string(),
-});
-
-const fieldSchema = z.object({
-  id: z.string().describe('Stable field ID used as the submitted value key.'),
-  label: z.string(),
-  type: z.enum(['text', 'textarea', 'number', 'boolean', 'select', 'multiselect', 'date']),
-  description: z.string().optional(),
-  placeholder: z.string().optional(),
-  required: z.boolean().optional(),
-  options: z.array(optionSchema).optional(),
-  defaultValue: z.unknown().optional(),
-});
-
-const listItemSchema = z.object({
-  id: z.string(),
-  label: z.string(),
-  description: z.string().optional(),
-  status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-});
-
-const widgetBaseSchema = {
-  widgetId: z.string().optional().describe('Stable widget ID. Defaults from toolCallId.'),
-  title: z.string().optional(),
-  description: z.string().optional(),
-  body: z.string().optional(),
-  state: z.enum(['open', 'submitted', 'cancelled', 'error']).optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-};
-
-const renderWidgetSchema = z.union([
-  z.object({
-    ...widgetBaseSchema,
-    kind: z.literal('message'),
-    actions: z.array(actionSchema).optional(),
-  }),
-  z.object({
-    ...widgetBaseSchema,
-    kind: z.literal('choice'),
-    actions: z.array(actionSchema).min(1),
-  }),
-  z.object({
-    ...widgetBaseSchema,
-    kind: z.literal('form'),
-    fields: z.array(fieldSchema).optional(),
-    submitLabel: z.string().optional(),
-    actions: z.array(actionSchema).optional(),
-    props: z.record(z.string(), z.unknown()).optional(),
-  }),
-  z.object({
-    ...widgetBaseSchema,
-    kind: z.literal('list'),
-    items: z.array(listItemSchema).optional(),
-    actions: z.array(actionSchema).optional(),
-  }),
-  z.object({
-    kind: z.enum(['approval', 'todo_list']).describe('Legacy preset. Prefer choice or list.'),
-    widgetId: z.string().optional(),
-    title: z.string().optional(),
-    props: z.record(z.string(), z.unknown()).optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-  }),
-]);
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  !!value && typeof value === 'object' && !Array.isArray(value);
-
-const readString = (value: unknown): string | undefined =>
-  typeof value === 'string' && value.trim() ? value : undefined;
-
-const asFields = (value: unknown): UIWidgetField[] | undefined =>
-  Array.isArray(value) ? (value as UIWidgetField[]) : undefined;
-
-const asListItems = (value: unknown): UIWidgetListItem[] | undefined =>
-  Array.isArray(value) ? (value as UIWidgetListItem[]) : undefined;
-
-const todoToListItem = (todo: unknown, index: number): UIWidgetListItem => {
-  if (!isRecord(todo)) {
-    return { id: `todo_${index + 1}`, label: String(todo) };
-  }
-  return {
-    id: readString(todo.id) || `todo_${index + 1}`,
-    label:
-      readString(todo.label) ||
-      readString(todo.task) ||
-      readString(todo.title) ||
-      `Todo ${index + 1}`,
-    description: readString(todo.description),
-    status: readString(todo.status) as UIWidgetListItem['status'],
-    metadata: todo,
-  };
-};
-
-const createWidgetId = (data: RenderUIWidgetData, toolCallId?: string): string => {
-  if ('widgetId' in data && data.widgetId) return data.widgetId;
-  if (toolCallId) return `widget_${toolCallId}`;
-  return `widget_${Date.now()}`;
-};
-
-const normalizeWidget = (
-  data: RenderUIWidgetData,
-  state: OpenBotState,
-  toolCallId?: string,
-): UIWidgetSpec => {
-  const widgetId = createWidgetId(data, toolCallId);
-
-  if (data.kind === 'approval') {
-    const props = data.props || {};
-    return {
-      widgetId,
-      kind: 'choice',
-      title: data.title || 'Approval Required',
-      body:
-        readString(props.message) ||
-        readString(props.summary) ||
-        'Please approve or deny this action.',
-      metadata: {
-        ...(data.metadata || {}),
-        legacyKind: 'approval',
-        actionId: props.actionId,
-      },
-      actions: [
-        { id: 'approve', label: 'Approve', value: props.actionId || 'approve', variant: 'primary' },
-        { id: 'deny', label: 'Deny', value: props.actionId || 'deny', variant: 'danger' },
-      ],
-    };
-  }
-
-  if (data.kind === 'todo_list') {
-    const props = data.props || {};
-    const stateTodos = isRecord(state.threadDetails?.state)
-      ? (state.threadDetails.state as Record<string, unknown>).todos
-      : undefined;
-    const todos = asListItems(props.todos) || asListItems(stateTodos) || [];
-    return {
-      widgetId,
-      kind: 'list',
-      title: data.title || readString(props.title) || 'Task List',
-      description: readString(props.description),
-      metadata: { ...(data.metadata || {}), legacyKind: 'todo_list' },
-      items: todos.map(todoToListItem),
-    };
-  }
-
-  if (data.kind === 'form') {
-    const propsSource = (data as unknown as { props?: unknown }).props;
-    const props = isRecord(propsSource) ? propsSource : {};
-    return {
-      widgetId,
-      kind: 'form',
-      title: data.title || 'Details Required',
-      description: data.description,
-      body: data.body,
-      state: data.state,
-      metadata: data.metadata,
-      fields: data.fields || asFields(props.schema) || [],
-      submitLabel: data.submitLabel || readString(props.submitLabel),
-      actions: data.actions,
-    };
-  }
-
-  if (data.kind === 'list') {
-    return { ...data, widgetId, title: data.title || 'Task List', items: data.items || [] };
-  }
-
-  if (data.kind === 'choice') {
-    return { ...data, widgetId, title: data.title || 'Choose an Option' };
-  }
-
-  if (data.kind === 'message') {
-    return { ...data, widgetId, title: data.title || 'Message' };
-  }
-
-  throw new Error(`Unsupported UI widget kind: ${(data as { kind?: string }).kind || 'unknown'}`);
-};
-
-const uiToolDefinitions = {
-  render_ui_widget: {
-    description:
-      'Render a small server-driven UI widget in the conversation. Prefer primitive kinds: message, choice, form, or list. Legacy presets approval and todo_list are accepted.',
-    inputSchema: renderWidgetSchema,
-  },
-};
-
-const uiPluginRuntime = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
-  builder.on('action:render_ui_widget', async function* (event, context) {
-    const widget = normalizeWidget(event.data, context.state, event.meta?.toolCallId);
-    yield {
-      type: 'client:ui:widget',
-      data: widget,
-      meta: event.meta,
-    };
-  });
-};
-
-export const uiPlugin: Plugin = {
-  id: 'ui',
-  name: 'UI Widgets',
-  description: 'Render server-driven UI widgets (messages, choices, forms, lists) in the conversation.',
-  toolDefinitions: uiToolDefinitions,
-  factory: () => uiPluginRuntime(),
-};
-
-export default uiPlugin;