@datalayer/agent-runtimes 0.0.2

package/lib/components/chat/inference/DatalayerInferenceProvider.js

@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { generateMessageId, createAssistantMessage } from '../types/message';
+import { BaseInferenceProvider } from './BaseInferenceProvider';
+/**
+ * Datalayer inference provider
+ */
+export class DatalayerInferenceProvider extends BaseInferenceProvider {
+    name = 'datalayer';
+    datalayerConfig;
+    constructor(config) {
+        super(config);
+        this.datalayerConfig = {
+            baseUrl: 'https://api.datalayer.run',
+            model: 'gpt-4o',
+            ...config,
+        };
+    }
+    /**
+     * Send a message and get a response (non-streaming)
+     */
+    async sendMessage(messages, options) {
+        const controller = this.createAbortController(options?.signal);
+        try {
+            const response = await fetch(`${this.datalayerConfig.baseUrl}/v1/chat/completions`, {
+                method: 'POST',
+                headers: this.buildHeaders(),
+                body: JSON.stringify({
+                    model: this.datalayerConfig.model,
+                    messages: this.convertMessages(messages),
+                    tools: options?.tools
+                        ? this.convertTools(options.tools)
+                        : undefined,
+                    temperature: options?.temperature,
+                    max_tokens: options?.maxTokens,
+                    stream: false,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`Datalayer API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            return this.parseResponse(data);
+        }
+        finally {
+            this.abortController = null;
+        }
+    }
+    /**
+     * Send a message with streaming response
+     */
+    async streamMessage(messages, options, onEvent) {
+        const controller = this.createAbortController(options?.signal);
+        const messageId = generateMessageId();
+        try {
+            const response = await fetch(`${this.datalayerConfig.baseUrl}/v1/chat/completions`, {
+                method: 'POST',
+                headers: this.buildHeaders(),
+                body: JSON.stringify({
+                    model: this.datalayerConfig.model,
+                    messages: this.convertMessages(messages),
+                    tools: options?.tools
+                        ? this.convertTools(options.tools)
+                        : undefined,
+                    temperature: options?.temperature,
+                    max_tokens: options?.maxTokens,
+                    stream: true,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`Datalayer API error: ${response.status} ${response.statusText}`);
+            }
+            // Emit message start
+            onEvent?.({
+                type: 'message-start',
+                messageId,
+            });
+            let fullContent = '';
+            const toolCalls = [];
+            let finishReason;
+            // Parse SSE stream
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('Response body is not readable');
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            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.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data === '[DONE]') {
+                            continue;
+                        }
+                        try {
+                            const parsed = JSON.parse(data);
+                            const delta = parsed.choices?.[0]?.delta;
+                            finishReason = parsed.choices?.[0]?.finish_reason;
+                            if (delta?.content) {
+                                fullContent += delta.content;
+                                onEvent?.({
+                                    type: 'content-delta',
+                                    messageId,
+                                    delta: {
+                                        messageId,
+                                        delta: { content: delta.content },
+                                    },
+                                });
+                            }
+                            // Handle tool calls in stream
+                            if (delta?.tool_calls) {
+                                for (const tc of delta.tool_calls) {
+                                    if (tc.index !== undefined) {
+                                        if (!toolCalls[tc.index]) {
+                                            toolCalls[tc.index] = {
+                                                type: 'tool-call',
+                                                toolCallId: tc.id || `tc_${Date.now()}_${tc.index}`,
+                                                toolName: tc.function?.name || '',
+                                                args: {},
+                                                status: 'pending',
+                                            };
+                                            onEvent?.({
+                                                type: 'tool-call-start',
+                                                toolCall: {
+                                                    toolCallId: toolCalls[tc.index].toolCallId,
+                                                    toolName: toolCalls[tc.index].toolName,
+                                                    args: {},
+                                                },
+                                            });
+                                        }
+                                        if (tc.function?.arguments) {
+                                            // Accumulate arguments (they come in chunks)
+                                            try {
+                                                const newArgs = tc.function.arguments;
+                                                // This is a simplified approach - real implementation would accumulate string chunks
+                                                toolCalls[tc.index].args = JSON.parse(newArgs);
+                                            }
+                                            catch {
+                                                // Arguments still incomplete
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch (e) {
+                            console.warn('[DatalayerProvider] Failed to parse SSE data:', e);
+                        }
+                    }
+                }
+            }
+            // Emit message end
+            onEvent?.({
+                type: 'message-end',
+                messageId,
+                finishReason,
+            });
+            const message = createAssistantMessage(fullContent, {
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            });
+            message.id = messageId;
+            return {
+                message,
+                finishReason: finishReason,
+            };
+        }
+        catch (error) {
+            onEvent?.({
+                type: 'error',
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+            throw error;
+        }
+        finally {
+            this.abortController = null;
+        }
+    }
+    /**
+     * Execute a backend tool
+     */
+    async executeBackendTool(toolName, args, options) {
+        const controller = this.createAbortController(options?.signal);
+        try {
+            const response = await fetch(`${this.datalayerConfig.baseUrl}/v1/tools/execute`, {
+                method: 'POST',
+                headers: this.buildHeaders(),
+                body: JSON.stringify({
+                    tool_name: toolName,
+                    arguments: args,
+                    agent_id: this.datalayerConfig.agentId,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                return {
+                    success: false,
+                    error: `Tool execution failed: ${response.status} ${response.statusText}`,
+                };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                result: data.result,
+                executionTime: data.execution_time,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+        finally {
+            this.abortController = null;
+        }
+    }
+    /**
+     * Check if provider is available
+     */
+    isAvailable() {
+        return !!this.datalayerConfig.apiKey;
+    }
+    /**
+     * Convert internal messages to OpenAI-compatible format
+     */
+    convertMessages(messages) {
+        return messages.map(msg => ({
+            role: msg.role,
+            content: typeof msg.content === 'string'
+                ? msg.content
+                : JSON.stringify(msg.content),
+            ...(msg.toolCalls && {
+                tool_calls: msg.toolCalls.map(tc => ({
+                    id: tc.toolCallId,
+                    type: 'function',
+                    function: {
+                        name: tc.toolName,
+                        arguments: JSON.stringify(tc.args),
+                    },
+                })),
+            }),
+        }));
+    }
+    /**
+     * Convert tool definitions to OpenAI format
+     */
+    convertTools(tools) {
+        return tools.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: {
+                    type: 'object',
+                    properties: Object.fromEntries(tool.parameters.map(p => [
+                        p.name,
+                        {
+                            type: p.type || 'string',
+                            description: p.description,
+                            enum: p.enum,
+                        },
+                    ])),
+                    required: tool.parameters.filter(p => p.required).map(p => p.name),
+                },
+            },
+        }));
+    }
+    /**
+     * Parse API response to internal format
+     */
+    parseResponse(data) {
+        const choice = data.choices?.[0];
+        const message = choice?.message;
+        const toolCalls = message?.tool_calls?.map((tc) => ({
+            type: 'tool-call',
+            toolCallId: tc.id,
+            toolName: tc.function.name,
+            args: JSON.parse(tc.function.arguments || '{}'),
+            status: 'pending',
+        })) || [];
+        return {
+            message: createAssistantMessage(message?.content || '', {
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            }),
+            usage: data.usage
+                ? {
+                    promptTokens: data.usage.prompt_tokens ?? 0,
+                    completionTokens: data.usage.completion_tokens ?? 0,
+                    totalTokens: data.usage.total_tokens ?? 0,
+                }
+                : undefined,
+            finishReason: choice?.finish_reason,
+        };
+    }
+}

package/lib/components/chat/inference/SelfHostedInferenceProvider.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Self-hosted inference provider for custom endpoints.
+ * Supports OpenAI-compatible APIs.
+ *
+ * @module components/chat/inference/SelfHostedInferenceProvider
+ */
+import type { InferenceProviderConfig, InferenceRequestOptions, InferenceResponse, StreamEventHandler } from '../types';
+import type { ChatMessage } from '../types/message';
+import { BaseInferenceProvider } from './BaseInferenceProvider';
+/**
+ * Self-hosted provider configuration
+ */
+export interface SelfHostedInferenceConfig extends InferenceProviderConfig {
+    /** Base URL for the API endpoint (required) */
+    baseUrl: string;
+    /** Model name */
+    model?: string;
+    /** Custom headers */
+    customHeaders?: Record<string, string>;
+    /** Whether the endpoint is OpenAI-compatible */
+    openaiCompatible?: boolean;
+}
+/**
+ * Self-hosted inference provider for custom OpenAI-compatible endpoints
+ */
+export declare class SelfHostedInferenceProvider extends BaseInferenceProvider {
+    readonly name = "self-hosted";
+    private selfHostedConfig;
+    constructor(config: SelfHostedInferenceConfig);
+    /**
+     * Send a message and get a response (non-streaming)
+     */
+    sendMessage(messages: ChatMessage[], options?: InferenceRequestOptions): Promise<InferenceResponse>;
+    /**
+     * Send a message with streaming response
+     */
+    streamMessage(messages: ChatMessage[], options?: InferenceRequestOptions, onEvent?: StreamEventHandler): Promise<InferenceResponse>;
+    /**
+     * Check if provider is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Convert internal messages to OpenAI format
+     */
+    protected convertMessages(messages: ChatMessage[]): unknown[];
+    /**
+     * Convert tool definitions to OpenAI format
+     */
+    private convertTools;
+    /**
+     * Parse API response to internal format
+     */
+    protected parseResponse(data: any): InferenceResponse;
+}

package/lib/components/chat/inference/SelfHostedInferenceProvider.js

@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { generateMessageId, createAssistantMessage } from '../types/message';
+import { BaseInferenceProvider } from './BaseInferenceProvider';
+/**
+ * Self-hosted inference provider for custom OpenAI-compatible endpoints
+ */
+export class SelfHostedInferenceProvider extends BaseInferenceProvider {
+    name = 'self-hosted';
+    selfHostedConfig;
+    constructor(config) {
+        super(config);
+        this.selfHostedConfig = {
+            openaiCompatible: true,
+            ...config,
+        };
+    }
+    /**
+     * Send a message and get a response (non-streaming)
+     */
+    async sendMessage(messages, options) {
+        const controller = this.createAbortController(options?.signal);
+        try {
+            const endpoint = this.selfHostedConfig.openaiCompatible
+                ? `${this.selfHostedConfig.baseUrl}/v1/chat/completions`
+                : this.selfHostedConfig.baseUrl;
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: this.buildHeaders(this.selfHostedConfig.customHeaders),
+                body: JSON.stringify({
+                    model: this.selfHostedConfig.model,
+                    messages: this.convertMessages(messages),
+                    tools: options?.tools ? this.convertTools(options.tools) : undefined,
+                    temperature: options?.temperature,
+                    max_tokens: options?.maxTokens,
+                    stream: false,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            return this.parseResponse(data);
+        }
+        finally {
+            this.abortController = null;
+        }
+    }
+    /**
+     * Send a message with streaming response
+     */
+    async streamMessage(messages, options, onEvent) {
+        const controller = this.createAbortController(options?.signal);
+        const messageId = generateMessageId();
+        try {
+            const endpoint = this.selfHostedConfig.openaiCompatible
+                ? `${this.selfHostedConfig.baseUrl}/v1/chat/completions`
+                : this.selfHostedConfig.baseUrl;
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: this.buildHeaders(this.selfHostedConfig.customHeaders),
+                body: JSON.stringify({
+                    model: this.selfHostedConfig.model,
+                    messages: this.convertMessages(messages),
+                    tools: options?.tools ? this.convertTools(options.tools) : undefined,
+                    temperature: options?.temperature,
+                    max_tokens: options?.maxTokens,
+                    stream: true,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`API error: ${response.status} ${response.statusText}`);
+            }
+            onEvent?.({ type: 'message-start', messageId });
+            let fullContent = '';
+            const toolCalls = [];
+            let finishReason;
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('Response body is not readable');
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            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.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const parsed = JSON.parse(data);
+                            const delta = parsed.choices?.[0]?.delta;
+                            finishReason = parsed.choices?.[0]?.finish_reason;
+                            if (delta?.content) {
+                                fullContent += delta.content;
+                                onEvent?.({
+                                    type: 'content-delta',
+                                    messageId,
+                                    delta: { messageId, delta: { content: delta.content } },
+                                });
+                            }
+                            if (delta?.tool_calls) {
+                                for (const tc of delta.tool_calls) {
+                                    if (tc.index !== undefined) {
+                                        if (!toolCalls[tc.index]) {
+                                            toolCalls[tc.index] = {
+                                                type: 'tool-call',
+                                                toolCallId: tc.id || `tc_${Date.now()}_${tc.index}`,
+                                                toolName: tc.function?.name || '',
+                                                args: {},
+                                                status: 'pending',
+                                            };
+                                            onEvent?.({
+                                                type: 'tool-call-start',
+                                                toolCall: {
+                                                    toolCallId: toolCalls[tc.index].toolCallId,
+                                                    toolName: toolCalls[tc.index].toolName,
+                                                    args: {},
+                                                },
+                                            });
+                                        }
+                                        if (tc.function?.arguments) {
+                                            try {
+                                                toolCalls[tc.index].args = JSON.parse(tc.function.arguments);
+                                            }
+                                            catch {
+                                                // Arguments still incomplete
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch (e) {
+                            console.warn('[SelfHostedProvider] Failed to parse SSE data:', e);
+                        }
+                    }
+                }
+            }
+            onEvent?.({ type: 'message-end', messageId, finishReason });
+            const message = createAssistantMessage(fullContent, {
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            });
+            message.id = messageId;
+            return { message, finishReason: finishReason };
+        }
+        catch (error) {
+            onEvent?.({
+                type: 'error',
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+            throw error;
+        }
+        finally {
+            this.abortController = null;
+        }
+    }
+    /**
+     * Check if provider is available
+     */
+    isAvailable() {
+        return !!this.selfHostedConfig.baseUrl;
+    }
+    /**
+     * Convert internal messages to OpenAI format
+     */
+    convertMessages(messages) {
+        return messages.map(msg => ({
+            role: msg.role,
+            content: typeof msg.content === 'string'
+                ? msg.content
+                : JSON.stringify(msg.content),
+            ...(msg.toolCalls && {
+                tool_calls: msg.toolCalls.map(tc => ({
+                    id: tc.toolCallId,
+                    type: 'function',
+                    function: {
+                        name: tc.toolName,
+                        arguments: JSON.stringify(tc.args),
+                    },
+                })),
+            }),
+        }));
+    }
+    /**
+     * Convert tool definitions to OpenAI format
+     */
+    convertTools(tools) {
+        return tools.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: {
+                    type: 'object',
+                    properties: Object.fromEntries(tool.parameters.map(p => [
+                        p.name,
+                        {
+                            type: p.type || 'string',
+                            description: p.description,
+                            enum: p.enum,
+                        },
+                    ])),
+                    required: tool.parameters.filter(p => p.required).map(p => p.name),
+                },
+            },
+        }));
+    }
+    /**
+     * Parse API response to internal format
+     */
+    parseResponse(data) {
+        const choice = data.choices?.[0];
+        const message = choice?.message;
+        const toolCalls = message?.tool_calls?.map((tc) => ({
+            type: 'tool-call',
+            toolCallId: tc.id,
+            toolName: tc.function.name,
+            args: JSON.parse(tc.function.arguments || '{}'),
+            status: 'pending',
+        })) || [];
+        return {
+            message: createAssistantMessage(message?.content || '', {
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            }),
+            usage: data.usage
+                ? {
+                    promptTokens: data.usage.prompt_tokens,
+                    completionTokens: data.usage.completion_tokens,
+                    totalTokens: data.usage.total_tokens,
+                }
+                : undefined,
+            finishReason: choice?.finish_reason,
+        };
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Inference provider exports for chat component.
+ *
+ * @module components/chat/inference
+ */
+export { BaseInferenceProvider } from './BaseInferenceProvider';
+export { DatalayerInferenceProvider, type DatalayerInferenceConfig, } from './DatalayerInferenceProvider';
+export { SelfHostedInferenceProvider, type SelfHostedInferenceConfig, } from './SelfHostedInferenceProvider';
+export type { InferenceProvider, InferenceProviderConfig, InferenceProviderFactory, InferenceProviderType, InferenceRequestOptions, InferenceResponse, StreamEvent, StreamEventType, StreamEventHandler, } from '../types/inference';

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

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Inference provider exports for chat component.
+ *
+ * @module components/chat/inference
+ */
+export { BaseInferenceProvider } from './BaseInferenceProvider';
+export { DatalayerInferenceProvider, } from './DatalayerInferenceProvider';
+export { SelfHostedInferenceProvider, } from './SelfHostedInferenceProvider';