@meetopenbot/openbot 0.1.1

package/dist/tools/ui.js

@@ -0,0 +1,120 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+/**
+ * `ui` — provides a tool for the agent to render interactive UI widgets.
+ *
+ * The model can choose which widget to render (form, choice, list, message)
+ * depending on the situation.
+ */
+export const uiPlugin = {
+    id: 'ui',
+    name: 'UI',
+    description: 'Render interactive UI widgets to interact with the user.',
+    toolDefinitions: {
+        render_widget: {
+            description: 'Render a UI widget to the user. Use "form" for data collection, "choice" for simple selection, "list" for displaying items, and "message" for simple notifications with actions. When using form widge to unquire user, do not provide complex forms with many fields, always try to make it simple to keep the experience smooth and straightforward.',
+            inputSchema: z.object({
+                kind: z.enum(['message', 'choice', 'form', 'list']).describe('The type of widget to render.'),
+                title: z.string().describe('The title of the widget.'),
+                description: z.string().optional().describe('A description or body text.'),
+                fields: z.array(z.object({
+                    id: z.string().describe('Unique ID for the field.'),
+                    label: z.string().describe('Label shown to the user.'),
+                    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(z.object({ label: z.string(), value: z.string() })).optional(),
+                    defaultValue: z.any().optional()
+                })).optional().describe('Required for kind="form". List of form fields.'),
+                actions: z.array(z.object({
+                    id: z.string(),
+                    label: z.string(),
+                    variant: z.enum(['primary', 'secondary', 'danger']).optional(),
+                })).optional().describe('Buttons or actions available on the widget.'),
+                items: z.array(z.object({
+                    id: z.string(),
+                    label: z.string(),
+                    description: z.string().optional(),
+                    status: z
+                        .string()
+                        .optional()
+                        .describe('Status label shown on the item (e.g. "Pending", "Shipped").'),
+                    statusVariant: z
+                        .enum(['default', 'success', 'warning', 'danger', 'info'])
+                        .optional()
+                        .describe('Semantic hint for status badge coloring in the client.'),
+                    metadata: z.record(z.string(), z.any()).optional()
+                })).optional().describe('Required for kind="list". List of items to display.'),
+                submitLabel: z.string().optional().describe('Label for the primary action button (e.g. "Submit", "Save").')
+            })
+        }
+    },
+    factory: () => (builder) => {
+        // Handle the tool call from the agent
+        builder.on('action:render_widget', async function* (event, context) {
+            const widgetEvent = event;
+            const toolCallId = widgetEvent.meta?.toolCallId;
+            const threadId = widgetEvent.meta?.threadId || context.state.threadId;
+            if (!toolCallId)
+                return;
+            const widgetId = randomUUID();
+            // Emit the UI widget event to the client
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    ...widgetEvent.data,
+                    widgetId,
+                    metadata: {
+                        type: 'ui:request',
+                        originalEvent: widgetEvent
+                    }
+                },
+                meta: { agentId: context.state.agentId, threadId }
+            };
+        });
+        // Handle the user's response from the UI widget
+        builder.on('client:ui:widget:response', async function* (event, context) {
+            const responseEvent = event;
+            const { widgetId, actionId, values, metadata } = responseEvent.data;
+            if (metadata?.type !== 'ui:request')
+                return;
+            const originalEvent = metadata.originalEvent;
+            const toolCallId = originalEvent?.meta?.toolCallId;
+            const threadId = originalEvent?.meta?.threadId || context.state.threadId;
+            if (!toolCallId)
+                return;
+            // Yield a "submitted" widget update to the UI to collapse/disable it
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    widgetId,
+                    title: originalEvent.data.title,
+                    kind: originalEvent.data.kind,
+                    state: 'submitted',
+                    body: "Thank you for your response. We will process it and get back to you soon.",
+                    display: 'collapsed',
+                    disabled: true,
+                    actions: [], // Clear actions to disable buttons in UI
+                },
+                meta: { agentId: context.state.agentId, threadId },
+            };
+            // Emit the tool result event so the agent runtime can resume
+            yield {
+                type: 'action:render_widget:result',
+                data: {
+                    success: true,
+                    actionId,
+                    values,
+                    output: JSON.stringify(values)
+                },
+                meta: {
+                    agentId: context.state.agentId,
+                    threadId,
+                    toolCallId
+                }
+            };
+        });
+    },
+};
+export default uiPlugin;

package/dist/types.d.ts

@@ -0,0 +1,80 @@
+import type { Plugin as SdkPlugin, PluginContext as SdkPluginContext, OpenBotState as SdkOpenBotState, ToolActionEvent, PluginFactory as SdkPluginFactory, PluginBuilder, PluginHandlerContext, OpenBotEvent } from '@meetopenbot/plugin-sdk';
+export { definePlugin } from '@meetopenbot/plugin-sdk';
+export type { AgentInvokeEvent, AgentOutputEvent, ConfigSchema, OpenBotEvent, PluginBuilder, PluginFactory, PluginHandlerContext, Storage, ToolDefinition, ToolActionEvent, UIWidgetListItem, UIWidgetResponseEvent, } from '@meetopenbot/plugin-sdk';
+export type MemoryScopeAlias = 'global' | 'agent' | 'channel';
+export type DelegateTaskEvent = ToolActionEvent<{
+    agentId: string;
+    prompt: string;
+}> & {
+    type: 'action:delegate_task';
+};
+export type RenderWidgetEvent = ToolActionEvent<Record<string, unknown>> & {
+    type: 'action:render_widget';
+};
+/** Runtime state extends the SDK with fields used by the OpenBot agent plugin. */
+export type OpenBotState = SdkOpenBotState & {
+    model?: string;
+    currentUser?: {
+        userName?: string;
+    };
+    pendingToolCallIds?: string[];
+    threadDetails?: SdkOpenBotState['threadDetails'] & {
+        name?: string;
+    };
+};
+/**
+ * Builder surface for registering `action:*` handlers.
+ * SDK `OpenBotEvent` includes a `type: string` fallback that prevents Melony from
+ * narrowing specific action events; this helper keeps handlers type-safe.
+ */
+export type ActionBuilder = {
+    on<TData = Record<string, unknown>>(action: string, handler: (event: ToolActionEvent<TData>, context: PluginHandlerContext) => AsyncGenerator<OpenBotEvent> | void): void;
+};
+export declare function asActionBuilder(builder: PluginBuilder): ActionBuilder;
+export interface PluginHost {
+    runAgent: (options: {
+        runId: string;
+        agentId: string;
+        event: OpenBotEvent;
+        channelId: string;
+        threadId?: string;
+        persistEvents?: boolean;
+        publicBaseUrl?: string;
+        onEvent: (event: OpenBotEvent, state?: OpenBotState) => Promise<void>;
+    }) => Promise<void>;
+    isCloudSystemAgent: (agentId: string) => boolean;
+    isCloudMode: () => boolean;
+    parseOpenbotAuthMode: (value: unknown) => 'credits' | 'byok';
+    resolveModelRegistry: () => Promise<{
+        providers?: Record<string, {
+            label: string;
+            models: Array<{
+                id: string;
+                label: string;
+                description: string;
+            }>;
+        }>;
+    }>;
+    listApiKeyProvidersFromRegistry: (registry: Awaited<ReturnType<PluginHost['resolveModelRegistry']>>) => Array<{
+        id: string;
+        label: string;
+    }>;
+    saveConfig: (patch: Record<string, unknown>) => void;
+    getBaseDir: () => string;
+    resolvePath: (p: string) => string;
+    orchestratorAgentId: string;
+    openbotPluginId: string;
+    defaultCloudAuthMode: 'credits' | 'byok';
+}
+/** Host context extends the SDK with OpenBot runtime wiring. */
+export interface PluginContext extends SdkPluginContext {
+    publicBaseUrl: string;
+    abortSignal?: AbortSignal;
+    host: PluginHost;
+}
+export interface Plugin extends Omit<SdkPlugin, 'factory' | 'configSchema'> {
+    configSchema?: SdkPlugin['configSchema'] | Record<string, unknown>;
+    factory: (context: PluginContext) => SdkPluginFactory;
+}
+/** Type-safe plugin definition for the extended OpenBot host context. */
+export declare function defineOpenbotPlugin<T extends Plugin>(definition: T): T;

package/dist/types.js

@@ -0,0 +1,12 @@
+export { definePlugin } from '@meetopenbot/plugin-sdk';
+export function asActionBuilder(builder) {
+    return {
+        on(action, handler) {
+            builder.on(`action:${action}`, handler);
+        },
+    };
+}
+/** Type-safe plugin definition for the extended OpenBot host context. */
+export function defineOpenbotPlugin(definition) {
+    return definition;
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_CHANNELS_DIR = "channels";
+export declare function resolvePath(p: string): string;
+export declare function getBaseDir(): string;

package/dist/utils/paths.js

@@ -0,0 +1,12 @@
+import path from 'node:path';
+import os from 'node:os';
+export const DEFAULT_CHANNELS_DIR = 'channels';
+export function resolvePath(p) {
+    return p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : path.resolve(p);
+}
+export function getBaseDir() {
+    const env = process.env.OPENBOT_BASE_DIR?.trim();
+    if (env)
+        return resolvePath(env);
+    return path.join(os.homedir(), '.openbot');
+}

package/dist/utils/workspace-url.d.ts

@@ -0,0 +1,5 @@
+export declare function buildWorkspaceFileUrl(args: {
+    baseUrl: string;
+    channelId: string;
+    filePath: string;
+}): string;

package/dist/utils/workspace-url.js

@@ -0,0 +1,6 @@
+export function buildWorkspaceFileUrl(args) {
+    const base = args.baseUrl.replace(/\/$/, '');
+    const data = encodeURIComponent(JSON.stringify({ path: args.filePath }));
+    const channelId = encodeURIComponent(args.channelId);
+    return `${base}/api/state?channelId=${channelId}&type=${encodeURIComponent('action:storage:serve-file')}&data=${data}`;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@meetopenbot/openbot",
+  "version": "0.1.1",
+  "description": "Monolithic OpenBot agent runtime with batteries-included tools.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.33",
+    "@ai-sdk/google": "^3.0.82",
+    "@ai-sdk/openai": "^3.0.13",
+    "@meetopenbot/plugin-sdk": "^0.1.5",
+    "ai": "^6.0.42",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.1",
+    "typescript": "^5.9.3"
+  }
+}