@datalayer/core 0.0.17 → 0.0.19

package/lib/examples/notebooks/NotebookExample1.ipynb.json

@@ -21,7 +21,7 @@
             "execution_count": 1,
             "metadata": {
                 "datalayer": {
-                    "_about": "AI Platform for Data Analysis"
+                    "_about": "AI Agents for Data Analysis"
                 }
             },
             "outputs": [

package/lib/hooks/useAIJupyterChat.js

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
 /*
  * Copyright (c) 2024-2025 Datalayer, Inc.
  *

package/lib/hooks/useBackdrop.d.ts

@@ -1,3 +1,4 @@
+import { ReactNode } from 'react';
 import PropTypes from 'prop-types';
 type BackdropContextType = {
     closeBackdrop: () => void;
@@ -10,19 +11,18 @@ export declare function useBackdrop(): BackdropContextType;
  */
 export declare const BackdropContextProvider: import("react").Provider<BackdropContextType>;
 type IBackdropProviderProps = {
-    children?: JSX.Element | JSX.Element[];
+    children?: ReactNode;
     zIndex?: number;
     disableDarken?: boolean;
     backdropSurface?: any;
 };
-export declare function BackdropProvider(props: IBackdropProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function BackdropProvider({ children, zIndex, disableDarken, backdropSurface, }: IBackdropProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace BackdropProvider {
     var propTypes: {
-        children: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        children: PropTypes.Requireable<NonNullable<PropTypes.ReactNodeLike>>;
         zIndex: PropTypes.Requireable<number>;
         disableDarken: PropTypes.Requireable<boolean>;
         backdropSurface: PropTypes.Requireable<(...args: any[]) => any>;
     };
-    var defaultProps: IBackdropProviderProps;
 }
 export {};

package/lib/hooks/useBackdrop.js

@@ -48,8 +48,7 @@ const App = () => (
 )
 export default App
 */
-export function BackdropProvider(props) {
-    const { children, zIndex, disableDarken, backdropSurface } = props;
+export function BackdropProvider({ children = null, zIndex = 9999, disableDarken = false, backdropSurface = null, }) {
     const defaultBackdropSurface = {
         position: 'fixed',
         top: 0,
@@ -82,7 +81,10 @@ export function BackdropProvider(props) {
                 (backdropSurface ? (backdropSurface(backdrop.render(closeBackdrop))) : (_jsx("div", { style: defaultBackdropSurface, children: backdrop.render(closeBackdrop) })))] }));
 }
 BackdropProvider.propTypes = {
-    children: PropTypes.element,
+    children: PropTypes.oneOfType([
+        PropTypes.node,
+        PropTypes.arrayOf(PropTypes.node),
+    ]),
     // zIndex of the backdrop surface. Unused if backdropSurface is overridden.
     zIndex: PropTypes.number,
     // If true, backdrop background is transparent.
@@ -92,9 +94,3 @@ BackdropProvider.propTypes = {
     // See /example/src/ExampleApp.jsx for proper use.
     backdropSurface: PropTypes.func,
 };
-BackdropProvider.defaultProps = {
-    children: undefined,
-    disableBackdrop: false,
-    zIndex: 9999,
-    backdropSurface: null,
-};

package/lib/hooks/useCache.d.ts

@@ -173,6 +173,7 @@ export declare const queryKeys: {
     };
     readonly contacts: {
         readonly all: () => readonly ["contacts"];
+        readonly lists: () => readonly ["contacts", "list"];
         readonly details: () => readonly ["contacts", "detail"];
         readonly detail: (id: string) => readonly ["contacts", "detail", string];
         readonly byHandle: (handle: string) => readonly ["contacts", "handle", string];
@@ -683,7 +684,9 @@ export declare const useCache: ({ loginRoute }?: CacheProps) => {
     useRefreshInvite: (options?: UseMutationOptions<unknown, Error, string>) => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
     useRefreshInvites: (options?: UseMutationOptions<unknown, Error, string>) => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
     useClearCachedInvites: (options?: UseMutationOptions<void, Error, void>) => import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
-    useContact: (contactId: string) => import("@tanstack/react-query").UseQueryResult<IContact | undefined, Error>;
+    useContact: (contactId: string, options?: {
+        enabled?: boolean;
+    }) => import("@tanstack/react-query").UseQueryResult<IContact | undefined, Error>;
     useContactByHandle: (handle: string) => import("@tanstack/react-query").UseQueryResult<IContact | null | undefined, Error>;
     useSearchContacts: (query: string) => import("@tanstack/react-query").UseQueryResult<any, Error>;
     useCreateContact: () => import("@tanstack/react-query").UseMutationResult<any, Error, IContact, unknown>;
@@ -893,6 +896,7 @@ export declare const useCache: ({ loginRoute }?: CacheProps) => {
         };
         readonly contacts: {
             readonly all: () => readonly ["contacts"];
+            readonly lists: () => readonly ["contacts", "list"];
             readonly details: () => readonly ["contacts", "detail"];
             readonly detail: (id: string) => readonly ["contacts", "detail", string];
             readonly byHandle: (handle: string) => readonly ["contacts", "handle", string];

package/lib/hooks/useCache.js

@@ -227,6 +227,7 @@ export const queryKeys = {
     // Contacts
     contacts: {
         all: () => ['contacts'],
+        lists: () => [...queryKeys.contacts.all(), 'list'],
         details: () => [...queryKeys.contacts.all(), 'detail'],
         detail: (id) => [...queryKeys.contacts.details(), id],
         byHandle: (handle) => [...queryKeys.contacts.all(), 'handle', handle],
@@ -1903,7 +1904,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     const useCreateToken = () => {
         return useMutation({
             mutationFn: async (token) => {
-                return requestDatalayer({
+                const resp = await requestDatalayer({
                     url: `${configuration.iamRunUrl}/api/iam/v1/tokens`,
                     method: 'POST',
                     body: {
@@ -1911,13 +1912,15 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                         expirationDate: token.expirationDate.getTime(),
                     },
                 });
+                // Transform the token in the response
+                if (resp.success && resp.token) {
+                    resp.token = toToken(resp.token);
+                }
+                return resp;
             },
             onSuccess: resp => {
                 if (resp.success && resp.token) {
-                    const tok = toToken(resp.token);
-                    if (tok) {
-                        queryClient.setQueryData(queryKeys.tokens.detail(tok.id), tok);
-                    }
+                    queryClient.setQueryData(queryKeys.tokens.detail(resp.token.id), resp.token);
                 }
                 queryClient.invalidateQueries({ queryKey: queryKeys.tokens.all() });
             },
@@ -1929,7 +1932,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     /**
      * Get contact by ID
      */
-    const useContact = (contactId) => {
+    const useContact = (contactId, options) => {
         return useQuery({
             queryKey: queryKeys.contacts.detail(contactId),
             queryFn: async () => {
@@ -1947,7 +1950,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 throw new Error(resp.message || 'Failed to fetch contact');
             },
             ...DEFAULT_QUERY_OPTIONS,
-            enabled: !!contactId,
+            enabled: options?.enabled ?? !!contactId,
         });
     };
     /**
@@ -2025,9 +2028,9 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 queryClient.invalidateQueries({
                     queryKey: queryKeys.contacts.detail(variables.contactId),
                 });
-                // Invalidate all contact queries
+                // Invalidate contact list queries (avoid re-fetching deleted detail)
                 queryClient.invalidateQueries({
-                    queryKey: queryKeys.contacts.all(),
+                    queryKey: queryKeys.contacts.lists(),
                 });
             },
         });
@@ -4027,7 +4030,10 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 });
             },
             onSuccess: () => {
-                queryClient.invalidateQueries({ queryKey: ['outbounds'] });
+                queryClient.invalidateQueries({
+                    queryKey: ['outbounds'],
+                    refetchType: 'inactive',
+                });
             },
         });
     };
@@ -4050,6 +4056,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             onSuccess: (_, outboundId) => {
                 queryClient.invalidateQueries({
                     queryKey: ['outbounds', outboundId],
+                    refetchType: 'inactive',
                 });
             },
         });
@@ -4068,10 +4075,13 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 });
             },
             onSuccess: (_, outboundId) => {
-                queryClient.invalidateQueries({
+                queryClient.removeQueries({
                     queryKey: ['outbounds', outboundId],
                 });
-                queryClient.invalidateQueries({ queryKey: ['outbounds'] });
+                queryClient.invalidateQueries({
+                    queryKey: ['outbounds'],
+                    refetchType: 'inactive',
+                });
             },
         });
     };
@@ -4102,10 +4112,13 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 });
             },
             onSuccess: (_, outboundId) => {
-                queryClient.invalidateQueries({
+                queryClient.removeQueries({
                     queryKey: ['outbounds', outboundId],
                 });
-                queryClient.invalidateQueries({ queryKey: ['outbounds'] });
+                queryClient.invalidateQueries({
+                    queryKey: ['outbounds'],
+                    refetchType: 'inactive',
+                });
             },
         });
     };

package/lib/hooks/useMobile.js

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
 /*
  * Copyright (c) 2024-2025 Datalayer, Inc.
  *

package/lib/hooks/useScreenshot.d.ts

@@ -1,3 +1,4 @@
+import { ReactNode } from 'react';
 type ScreenshotContextType = {
     closeScreenshot: () => void;
     displayScreenshot: (nextScreenshot: any) => void;
@@ -9,13 +10,10 @@ export declare function useScreenshot(): ScreenshotContextType;
  */
 export declare const ScreenshotContextProvider: import("react").Provider<ScreenshotContextType>;
 type IScreenshotProviderProps = {
-    children?: JSX.Element | JSX.Element[];
+    children?: ReactNode;
     zIndex?: number;
     disableDarken?: boolean;
     screenshotSurface?: (qfds: any) => JSX.Element;
 };
-export declare function ScreenshotProvider(props: IScreenshotProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace ScreenshotProvider {
-    var defaultProps: IScreenshotProviderProps;
-}
+export declare function ScreenshotProvider({ children, zIndex, disableDarken, screenshotSurface, }: IScreenshotProviderProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/lib/hooks/useScreenshot.js

@@ -19,8 +19,7 @@ export function useScreenshot() {
  * The type for the Screenshot context provider.
  */
 export const ScreenshotContextProvider = ScreenshotContext.Provider;
-export function ScreenshotProvider(props) {
-    const { children, zIndex, disableDarken, screenshotSurface } = props;
+export function ScreenshotProvider({ children = null, zIndex = 9999, disableDarken = false, screenshotSurface = undefined, }) {
     const defaultScreenshotSurface = {
         position: 'fixed',
         top: 0,
@@ -52,9 +51,3 @@ export function ScreenshotProvider(props) {
     return (_jsxs(ScreenshotContextProvider, { value: { closeScreenshot, displayScreenshot }, children: [_jsx(LayoutScreenshot, {}), children, screenshot.open &&
                 (screenshotSurface ? (screenshotSurface(screenshot.render(closeScreenshot))) : (_jsx("div", { style: defaultScreenshotSurface, children: screenshot.render(closeScreenshot) })))] }));
 }
-ScreenshotProvider.defaultProps = {
-    children: undefined,
-    disableScreenshot: false,
-    zIndex: 9999,
-    screenshotSurface: undefined,
-};

package/lib/models/Outbound.d.ts

@@ -1,5 +1,6 @@
 export declare class Outbound implements IOutbound {
     id: string;
+    uid: string;
     subType: string;
     name: string;
     description: string;
@@ -24,6 +25,7 @@ export declare class Outbound implements IOutbound {
 export declare function asOutbound(u: any): IOutbound;
 export type IOutbound = {
     id: string;
+    uid: string;
     subType: string;
     name: string;
     description: string;

package/lib/models/Outbound.js

@@ -4,6 +4,7 @@
  */
 export class Outbound {
     id;
+    uid;
     subType;
     name;
     description;
@@ -18,7 +19,8 @@ export class Outbound {
     lastUpdateDate;
     launchedDate;
     constructor(u) {
-        this.id = u.uid;
+        this.id = u.id;
+        this.uid = u.uid;
         this.subType = u.subType;
         this.name = u.name;
         this.description = u.description;

package/lib/state/substates/CoreState.js

@@ -35,7 +35,7 @@ let initialConfiguration = {
     },
     brand: {
         name: 'Datalayer',
-        about: 'AI Platform for Data Analysis',
+        about: 'AI Agents for Data Analysis',
         logoUrl: 'https://assets.datalayer.tech/datalayer-25.svg',
         logoSquareUrl: 'https://assets.datalayer.tech/datalayer-square.png',
         copyright: '© 2025 Datalayer, Inc',

package/lib/state/substates/IAMState.js

@@ -268,15 +268,24 @@ iamStore
     }
     // Start the credits poll in any case after trying to validate the user token.
     creditsPoll.start();
-    // Force a refresh when the user comeback to the application tab
+    // Force a refresh when the user comes back to the application tab.
     // Useful for checkout platform redirecting to another tab to add credits.
-    if (typeof document !== 'undefined') {
-        document.addEventListener('visibilitychange', () => {
-            if (!document.hidden && iamStore.getState().user?.id) {
+    const maybeSetupVisibilityListener = () => {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const doc = window.document;
+        if (!doc || typeof doc.addEventListener !== 'function') {
+            return;
+        }
+        const onVisibilityChange = () => {
+            if (!doc.hidden && iamStore.getState().user?.id) {
                 creditsPoll.refresh();
             }
-        });
-    }
+        };
+        doc.addEventListener('visibilitychange', onVisibilityChange);
+    };
+    maybeSetupVisibilityListener();
 });
 // Connect the core store with the iam store.
 coreStore.subscribe((state, prevState) => {

package/lib/tools/adapters/agui/AgUIToolAdapter.d.ts

@@ -0,0 +1,75 @@
+/**
+ * ag-ui/CopilotKit Tool Adapter
+ *
+ * Converts unified tool definitions to CopilotKit's useCopilotAction format.
+ *
+ * @see https://docs.copilotkit.ai/langgraph/frontend-actions
+ * @module tools/adapters/agui/AgUIToolAdapter
+ */
+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/agui/AgUIToolAdapter.js

@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2023-2025 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(`[ag-ui] 🚫 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(`[ag-ui] 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('[ag-ui] 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(`[ag-ui] ========== HANDLER CALLED ==========`);
+            console.log(`[ag-ui] Tool: ${definition.name}`);
+            console.log(`[ag-ui] Operation: ${definition.operation}`);
+            console.log(`[ag-ui] Params:`, params);
+            console.log(`[ag-ui] Context:`, context);
+            // Check for duplicate execution
+            const signature = `${definition.name}:${JSON.stringify(params)}`;
+            console.log(`[ag-ui] 🔍 Signature:`, signature.substring(0, 150));
+            if (isRecentDuplicate(definition.name, params)) {
+                console.log(`[ag-ui] 🚫 DUPLICATE DETECTED - Returning early`);
+                return 'Operation already executed recently (duplicate detected and skipped)';
+            }
+            console.log(`[ag-ui] ✅ 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(`[ag-ui] Calling runner.execute with TOON format...`);
+                console.log(`[ag-ui] Operation name:`, operation);
+                console.log(`[ag-ui] Parsed params being passed:`, JSON.stringify(parsedParams, null, 2));
+                console.log(`[ag-ui] 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(`[ag-ui] 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(`[ag-ui] ❌ ERROR in handler:`, error);
+                console.error(`[ag-ui] 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 ag-ui
+        // Note: config supports platform-specific extensions, cast to any for flexibility
+        render: definition.config?.agui?.renderingHints?.customRender
+            ? definition.config.agui.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(`[ag-ui Tools] No operation found for ${definition.name} (operation: ${definition.operation})`);
+            continue;
+        }
+        const action = createCopilotKitAction(definition, operation, context);
+        actions.push(action);
+    }
+    console.log(`[ag-ui Tools] Created ${actions.length} CopilotKit actions`);
+    return actions;
+}