@datalayer/agent-runtimes 0.0.2

package/lib/components/chat/extensions/A2UIExtension.js

@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * A2UI extension for chat component.
+ * Renders A2UI protocol messages from A2A agents.
+ *
+ * @module components/chat/extensions/A2UIExtension
+ */
+import React from 'react';
+/**
+ * Create A2UI activity renderer
+ */
+export function createA2UIRenderer(customRenderers) {
+    // Track surfaces per session
+    const contexts = new Map();
+    const getContext = (sessionId) => {
+        if (!contexts.has(sessionId)) {
+            contexts.set(sessionId, {
+                surfaces: new Map(),
+                dataModels: new Map(),
+            });
+        }
+        return contexts.get(sessionId);
+    };
+    return {
+        name: 'a2ui-renderer',
+        type: 'activity-renderer',
+        activityTypes: ['a2ui'],
+        render: ({ activityType: _activityType, data, message: _message }) => {
+            // Use default session for now
+            const sessionId = 'default';
+            const a2uiContext = getContext(sessionId);
+            const a2uiData = data;
+            // Handle begin rendering
+            if (a2uiData.beginRendering) {
+                a2uiContext.surfaces.set(a2uiData.beginRendering.surface, {
+                    surface: a2uiData.beginRendering.surface,
+                    mimeType: a2uiData.beginRendering.mimeType,
+                    content: null,
+                    finished: false,
+                });
+            }
+            // Handle surface update
+            if (a2uiData.surfaceUpdate) {
+                const surface = a2uiContext.surfaces.get(a2uiData.surfaceUpdate.surface);
+                if (surface) {
+                    if (a2uiData.surfaceUpdate.replace !== undefined) {
+                        surface.content = a2uiData.surfaceUpdate.replace;
+                    }
+                    else if (a2uiData.surfaceUpdate.patch !== undefined) {
+                        // Apply JSON patch (simplified)
+                        surface.content = applyPatch(surface.content, a2uiData.surfaceUpdate.patch);
+                    }
+                }
+            }
+            // Handle data model update
+            if (a2uiData.dataModelUpdate) {
+                const existing = a2uiContext.dataModels.get(a2uiData.dataModelUpdate.dataModel);
+                if (a2uiData.dataModelUpdate.replace !== undefined) {
+                    a2uiContext.dataModels.set(a2uiData.dataModelUpdate.dataModel, a2uiData.dataModelUpdate.replace);
+                }
+                else if (a2uiData.dataModelUpdate.patch !== undefined) {
+                    a2uiContext.dataModels.set(a2uiData.dataModelUpdate.dataModel, applyPatch(existing, a2uiData.dataModelUpdate.patch));
+                }
+            }
+            // Handle finish rendering
+            if (a2uiData.finishRendering) {
+                const surface = a2uiContext.surfaces.get(a2uiData.finishRendering.surface);
+                if (surface) {
+                    surface.finished = true;
+                }
+            }
+            // Render surfaces
+            const surfacesToRender = Array.from(a2uiContext.surfaces.values());
+            return React.createElement('div', { className: 'chat-a2ui-container' }, surfacesToRender.map(surface => {
+                // Check for custom renderer
+                if (customRenderers &&
+                    surface.mimeType &&
+                    customRenderers[surface.mimeType]) {
+                    const CustomRenderer = customRenderers[surface.mimeType];
+                    return React.createElement(CustomRenderer, {
+                        key: surface.surface,
+                        content: surface.content,
+                    });
+                }
+                // Default rendering based on mime type
+                return React.createElement('div', {
+                    key: surface.surface,
+                    className: `chat-a2ui-surface chat-a2ui-surface--${surface.mimeType?.replace('/', '-') || 'unknown'}`,
+                }, renderSurfaceContent(surface));
+            }));
+        },
+        priority: 10,
+    };
+}
+/**
+ * Render surface content based on mime type
+ */
+function renderSurfaceContent(surface) {
+    const { content, mimeType } = surface;
+    if (content === null || content === undefined) {
+        return null;
+    }
+    // Handle different mime types
+    switch (mimeType) {
+        case 'text/plain':
+            return React.createElement('pre', null, String(content));
+        case 'text/markdown':
+            // Would need markdown renderer
+            return React.createElement('div', { className: 'markdown' }, String(content));
+        case 'text/html':
+            return React.createElement('div', {
+                dangerouslySetInnerHTML: { __html: String(content) },
+            });
+        case 'application/json':
+            return React.createElement('pre', { className: 'json' }, JSON.stringify(content, null, 2));
+        case 'image/png':
+        case 'image/jpeg':
+        case 'image/gif':
+        case 'image/webp':
+            if (typeof content === 'string') {
+                return React.createElement('img', {
+                    src: content.startsWith('data:')
+                        ? content
+                        : `data:${mimeType};base64,${content}`,
+                    alt: surface.surface,
+                });
+            }
+            break;
+        default:
+            // Try to render as string or JSON
+            if (typeof content === 'string') {
+                return React.createElement('pre', null, content);
+            }
+            return React.createElement('pre', null, JSON.stringify(content, null, 2));
+    }
+    return null;
+}
+/**
+ * Simple JSON patch application (RFC 6902 subset)
+ */
+function applyPatch(target, patch) {
+    if (!Array.isArray(patch)) {
+        return patch;
+    }
+    const result = structuredClone(target) || {};
+    for (const op of patch) {
+        if (typeof op !== 'object' || !op)
+            continue;
+        const { op: operation, path, value, } = op;
+        const pathParts = path.split('/').filter(Boolean);
+        switch (operation) {
+            case 'add':
+            case 'replace':
+                setNestedValue(result, pathParts, value);
+                break;
+            case 'remove':
+                removeNestedValue(result, pathParts);
+                break;
+            case 'copy':
+            case 'move':
+                // Simplified - not fully implemented
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Set a nested value in an object
+ */
+function setNestedValue(obj, path, value) {
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (!(key in current)) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    if (path.length > 0) {
+        current[path[path.length - 1]] = value;
+    }
+}
+/**
+ * Remove a nested value from an object
+ */
+function removeNestedValue(obj, path) {
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (!(key in current))
+            return;
+        current = current[key];
+    }
+    if (path.length > 0) {
+        delete current[path[path.length - 1]];
+    }
+}
+/**
+ * A2UI Extension implementation class
+ */
+export class A2UIExtensionImpl {
+    name = 'a2ui';
+    type = 'activity-renderer';
+    activityTypes = ['a2ui'];
+    priority = 10;
+    contexts = new Map();
+    customRenderers = {};
+    /**
+     * Register a custom renderer for a mime type
+     */
+    registerRenderer(mimeType, component) {
+        this.customRenderers[mimeType] = component;
+    }
+    /**
+     * Get the current surfaces for a session
+     */
+    getSurfaces(sessionId) {
+        const context = this.contexts.get(sessionId);
+        if (!context)
+            return new Map();
+        const result = new Map();
+        for (const [key, surface] of context.surfaces) {
+            result.set(key, surface.content);
+        }
+        return result;
+    }
+    /**
+     * Get the current data models for a session
+     */
+    getDataModels(sessionId) {
+        return this.contexts.get(sessionId)?.dataModels || new Map();
+    }
+    /**
+     * Process an A2UI message
+     */
+    processMessage(sessionId, message) {
+        if (!this.contexts.has(sessionId)) {
+            this.contexts.set(sessionId, {
+                surfaces: new Map(),
+                dataModels: new Map(),
+            });
+        }
+        const context = this.contexts.get(sessionId);
+        if (message.beginRendering) {
+            context.surfaces.set(message.beginRendering.surface, {
+                surface: message.beginRendering.surface,
+                mimeType: message.beginRendering.mimeType,
+                content: null,
+                finished: false,
+            });
+        }
+        if (message.surfaceUpdate) {
+            const surface = context.surfaces.get(message.surfaceUpdate.surface);
+            if (surface) {
+                if (message.surfaceUpdate.replace !== undefined) {
+                    surface.content = message.surfaceUpdate.replace;
+                }
+                else if (message.surfaceUpdate.patch !== undefined) {
+                    surface.content = applyPatch(surface.content, message.surfaceUpdate.patch);
+                }
+            }
+        }
+        if (message.dataModelUpdate) {
+            const existing = context.dataModels.get(message.dataModelUpdate.dataModel);
+            if (message.dataModelUpdate.replace !== undefined) {
+                context.dataModels.set(message.dataModelUpdate.dataModel, message.dataModelUpdate.replace);
+            }
+            else if (message.dataModelUpdate.patch !== undefined) {
+                context.dataModels.set(message.dataModelUpdate.dataModel, applyPatch(existing, message.dataModelUpdate.patch));
+            }
+        }
+        if (message.finishRendering) {
+            const surface = context.surfaces.get(message.finishRendering.surface);
+            if (surface) {
+                surface.finished = true;
+            }
+        }
+    }
+    /**
+     * Clear a session's context
+     */
+    clearSession(sessionId) {
+        this.contexts.delete(sessionId);
+    }
+    /**
+     * Render method for the extension
+     */
+    render = ({ activityType: _activityType, data, message: _message, }) => {
+        const sessionId = 'default';
+        this.processMessage(sessionId, data);
+        const ctx = this.contexts.get(sessionId);
+        if (!ctx)
+            return null;
+        const surfacesToRender = Array.from(ctx.surfaces.values());
+        return React.createElement('div', { className: 'chat-a2ui-container' }, surfacesToRender.map(surface => {
+            if (this.customRenderers[surface.mimeType || '']) {
+                const CustomRenderer = this.customRenderers[surface.mimeType || ''];
+                return React.createElement(CustomRenderer, {
+                    key: surface.surface,
+                    content: surface.content,
+                });
+            }
+            return React.createElement('div', {
+                key: surface.surface,
+                className: `chat-a2ui-surface`,
+            }, renderSurfaceContent(surface));
+        }));
+    };
+}

package/lib/components/chat/extensions/ExtensionRegistry.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Extension registry for chat component.
+ * Manages custom renderers and extension points.
+ *
+ * @module components/chat/extensions/ExtensionRegistry
+ */
+import type { ChatExtension, MessageRendererExtension, ActivityRendererExtension, ToolUIExtension, ProtocolEventExtension, PanelExtension } from '../types/extension';
+/** Internal extension type for registry organization */
+type InternalExtensionType = 'message-renderer' | 'activity-renderer' | 'tool-ui' | 'protocol-event' | 'panel';
+/**
+ * Extension registry class
+ */
+export declare class ExtensionRegistry {
+    private extensions;
+    private byType;
+    constructor();
+    /**
+     * Register an extension
+     */
+    register(extension: ChatExtension): void;
+    /**
+     * Unregister an extension
+     */
+    unregister(extensionName: string): void;
+    /**
+     * Get an extension by name
+     */
+    get<T extends ChatExtension>(extensionName: string): T | undefined;
+    /**
+     * Get all extensions of a specific type
+     */
+    getByType<T extends ChatExtension>(type: InternalExtensionType): T[];
+    /**
+     * Get all registered extensions
+     */
+    getAll(): ChatExtension[];
+    /**
+     * Check if an extension is registered
+     */
+    has(extensionName: string): boolean;
+    /**
+     * Get message renderers
+     */
+    getMessageRenderers(): MessageRendererExtension[];
+    /**
+     * Get activity renderer for a specific activity type
+     */
+    getActivityRenderer(activityType: string): ActivityRendererExtension | undefined;
+    /**
+     * Get tool UI for a specific tool
+     */
+    getToolUI(toolName: string): ToolUIExtension | undefined;
+    /**
+     * Get all panels
+     */
+    getPanels(): PanelExtension[];
+    /**
+     * Get protocol event handlers for an event type
+     */
+    getProtocolEventHandlers(eventType: string): ProtocolEventExtension[];
+    /**
+     * Clear all extensions
+     */
+    clear(): void;
+}
+export { createMessageRenderer, createActivityRenderer, } from '../types/extension';

package/lib/components/chat/extensions/ExtensionRegistry.js

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Get the internal type string from an extension
+ */
+function getExtensionType(ext) {
+    return ext.type;
+}
+/**
+ * Get the name from an extension
+ */
+function getExtensionName(ext) {
+    return ext.name;
+}
+/**
+ * Extension registry class
+ */
+export class ExtensionRegistry {
+    extensions = new Map();
+    byType = new Map();
+    constructor() {
+        // Initialize type maps
+        const types = [
+            'message-renderer',
+            'activity-renderer',
+            'tool-ui',
+            'protocol-event',
+            'panel',
+        ];
+        for (const type of types) {
+            this.byType.set(type, new Set());
+        }
+    }
+    /**
+     * Register an extension
+     */
+    register(extension) {
+        const name = getExtensionName(extension);
+        if (this.extensions.has(name)) {
+            console.warn(`[ExtensionRegistry] Extension ${name} already registered, replacing`);
+        }
+        this.extensions.set(name, extension);
+        this.byType.get(getExtensionType(extension))?.add(name);
+    }
+    /**
+     * Unregister an extension
+     */
+    unregister(extensionName) {
+        const extension = this.extensions.get(extensionName);
+        if (extension) {
+            this.byType.get(getExtensionType(extension))?.delete(extensionName);
+            this.extensions.delete(extensionName);
+        }
+    }
+    /**
+     * Get an extension by name
+     */
+    get(extensionName) {
+        return this.extensions.get(extensionName);
+    }
+    /**
+     * Get all extensions of a specific type
+     */
+    getByType(type) {
+        const names = this.byType.get(type) || new Set();
+        return Array.from(names)
+            .map(name => this.extensions.get(name))
+            .filter(ext => ext !== undefined);
+    }
+    /**
+     * Get all registered extensions
+     */
+    getAll() {
+        return Array.from(this.extensions.values());
+    }
+    /**
+     * Check if an extension is registered
+     */
+    has(extensionName) {
+        return this.extensions.has(extensionName);
+    }
+    /**
+     * Get message renderers
+     */
+    getMessageRenderers() {
+        return this.getByType('message-renderer');
+    }
+    /**
+     * Get activity renderer for a specific activity type
+     */
+    getActivityRenderer(activityType) {
+        const renderers = this.getByType('activity-renderer');
+        return renderers.find(r => r.activityTypes.includes(activityType));
+    }
+    /**
+     * Get tool UI for a specific tool
+     */
+    getToolUI(toolName) {
+        const toolUIs = this.getByType('tool-ui');
+        return toolUIs.find(ui => ui.toolNames === '*' || ui.toolNames.includes(toolName));
+    }
+    /**
+     * Get all panels
+     */
+    getPanels() {
+        return this.getByType('panel');
+    }
+    /**
+     * Get protocol event handlers for an event type
+     */
+    getProtocolEventHandlers(eventType) {
+        const handlers = this.getByType('protocol-event');
+        return handlers.filter(h => h.eventTypes.includes(eventType) || h.eventTypes.includes('*'));
+    }
+    /**
+     * Clear all extensions
+     */
+    clear() {
+        this.extensions.clear();
+        for (const set of this.byType.values()) {
+            set.clear();
+        }
+    }
+}
+// Re-export the helper functions from types/extension
+export { createMessageRenderer, createActivityRenderer, } from '../types/extension';

package/lib/components/chat/extensions/MCPUIExtension.d.ts

@@ -0,0 +1,77 @@
+/**
+ * MCP-UI extension for chat component.
+ * Renders MCP UI protocol messages and resources.
+ *
+ * @module components/chat/extensions/MCPUIExtension
+ */
+import React from 'react';
+import type { ActivityRendererExtension } from '../types/extension';
+/**
+ * MCP-UI resource types
+ */
+export interface MCPUIResource {
+    /** Resource URI */
+    uri: string;
+    /** Resource name */
+    name?: string;
+    /** Resource description */
+    description?: string;
+    /** MIME type */
+    mimeType?: string;
+    /** Resource content */
+    content?: unknown;
+    /** Text content */
+    text?: string;
+    /** Blob content */
+    blob?: string;
+}
+/**
+ * MCP-UI message types
+ */
+export interface MCPUIMessage {
+    /** Resource list update */
+    resourceList?: {
+        resources: MCPUIResource[];
+    };
+    /** Resource content */
+    resourceContent?: {
+        uri: string;
+        content: MCPUIResource;
+    };
+    /** UI element */
+    uiElement?: {
+        type: string;
+        props?: Record<string, unknown>;
+        children?: MCPUIMessage[];
+    };
+}
+/**
+ * Create MCP-UI activity renderer
+ */
+export declare function createMCPUIRenderer(customRenderers?: Record<string, React.ComponentType<{
+    resource: MCPUIResource;
+}>>): ActivityRendererExtension;
+/**
+ * MCP-UI Extension implementation class
+ */
+export declare class MCPUIExtensionImpl {
+    private renderer;
+    private customRenderers;
+    constructor(customRenderers?: Record<string, React.ComponentType<{
+        resource: MCPUIResource;
+    }>>);
+    /**
+     * Get the activity renderer extension
+     */
+    getRenderer(): ActivityRendererExtension;
+    /**
+     * Register a custom renderer for a MIME type
+     */
+    registerMimeTypeRenderer(mimeType: string, renderer: React.ComponentType<{
+        resource: MCPUIResource;
+    }>): void;
+    /**
+     * Cleanup extension state
+     */
+    cleanup(): void;
+}