openbot 0.4.7 → 0.5.4

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

@@ -1,72 +0,0 @@
-import { generateText } from 'ai';
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { THREAD_NAMER_AGENT_ID } from '../../app/agent-ids.js';
-import { loadConfig } from '../../app/config.js';
-const DEFAULT_MODEL = 'openai/gpt-4o-mini';
-const TITLE_SYSTEM_PROMPT = 'Generate a concise thread title from the user message. Reply with the title only: no quotes, no punctuation at the end, max 8 words.';
-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}"`);
-    }
-}
-/**
- * `thread-namer` — internal agent plugin that generates short thread titles via LLM.
- */
-export const threadNamerPlugin = {
-    id: 'thread-namer',
-    name: 'Thread namer',
-    description: 'Generates concise thread titles from seed messages.',
-    configSchema: {
-        type: 'object',
-        properties: {
-            model: {
-                type: 'string',
-                description: 'Provider model string, e.g. openai/gpt-4o-mini',
-                default: DEFAULT_MODEL,
-            },
-        },
-    },
-    factory: ({ agentId, config }) => {
-        if (agentId !== THREAD_NAMER_AGENT_ID) {
-            return () => { };
-        }
-        const configuredModel = typeof config?.model === 'string' && config.model.trim()
-            ? config.model.trim()
-            : loadConfig().model?.trim() || DEFAULT_MODEL;
-        return (builder) => {
-            builder.on('thread:title:generate', async function* (event) {
-                const data = (event.data || {});
-                const seedMessage = typeof data.seedMessage === 'string' ? data.seedMessage.trim() : '';
-                if (!seedMessage) {
-                    yield {
-                        type: 'thread:title:generated',
-                        data: { title: 'New thread', channelId: data.channelId },
-                    };
-                    return;
-                }
-                const result = await generateText({
-                    model: resolveModel(configuredModel),
-                    system: TITLE_SYSTEM_PROMPT,
-                    prompt: seedMessage,
-                });
-                const title = result.text.replace(/\s+/g, ' ').trim() || 'New thread';
-                yield {
-                    type: 'thread:title:generated',
-                    data: { title, channelId: data.channelId },
-                };
-            });
-        };
-    },
-};
-export default threadNamerPlugin;

package/dist/plugins/threads/index.js

@@ -1,114 +0,0 @@
-import { generateId } from 'melony';
-import { STATE_AGENT_ID, THREAD_NAMER_AGENT_ID } from '../../app/agent-ids.js';
-import { runAgent } from '../../harness/index.js';
-const THREAD_TITLE_MAX_LENGTH = 80;
-function buildFallbackTitle(seedMessage) {
-    const normalized = seedMessage.replace(/\s+/g, ' ').trim();
-    if (!normalized)
-        return 'New thread';
-    if (normalized.length <= THREAD_TITLE_MAX_LENGTH)
-        return normalized;
-    return `${normalized.slice(0, THREAD_TITLE_MAX_LENGTH).trimEnd()}...`;
-}
-async function requestTitleFromSystem(args) {
-    let title;
-    await runAgent({
-        runId: `tn_${generateId()}`,
-        agentId: THREAD_NAMER_AGENT_ID,
-        channelId: args.channelId,
-        threadId: args.threadId,
-        persistEvents: false,
-        event: {
-            type: 'thread:title:generate',
-            data: {
-                seedMessage: args.seedMessage,
-                channelId: args.channelId,
-            },
-        },
-        onEvent: async (chunk) => {
-            if (chunk.type === 'thread:title:generated') {
-                const generated = chunk.data.title;
-                if (typeof generated === 'string' && generated.trim()) {
-                    title = generated.trim();
-                }
-            }
-        },
-    });
-    if (!title) {
-        throw new Error('Thread namer did not return a title');
-    }
-    return title;
-}
-/**
- * `threads` — orchestrates explicit thread creation on the state agent.
- */
-export const threadsPlugin = {
-    id: 'threads',
-    name: 'Threads',
-    description: 'Creates threads with LLM-generated titles and notifies clients.',
-    factory: ({ agentId, storage }) => {
-        if (agentId !== STATE_AGENT_ID) {
-            return () => { };
-        }
-        return (builder) => {
-            builder.on('thread:create', async function* (event, context) {
-                const data = (event.data || {});
-                const channelId = (data.channelId || context.state.channelId || '').trim();
-                const threadId = (data.threadId || '').trim();
-                if (!channelId || !threadId) {
-                    yield {
-                        type: 'thread:create:failed',
-                        data: {
-                            channelId,
-                            threadId,
-                            error: 'channelId and threadId are required',
-                        },
-                    };
-                    return;
-                }
-                const seedMessage = typeof data.seedMessage === 'string' ? data.seedMessage.trim() : '';
-                let title = threadId;
-                if (seedMessage) {
-                    try {
-                        title = await requestTitleFromSystem({ channelId, threadId, seedMessage });
-                    }
-                    catch (error) {
-                        console.warn('[threads] Title generation failed, using fallback', error);
-                        title = buildFallbackTitle(seedMessage);
-                    }
-                }
-                try {
-                    await storage.createThread({
-                        channelId,
-                        threadId,
-                        threadTitle: title,
-                        initialState: data.initialState,
-                    });
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    if (message.includes('already exists')) {
-                        const existing = await storage.getThreadDetails({ channelId, threadId });
-                        title = existing.name || title;
-                    }
-                    else {
-                        yield {
-                            type: 'thread:create:failed',
-                            data: { channelId, threadId, error: message },
-                        };
-                        return;
-                    }
-                }
-                yield {
-                    type: 'thread:created',
-                    data: { channelId, threadId, title },
-                };
-                yield {
-                    type: 'client:invalidate',
-                    data: { channelId, scopes: ['threads'], threadId },
-                };
-            });
-        };
-    },
-};
-export default threadsPlugin;

package/dist/plugins/ui.js

@@ -1,211 +0,0 @@
-import z from 'zod';
-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('Optional 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()
-            .describe('Legacy form props. Prefer fields and submitLabel.'),
-    }),
-    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) => !!value && typeof value === 'object' && !Array.isArray(value);
-const readString = (value) => typeof value === 'string' && value.trim() ? value : undefined;
-const asFields = (value) => Array.isArray(value) ? value : undefined;
-const asListItems = (value) => Array.isArray(value) ? value : undefined;
-const todoToListItem = (todo, index) => {
-    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),
-        metadata: todo,
-    };
-};
-const createWidgetId = (data, toolCallId) => {
-    if ('widgetId' in data && data.widgetId)
-        return data.widgetId;
-    if (toolCallId)
-        return `widget_${toolCallId}`;
-    return `widget_${Date.now()}`;
-};
-const normalizeWidget = (data, state, toolCallId) => {
-    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.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.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.kind || 'unknown'}`);
-};
-/**
- * UI Plugin for Melony.
- * Provides tools for agents to trigger interactive UI widgets.
- */
-export const uiPlugin = () => (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 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 still accepted.',
-        inputSchema: renderWidgetSchema,
-    },
-};
-export const plugin = {
-    name: 'ui',
-    description: 'UI Widgets plugin',
-    version: '1.0.0',
-    author: 'OpenBot',
-    license: 'MIT',
-    factory: uiPlugin,
-    toolDefinitions: uiToolDefinitions,
-};

package/dist/plugins/workflow/index.js

@@ -1,65 +0,0 @@
-import z from 'zod';
-import { setWorkflowPlan, updateWorkflowTodo } from '../../workflow/service.js';
-const workflowToolDefinitions = {
-    workflow_set_plan: {
-        description: 'Define or replace the multi-agent plan for this thread.',
-        inputSchema: z.object({
-            title: z.string().optional().describe('Optional title for the plan.'),
-            todos: z.array(z.object({
-                id: z.string().optional().describe('Optional stable id.'),
-                text: z.string().describe('What needs to be done.'),
-            })).min(1).describe('Ordered steps.'),
-        }),
-    },
-    workflow_update_todo: {
-        description: 'Update a step in the plan with progress or results.',
-        inputSchema: z.object({
-            todoId: z.string().describe('The id of the todo to update.'),
-            status: z.enum(['pending', 'done', 'failed']).optional().describe('New status.'),
-            summary: z.string().optional().describe('Concise result or note about this step.'),
-        }),
-    },
-};
-const workflowPluginRuntime = () => (builder) => {
-    builder.on('action:workflow_set_plan', async function* (event, context) {
-        const { threadId, channelId } = context.state;
-        if (!threadId) {
-            yield { type: 'action:workflow_set_plan:result', data: { success: false, error: 'No active thread.' }, meta: event.meta };
-            return;
-        }
-        try {
-            const workflow = await setWorkflowPlan({ channelId, threadId, plan: event.data });
-            yield { type: 'action:workflow_set_plan:result', data: { success: true, workflowId: workflow.id }, meta: event.meta };
-            yield {
-                type: 'agent:output',
-                data: { content: `Plan updated: **${workflow.title || workflow.id}** (${workflow.todos.length} steps).` },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId, threadId },
-            };
-        }
-        catch (error) {
-            yield { type: 'action:workflow_set_plan:result', data: { success: false, error: String(error) }, meta: event.meta };
-        }
-    });
-    builder.on('action:workflow_update_todo', async function* (event, context) {
-        const { threadId, channelId } = context.state;
-        if (!threadId) {
-            yield { type: 'action:workflow_update_todo:result', data: { success: false, error: 'No active thread.' }, meta: event.meta };
-            return;
-        }
-        try {
-            const workflow = await updateWorkflowTodo({ channelId, threadId, update: event.data });
-            yield { type: 'action:workflow_update_todo:result', data: { success: true, todoId: event.data.todoId }, meta: event.meta };
-        }
-        catch (error) {
-            yield { type: 'action:workflow_update_todo:result', data: { success: false, error: String(error) }, meta: event.meta };
-        }
-    });
-};
-export const workflowPlugin = {
-    id: 'workflow',
-    name: 'Workflow',
-    description: 'Simple thread-scoped planning for multi-agent coordination.',
-    toolDefinitions: workflowToolDefinitions,
-    factory: () => workflowPluginRuntime(),
-};
-export default workflowPlugin;

package/dist/registry/agents.js

@@ -1,138 +0,0 @@
-import fs from 'node:fs';
-import fsPromises from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { openBotAgentPackage } from '../agents/openbot/index.js';
-import { DEFAULT_AGENT_PACKAGES_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
-let agentPackagesDir = null;
-const loadedPackages = new Set();
-const cache = new Map();
-const BUILT_IN = {
-    [openBotAgentPackage.id]: openBotAgentPackage,
-};
-/**
- * Normalize a dynamically imported agent package module. Supports:
- * - `agentPackage`, `default` (current AgentPackage layout)
- * - `plugin`: legacy/community bundles that used `{ kind: "runtime", factory: (opts) => ... }`
- *   where opts should come from agent config (merged at runtime via AgentPackageContext).
- */
-export function parseAgentPackageModule(module) {
-    const raw = module.agentPackage ??
-        module.default ??
-        module.plugin;
-    if (!raw || typeof raw !== 'object')
-        return null;
-    const id = raw.id;
-    const name = raw.name;
-    const factory = raw.factory;
-    if (typeof id !== 'string' || typeof name !== 'string' || typeof factory !== 'function') {
-        return null;
-    }
-    const description = typeof raw.description === 'string' ? raw.description : '';
-    if (raw.kind === 'runtime') {
-        const legacyFactory = factory;
-        return {
-            id,
-            name,
-            description,
-            image: typeof raw.image === 'string' ? raw.image : undefined,
-            defaultInstructions: typeof raw.defaultInstructions === 'string' ? raw.defaultInstructions : undefined,
-            configSchema: raw.configSchema,
-            factory: (ctx) => {
-                const opts = ctx.config && typeof ctx.config === 'object' && !Array.isArray(ctx.config)
-                    ? { ...ctx.config }
-                    : {};
-                return legacyFactory(opts);
-            },
-        };
-    }
-    return raw;
-}
-async function resolveCommunityDistPath(agentPackagesDir, id) {
-    const direct = path.join(agentPackagesDir, id, 'dist', 'index.js');
-    if (fs.existsSync(direct))
-        return direct;
-    try {
-        const entries = await fsPromises.readdir(agentPackagesDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name.startsWith('.'))
-                continue;
-            if (!entry.isDirectory() && !entry.isSymbolicLink())
-                continue;
-            const distPath = path.join(agentPackagesDir, entry.name, 'dist', 'index.js');
-            if (!fs.existsSync(distPath))
-                continue;
-            try {
-                const mod = await import(pathToFileURL(distPath).href);
-                const pkg = parseAgentPackageModule(mod);
-                if (pkg?.id === id)
-                    return distPath;
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}
-/** Initialize the on-disk agent packages directory (defaults to ~/.openbot/agent-packages). */
-export function initAgentPackages(dir) {
-    if (dir) {
-        agentPackagesDir = dir;
-    }
-    else {
-        const config = loadConfig();
-        const baseDir = config.baseDir || DEFAULT_BASE_DIR;
-        agentPackagesDir = path.join(resolvePath(baseDir), DEFAULT_AGENT_PACKAGES_DIR);
-    }
-}
-/**
- * Resolve an AgentPackage by id. Looks up built-in packages first, then any
- * community packages installed under the agent-packages directory.
- */
-export async function resolveAgentPackage(id) {
-    if (cache.has(id))
-        return cache.get(id);
-    if (BUILT_IN[id]) {
-        cache.set(id, BUILT_IN[id]);
-        return BUILT_IN[id];
-    }
-    if (!agentPackagesDir) {
-        initAgentPackages();
-    }
-    if (!agentPackagesDir)
-        return null;
-    const distPath = await resolveCommunityDistPath(agentPackagesDir, id);
-    if (!distPath) {
-        console.warn(`[agents] AgentPackage "${id}" not found in registry or under ${agentPackagesDir}.`);
-        return null;
-    }
-    try {
-        const module = await import(pathToFileURL(distPath).href);
-        const pkg = parseAgentPackageModule(module);
-        if (!pkg) {
-            console.warn(`[agents] AgentPackage "${id}" at ${distPath} has no recognizable export.`);
-            return null;
-        }
-        cache.set(id, pkg);
-        if (!loadedPackages.has(id)) {
-            console.log(`[agents] Loaded community agent package "${id}" from ${distPath}`);
-            loadedPackages.add(id);
-        }
-        return pkg;
-    }
-    catch (e) {
-        console.warn(`[agents] Failed to load agent package "${id}" from ${distPath}:`, e);
-        return null;
-    }
-}
-/** List built-in agent package descriptors (for marketplace/registry views). */
-export function listBuiltInAgentPackages() {
-    return Object.values(BUILT_IN);
-}
-export function getAgentPackagesDir() {
-    return agentPackagesDir;
-}