@datalayer/agent-runtimes 0.0.4 → 0.0.7

package/lib/runtime/useAgentRuntime.js

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Combined hook for using a runtime with an AI agent.
+ *
+ * This is the main entry point for consumers who want a simple,
+ * all-in-one solution for cloud runtime + agent management.
+ *
+ * @module runtime/useAgentRuntime
+ */
+import { useEffect, useRef, useCallback } from 'react';
+import { useRuntimeStore, useRuntime, useAgent, useRuntimeStatus, useRuntimeError, useIsLaunching, } from './runtimeStore';
+/**
+ * Combined hook for using a runtime with an AI agent.
+ *
+ * This hook provides everything needed to:
+ * 1. Connect to an existing runtime (or launch a new one)
+ * 2. Create an AI agent on the runtime
+ *
+ * Use this in conjunction with useNotebookTools or useLexicalTools
+ * for frontend tool execution.
+ *
+ * @param options - Configuration options
+ * @returns Complete agent runtime state and controls
+ *
+ * @example
+ * ```tsx
+ * // For notebooks
+ * import { useAgentRuntime } from '@datalayer/agent-runtimes/lib/runtime';
+ * import { useNotebookTools } from '@datalayer/agent-runtimes/lib/tools/adapters/agent-runtimes';
+ *
+ * function NotebookEditor({ notebookId }) {
+ *   const {
+ *     isReady,
+ *     endpoint,
+ *     error,
+ *     connectToRuntime,
+ *   } = useAgentRuntime({
+ *     autoCreateAgent: true,
+ *     agentConfig: {
+ *       model: 'anthropic:claude-sonnet-4-5',
+ *       systemPrompt: 'You help users with Jupyter notebooks.',
+ *     },
+ *   });
+ *
+ *   // Get tools separately
+ *   const tools = useNotebookTools(notebookId);
+ *
+ *   // Connect when user assigns a runtime
+ *   const onRuntimeAssigned = (serviceManager, podName, poolName) => {
+ *     connectToRuntime({ serviceManager, podName, jupyterpoolName: poolName });
+ *   };
+ *
+ *   return (
+ *     <>
+ *       <Notebook />
+ *       {isReady && (
+ *         <ChatFloating endpoint={endpoint} tools={tools} />
+ *       )}
+ *       {error && <ErrorBanner>{error}</ErrorBanner>}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export function useAgentRuntime(options = {}) {
+    const { agentConfig, autoCreateAgent = true } = options;
+    // Get store state
+    const runtime = useRuntime();
+    const agent = useAgent();
+    const status = useRuntimeStatus();
+    const error = useRuntimeError();
+    const isLaunching = useIsLaunching();
+    // Get store actions
+    const launchRuntime = useRuntimeStore(state => state.launchRuntime);
+    const connectToRuntime = useRuntimeStore(state => state.connectToRuntime);
+    const disconnect = useRuntimeStore(state => state.disconnect);
+    const createAgentAction = useRuntimeStore(state => state.createAgent);
+    // Track if we've created the agent to prevent duplicates
+    const hasCreatedAgentRef = useRef(false);
+    const agentConfigRef = useRef(agentConfig);
+    agentConfigRef.current = agentConfig;
+    // Auto-create agent when runtime is ready
+    useEffect(() => {
+        if (autoCreateAgent &&
+            runtime &&
+            status === 'ready' &&
+            !agent &&
+            !hasCreatedAgentRef.current) {
+            hasCreatedAgentRef.current = true;
+            createAgentAction(agentConfigRef.current).catch(err => {
+                console.error('[useAgentRuntime] Failed to auto-create agent:', err);
+                hasCreatedAgentRef.current = false;
+            });
+        }
+    }, [autoCreateAgent, runtime, status, agent, createAgentAction]);
+    // Reset agent creation tracking on disconnect
+    useEffect(() => {
+        if (status === 'disconnected' || status === 'idle') {
+            hasCreatedAgentRef.current = false;
+        }
+    }, [status]);
+    // Memoized create agent function
+    const createAgent = useCallback((config) => createAgentAction(config || agentConfig), [createAgentAction, agentConfig]);
+    // Derived state
+    const isReady = status === 'ready' && !!agent?.isReady;
+    const endpoint = agent?.endpoint || null;
+    const serviceManager = runtime?.serviceManager || null;
+    return {
+        runtime,
+        agent,
+        status,
+        error,
+        isLaunching,
+        isReady,
+        endpoint,
+        serviceManager,
+        launchRuntime,
+        connectToRuntime,
+        createAgent,
+        disconnect,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datalayer/agent-runtimes",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "type": "module",
   "workspaces": [
     ".",
@@ -28,7 +28,9 @@
   "files": [
     "lib/**/*.{css,d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}",
     "style/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}",
-    "schema/*.json"
+    "schema/*.json",
+    "patches/",
+    "scripts/"
   ],
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/patches/.gitkeep

@@ -0,0 +1 @@
+# Patches directory for patch-package

package/scripts/apply-patches.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Copyright (c) 2025-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+# Apply patch-package patches for jupyter packages
+# This is normally run automatically via npm's postinstall hook,
+# but can be run manually if needed.
+
+set -e
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}📝 Applying patches...${NC}"
+
+# Get the script directory and project root
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+CORE_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+
+cd "$CORE_ROOT"
+
+npx patch-package
+
+echo -e "${GREEN}✅ Patches applied successfully${NC}"

package/scripts/create-patches.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# Copyright (c) 2025-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+# Create patch-package patches for locally modified jupyter packages
+# This script generates patches that can be committed to the repo and
+# applied automatically during npm install via the postinstall hook.
+
+set -e
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}🔧 Creating patches for jupyter packages...${NC}"
+
+# Get the script directory and project root
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+CORE_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+
+cd "$CORE_ROOT"
+
+# First, sync the latest changes from jupyter-ui to ensure patches include all modifications
+echo -e "${BLUE}🔄 Syncing latest changes from jupyter-ui...${NC}"
+bash "$SCRIPT_DIR/sync-jupyter.sh"
+
+# Ensure package-lock.json exists (required by patch-package)
+if [ ! -f "package-lock.json" ]; then
+  echo -e "${YELLOW}⚠️  No package-lock.json found. Creating one...${NC}"
+  npm i --package-lock-only
+fi
+
+# Create patches
+echo -e "${BLUE}📝 Generating patches with patch-package...${NC}"
+npx patch-package @datalayer/jupyter-lexical @datalayer/jupyter-react
+
+echo -e "${GREEN}✅ Patches created successfully in patches/ directory${NC}"
+echo -e "${BLUE}ℹ️  Patches will be applied automatically on 'npm install' via postinstall hook${NC}"

package/scripts/download-ai-elements.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+"""
+Download AI Elements components directly from the registry
+"""
+
+import json
+import os
+import urllib.request
+import sys
+
+BASE_URL = "https://registry.ai-sdk.dev"
+COMPONENTS_DIR = "src/components/ai-elements"
+
+# Components to download
+COMPONENTS = [
+    "message",
+    "conversation",
+    "prompt-input",
+    "model-selector",
+    "artifact",
+    "code-block",
+    "suggestion",
+    "sources",
+    "reasoning",
+    "tool",
+    "loader",
+    "shimmer",
+]
+
+def download_component(component_name):
+    """Download a component from the registry"""
+    url = f"{BASE_URL}/{component_name}.json"
+    print(f"Downloading {component_name}...")
+    
+    try:
+        with urllib.request.urlopen(url) as response:
+            data = json.loads(response.read())
+        
+        # Get the first file (main component file)
+        if 'files' in data and len(data['files']) > 0:
+            file_data = data['files'][0]
+            content = file_data.get('content', '')
+            target = file_data.get('target', f"components/ai-elements/{component_name}.tsx")
+            
+            # Adjust target path
+            target_path = os.path.join(COMPONENTS_DIR, f"{component_name}.tsx")
+            
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(target_path), exist_ok=True)
+            
+            # Write file
+            with open(target_path, 'w') as f:
+                f.write(content)
+            
+            print(f"✓ Downloaded {component_name} to {target_path}")
+            return True
+        else:
+            print(f"✗ No files found for {component_name}")
+            return False
+            
+    except Exception as e:
+        print(f"✗ Error downloading {component_name}: {e}")
+        return False
+
+def main():
+    print(f"Downloading AI Elements components to {COMPONENTS_DIR}")
+    print(f"Components: {', '.join(COMPONENTS)}\n")
+    
+    # Create components directory
+    os.makedirs(COMPONENTS_DIR, exist_ok=True)
+    
+    success_count = 0
+    for component in COMPONENTS:
+        if download_component(component):
+            success_count += 1
+    
+    print(f"\n✓ Successfully downloaded {success_count}/{len(COMPONENTS)} components")
+    
+    if success_count < len(COMPONENTS):
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/scripts/sync-jupyter.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+# Copyright (c) 2025-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+# Sync local jupyter-ui packages to @datalayer/agent-runtimes node_modules
+# This script builds the local jupyter packages and copies their lib/ outputs
+# into the core package's node_modules for quick testing during development.
+#
+# Usage:
+#   ./sync-jupyter.sh          # Run once and exit
+#   ./sync-jupyter.sh --watch  # Watch for changes and auto-sync
+
+set -e
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Get the script directory and project root
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+CORE_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+JUPYTER_UI_ROOT="$( cd "$CORE_ROOT/../jupyter-ui" && pwd )"
+
+# Function to perform the sync
+sync_packages() {
+  echo -e "${BLUE}🔄 Syncing jupyter-ui packages to @datalayer/agent-runtimes...${NC}"
+
+  # Build jupyter-react FIRST (lexical depends on it)
+  echo -e "${BLUE}📦 Building @datalayer/jupyter-react...${NC}"
+  cd "$JUPYTER_UI_ROOT/packages/react"
+  echo -e "${YELLOW}[DEBUG] Current directory: $(pwd)${NC}"
+  rm -f tsconfig.tsbuildinfo
+  rm -rf lib
+  echo -e "${YELLOW}[DEBUG] Running gulp resources-to-lib...${NC}"
+  npx gulp resources-to-lib
+  echo -e "${YELLOW}[DEBUG] Running TypeScript...${NC}"
+  npx tsc --noEmitOnError false
+  TSC_EXIT=$?
+  echo -e "${YELLOW}[DEBUG] TypeScript exit code: $TSC_EXIT${NC}"
+  echo -e "${YELLOW}[DEBUG] Checking if lib exists...${NC}"
+  ls -la lib 2>&1 | head -5
+
+  # Verify lib was created
+  if [ ! -d "lib" ]; then
+    echo -e "${YELLOW}⚠️  lib directory was not created by TypeScript!${NC}"
+    exit 1
+  fi
+  echo -e "${YELLOW}[DEBUG] lib directory verified!${NC}"
+
+  # Copy react to core's node_modules for patch-package
+  echo -e "${BLUE}📋 Copying react to core/node_modules...${NC}"
+  cd "$CORE_ROOT"
+  # Only replace lib/ directory, preserving LICENSE, README.md, etc.
+  rm -rf node_modules/@datalayer/jupyter-react/lib
+  mkdir -p node_modules/@datalayer/jupyter-react/lib
+  cp -r "$JUPYTER_UI_ROOT/packages/react/lib/." node_modules/@datalayer/jupyter-react/lib/
+  cp "$JUPYTER_UI_ROOT/packages/react/package.json" node_modules/@datalayer/jupyter-react/
+
+  # Now build jupyter-lexical (finds react via workspace hoisting)
+  echo -e "${BLUE}📦 Building @datalayer/jupyter-lexical...${NC}"
+  cd "$JUPYTER_UI_ROOT/packages/lexical"
+  rm -f tsconfig.tsbuildinfo
+  rm -rf lib
+  echo -e "${YELLOW}[DEBUG] Running gulp resources-to-lib...${NC}"
+  npx gulp resources-to-lib
+  echo -e "${YELLOW}[DEBUG] Running TypeScript...${NC}"
+  npx tsc --noEmitOnError false
+
+  # Copy lexical to node_modules
+  echo -e "${BLUE}📋 Copying lexical to node_modules...${NC}"
+  cd "$CORE_ROOT"
+  # Only replace lib/ directory, preserving LICENSE, README.md, etc.
+  rm -rf node_modules/@datalayer/jupyter-lexical/lib
+  mkdir -p node_modules/@datalayer/jupyter-lexical/lib
+  cp -r "$JUPYTER_UI_ROOT/packages/lexical/lib/." node_modules/@datalayer/jupyter-lexical/lib/
+  cp "$JUPYTER_UI_ROOT/packages/lexical/package.json" node_modules/@datalayer/jupyter-lexical/
+
+  echo -e "${GREEN}✅ Successfully synced at $(date +"%H:%M:%S")${NC}"
+}
+
+# Check if watch mode is requested
+if [[ "$1" == "--watch" ]]; then
+  # Check if fswatch is installed
+  if ! command -v fswatch &> /dev/null; then
+    echo -e "${YELLOW}⚠️  fswatch not found. Installing via Homebrew...${NC}"
+    if command -v brew &> /dev/null; then
+      brew install fswatch
+    else
+      echo -e "${YELLOW}⚠️  Homebrew not found. Please install fswatch manually:${NC}"
+      echo -e "${YELLOW}    brew install fswatch${NC}"
+      echo -e "${YELLOW}    or visit: https://github.com/emcrisostomo/fswatch${NC}"
+      exit 1
+    fi
+  fi
+
+  echo -e "${BLUE}👁️  Watch mode enabled. Monitoring jupyter-ui packages for changes...${NC}"
+  echo -e "${YELLOW}📁 Watching:${NC}"
+  echo -e "${YELLOW}   - $JUPYTER_UI_ROOT/packages/lexical/src${NC}"
+  echo -e "${YELLOW}   - $JUPYTER_UI_ROOT/packages/react/src${NC}"
+  echo -e "${YELLOW}Press Ctrl+C to stop${NC}"
+  echo ""
+
+  # Initial sync
+  sync_packages
+
+  # Watch for changes in src directories and trigger sync
+  # Using fswatch with:
+  # -r: recursive
+  # -e: exclude patterns (node_modules, lib, etc.)
+  # -l 1: latency 1 second (debounce rapid changes)
+  fswatch -r -l 1 \
+    -e ".*" -i "\\.tsx?$" -i "\\.jsx?$" -i "\\.css$" \
+    "$JUPYTER_UI_ROOT/packages/lexical/src" \
+    "$JUPYTER_UI_ROOT/packages/react/src" | while read -r file; do
+    echo -e "\n${YELLOW}📝 Change detected in: $(basename "$file")${NC}"
+    sync_packages
+  done
+else
+  # Single run mode
+  sync_packages
+fi