@datalayer/agent-runtimes 0.0.2

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

@@ -0,0 +1,212 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * MCP-UI extension for chat component.
+ * Renders MCP UI protocol messages and resources.
+ *
+ * @module components/chat/extensions/MCPUIExtension
+ */
+import React from 'react';
+/**
+ * Create MCP-UI activity renderer
+ */
+export function createMCPUIRenderer(customRenderers) {
+    // Track resources per session
+    const contexts = new Map();
+    const getContext = (sessionId) => {
+        if (!contexts.has(sessionId)) {
+            contexts.set(sessionId, {
+                resources: new Map(),
+            });
+        }
+        return contexts.get(sessionId);
+    };
+    return {
+        name: 'mcp-ui-renderer',
+        type: 'activity-renderer',
+        activityTypes: ['mcp-ui'],
+        render: ({ activityType: _activityType, data, message: _message }) => {
+            // Use default session for now
+            const sessionId = 'default';
+            const mcpContext = getContext(sessionId);
+            const mcpData = data;
+            // Handle resource list
+            if (mcpData.resourceList) {
+                for (const resource of mcpData.resourceList.resources) {
+                    mcpContext.resources.set(resource.uri, resource);
+                }
+                return (_jsx("div", { className: "mcp-ui-resource-list", children: mcpData.resourceList.resources.map((resource, index) => (_jsx(ResourceItem, { resource: resource }, resource.uri || index))) }));
+            }
+            // Handle resource content
+            if (mcpData.resourceContent) {
+                const { uri, content } = mcpData.resourceContent;
+                mcpContext.resources.set(uri, content);
+                // Check for custom renderer
+                if (customRenderers && content.mimeType) {
+                    const CustomRenderer = customRenderers[content.mimeType];
+                    if (CustomRenderer) {
+                        return _jsx(CustomRenderer, { resource: content });
+                    }
+                }
+                return _jsx(ResourceContent, { resource: content });
+            }
+            // Handle UI element
+            if (mcpData.uiElement) {
+                return _jsx(UIElement, { element: mcpData.uiElement });
+            }
+            // Fallback: render raw data
+            return _jsx("pre", { className: "mcp-ui-raw", children: JSON.stringify(data, null, 2) });
+        },
+    };
+}
+/**
+ * Resource item component
+ */
+const ResourceItem = ({ resource }) => {
+    return (_jsxs("div", { style: {
+            padding: '8px 12px',
+            margin: '4px 0',
+            backgroundColor: 'var(--color-canvas-subtle)',
+            borderRadius: '6px',
+            border: '1px solid var(--color-border-default)',
+        }, children: [_jsx("div", { style: { fontWeight: 500, marginBottom: '4px' }, children: resource.name || resource.uri }), resource.description && (_jsx("div", { style: { fontSize: '12px', color: 'var(--color-fg-muted)' }, children: resource.description })), resource.mimeType && (_jsx("div", { style: {
+                    fontSize: '11px',
+                    color: 'var(--color-fg-subtle)',
+                    marginTop: '4px',
+                }, children: resource.mimeType }))] }));
+};
+/**
+ * Resource content component
+ */
+const ResourceContent = ({ resource, }) => {
+    const mimeType = resource.mimeType || 'text/plain';
+    // Handle text content
+    if (resource.text ||
+        (mimeType.startsWith('text/') && typeof resource.content === 'string')) {
+        const text = resource.text || resource.content;
+        if (mimeType === 'text/html') {
+            return (_jsx("div", { className: "mcp-ui-html", dangerouslySetInnerHTML: { __html: text }, style: {
+                    padding: '12px',
+                    backgroundColor: 'var(--color-canvas-subtle)',
+                    borderRadius: '6px',
+                } }));
+        }
+        if (mimeType === 'text/markdown') {
+            // For markdown, we'd ideally use a markdown renderer
+            // For now, just show as preformatted text
+            return (_jsx("pre", { style: {
+                    padding: '12px',
+                    backgroundColor: 'var(--color-canvas-subtle)',
+                    borderRadius: '6px',
+                    overflow: 'auto',
+                    whiteSpace: 'pre-wrap',
+                }, children: text }));
+        }
+        // Plain text or code
+        return (_jsx("pre", { style: {
+                padding: '12px',
+                backgroundColor: 'var(--color-canvas-subtle)',
+                borderRadius: '6px',
+                overflow: 'auto',
+                whiteSpace: 'pre-wrap',
+                fontFamily: 'monospace',
+            }, children: text }));
+    }
+    // Handle blob content (base64 encoded)
+    if (resource.blob) {
+        if (mimeType.startsWith('image/')) {
+            return (_jsx("img", { src: `data:${mimeType};base64,${resource.blob}`, alt: resource.name || 'MCP Resource', style: { maxWidth: '100%', borderRadius: '6px' } }));
+        }
+        // For other blob types, show download link
+        return (_jsxs("a", { href: `data:${mimeType};base64,${resource.blob}`, download: resource.name || 'resource', style: {
+                display: 'inline-block',
+                padding: '8px 16px',
+                backgroundColor: 'var(--color-accent-emphasis)',
+                color: 'var(--color-fg-on-emphasis)',
+                borderRadius: '6px',
+                textDecoration: 'none',
+            }, children: ["Download ", resource.name || 'resource'] }));
+    }
+    // Handle JSON content
+    if (mimeType === 'application/json' || typeof resource.content === 'object') {
+        return (_jsx("pre", { style: {
+                padding: '12px',
+                backgroundColor: 'var(--color-canvas-subtle)',
+                borderRadius: '6px',
+                overflow: 'auto',
+                fontFamily: 'monospace',
+            }, children: JSON.stringify(resource.content, null, 2) }));
+    }
+    // Fallback
+    return (_jsxs("div", { style: {
+            padding: '12px',
+            backgroundColor: 'var(--color-canvas-subtle)',
+            borderRadius: '6px',
+            color: 'var(--color-fg-muted)',
+        }, children: ["Resource: ", resource.uri] }));
+};
+/**
+ * UI Element component for rendering MCP UI elements
+ */
+const UIElement = ({ element, }) => {
+    if (!element)
+        return null;
+    const { type, props = {}, children } = element;
+    // Map MCP UI element types to HTML elements
+    const elementMap = {
+        container: 'div',
+        text: 'span',
+        button: 'button',
+        input: 'input',
+        form: 'form',
+        list: 'ul',
+        listItem: 'li',
+        heading: 'h3',
+        paragraph: 'p',
+        link: 'a',
+        image: 'img',
+        code: 'code',
+        pre: 'pre',
+    };
+    const htmlTag = elementMap[type] || 'div';
+    return React.createElement(htmlTag, {
+        ...props,
+        style: {
+            ...(props.style || {}),
+        },
+    }, children?.map((child, index) => (_jsx(UIElement, { element: child.uiElement }, index))));
+};
+/**
+ * MCP-UI Extension implementation class
+ */
+export class MCPUIExtensionImpl {
+    renderer;
+    customRenderers;
+    constructor(customRenderers) {
+        this.customRenderers = customRenderers || {};
+        this.renderer = createMCPUIRenderer(this.customRenderers);
+    }
+    /**
+     * Get the activity renderer extension
+     */
+    getRenderer() {
+        return this.renderer;
+    }
+    /**
+     * Register a custom renderer for a MIME type
+     */
+    registerMimeTypeRenderer(mimeType, renderer) {
+        this.customRenderers[mimeType] = renderer;
+        // Recreate renderer with updated custom renderers
+        this.renderer = createMCPUIRenderer(this.customRenderers);
+    }
+    /**
+     * Cleanup extension state
+     */
+    cleanup() {
+        // Context cleanup handled by renderer garbage collection
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Extension exports for chat component.
+ *
+ * @module components/chat/extensions
+ */
+export { ExtensionRegistry, createMessageRenderer, createActivityRenderer, } from './ExtensionRegistry';
+export { createA2UIRenderer, A2UIExtensionImpl, type A2UIMessage, } from './A2UIExtension';
+export { createMCPUIRenderer, MCPUIExtensionImpl, type MCPUIMessage, type MCPUIResource, } from './MCPUIExtension';
+export type { ChatExtension, ExtensionType, MessageRendererExtension, ActivityRendererExtension, ToolUIExtension, ProtocolEventExtension, PanelExtension, A2UIExtension, } from '../types/extension';

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

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Extension exports for chat component.
+ *
+ * @module components/chat/extensions
+ */
+export { ExtensionRegistry, createMessageRenderer, createActivityRenderer, } from './ExtensionRegistry';
+export { createA2UIRenderer, A2UIExtensionImpl, } from './A2UIExtension';
+export { createMCPUIRenderer, MCPUIExtensionImpl, } from './MCPUIExtension';

package/lib/components/chat/handler.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Call the API extension
+ *
+ * @param endPoint - API REST end point for the extension
+ * @param init - Initial values for the request
+ * @returns The response body interpreted as JSON
+ *
+ * @example
+ * ```typescript
+ * // GET request
+ * const config = await requestAPI<Config>('config');
+ *
+ * // POST request
+ * const result = await requestAPI<Result>('chat', {
+ *   method: 'POST',
+ *   body: JSON.stringify({ message: 'Hello' }),
+ * });
+ * ```
+ */
+export declare function requestAPI<T>(endPoint?: string, init?: RequestInit): Promise<T>;

package/lib/components/chat/handler.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Simple API request handler.
+ * Helper function to make API requests to the Simple server.
+ *
+ * @module components/chat/handler
+ */
+import { URLExt } from '@jupyterlab/coreutils';
+import { ServerConnection } from '@jupyterlab/services';
+/**
+ * Call the API extension
+ *
+ * @param endPoint - API REST end point for the extension
+ * @param init - Initial values for the request
+ * @returns The response body interpreted as JSON
+ *
+ * @example
+ * ```typescript
+ * // GET request
+ * const config = await requestAPI<Config>('config');
+ *
+ * // POST request
+ * const result = await requestAPI<Result>('chat', {
+ *   method: 'POST',
+ *   body: JSON.stringify({ message: 'Hello' }),
+ * });
+ * ```
+ */
+export async function requestAPI(endPoint = '', init = {}) {
+    // Make request to Simple API
+    const settings = ServerConnection.makeSettings();
+    const requestUrl = URLExt.join(settings.baseUrl, 'agent_runtimes', endPoint);
+    let response;
+    try {
+        response = await ServerConnection.makeRequest(requestUrl, init, settings);
+    }
+    catch (error) {
+        throw new ServerConnection.NetworkError(error);
+    }
+    let data = await response.text();
+    if (data.length > 0) {
+        try {
+            data = JSON.parse(data);
+        }
+        catch {
+            // Not a JSON response body
+        }
+    }
+    if (!response.ok) {
+        throw new ServerConnection.ResponseError(response, data.message || data);
+    }
+    return data;
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Chat - Next generation chat component for agent-runtimes.
+ *
+ * Features:
+ * - Multiple transport support: AG-UI, A2A, ACP
+ * - Hybrid tool execution (frontend/backend)
+ * - Human-in-the-loop (HITL) tool approval
+ * - Middleware pipeline for extensibility
+ * - Extension registry for custom renderers
+ * - Primer React UI components
+ * - Zustand state management (NO provider required!)
+ *
+ * @module components/chat
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   useChatStore,
+ *   ChatSidebar,
+ *   useFrontendTool,
+ *   DatalayerInferenceProvider,
+ * } from './chat';
+ *
+ * // Setup inference provider (once at app init)
+ * const provider = new DatalayerInferenceProvider({
+ *   apiKey: 'your-api-key',
+ *   baseUrl: 'https://api.datalayer.io',
+ * });
+ * useChatStore.getState().setInferenceProvider(provider);
+ *
+ * function App() {
+ *   return (
+ *     <>
+ *       <ToolRegistrar />
+ *       <ChatSidebar title="Assistant" />
+ *     </>
+ *   );
+ * }
+ *
+ * function ToolRegistrar() {
+ *   useFrontendTool({
+ *     name: 'greet',
+ *     description: 'Greet a user',
+ *     parameters: [{ name: 'name', type: 'string', required: true }],
+ *     handler: async ({ name }) => ({ greeting: `Hello, ${name}!` }),
+ *   });
+ *   return null;
+ * }
+ * ```
+ */
+export * from './types';
+export { useChatStore, useChatMessages, useChatLoading, useChatStreaming, useChatError, useChatTools, useChatOpen, useChatConfig, useChatReady, useChatInferenceProvider, useChatExtensionRegistry, defaultChatConfig, type ChatStore, type ChatConfig, } from './store';
+export { useChat, useFrontendTool, useBackendTool, ActionRegistrar, type UseChatReturn, type UseFrontendToolFn, } from '../../hooks';
+export { BaseInferenceProvider, DatalayerInferenceProvider, SelfHostedInferenceProvider, type DatalayerInferenceConfig, type SelfHostedInferenceConfig, } from './inference';
+export { BaseProtocolAdapter, AGUIAdapter, A2AAdapter, ACPAdapter, type AGUIAdapterConfig, type A2AAdapterConfig, type ACPAdapterConfig, type ACPSession, type ACPAgent, type ACPPendingPermission, } from './protocols';
+export { ToolExecutor, type ToolExecutionContext } from './tools';
+export { MiddlewarePipeline, createMiddleware, loggingMiddleware, createHITLMiddleware, type RequestContext, type ResponseContext, } from './middleware';
+export { ExtensionRegistry, createMessageRenderer, createActivityRenderer, createA2UIRenderer, A2UIExtensionImpl, type A2UIMessage, } from './extensions';
+export { ChatMessages, ChatInputPrompt, ChatSidebar, ChatStandalone, ChatBase, ToolApprovalDialog, useToolApprovalDialog, PoweredByTag, FloatingBrandButton, ChatHeader, MessagePart, TextPart, ReasoningPart, ToolPart, DynamicToolPart, ToolCallDisplay, Chat, ChatFloating, type ChatMessagesProps, type ChatInputPromptProps, type ChatSidebarProps, type ChatStandaloneProps, type MessageHandler, type ChatBaseProps, type ProtocolConfig, type ToolApprovalDialogProps, type PoweredByTagProps, type FloatingBrandButtonProps, type ChatFloatingProps, type ToolCallRenderContext, type ToolCallStatus, type RenderToolResult, type RespondCallback, type Suggestion, type ChatHeaderProps, type ConnectionState, type MessagePartProps, type TextPartProps, type ReasoningPartProps, type ToolPartProps, type DynamicToolPartProps, type ToolCallDisplayProps, type ChatProps, type Transport, type Extension, } from './components';
+export { requestAPI } from './handler';
+export { useKeyboardShortcuts, useChatKeyboardShortcuts, getShortcutDisplay, type KeyboardShortcut, type UseKeyboardShortcutsOptions, } from '../../hooks';

package/lib/components/chat/index.js

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Chat - Next generation chat component for agent-runtimes.
+ *
+ * Features:
+ * - Multiple transport support: AG-UI, A2A, ACP
+ * - Hybrid tool execution (frontend/backend)
+ * - Human-in-the-loop (HITL) tool approval
+ * - Middleware pipeline for extensibility
+ * - Extension registry for custom renderers
+ * - Primer React UI components
+ * - Zustand state management (NO provider required!)
+ *
+ * @module components/chat
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   useChatStore,
+ *   ChatSidebar,
+ *   useFrontendTool,
+ *   DatalayerInferenceProvider,
+ * } from './chat';
+ *
+ * // Setup inference provider (once at app init)
+ * const provider = new DatalayerInferenceProvider({
+ *   apiKey: 'your-api-key',
+ *   baseUrl: 'https://api.datalayer.io',
+ * });
+ * useChatStore.getState().setInferenceProvider(provider);
+ *
+ * function App() {
+ *   return (
+ *     <>
+ *       <ToolRegistrar />
+ *       <ChatSidebar title="Assistant" />
+ *     </>
+ *   );
+ * }
+ *
+ * function ToolRegistrar() {
+ *   useFrontendTool({
+ *     name: 'greet',
+ *     description: 'Greet a user',
+ *     parameters: [{ name: 'name', type: 'string', required: true }],
+ *     handler: async ({ name }) => ({ greeting: `Hello, ${name}!` }),
+ *   });
+ *   return null;
+ * }
+ * ```
+ */
+// Types
+export * from './types';
+// Store (primary state management - no provider needed!)
+export { useChatStore, useChatMessages, useChatLoading, useChatStreaming, useChatError, useChatTools, useChatOpen, useChatConfig, useChatReady, useChatInferenceProvider, useChatExtensionRegistry, defaultChatConfig, } from './store';
+// Hooks (re-exported from main hooks folder)
+export { useChat, useFrontendTool, useBackendTool, ActionRegistrar, } from '../../hooks';
+// Inference Providers
+export { BaseInferenceProvider, DatalayerInferenceProvider, SelfHostedInferenceProvider, } from './inference';
+// Protocol Adapters
+export { BaseProtocolAdapter, AGUIAdapter, A2AAdapter, ACPAdapter, } from './protocols';
+// Tools
+export { ToolExecutor } from './tools';
+// Middleware
+export { MiddlewarePipeline, createMiddleware, loggingMiddleware, createHITLMiddleware, } from './middleware';
+// Extensions
+export { ExtensionRegistry, createMessageRenderer, createActivityRenderer, createA2UIRenderer, A2UIExtensionImpl, } from './extensions';
+// Components
+export { ChatMessages, ChatInputPrompt, ChatSidebar, ChatStandalone, ChatBase, ToolApprovalDialog, useToolApprovalDialog, PoweredByTag, FloatingBrandButton, ChatHeader, MessagePart, TextPart, ReasoningPart, ToolPart, DynamicToolPart, ToolCallDisplay, Chat, ChatFloating, } from './components';
+// Simple API request handler (merged from chat)
+export { requestAPI } from './handler';
+// Keyboard shortcuts (re-exported from main hooks folder)
+export { useKeyboardShortcuts, useChatKeyboardShortcuts, getShortcutDisplay, } from '../../hooks';

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

@@ -0,0 +1,57 @@
+/**
+ * Base inference provider class with common functionality.
+ *
+ * @module components/chat/inference/BaseInferenceProvider
+ */
+import type { InferenceProvider, InferenceProviderConfig, InferenceRequestOptions, InferenceResponse, StreamEventHandler } from '../types';
+import type { ChatMessage } from '../types/message';
+import type { ToolExecutionResult } from '../types/tool';
+/**
+ * Abstract base class for inference providers
+ */
+export declare abstract class BaseInferenceProvider implements InferenceProvider {
+    protected config: InferenceProviderConfig;
+    protected abortController: AbortController | null;
+    abstract readonly name: string;
+    constructor(config: InferenceProviderConfig);
+    /**
+     * Send a message and get a response (non-streaming)
+     */
+    abstract sendMessage(messages: ChatMessage[], options?: InferenceRequestOptions): Promise<InferenceResponse>;
+    /**
+     * Send a message with streaming response
+     */
+    abstract streamMessage(messages: ChatMessage[], options?: InferenceRequestOptions, onEvent?: StreamEventHandler): Promise<InferenceResponse>;
+    /**
+     * Cancel an ongoing request
+     */
+    cancelRequest(): void;
+    /**
+     * Execute a backend tool (optional, for hybrid execution)
+     */
+    executeBackendTool(_toolName: string, _args: Record<string, unknown>, _options?: InferenceRequestOptions): Promise<ToolExecutionResult>;
+    /**
+     * Check if provider is available/configured
+     */
+    isAvailable(): boolean;
+    /**
+     * Get provider configuration
+     */
+    getConfig(): InferenceProviderConfig;
+    /**
+     * Create abort controller for request
+     */
+    protected createAbortController(signal?: AbortSignal): AbortController;
+    /**
+     * Build headers for API requests
+     */
+    protected buildHeaders(additionalHeaders?: Record<string, string>): Record<string, string>;
+    /**
+     * Convert internal messages to provider-specific format
+     */
+    protected abstract convertMessages(messages: ChatMessage[]): unknown[];
+    /**
+     * Parse provider response to internal format
+     */
+    protected abstract parseResponse(response: unknown): InferenceResponse;
+}

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Abstract base class for inference providers
+ */
+export class BaseInferenceProvider {
+    config;
+    abortController = null;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Cancel an ongoing request
+     */
+    cancelRequest() {
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = null;
+        }
+    }
+    /**
+     * Execute a backend tool (optional, for hybrid execution)
+     */
+    async executeBackendTool(_toolName, _args, _options) {
+        return {
+            success: false,
+            error: `Backend tool execution not supported by ${this.name} provider`,
+        };
+    }
+    /**
+     * Check if provider is available/configured
+     */
+    isAvailable() {
+        return !!this.config.apiKey || !!this.config.baseUrl;
+    }
+    /**
+     * Get provider configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Create abort controller for request
+     */
+    createAbortController(signal) {
+        this.abortController = new AbortController();
+        // Link to external signal if provided
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                this.abortController?.abort();
+            });
+        }
+        return this.abortController;
+    }
+    /**
+     * Build headers for API requests
+     */
+    buildHeaders(additionalHeaders) {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.config.apiKey) {
+            headers['Authorization'] = `Bearer ${this.config.apiKey}`;
+        }
+        return { ...headers, ...additionalHeaders };
+    }
+}

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

@@ -0,0 +1,83 @@
+/**
+ * Datalayer inference provider implementation.
+ * Uses Datalayer's API for LLM inference.
+ *
+ * @module components/chat/inference/DatalayerInferenceProvider
+ */
+import type { InferenceProviderConfig, InferenceRequestOptions, InferenceResponse, StreamEventHandler } from '../types';
+import type { ChatMessage } from '../types/message';
+import type { ToolExecutionResult } from '../types/tool';
+import { BaseInferenceProvider } from './BaseInferenceProvider';
+/**
+ * Finish reason type for inference responses
+ */
+export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'error';
+/**
+ * Datalayer-specific configuration
+ */
+export interface DatalayerInferenceConfig extends InferenceProviderConfig {
+    /** Datalayer API key */
+    apiKey: string;
+    /** Base URL for Datalayer API */
+    baseUrl?: string;
+    /** Model to use */
+    model?: string;
+    /** Agent ID for agent-specific inference */
+    agentId?: string;
+}
+/**
+ * Datalayer inference provider
+ */
+export declare class DatalayerInferenceProvider extends BaseInferenceProvider {
+    readonly name = "datalayer";
+    private datalayerConfig;
+    constructor(config: DatalayerInferenceConfig);
+    /**
+     * 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>;
+    /**
+     * Execute a backend tool
+     */
+    executeBackendTool(toolName: string, args: Record<string, unknown>, options?: InferenceRequestOptions): Promise<ToolExecutionResult>;
+    /**
+     * Check if provider is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Convert internal messages to OpenAI-compatible format
+     */
+    protected convertMessages(messages: ChatMessage[]): unknown[];
+    /**
+     * Convert tool definitions to OpenAI format
+     */
+    private convertTools;
+    /**
+     * Parse API response to internal format
+     */
+    protected parseResponse(data: {
+        choices?: Array<{
+            message?: {
+                role?: string;
+                content?: string;
+                tool_calls?: Array<{
+                    id: string;
+                    function: {
+                        name: string;
+                        arguments: string;
+                    };
+                }>;
+            };
+            finish_reason?: string;
+        }>;
+        usage?: {
+            prompt_tokens?: number;
+            completion_tokens?: number;
+            total_tokens?: number;
+        };
+    }): InferenceResponse;
+}