@datalayer/agent-runtimes 0.0.2

package/lib/components/chat/protocols/BaseProtocolAdapter.js

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Abstract base class for protocol adapters
+ */
+export class BaseProtocolAdapter {
+    config;
+    _connectionState = 'disconnected';
+    eventHandlers = new Set();
+    reconnectAttempts = 0;
+    constructor(config) {
+        this.config = {
+            autoReconnect: true,
+            reconnectDelay: 1000,
+            maxReconnectAttempts: 5,
+            timeout: 30000,
+            ...config,
+        };
+    }
+    get connectionState() {
+        return this._connectionState;
+    }
+    /**
+     * Subscribe to protocol events
+     */
+    subscribe(handler) {
+        this.eventHandlers.add(handler);
+        return () => {
+            this.eventHandlers.delete(handler);
+        };
+    }
+    /**
+     * Get agent card (optional, mainly for A2A)
+     */
+    async getAgentCard() {
+        return null;
+    }
+    /**
+     * Check if protocol supports a specific feature
+     */
+    supportsFeature(feature) {
+        // Override in subclasses
+        return false;
+    }
+    /**
+     * Emit an event to all subscribers
+     */
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (error) {
+                console.error(`[${this.type}] Error in event handler:`, error);
+            }
+        }
+    }
+    /**
+     * Update connection state and emit event
+     */
+    setConnectionState(state) {
+        const previousState = this._connectionState;
+        this._connectionState = state;
+        if (previousState !== state) {
+            this.emit({
+                type: state === 'connected' ? 'connected' : 'disconnected',
+                timestamp: new Date(),
+            });
+        }
+    }
+    /**
+     * Handle reconnection logic
+     */
+    async handleReconnect() {
+        if (!this.config.autoReconnect) {
+            return;
+        }
+        if (this.reconnectAttempts >= (this.config.maxReconnectAttempts || 5)) {
+            this.setConnectionState('error');
+            this.emit({
+                type: 'error',
+                error: new Error('Max reconnection attempts reached'),
+                timestamp: new Date(),
+            });
+            return;
+        }
+        this.setConnectionState('reconnecting');
+        this.reconnectAttempts++;
+        const delay = this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        try {
+            await this.connect();
+            this.reconnectAttempts = 0;
+        }
+        catch (error) {
+            await this.handleReconnect();
+        }
+    }
+    /**
+     * Build headers for HTTP requests
+     */
+    buildHeaders(additionalHeaders) {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.config.authToken) {
+            headers['Authorization'] = `Bearer ${this.config.authToken}`;
+        }
+        return { ...headers, ...additionalHeaders };
+    }
+    /**
+     * Create abort signal with timeout
+     */
+    createTimeoutSignal() {
+        return AbortSignal.timeout(this.config.timeout || 30000);
+    }
+}

package/lib/components/chat/protocols/VercelAIAdapter.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Vercel AI protocol adapter using SSE transport.
+ * Implements Pydantic AI's Vercel AI Data Stream Protocol.
+ *
+ * @see https://ai.pydantic.dev/ui/vercel-ai/
+ *
+ * @module components/chat/protocols/VercelAIAdapter
+ */
+import type { ProtocolAdapterConfig } from '../types/protocol';
+import type { ChatMessage } from '../types/message';
+import type { ToolDefinition, ToolExecutionResult } from '../types/tool';
+import { BaseProtocolAdapter } from './BaseProtocolAdapter';
+/**
+ * Vercel AI specific configuration
+ */
+export interface VercelAIAdapterConfig extends ProtocolAdapterConfig {
+    /** Agent ID */
+    agentId?: string;
+    /** Custom headers for requests (e.g., for Jupyter authentication) */
+    headers?: Record<string, string>;
+    /** Custom fetch options */
+    fetchOptions?: {
+        /** Request mode */
+        mode?: RequestMode;
+        /** Credentials mode */
+        credentials?: RequestCredentials;
+    };
+}
+/**
+ * Vercel AI protocol adapter
+ * Uses HTTP POST with SSE streaming for responses
+ * Compatible with Pydantic AI's Vercel AI Data Stream Protocol
+ */
+export declare class VercelAIAdapter extends BaseProtocolAdapter {
+    readonly type: "vercel-ai";
+    readonly transport: "sse";
+    private vercelConfig;
+    private abortController;
+    private currentRequestId;
+    constructor(config: VercelAIAdapterConfig);
+    /**
+     * Connect to Vercel AI endpoint (SSE doesn't require persistent connection)
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect and terminate any ongoing request
+     */
+    disconnect(): void;
+    /**
+     * Terminate a running request on the backend
+     */
+    terminateRequest(requestId?: string): Promise<void>;
+    /**
+     * Send a message using Vercel AI Data Stream Protocol
+     */
+    sendMessage(message: ChatMessage, options?: {
+        tools?: ToolDefinition[];
+        threadId?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * Parse SSE stream from Vercel AI
+     */
+    private parseSSEStream;
+    /**
+     * Send tool result (not supported in Vercel AI adapter)
+     */
+    sendToolResult(_toolCallId: string, _result: ToolExecutionResult): Promise<void>;
+    /**
+     * Request permission (not supported in Vercel AI)
+     */
+    requestPermission(_permission: string): Promise<boolean>;
+    /**
+     * Stop generation
+     */
+    stopGeneration(): void;
+}

package/lib/components/chat/protocols/VercelAIAdapter.js

@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { generateMessageId, createAssistantMessage } from '../types/message';
+import { BaseProtocolAdapter } from './BaseProtocolAdapter';
+/**
+ * Vercel AI protocol adapter
+ * Uses HTTP POST with SSE streaming for responses
+ * Compatible with Pydantic AI's Vercel AI Data Stream Protocol
+ */
+export class VercelAIAdapter extends BaseProtocolAdapter {
+    type = 'vercel-ai';
+    transport = 'sse';
+    vercelConfig;
+    abortController = null;
+    currentRequestId = null;
+    constructor(config) {
+        super(config);
+        this.vercelConfig = config;
+    }
+    /**
+     * Connect to Vercel AI endpoint (SSE doesn't require persistent connection)
+     */
+    async connect() {
+        this.setConnectionState('connecting');
+        // Vercel AI uses SSE, no persistent connection needed
+        // Just mark as connected
+        this.setConnectionState('connected');
+    }
+    /**
+     * Disconnect and terminate any ongoing request
+     */
+    disconnect() {
+        this.abortController?.abort();
+        this.abortController = null;
+        // Send terminate request to backend if we have a request ID
+        if (this.currentRequestId) {
+            this.terminateRequest(this.currentRequestId).catch(err => {
+                console.warn('[VercelAIAdapter] Failed to terminate request:', err);
+            });
+        }
+        this.setConnectionState('disconnected');
+    }
+    /**
+     * Terminate a running request on the backend
+     */
+    async terminateRequest(requestId) {
+        try {
+            // Derive the terminate endpoint from the base URL
+            const baseUrl = new URL(this.vercelConfig.baseUrl);
+            const terminateUrl = `${baseUrl.origin}/api/v1/vercel-ai/terminate`;
+            const response = await fetch(terminateUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    request_id: requestId || this.currentRequestId,
+                }),
+            });
+            if (!response.ok) {
+                console.warn(`[VercelAIAdapter] Terminate request failed: ${response.status}`);
+            }
+            else {
+                // Consume the response (terminate result)
+                await response.json();
+            }
+        }
+        catch {
+            // Ignore errors - request may have already completed
+        }
+    }
+    /**
+     * Send a message using Vercel AI Data Stream Protocol
+     */
+    async sendMessage(message, options) {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+        this.abortController = new AbortController();
+        // Generate request ID for tracking
+        const requestId = options?.threadId || generateMessageId();
+        this.currentRequestId = requestId;
+        try {
+            // Extract the message content as a string
+            const messageContent = typeof message.content === 'string'
+                ? message.content
+                : String(message.content);
+            // Build single message in Vercel AI SDK format
+            const vercelMessage = {
+                id: message.id,
+                role: message.role,
+                parts: [
+                    {
+                        type: 'text',
+                        text: messageContent,
+                    },
+                ],
+            };
+            // Build Vercel AI request
+            const requestBody = {
+                id: requestId, // Run ID for tracking
+                messages: [vercelMessage],
+                trigger: 'submit-message',
+                // Optional fields based on Pydantic AI's Vercel adapter
+                ...(options?.tools && { tools: options.tools }),
+            };
+            // Merge custom headers with defaults
+            const headers = {
+                'Content-Type': 'application/json',
+                Accept: 'text/event-stream',
+                ...this.vercelConfig.headers,
+            };
+            // Add auth token if provided
+            if (this.vercelConfig.authToken) {
+                headers['Authorization'] = `token ${this.vercelConfig.authToken}`;
+            }
+            const response = await fetch(this.vercelConfig.baseUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(requestBody),
+                signal: this.abortController.signal,
+                mode: this.vercelConfig.fetchOptions?.mode,
+                credentials: this.vercelConfig.fetchOptions?.credentials,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('Response body is null');
+            }
+            // Parse SSE stream
+            await this.parseSSEStream(response.body);
+        }
+        catch (error) {
+            if (error.name !== 'AbortError') {
+                console.error('[VercelAIAdapter] Send error:', error);
+                throw error;
+            }
+        }
+        finally {
+            this.abortController = null;
+        }
+    }
+    /**
+     * Parse SSE stream from Vercel AI
+     */
+    async parseSSEStream(stream) {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let currentMessageId = generateMessageId();
+        let accumulatedText = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim() || line.startsWith(':')) {
+                        continue;
+                    }
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data === '[DONE]') {
+                            // Stream complete
+                            if (accumulatedText) {
+                                const message = createAssistantMessage(accumulatedText);
+                                message.id = currentMessageId;
+                                this.emit({
+                                    type: 'message',
+                                    message,
+                                    timestamp: new Date(),
+                                });
+                            }
+                            break;
+                        }
+                        try {
+                            const event = JSON.parse(data);
+                            // Handle Vercel AI event types
+                            // Server sends: {"type":"text-delta","delta":"Hello","id":"..."}
+                            if (event.type === 'text-delta' && event.delta) {
+                                accumulatedText += event.delta;
+                                // Emit 'message' event with accumulated content for useChat
+                                const message = createAssistantMessage(accumulatedText);
+                                message.id = currentMessageId;
+                                this.emit({
+                                    type: 'message',
+                                    message,
+                                    timestamp: new Date(),
+                                });
+                            }
+                            else if (event.type === 'text-start') {
+                                // New text block starting
+                                currentMessageId = event.id || generateMessageId();
+                                accumulatedText = '';
+                            }
+                            else if (event.type === 'finish' || event.type === 'end-step') {
+                                if (accumulatedText) {
+                                    const message = createAssistantMessage(accumulatedText);
+                                    message.id = currentMessageId;
+                                    this.emit({
+                                        type: 'message',
+                                        message,
+                                        timestamp: new Date(),
+                                    });
+                                }
+                            }
+                            else if (event.type === 'error') {
+                                this.emit({
+                                    type: 'error',
+                                    error: new Error(event.error || 'Unknown error'),
+                                    timestamp: new Date(),
+                                });
+                            }
+                        }
+                        catch (parseError) {
+                            console.error('[VercelAIAdapter] Failed to parse SSE data:', parseError);
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Send tool result (not supported in Vercel AI adapter)
+     */
+    async sendToolResult(_toolCallId, _result) {
+        throw new Error('Tool result not supported in Vercel AI adapter');
+    }
+    /**
+     * Request permission (not supported in Vercel AI)
+     */
+    async requestPermission(_permission) {
+        return true;
+    }
+    /**
+     * Stop generation
+     */
+    stopGeneration() {
+        this.abortController?.abort();
+        this.abortController = null;
+    }
+}

package/lib/components/chat/protocols/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Protocol adapter exports for chat component.
+ *
+ * @module components/chat/protocols
+ */
+export { BaseProtocolAdapter } from './BaseProtocolAdapter';
+export { AGUIAdapter, type AGUIAdapterConfig } from './AGUIAdapter';
+export { A2AAdapter, type A2AAdapterConfig } from './A2AAdapter';
+export { VercelAIAdapter, type VercelAIAdapterConfig } from './VercelAIAdapter';
+export { ACPAdapter, type ACPAdapterConfig, type ACPSession, type ACPAgent, type ACPPendingPermission, } from './ACPAdapter';
+export type { ProtocolAdapter, ProtocolAdapterConfig, ProtocolAdapterFactory, TransportType, ProtocolTransport, ProtocolConnectionState, ProtocolEvent, ProtocolEventType, ProtocolEventHandler, ProtocolMessageConverter, AgentCard, AGUI, A2A, ACP, } from '../types/protocol';

package/lib/components/chat/protocols/index.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Protocol adapter exports for chat component.
+ *
+ * @module components/chat/protocols
+ */
+export { BaseProtocolAdapter } from './BaseProtocolAdapter';
+export { AGUIAdapter } from './AGUIAdapter';
+export { A2AAdapter } from './A2AAdapter';
+export { VercelAIAdapter } from './VercelAIAdapter';
+export { ACPAdapter, } from './ACPAdapter';

package/lib/components/chat/store/chatStore.d.ts

@@ -0,0 +1,158 @@
+import type { ChatMessage, ChatThread, ToolRegistryEntry, ToolDefinition, ChatExtension, ExtensionRegistryEntry, ChatMiddleware, ToolCallStatus } from '../types';
+import type { InferenceProvider } from '../types/inference';
+import type { ProtocolAdapter } from '../types/protocol';
+import type { ToolExecutor } from '../tools/ToolExecutor';
+import type { MiddlewarePipeline } from '../middleware/MiddlewarePipeline';
+import type { ExtensionRegistry } from '../extensions/ExtensionRegistry';
+/**
+ * Chat configuration options
+ */
+export interface ChatConfig {
+    /** Default inference provider type */
+    defaultProvider?: 'datalayer' | 'openai' | 'anthropic' | 'self-hosted';
+    /** Default protocol type */
+    defaultProtocol?: 'ag-ui' | 'a2a' | 'acp' | 'mcp-ui';
+    /** API base URL for inference */
+    apiBaseUrl?: string;
+    /** API key for inference */
+    apiKey?: string;
+    /** Default model to use */
+    defaultModel?: string;
+    /** Enable tool approval by default */
+    requireToolApproval?: boolean;
+    /** Enable streaming by default */
+    enableStreaming?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Session ID for persistence */
+    sessionId?: string;
+    /** Enable local storage persistence */
+    persistToLocalStorage?: boolean;
+    /** Custom headers for API requests */
+    customHeaders?: Record<string, string>;
+}
+/**
+ * Default configuration
+ */
+export declare const defaultChatConfig: ChatConfig;
+/**
+ * Tool call tracking state
+ */
+export interface ToolCallState {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    status: ToolCallStatus;
+    result?: unknown;
+    error?: string;
+    startedAt: Date;
+    completedAt?: Date;
+}
+/**
+ * Chat store state
+ */
+interface ChatState {
+    config: ChatConfig;
+    ready: boolean;
+    inferenceProvider: InferenceProvider | null;
+    protocolAdapter: ProtocolAdapter | null;
+    toolExecutor: ToolExecutor | null;
+    middlewarePipeline: MiddlewarePipeline | null;
+    extensionRegistry: ExtensionRegistry | null;
+    messages: ChatMessage[];
+    isLoading: boolean;
+    isStreaming: boolean;
+    streamingMessageId: string | null;
+    currentThreadId: string | null;
+    threads: Map<string, ChatThread>;
+    tools: Map<string, ToolRegistryEntry>;
+    pendingToolCalls: Map<string, ToolCallState>;
+    extensions: Map<string, ExtensionRegistryEntry>;
+    middlewares: ChatMiddleware[];
+    isOpen: boolean;
+    error: Error | null;
+    suggestions: string[];
+}
+/**
+ * Chat store actions
+ */
+interface ChatActions {
+    setConfig: (config: Partial<ChatConfig>) => void;
+    setReady: (ready: boolean) => void;
+    setInferenceProvider: (provider: InferenceProvider | null) => void;
+    setProtocolAdapter: (adapter: ProtocolAdapter | null) => void;
+    setToolExecutor: (executor: ToolExecutor | null) => void;
+    setMiddlewarePipeline: (pipeline: MiddlewarePipeline | null) => void;
+    setExtensionRegistry: (registry: ExtensionRegistry | null) => void;
+    addMessage: (message: ChatMessage) => void;
+    updateMessage: (messageId: string, updates: Partial<ChatMessage>) => void;
+    deleteMessage: (messageId: string) => void;
+    setMessages: (messages: ChatMessage[]) => void;
+    clearMessages: () => void;
+    startStreaming: (messageId: string) => void;
+    appendToStream: (messageId: string, content: string) => void;
+    stopStreaming: () => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: Error | null) => void;
+    setCurrentThread: (threadId: string | null) => void;
+    createThread: (title?: string) => string;
+    deleteThread: (threadId: string) => void;
+    registerTool: (definition: ToolDefinition) => void;
+    unregisterTool: (name: string) => void;
+    getTool: (name: string) => ToolRegistryEntry | undefined;
+    getTools: () => ToolDefinition[];
+    startToolCall: (toolCallId: string, toolName: string, args: Record<string, unknown>) => void;
+    updateToolCallStatus: (toolCallId: string, status: ToolCallStatus, result?: unknown, error?: string) => void;
+    getPendingToolCalls: () => ToolCallState[];
+    registerExtension: (extension: ChatExtension, options?: {
+        enabled?: boolean;
+    }) => void;
+    unregisterExtension: (name: string) => void;
+    enableExtension: (name: string) => void;
+    disableExtension: (name: string) => void;
+    getExtensions: <T extends ChatExtension>(type?: T['type']) => T[];
+    addMiddleware: (middleware: ChatMiddleware) => void;
+    removeMiddleware: (name: string) => void;
+    getMiddlewares: () => ChatMiddleware[];
+    setOpen: (open: boolean) => void;
+    toggleOpen: () => void;
+    setSuggestions: (suggestions: string[]) => void;
+    reset: () => void;
+}
+/**
+ * Combined store type
+ */
+export type ChatStore = ChatState & ChatActions;
+/**
+ * Create the chat store
+ */
+export declare const useChatStore: import("zustand").UseBoundStore<Omit<Omit<import("zustand").StoreApi<ChatStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: ChatStore | Partial<ChatStore> | ((state: ChatStore) => ChatStore | Partial<ChatStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: ChatStore, previousSelectedState: ChatStore) => void): () => void;
+        <U>(selector: (state: ChatStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+/**
+ * Selector hooks for specific state slices
+ */
+export declare const useChatMessages: () => ChatMessage[];
+export declare const useChatLoading: () => boolean;
+export declare const useChatStreaming: () => {
+    isStreaming: boolean;
+    streamingMessageId: string | null;
+};
+export declare const useChatError: () => Error | null;
+export declare const useChatTools: () => ToolDefinition[];
+export declare const useChatOpen: () => boolean;
+export declare const useChatConfig: () => ChatConfig;
+export declare const useChatReady: () => boolean;
+export declare const useChatInferenceProvider: () => InferenceProvider | null;
+export declare const useChatExtensionRegistry: () => ExtensionRegistry | null;
+export {};