@datalayer/agent-runtimes 0.0.2

package/lib/tools/adapters/agent-runtimes/notebookHooks.js

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * React hooks for agent-runtimes notebook tool registration.
+ * Provides: useNotebookTools hook for ChatFloating integration.
+ *
+ * @module tools/adapters/agent-runtimes/notebookHooks
+ */
+import { useMemo } from 'react';
+import { notebookStore, DefaultExecutor, notebookToolDefinitions, notebookToolOperations, } from '@datalayer/jupyter-react';
+import { createAllAgentRuntimesTools, } from './AgentRuntimesToolAdapter';
+// Hook wrapper to get notebook store state
+const useNotebookStore = () => notebookStore.getState();
+/**
+ * Hook that creates agent-runtimes tools for notebook operations.
+ * Returns stable tools array that won't cause re-renders.
+ *
+ * @param documentId - Document ID (notebook identifier)
+ * @param contextOverrides - Optional context overrides (format, extras, etc.)
+ * @returns Agent-runtimes tools array for ChatFloating
+ *
+ * @example
+ * ```typescript
+ * // Default context (toon format for AI)
+ * const tools = useNotebookTools("my-notebook-id");
+ *
+ * // Use with ChatFloating
+ * <ChatFloating
+ *   endpoint="http://localhost:8765/api/v1/ag-ui/agent/"
+ *   tools={tools}
+ * />
+ * ```
+ */
+export function useNotebookTools(documentId, contextOverrides) {
+    const notebookStoreState = useNotebookStore();
+    // Create DefaultExecutor (stable reference)
+    // Only recreate when documentId changes, not on every state update
+    const executor = useMemo(() => new DefaultExecutor(documentId, notebookStoreState), [documentId]);
+    // Create stable context object with useMemo
+    // Defaults: format='toon' for conversational AI responses
+    const context = useMemo(() => ({
+        documentId,
+        executor,
+        format: 'toon',
+        ...contextOverrides,
+    }), [documentId, executor, contextOverrides]);
+    // Create and return tools (stable reference)
+    return useMemo(() => createAllAgentRuntimesTools(notebookToolDefinitions, notebookToolOperations, context), [context]);
+}

package/lib/tools/adapters/copilotkit/CopilotKitToolAdapter.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Converts unified tool definitions to CopilotKit's useCopilotAction format.
+ *
+ * @see https://docs.copilotkit.ai/langgraph/frontend-actions
+ * @module tools/adapters/copilotkit/CopilotKitToolAdapter
+ */
+import type { ToolDefinition, ToolOperation, ToolExecutionContext } from '@datalayer/jupyter-react';
+/**
+ * Type signature for CopilotKit's useFrontendTool hook
+ * This is shared across both notebook and lexical adapters
+ */
+export type UseFrontendToolFn = (tool: {
+    name: string;
+    description: string;
+    parameters: any;
+    handler: (params: any) => Promise<string>;
+    render?: (props: any) => any;
+}, dependencies?: any[]) => void;
+/**
+ * Component to register a single action with CopilotKit
+ * Must be used inside CopilotKit context
+ */
+export declare function ActionRegistrar({ action, useFrontendTool, }: {
+    action: any;
+    useFrontendTool: UseFrontendToolFn;
+}): null;
+/**
+ * CopilotKit parameter definition (array format, not JSON Schema)
+ */
+export interface CopilotKitParameter {
+    name: string;
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'object[]';
+    description?: string;
+    required?: boolean;
+    attributes?: CopilotKitParameter[];
+}
+/**
+ * CopilotKit action definition (matches useCopilotAction interface)
+ */
+export interface CopilotKitAction {
+    /** Action name */
+    name: string;
+    /** Description for AI model */
+    description: string;
+    /** Parameters array (NOT JSON Schema) */
+    parameters: CopilotKitParameter[];
+    /** Handler function */
+    handler: (params: unknown) => Promise<string>;
+    /** Optional custom UI renderer */
+    render?: (props: {
+        status: string;
+        args: unknown;
+        result: unknown;
+    }) => React.ReactNode;
+}
+/**
+ * Converts unified tool definition to CopilotKit action format
+ *
+ * @param definition - Tool definition
+ * @param operation - Core operation
+ * @param context - Execution context (documentId + executor)
+ * @returns CopilotKit action
+ */
+export declare function createCopilotKitAction(definition: ToolDefinition, operation: ToolOperation<unknown, unknown>, context: ToolExecutionContext): CopilotKitAction;
+/**
+ * Creates CopilotKit actions from all tool definitions
+ *
+ * @param definitions - Tool definitions
+ * @param operations - Core operations registry
+ * @param context - Execution context (documentId + executor)
+ * @returns CopilotKit actions
+ */
+export declare function createAllCopilotKitActions(definitions: ToolDefinition[], operations: Record<string, ToolOperation<unknown, unknown>>, context: ToolExecutionContext): CopilotKitAction[];

package/lib/tools/adapters/copilotkit/CopilotKitToolAdapter.js

@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { OperationRunner } from '@datalayer/jupyter-react';
+/**
+ * Component to register a single action with CopilotKit
+ * Must be used inside CopilotKit context
+ */
+export function ActionRegistrar({ action, useFrontendTool, }) {
+    useFrontendTool(action, [action]);
+    return null;
+}
+/**
+ * Deduplication cache to prevent executing the same operation multiple times
+ * Maps operation signature (hash of tool + params) to timestamp
+ */
+const executionCache = new Map();
+const CACHE_TTL_MS = 2000; // 2 seconds - operations within this window are considered duplicates
+/**
+ * Generate a unique signature for an operation call
+ */
+function getOperationSignature(toolName, params) {
+    return `${toolName}:${JSON.stringify(params)}`;
+}
+/**
+ * Check if this operation was recently executed
+ */
+function isRecentDuplicate(toolName, params) {
+    const signature = getOperationSignature(toolName, params);
+    const lastExecution = executionCache.get(signature);
+    if (lastExecution) {
+        const timeSinceExecution = Date.now() - lastExecution;
+        if (timeSinceExecution < CACHE_TTL_MS) {
+            console.log(`[copilotkit] 🚫 DUPLICATE DETECTED - Skipping execution (${timeSinceExecution}ms since last call)`);
+            return true;
+        }
+    }
+    // Clean up old entries while we're here
+    for (const [key, timestamp] of executionCache.entries()) {
+        if (Date.now() - timestamp > CACHE_TTL_MS * 2) {
+            executionCache.delete(key);
+        }
+    }
+    // Mark this execution
+    executionCache.set(signature, Date.now());
+    return false;
+}
+/**
+ * Parses array parameters from CopilotKit's string format to actual arrays.
+ *
+ * CopilotKit doesn't have native support for primitive arrays, so it sends them
+ * as JSON strings (e.g., "[1, 2, 3]"). This function parses those strings back
+ * into actual arrays based on the schema definition.
+ *
+ * @param params - Raw parameters from CopilotKit
+ * @param jsonSchema - JSON Schema definition to identify array parameters
+ * @returns Parsed parameters with arrays converted from strings
+ */
+function parseArrayParameters(params, jsonSchema) {
+    if (typeof params !== 'object' || params === null) {
+        return params;
+    }
+    const parsedParams = { ...params };
+    // Iterate through schema properties to find array types
+    for (const [name, schema] of Object.entries(jsonSchema.properties || {})) {
+        const propSchema = schema;
+        // If this property is an array type and the value is a string, parse it
+        if (propSchema.type === 'array' && typeof parsedParams[name] === 'string') {
+            try {
+                const parsed = JSON.parse(parsedParams[name]);
+                // Validate it's actually an array after parsing
+                if (Array.isArray(parsed)) {
+                    parsedParams[name] = parsed;
+                }
+            }
+            catch (error) {
+                // If parsing fails, log warning but keep original value
+                console.warn(`[copilotkit] Failed to parse array parameter "${name}":`, error);
+            }
+        }
+    }
+    return parsedParams;
+}
+/**
+ * Converts JSON Schema to CopilotKit parameter array format
+ *
+ * @param jsonSchema - JSON Schema parameters object
+ * @returns CopilotKit parameters array
+ */
+function jsonSchemaToParameters(jsonSchema) {
+    const parameters = [];
+    const required = jsonSchema.required || [];
+    for (const [name, schema] of Object.entries(jsonSchema.properties || {})) {
+        const propSchema = schema;
+        // Map JSON Schema type to CopilotKit type
+        let copilotType = 'string';
+        if (propSchema.type === 'array') {
+            // Handle array types based on items type
+            const itemsType = propSchema.items?.type;
+            if (itemsType === 'object') {
+                copilotType = 'object[]';
+            }
+            else {
+                // For primitive arrays (number[], string[], etc.)
+                // CopilotKit doesn't have explicit support, but we can use the description
+                // to clarify and handle parsing in the handler
+                copilotType = 'string'; // Will be parsed as JSON array string
+                // Enhance description to clarify it's an array
+                propSchema.description =
+                    `${propSchema.description || ''} (JSON array of ${itemsType || 'values'})`.trim();
+            }
+        }
+        else {
+            // Original logic for non-array types
+            copilotType =
+                propSchema.type || 'string';
+        }
+        const param = {
+            name,
+            type: copilotType,
+            description: propSchema.description,
+            required: required.includes(name),
+        };
+        // Handle nested object properties (for object types)
+        if (propSchema.type === 'object' && propSchema.properties) {
+            // Cast to proper type for recursive call
+            param.attributes = jsonSchemaToParameters({
+                type: 'object',
+                properties: propSchema.properties, // eslint-disable-line @typescript-eslint/no-explicit-any
+                required: propSchema.required || [],
+            });
+        }
+        parameters.push(param);
+    }
+    console.log('[copilotkit] Converted parameters:', JSON.stringify(parameters, null, 2));
+    return parameters;
+}
+/**
+ * Converts unified tool definition to CopilotKit action format
+ *
+ * @param definition - Tool definition
+ * @param operation - Core operation
+ * @param context - Execution context (documentId + executor)
+ * @returns CopilotKit action
+ */
+export function createCopilotKitAction(definition, operation, context) {
+    // Create runner instance for this action
+    const runner = new OperationRunner();
+    const action = {
+        name: definition.toolReferenceName || definition.name,
+        description: definition.description,
+        parameters: jsonSchemaToParameters(definition.parameters),
+        // CRITICAL FIX: Set to true to enable CopilotKit's deduplication mechanism
+        // See https://github.com/CopilotKit/CopilotKit/issues/2310
+        // Without this, actions get re-executed cumulatively (A → A,B → A,B,C)
+        _isRenderAndWait: true,
+        handler: async (params) => {
+            console.log(`[copilotkit] ========== HANDLER CALLED ==========`);
+            console.log(`[copilotkit] Tool: ${definition.name}`);
+            console.log(`[copilotkit] Operation: ${definition.operation}`);
+            console.log(`[copilotkit] Params:`, params);
+            console.log(`[copilotkit] Context:`, context);
+            // Check for duplicate execution
+            const signature = `${definition.name}:${JSON.stringify(params)}`;
+            console.log(`[copilotkit] 🔍 Signature:`, signature.substring(0, 150));
+            if (isRecentDuplicate(definition.name, params)) {
+                console.log(`[copilotkit] 🚫 DUPLICATE DETECTED - Returning early`);
+                return 'Operation already executed recently (duplicate detected and skipped)';
+            }
+            console.log(`[copilotkit] ✅ NOT a duplicate - Proceeding with execution`);
+            try {
+                // Parse array parameters that CopilotKit sends as JSON strings
+                // CopilotKit doesn't have native support for primitive arrays, so they're sent as strings
+                const parsedParams = parseArrayParameters(params, definition.parameters);
+                console.log(`[copilotkit] Calling runner.execute with TOON format...`);
+                console.log(`[copilotkit] Operation name:`, operation);
+                console.log(`[copilotkit] Parsed params being passed:`, JSON.stringify(parsedParams, null, 2));
+                console.log(`[copilotkit] Context being passed:`, JSON.stringify(context, null, 2));
+                // Use OperationRunner to execute operation with TOON format
+                // TOON format returns human/LLM-readable string (default)
+                const result = await runner.execute(operation, parsedParams, {
+                    ...context,
+                    format: 'toon', // CopilotKit expects string responses
+                });
+                console.log(`[copilotkit] Operation result:`, result);
+                // Result is already a string (TOON format)
+                if (typeof result === 'string') {
+                    return result;
+                }
+                // Fallback: if somehow we got an object (shouldn't happen with format='toon')
+                if (typeof result === 'object' && result !== null) {
+                    const resultObj = result;
+                    // Return success message if available
+                    if (resultObj.message) {
+                        return resultObj.message;
+                    }
+                    // Return error if failed
+                    if (resultObj.success === false && resultObj.error) {
+                        return `❌ Error: ${resultObj.error}`;
+                    }
+                    // Otherwise format as JSON
+                    return JSON.stringify(result, null, 2);
+                }
+                return String(result);
+            }
+            catch (error) {
+                console.error(`[copilotkit] ❌ ERROR in handler:`, error);
+                console.error(`[copilotkit] Error stack:`, error instanceof Error ? error.stack : 'N/A');
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return `❌ Error: ${errorMessage}`;
+            }
+        },
+        // Optional: Custom render function for copilotkit
+        // Note: config supports platform-specific extensions, cast to any for flexibility
+        render: definition.config?.copilotkit?.renderingHints?.customRender
+            ? definition.config.copilotkit.renderingHints
+                .customRender
+            : undefined,
+    };
+    return action;
+}
+/**
+ * Creates CopilotKit actions from all tool definitions
+ *
+ * @param definitions - Tool definitions
+ * @param operations - Core operations registry
+ * @param context - Execution context (documentId + executor)
+ * @returns CopilotKit actions
+ */
+export function createAllCopilotKitActions(definitions, operations, context) {
+    const actions = [];
+    for (const definition of definitions) {
+        const operation = operations[definition.operation];
+        if (!operation) {
+            console.warn(`[copilotkit Tools] No operation found for ${definition.name} (operation: ${definition.operation})`);
+            continue;
+        }
+        const action = createCopilotKitAction(definition, operation, context);
+        actions.push(action);
+    }
+    console.log(`[copilotkit Tools] Created ${actions.length} CopilotKit actions`);
+    return actions;
+}

package/lib/tools/adapters/copilotkit/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * copilotkit CopilotKit adapter module.
+ * Exports: CopilotKit adapters, hooks (useNotebookToolActions, useLexicalToolActions).
+ * Note: DefaultExecutor is imported from datalayer-react/tools/core/executor
+ *
+ * @module tools/adapters/copilotkit
+ */
+export * from './CopilotKitToolAdapter';
+export * from './notebookHooks';
+export * from './lexicalHooks';

package/lib/tools/adapters/copilotkit/index.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * copilotkit CopilotKit adapter module.
+ * Exports: CopilotKit adapters, hooks (useNotebookToolActions, useLexicalToolActions).
+ * Note: DefaultExecutor is imported from datalayer-react/tools/core/executor
+ *
+ * @module tools/adapters/copilotkit
+ */
+export * from './CopilotKitToolAdapter';
+export * from './notebookHooks';
+export * from './lexicalHooks';

package/lib/tools/adapters/copilotkit/lexicalHooks.d.ts

@@ -0,0 +1,27 @@
+import type { ToolExecutionContext } from '@datalayer/jupyter-react';
+import { createAllCopilotKitActions, ActionRegistrar, type UseFrontendToolFn } from './CopilotKitToolAdapter';
+/**
+ * Hook that creates CopilotKit actions for lexical tools.
+ * Returns stable actions array that won't cause re-renders.
+ *
+ * @param documentId - Document ID (lexical document identifier)
+ * @param contextOverrides - Optional context overrides (format, extras, etc.)
+ * @returns CopilotKit actions
+ *
+ * @example
+ * ```typescript
+ * // Default context (toon format for AI)
+ * const actions = useLexicalToolActions("doc-123");
+ *
+ * // Custom format
+ * const actions = useLexicalToolActions("doc-123", { format: 'json' });
+ *
+ * // With extras
+ * const actions = useLexicalToolActions("doc-123", {
+ *   format: 'toon',
+ *   extras: { userId: '123', theme: 'dark' }
+ * });
+ * ```
+ */
+export declare function useLexicalToolActions(documentId: string, contextOverrides?: Partial<Omit<ToolExecutionContext, 'executor' | 'documentId'>>): ReturnType<typeof createAllCopilotKitActions>;
+export { ActionRegistrar, type UseFrontendToolFn };

package/lib/tools/adapters/copilotkit/lexicalHooks.js

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * React hooks and components for copilotkit (CopilotKit) lexical tool registration.
+ * Provides: useLexicalToolActions, ActionRegistrar, UseFrontendToolFn.
+ *
+ * @module tools/adapters/copilotkit/lexicalHooks
+ */
+import { useMemo } from 'react';
+import { useLexicalStore, DefaultExecutor as LexicalDefaultExecutor, lexicalToolDefinitions, lexicalToolOperations, } from '@datalayer/jupyter-lexical';
+import { createAllCopilotKitActions, ActionRegistrar, } from './CopilotKitToolAdapter';
+/**
+ * Hook that creates CopilotKit actions for lexical tools.
+ * Returns stable actions array that won't cause re-renders.
+ *
+ * @param documentId - Document ID (lexical document identifier)
+ * @param contextOverrides - Optional context overrides (format, extras, etc.)
+ * @returns CopilotKit actions
+ *
+ * @example
+ * ```typescript
+ * // Default context (toon format for AI)
+ * const actions = useLexicalToolActions("doc-123");
+ *
+ * // Custom format
+ * const actions = useLexicalToolActions("doc-123", { format: 'json' });
+ *
+ * // With extras
+ * const actions = useLexicalToolActions("doc-123", {
+ *   format: 'toon',
+ *   extras: { userId: '123', theme: 'dark' }
+ * });
+ * ```
+ */
+export function useLexicalToolActions(documentId, contextOverrides) {
+    // Call useLexicalStore() with no selector to get state object (matches notebook pattern)
+    const lexicalStoreState = useLexicalStore();
+    // Create LexicalDefaultExecutor (stable reference)
+    // Only recreate when documentId changes, not on every state update
+    // The executor holds a reference to the store which is always current
+    const executor = useMemo(() => new LexicalDefaultExecutor(documentId, lexicalStoreState), [documentId]);
+    // Create stable context object with useMemo
+    // Defaults: format='toon' for conversational AI responses
+    // Can be overridden with contextOverrides parameter
+    const context = useMemo(() => ({
+        documentId,
+        executor,
+        format: 'toon', // Default format
+        ...contextOverrides, // Override with user-provided values
+    }), [documentId, executor, contextOverrides]);
+    // Create and return CopilotKit actions (stable reference)
+    // Only re-create when context changes (i.e., when documentId or contextOverrides change)
+    const actions = useMemo(() => createAllCopilotKitActions(lexicalToolDefinitions, lexicalToolOperations, context), [context]);
+    return actions;
+}
+// Re-export shared types and components for convenience
+export { ActionRegistrar };

package/lib/tools/adapters/copilotkit/notebookHooks.d.ts

@@ -0,0 +1,27 @@
+import type { ToolExecutionContext } from '@datalayer/jupyter-react';
+import { createAllCopilotKitActions, ActionRegistrar, type UseFrontendToolFn } from './CopilotKitToolAdapter';
+/**
+ * Hook that creates CopilotKit actions for notebook tools.
+ * Returns stable actions array that won't cause re-renders.
+ *
+ * @param documentId - Document ID (notebook identifier)
+ * @param contextOverrides - Optional context overrides (format, extras, etc.)
+ * @returns CopilotKit actions
+ *
+ * @example
+ * ```typescript
+ * // Default context (toon format for AI)
+ * const actions = useNotebookToolActions("my-notebook-id");
+ *
+ * // Custom format
+ * const actions = useNotebookToolActions("my-notebook-id", { format: 'json' });
+ *
+ * // With extras
+ * const actions = useNotebookToolActions("my-notebook-id", {
+ *   format: 'toon',
+ *   extras: { userId: '123', theme: 'dark' }
+ * });
+ * ```
+ */
+export declare function useNotebookToolActions(documentId: string, contextOverrides?: Partial<Omit<ToolExecutionContext, 'executor' | 'documentId'>>): ReturnType<typeof createAllCopilotKitActions>;
+export { ActionRegistrar, type UseFrontendToolFn };

package/lib/tools/adapters/copilotkit/notebookHooks.js

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * React hooks and components for copilotkit (CopilotKit) notebook tool registration.
+ * Provides: useNotebookToolActions, ActionRegistrar, UseFrontendToolFn.
+ *
+ * @module tools/adapters/copilotkit/notebookHooks
+ */
+import { useMemo } from 'react';
+import { notebookStore, DefaultExecutor, notebookToolDefinitions, notebookToolOperations, } from '@datalayer/jupyter-react';
+import { createAllCopilotKitActions, ActionRegistrar, } from './CopilotKitToolAdapter';
+// Hook wrapper to get notebook store state
+const useNotebookStore = () => notebookStore.getState();
+/**
+ * Hook that creates CopilotKit actions for notebook tools.
+ * Returns stable actions array that won't cause re-renders.
+ *
+ * @param documentId - Document ID (notebook identifier)
+ * @param contextOverrides - Optional context overrides (format, extras, etc.)
+ * @returns CopilotKit actions
+ *
+ * @example
+ * ```typescript
+ * // Default context (toon format for AI)
+ * const actions = useNotebookToolActions("my-notebook-id");
+ *
+ * // Custom format
+ * const actions = useNotebookToolActions("my-notebook-id", { format: 'json' });
+ *
+ * // With extras
+ * const actions = useNotebookToolActions("my-notebook-id", {
+ *   format: 'toon',
+ *   extras: { userId: '123', theme: 'dark' }
+ * });
+ * ```
+ */
+export function useNotebookToolActions(documentId, contextOverrides) {
+    const notebookStore = useNotebookStore();
+    // Create DefaultExecutor (stable reference)
+    // Only recreate when documentId changes, not on every state update
+    // The executor holds a reference to the store which is always current
+    const executor = useMemo(() => new DefaultExecutor(documentId, notebookStore), [documentId]);
+    // Create stable context object with useMemo
+    // Defaults: format='toon' for conversational AI responses
+    // Can be overridden with contextOverrides parameter
+    const context = useMemo(() => ({
+        documentId,
+        executor,
+        format: 'toon', // Default format
+        ...contextOverrides, // Override with user-provided values
+    }), [documentId, executor, contextOverrides]);
+    // Create and return CopilotKit actions (stable reference)
+    return useMemo(() => createAllCopilotKitActions(notebookToolDefinitions, notebookToolOperations, context), [context]);
+}
+// Re-export shared types and components for convenience
+export { ActionRegistrar };

package/lib/tools/adapters/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tools/adapters/index.js

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

package/lib/tools/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Platform-agnostic tools for notebook and lexical integration with AI frameworks
+ *
+ * @module tools
+ */
+export * from './adapters/copilotkit';

package/lib/tools/index.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Platform-agnostic tools for notebook and lexical integration with AI frameworks
+ *
+ * @module tools
+ */
+// Export adapters
+export * from './adapters/copilotkit';
+// TODO: Re-export tool types from jupyter-react when available
+// export type {
+//   ToolDefinition,
+//   ToolConfig,
+//   ToolOperation,
+//   ToolExecutionContext,
+// } from '@datalayer/jupyter-react';

package/lib/types.d.ts

@@ -0,0 +1,5 @@
+export interface ConversationEntry {
+    id: string;
+    firstMessage?: string;
+    timestamp: number;
+}

package/lib/types.js

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