@datalayer/agent-runtimes 0.0.2

package/lib/components/chat/types/middleware.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Helper to create a simple before-request middleware
+ */
+export function createBeforeRequestMiddleware(name, handler) {
+    return {
+        name,
+        beforeRequest: handler,
+    };
+}
+/**
+ * Helper to create a simple after-request middleware
+ */
+export function createAfterRequestMiddleware(name, handler) {
+    return {
+        name,
+        afterRequest: handler,
+    };
+}
+/**
+ * Helper to create a tool call middleware
+ */
+export function createToolCallMiddleware(name, onToolCall, onToolResult) {
+    return {
+        name,
+        onToolCall,
+        onToolResult,
+    };
+}

package/lib/components/chat/types/protocol.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Protocol adapter types for chat component.
+ * Supports AG-UI (SSE), A2A (SSE), ACP (WebSocket), MCP-UI.
+ *
+ * @module components/chat/types/protocol
+ */
+import type { ChatMessage } from './message';
+import type { ToolDefinition, ToolCallRequest, ToolExecutionResult } from './tool';
+/**
+ * Supported transport types (communication transports)
+ */
+export type TransportType = 'ag-ui' | 'a2a' | 'acp' | 'vercel-ai';
+/**
+ * UI format for interactive elements
+ */
+export type Extension = 'mcp-ui' | 'a2ui';
+/**
+ * Protocol transport mechanism
+ */
+export type ProtocolTransport = 'sse' | 'websocket' | 'http';
+/**
+ * Protocol connection state
+ */
+export type ProtocolConnectionState = 'disconnected' | 'connecting' | 'connected' | 'error' | 'reconnecting';
+/**
+ * Transport adapter configuration
+ */
+export interface ProtocolAdapterConfig {
+    /** Transport type */
+    type: TransportType;
+    /** Base URL for the protocol endpoint */
+    baseUrl: string;
+    /** Authentication token/key */
+    authToken?: string;
+    /** Agent ID or name */
+    agentId?: string;
+    /** Auto-reconnect on disconnect */
+    autoReconnect?: boolean;
+    /** Reconnect delay in milliseconds */
+    reconnectDelay?: number;
+    /** Max reconnection attempts */
+    maxReconnectAttempts?: number;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Additional protocol-specific options */
+    options?: Record<string, unknown>;
+}
+/**
+ * Protocol event types
+ */
+export type ProtocolEventType = 'connected' | 'disconnected' | 'message' | 'tool-call' | 'tool-result' | 'activity' | 'state-update' | 'error';
+/**
+ * Protocol event
+ */
+export interface ProtocolEvent {
+    type: ProtocolEventType;
+    data?: unknown;
+    message?: ChatMessage;
+    toolCall?: ToolCallRequest;
+    toolResult?: ToolExecutionResult;
+    activity?: {
+        type: string;
+        data: unknown;
+    };
+    error?: Error;
+    timestamp: Date;
+}
+/**
+ * Callback for handling protocol events
+ */
+export type ProtocolEventHandler = (event: ProtocolEvent) => void;
+/**
+ * Agent card for A2A protocol
+ */
+export interface AgentCard {
+    name: string;
+    description?: string;
+    url: string;
+    version?: string;
+    capabilities?: {
+        streaming?: boolean;
+        extensions?: string[];
+    };
+    skills?: Array<{
+        id: string;
+        name: string;
+        description?: string;
+        examples?: string[];
+    }>;
+}
+/**
+ * Abstract protocol adapter interface
+ */
+export interface ProtocolAdapter {
+    /** Transport type */
+    readonly type: TransportType;
+    /** Transport mechanism used */
+    readonly transport: ProtocolTransport;
+    /** Current connection state */
+    readonly connectionState: ProtocolConnectionState;
+    /**
+     * Connect to the protocol endpoint
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the endpoint
+     */
+    disconnect(): void;
+    /**
+     * Send a message through the protocol
+     */
+    sendMessage(message: ChatMessage, options?: {
+        tools?: ToolDefinition[];
+        threadId?: string;
+        metadata?: Record<string, unknown>;
+        /** Full conversation history to send with the message */
+        messages?: ChatMessage[];
+    }): Promise<void>;
+    /**
+     * Send tool execution result back
+     */
+    sendToolResult(toolCallId: string, result: ToolExecutionResult): Promise<void>;
+    /**
+     * Subscribe to protocol events
+     */
+    subscribe(handler: ProtocolEventHandler): () => void;
+    /**
+     * Get agent card (for A2A protocol)
+     */
+    getAgentCard?(): Promise<AgentCard | null>;
+    /**
+     * Check if protocol supports a specific feature
+     */
+    supportsFeature(feature: string): boolean;
+}
+/**
+ * Factory function type for creating protocol adapters
+ */
+export type ProtocolAdapterFactory = (config: ProtocolAdapterConfig) => ProtocolAdapter;
+/**
+ * Protocol-specific message format converters
+ */
+export interface ProtocolMessageConverter {
+    /** Convert internal message to protocol format */
+    toProtocol(message: ChatMessage): unknown;
+    /** Convert protocol message to internal format */
+    fromProtocol(data: unknown): ChatMessage | null;
+}
+/**
+ * AG-UI specific types
+ */
+export declare namespace AGUI {
+    interface RunAgentInput {
+        threadId: string;
+        runId: string;
+        messages: ChatMessage[];
+        state: Record<string, unknown> | null;
+        tools: ToolDefinition[];
+        context: Array<{
+            type: string;
+            content: string;
+        }>;
+        forwardedProps: Record<string, unknown> | null;
+    }
+    interface Event {
+        type: string;
+        data?: unknown;
+    }
+}
+/**
+ * A2A specific types
+ */
+export declare namespace A2A {
+    interface Task {
+        id: string;
+        status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+        messages: ChatMessage[];
+        result?: unknown;
+    }
+    interface Message {
+        role: string;
+        parts: Array<{
+            type: string;
+            text?: string;
+            data?: unknown;
+        }>;
+    }
+}
+/**
+ * ACP specific types (WebSocket-based)
+ */
+export declare namespace ACP {
+    interface JsonRpcRequest {
+        jsonrpc: '2.0';
+        method: string;
+        params?: unknown;
+        id: string | number;
+    }
+    interface JsonRpcResponse {
+        jsonrpc: '2.0';
+        result?: unknown;
+        error?: {
+            code: number;
+            message: string;
+            data?: unknown;
+        };
+        id: string | number;
+    }
+}

package/lib/components/chat/types/protocol.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};

package/lib/components/chat/types/tool.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Tool types for chat component.
+ * Supports hybrid execution (frontend + backend) with per-tool annotation.
+ *
+ * @module components/chat/types/tool
+ */
+import type { ReactNode } from 'react';
+/**
+ * Tool execution location
+ * - 'frontend': Executes in browser (default if not specified)
+ * - 'backend': Executes on server via inference provider
+ */
+export type ToolLocation = 'frontend' | 'backend';
+/**
+ * Tool parameter definition (CopilotKit-compatible format)
+ */
+export interface ToolParameter {
+    name: string;
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'object[]' | 'string[]' | 'number[]';
+    description?: string;
+    required?: boolean;
+    attributes?: ToolParameter[];
+    enum?: string[];
+    default?: unknown;
+}
+/**
+ * Tool call status for render props
+ */
+export type ToolRenderStatus = 'inProgress' | 'executing' | 'complete' | 'failed';
+/**
+ * Props passed to tool render function
+ */
+export interface ToolRenderProps<TArgs = Record<string, unknown>, TResult = unknown> {
+    /** Current execution status */
+    status: ToolRenderStatus;
+    /** Tool arguments from the LLM */
+    args: TArgs;
+    /** Result after execution (only when status is 'complete') */
+    result?: TResult;
+    /** Error message (only when status is 'failed') */
+    error?: string;
+}
+/**
+ * Props passed to renderAndWaitForResponse (HITL pattern)
+ */
+export interface ToolRenderAndWaitProps<TArgs = Record<string, unknown>, TResult = unknown> extends ToolRenderProps<TArgs, TResult> {
+    /** Call this to respond with a result (for HITL approval) */
+    respond: (result: TResult) => Promise<void>;
+}
+/**
+ * Frontend tool definition (compatible with CopilotKit useFrontendTool)
+ */
+export interface FrontendToolDefinition<TArgs = Record<string, unknown>, TResult = unknown> {
+    /** Unique tool name */
+    name: string;
+    /** Description for the LLM */
+    description: string;
+    /** Parameter definitions */
+    parameters: ToolParameter[];
+    /**
+     * Execution location
+     * @default 'frontend'
+     */
+    location?: ToolLocation;
+    /**
+     * Handler function for frontend execution
+     * Required when location is 'frontend' (default)
+     */
+    handler?: (args: TArgs) => Promise<TResult>;
+    /**
+     * Optional render function for custom UI during execution
+     */
+    render?: (props: ToolRenderProps<TArgs, TResult>) => ReactNode;
+    /**
+     * Render function that waits for user response (HITL pattern)
+     * Mutually exclusive with 'render'
+     */
+    renderAndWaitForResponse?: (props: ToolRenderAndWaitProps<TArgs, TResult>) => ReactNode;
+}
+/**
+ * Backend tool definition (tool runs on server)
+ */
+export interface BackendToolDefinition {
+    /** Unique tool name */
+    name: string;
+    /** Description for the LLM */
+    description: string;
+    /** Parameter definitions */
+    parameters: ToolParameter[];
+    /** Must be 'backend' */
+    location: 'backend';
+    /**
+     * Optional render function for custom UI during execution
+     */
+    render?: (props: ToolRenderProps) => ReactNode;
+}
+/**
+ * Union type for all tool definitions
+ */
+export type ToolDefinition = FrontendToolDefinition | BackendToolDefinition;
+/**
+ * Tool execution result
+ */
+export interface ToolExecutionResult<T = unknown> {
+    /** Tool call ID from the original request */
+    toolCallId?: string;
+    success: boolean;
+    result?: T;
+    error?: string;
+    executionTime?: number;
+}
+/**
+ * Tool call request (from LLM)
+ */
+export interface ToolCallRequest {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+/**
+ * Tool registry entry (internal)
+ */
+export interface ToolRegistryEntry {
+    definition: ToolDefinition;
+    registeredAt: Date;
+}
+/**
+ * Type guard to check if tool is frontend tool
+ */
+export declare function isFrontendTool(tool: ToolDefinition): tool is FrontendToolDefinition;
+/**
+ * Type guard to check if tool is backend tool
+ */
+export declare function isBackendTool(tool: ToolDefinition): tool is BackendToolDefinition;
+/**
+ * Type guard to check if tool has HITL render
+ */
+export declare function hasHitlRender(tool: ToolDefinition): tool is FrontendToolDefinition & {
+    renderAndWaitForResponse: NonNullable<FrontendToolDefinition['renderAndWaitForResponse']>;
+};

package/lib/components/chat/types/tool.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Type guard to check if tool is frontend tool
+ */
+export function isFrontendTool(tool) {
+    return tool.location !== 'backend';
+}
+/**
+ * Type guard to check if tool is backend tool
+ */
+export function isBackendTool(tool) {
+    return tool.location === 'backend';
+}
+/**
+ * Type guard to check if tool has HITL render
+ */
+export function hasHitlRender(tool) {
+    return ('renderAndWaitForResponse' in tool &&
+        tool.renderAndWaitForResponse !== undefined);
+}

package/lib/components/index.d.ts

@@ -0,0 +1 @@
+export * from './chat';

package/lib/components/index.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+// Primary exports from chat (next-gen chat component)
+export * from './chat';

package/lib/components/sparklines/Sparklines.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { SparklinesProps } from './types';
+/**
+ * Sparklines Component
+ *
+ * A lightweight, composable sparkline chart component.
+ * Renders an SVG container and processes data into points for child components.
+ *
+ * @example
+ * ```tsx
+ * <Sparklines data={[1, 2, 3, 4, 5]} width={100} height={30}>
+ *   <SparklinesLine color="#0969da" />
+ * </Sparklines>
+ * ```
+ */
+export declare const Sparklines: React.FC<SparklinesProps>;

package/lib/components/sparklines/Sparklines.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import React, { useMemo } from 'react';
+import { dataToPoints } from './dataProcessing';
+/**
+ * Sparklines Component
+ *
+ * A lightweight, composable sparkline chart component.
+ * Renders an SVG container and processes data into points for child components.
+ *
+ * @example
+ * ```tsx
+ * <Sparklines data={[1, 2, 3, 4, 5]} width={100} height={30}>
+ *   <SparklinesLine color="#0969da" />
+ * </Sparklines>
+ * ```
+ */
+export const Sparklines = ({ data = [], width = 240, height = 60, svgWidth, svgHeight, preserveAspectRatio = 'none', margin = 2, style, min, max, limit, children, }) => {
+    // Convert data to points
+    const points = useMemo(() => {
+        if (data.length === 0) {
+            return [];
+        }
+        return dataToPoints({
+            data,
+            limit,
+            width,
+            height,
+            margin,
+            max,
+            min,
+        });
+    }, [data, limit, width, height, margin, max, min]);
+    if (data.length === 0) {
+        return null;
+    }
+    // Build SVG props
+    const svgProps = {
+        style,
+        viewBox: `0 0 ${width} ${height}`,
+        preserveAspectRatio,
+    };
+    if (svgWidth && svgWidth > 0) {
+        svgProps.width = svgWidth;
+    }
+    if (svgHeight && svgHeight > 0) {
+        svgProps.height = svgHeight;
+    }
+    return (_jsx("svg", { ...svgProps, children: React.Children.map(children, child => {
+            if (React.isValidElement(child)) {
+                return React.cloneElement(child, {
+                    data,
+                    points,
+                    width,
+                    height,
+                    margin,
+                    ...child.props,
+                });
+            }
+            return child;
+        }) }));
+};

package/lib/components/sparklines/SparklinesLine.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { SparklinesLineProps } from './types';
+/**
+ * Sparklines Line Component
+ *
+ * Renders a line chart within a Sparklines container.
+ */
+export declare const SparklinesLine: React.FC<SparklinesLineProps>;

package/lib/components/sparklines/SparklinesLine.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Sparklines Line Component
+ *
+ * Renders a line chart within a Sparklines container.
+ */
+export const SparklinesLine = ({ points = [], height = 60, margin = 2, color = '#0969da', style = {}, }) => {
+    if (!points || points.length === 0) {
+        return null;
+    }
+    // Convert points to polyline format
+    const linePoints = points.map(p => `${p.x},${p.y}`).join(' ');
+    // Create fill area by closing the path
+    const closePolyPoints = [
+        { x: points[points.length - 1].x, y: height - margin },
+        { x: margin, y: height - margin },
+        { x: margin, y: points[0].y },
+    ];
+    const fillPoints = points
+        .concat(closePolyPoints)
+        .map(p => `${p.x},${p.y}`)
+        .join(' ');
+    const lineStyle = {
+        stroke: color || style.stroke || 'slategray',
+        strokeWidth: style.strokeWidth || '1.5',
+        strokeLinejoin: 'round',
+        strokeLinecap: 'round',
+        fill: 'none',
+    };
+    const fillStyle = {
+        stroke: 'none',
+        strokeWidth: '0',
+        fillOpacity: style.fillOpacity || '0.1',
+        fill: style.fill || color || 'slategray',
+    };
+    return (_jsxs("g", { children: [_jsx("polyline", { points: fillPoints, style: fillStyle }), _jsx("polyline", { points: linePoints, style: lineStyle })] }));
+};

package/lib/components/sparklines/dataProcessing.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Get minimum value from array
+ */
+export declare const min: (data: number[]) => number;
+/**
+ * Get maximum value from array
+ */
+export declare const max: (data: number[]) => number;
+/**
+ * Convert data array to SVG points
+ */
+export interface DataToPointsOptions {
+    data: number[];
+    limit?: number;
+    width?: number;
+    height?: number;
+    margin?: number;
+    max?: number;
+    min?: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export declare const dataToPoints: ({ data, limit, width, height, margin, max: maxVal, min: minVal, }: DataToPointsOptions) => Point[];

package/lib/components/sparklines/dataProcessing.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Get minimum value from array
+ */
+export const min = (data) => {
+    return Math.min(...data);
+};
+/**
+ * Get maximum value from array
+ */
+export const max = (data) => {
+    return Math.max(...data);
+};
+export const dataToPoints = ({ data, limit, width = 1, height = 1, margin = 0, max: maxVal, min: minVal, }) => {
+    let processedData = [...data];
+    const len = processedData.length;
+    // Limit data if specified
+    if (limit && limit < len) {
+        processedData = processedData.slice(len - limit);
+    }
+    // Calculate min/max if not provided
+    const dataMax = maxVal ?? max(processedData);
+    const dataMin = minVal ?? min(processedData);
+    // Calculate scaling factors
+    const vfactor = (height - margin * 2) / (dataMax - dataMin || 2);
+    const hfactor = (width - margin * 2) / ((limit || len) - (len > 1 ? 1 : 0));
+    // Map data to points
+    return processedData.map((d, i) => ({
+        x: i * hfactor + margin,
+        y: (dataMax === dataMin ? 1 : dataMax - d) * vfactor + margin,
+    }));
+};

package/lib/components/sparklines/index.d.ts

@@ -0,0 +1,4 @@
+export { Sparklines } from './Sparklines';
+export { SparklinesLine } from './SparklinesLine';
+export type { SparklinesProps, SparklinesLineProps, Point } from './types';
+export { dataToPoints, min, max } from './dataProcessing';

package/lib/components/sparklines/index.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export { Sparklines } from './Sparklines';
+export { SparklinesLine } from './SparklinesLine';
+export { dataToPoints, min, max } from './dataProcessing';

package/lib/components/sparklines/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Point interface for sparkline coordinates
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Sparklines component props
+ */
+export interface SparklinesProps {
+    data: number[];
+    width?: number;
+    height?: number;
+    svgWidth?: number;
+    svgHeight?: number;
+    preserveAspectRatio?: string;
+    margin?: number;
+    style?: React.CSSProperties;
+    min?: number;
+    max?: number;
+    limit?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Sparklines Line component props
+ */
+export interface SparklinesLineProps {
+    data?: number[];
+    points?: Point[];
+    width?: number;
+    height?: number;
+    margin?: number;
+    color?: string;
+    style?: React.CSSProperties;
+}

package/lib/components/sparklines/types.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};

package/lib/components/ui/accordion.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+declare function Accordion({ ...props }: React.ComponentProps<typeof AccordionPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionItem({ className, ...props }: React.ComponentProps<typeof AccordionPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionContent({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };