@datalayer/agent-runtimes 1.0.9 → 1.0.17

package/lib/examples/AgentspecsExample.js

@@ -211,11 +211,11 @@ const resolveCloudRuntimeBaseUrlFromSpec = (spec) => {
         return null;
     }
     const preferredKeys = [
-        'runtimesRunUrl',
-        'runtimeRunUrl',
+        'runtimesUrl',
+        'runtimeUrl',
         'runtimes_url',
         'runtime_url',
-        'runUrl',
+        'datalayerUrl',
         'baseUrl',
         'endpoint',
     ];
@@ -298,13 +298,13 @@ githubClientId, kaggleToken, }) => {
     const { configuration } = useCoreStore();
     const { token } = useSimpleAuthStore();
     const cloudCatalogBaseUrl = useMemo(() => {
-        const configured = normalizeHttpUrl(configuration?.runtimesRunUrl);
+        const configured = normalizeHttpUrl(configuration?.runtimesUrl);
         const envConfigured = normalizeHttpUrl(import.meta.env.VITE_DATALAYER_AGENT_RUNTIMES_URL);
         if (configured && !isLocalhostUrl(configured)) {
             return configured;
         }
         return envConfigured || 'https://r1.datalayer.run';
-    }, [configuration?.runtimesRunUrl]);
+    }, [configuration?.runtimesUrl]);
     const isCloudMode = isCloudSpecSelection(selectedAgentId);
     const selectedSpec = selectedCloudSpec || selectedLibrarySpec;
     const cloudRuntimeCreationBaseUrl = useMemo(() => {
@@ -770,42 +770,64 @@ githubClientId, kaggleToken, }) => {
             const specId = isSpecSelection(selectedAgentId)
                 ? getSpecId(selectedAgentId)
                 : undefined;
-            const response = await fetch(`${baseUrl}/api/v1/agents`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    name: agentName,
-                    description: description || `Agent created via UI (${agentLibrary})`,
-                    goal: goal || undefined,
-                    agent_library: agentLibrary,
-                    transport: transport,
-                    model: model,
-                    system_prompt: systemPrompt || DEFAULT_SYSTEM_PROMPT,
-                    system_prompt_codemode_addons: systemPromptCodemodeAddons || undefined,
-                    tools: tools,
-                    sandbox_variant: sandboxVariant || undefined,
-                    enable_skills: enableSkills,
-                    enable_codemode: enableCodemode,
-                    allow_direct_tool_calls: allowDirectToolCalls,
-                    enable_tool_reranker: enableToolReranker,
-                    selected_mcp_servers: selectedMcpServers,
-                    skills: selectedSkills,
-                    jupyter_sandbox: useJupyterSandbox ? jupyterSandboxUrl : undefined,
-                    agent_spec: mergedSpecForLaunch,
-                    ...(specId ? { agent_spec_id: specId } : {}),
-                }),
-            });
-            if (!response.ok) {
-                const errorData = await response
-                    .json()
-                    .catch(() => ({ detail: 'Unknown error' }));
-                throw new Error(errorData.detail || `Failed to create agent: ${response.status}`);
+            const createRequestBody = {
+                name: agentName,
+                description: description || `Agent created via UI (${agentLibrary})`,
+                goal: goal || undefined,
+                agent_library: agentLibrary,
+                transport: transport,
+                model: model,
+                system_prompt: systemPrompt || DEFAULT_SYSTEM_PROMPT,
+                system_prompt_codemode_addons: systemPromptCodemodeAddons || undefined,
+                tools: tools,
+                sandbox_variant: sandboxVariant || undefined,
+                enable_skills: enableSkills,
+                enable_codemode: enableCodemode,
+                allow_direct_tool_calls: allowDirectToolCalls,
+                enable_tool_reranker: enableToolReranker,
+                selected_mcp_servers: selectedMcpServers,
+                skills: selectedSkills,
+                jupyter_sandbox: useJupyterSandbox ? jupyterSandboxUrl : undefined,
+                agent_spec: mergedSpecForLaunch,
+                ...(specId ? { agent_spec_id: specId } : {}),
+            };
+            const tryCreate = async () => {
+                const response = await fetch(`${baseUrl}/api/v1/agents`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(createRequestBody),
+                });
+                if (!response.ok) {
+                    const errorData = await response
+                        .json()
+                        .catch(() => ({ detail: 'Unknown error' }));
+                    throw new Error(errorData.detail || `Failed to create agent: ${response.status}`);
+                }
+                const data = await response.json();
+                console.log('[AgentRuntimeExample] Agent created:', data);
+                return data.id;
+            };
+            try {
+                return await tryCreate();
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to create agent';
+                const alreadyExists = /already exists/i.test(errorMessage);
+                // If the agent already exists, terminate (delete) it then retry once.
+                if (alreadyExists && agentName) {
+                    console.warn(`[AgentRuntimeExample] Agent '${agentName}' already exists, deleting and retrying create once.`);
+                    const deleteResponse = await fetch(`${baseUrl}/api/v1/agents/${encodeURIComponent(agentName)}`, {
+                        method: 'DELETE',
+                    });
+                    if (deleteResponse.ok) {
+                        return await tryCreate();
+                    }
+                    throw new Error(`Failed to delete existing agent '${agentName}' before retry: ${deleteResponse.status}`);
+                }
+                throw error;
             }
-            const data = await response.json();
-            console.log('[AgentRuntimeExample] Agent created:', data);
-            return data.id;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Failed to create agent';
@@ -1021,7 +1043,7 @@ githubClientId, kaggleToken, }) => {
                                                     showModelSelector: true,
                                                     showToolsMenu: true,
                                                     showSkillsMenu: true,
-                                                    showInformation: false,
+                                                    showInformation: true,
                                                     codemodeEnabled: enableCodemode,
                                                     initialModel: model,
                                                     mcpServers: selectedMcpServers,

package/lib/examples/ChatCustomExample.js

@@ -3,13 +3,13 @@ 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.
  */
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { useMemo } from 'react';
 import { Spinner, Text } from '@primer/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { Box } from '@datalayer/primer-addons';
 import { ThemedProvider } from './utils/themedProvider';
 import { uniqueAgentId } from './utils/agentId';
-import { useExampleAgentRuntimesUrl } from './utils/useExampleAgentRuntimesUrl';
+import { useExampleAgentRuntime } from './hooks/useExampleAgentRuntime';
 import { Chat } from '../chat';
 // Create a query client for React Query
 const queryClient = new QueryClient({
@@ -24,28 +24,24 @@ const queryClient = new QueryClient({
 });
 const AGENT_NAME = 'datalayer-assistant';
 /**
- * Hook to ensure the agent exists on the server
- * Creates the agent if it doesn't exist
+ * Agent Runtime Custom Example Component
+ *
+ * Demonstrates the unified Chat component with AG-UI transport
+ * and all necessary providers:
+ * - QueryClientProvider for data fetching
+ * - Auto-creates agent on the server if it doesn't exist
  */
-function useEnsureAgent(baseUrl) {
-    const agentName = useRef(uniqueAgentId(AGENT_NAME)).current;
-    const [agentId, setAgentId] = useState(null);
-    const [isLoading, setIsLoading] = useState(true);
-    const [error, setError] = useState(null);
-    const createAgent = useCallback(async () => {
-        try {
-            const response = await fetch(`${baseUrl}/api/v1/agents`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    name: agentName,
-                    description: 'Datalayer AI Assistant - Your helpful coding companion',
-                    agent_library: 'pydantic-ai',
-                    transport: 'ag-ui',
-                    model: 'openai:gpt-4o-mini',
-                    system_prompt: `You are custom chat assistant, a helpful AI assistant specialized in data science, Python programming, and Jupyter notebooks.
+const AgentRuntimeCustomExample = () => {
+    const agentName = useMemo(() => uniqueAgentId(AGENT_NAME), []);
+    const { agentId, status, error, isReady } = useExampleAgentRuntime({
+        exampleId: 'ChatCustomExample',
+        agentName,
+        agentConfig: {
+            description: 'Datalayer AI Assistant - Your helpful coding companion',
+            agentLibrary: 'pydantic-ai',
+            protocol: 'ag-ui',
+            model: 'bedrock:us.anthropic.claude-sonnet-4-5-20250929-v1:0',
+            systemPrompt: `You are custom chat assistant, a helpful AI assistant specialized in data science, Python programming, and Jupyter notebooks.
 
 You can help users with:
 - Writing and debugging Python code
@@ -55,60 +51,10 @@ You can help users with:
 - General programming questions
 
 Be concise, helpful, and provide working code examples when appropriate.`,
-                }),
-            });
-            if (!response.ok) {
-                const errorData = await response
-                    .json()
-                    .catch(() => ({ detail: 'Unknown error' }));
-                throw new Error(errorData.detail || `Failed to create agent: ${response.status}`);
-            }
-            const data = await response.json();
-            console.log('[AgentRuntimeCustomExample] Agent created:', data);
-            return data.id;
-        }
-        catch (err) {
-            console.error('[AgentRuntimeCustomExample] Error creating agent:', err);
-            throw err;
-        }
-    }, [agentName, baseUrl]);
-    const initAgent = useCallback(async () => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            console.log('[AgentRuntimeCustomExample] Creating new agent...');
-            const newAgentId = await createAgent();
-            if (newAgentId) {
-                setAgentId(newAgentId);
-            }
-            else {
-                setError('Failed to create agent');
-            }
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to initialize agent';
-            setError(errorMessage);
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [createAgent]);
-    useEffect(() => {
-        initAgent();
-    }, [initAgent]);
-    return { agentId, isLoading, error, retry: initAgent };
-}
-/**
- * Agent Runtime Custom Example Component
- *
- * Demonstrates the unified Chat component with AG-UI transport
- * and all necessary providers:
- * - QueryClientProvider for data fetching
- * - Auto-creates agent on the server if it doesn't exist
- */
-const AgentRuntimeCustomExample = () => {
-    const baseUrl = useExampleAgentRuntimesUrl();
-    const { agentId, isLoading, error, retry } = useEnsureAgent(baseUrl);
+        },
+    });
+    const isLoading = !isReady && status !== 'error';
+    const retry = () => window.location.reload();
     return (_jsx(QueryClientProvider, { client: queryClient, children: _jsx(ThemedProvider, { children: _jsxs(Box, { sx: {
                     display: 'flex',
                     flexDirection: 'column',

package/lib/examples/ChatExample.js

@@ -15,62 +15,31 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  *
  * Backend: POST /api/v1/agents  →  /api/v1/ag-ui/{agentId}/
  */
-import { useEffect, useState } from 'react';
+import { useMemo } from 'react';
 import { Text, Spinner } from '@primer/react';
 import { Box, setupPrimerPortals } from '@datalayer/primer-addons';
 import { ThemedProvider } from './utils/themedProvider';
 import { uniqueAgentId } from './utils/agentId';
 import { useExampleAgentRuntimesUrl } from './utils/useExampleAgentRuntimesUrl';
+import { useExampleAgentRuntime } from './hooks/useExampleAgentRuntime';
 import { ErrorView } from './components';
 import { Chat } from '../chat';
 setupPrimerPortals();
-const AGENT_SPEC_ID = 'example-simple';
+const AGENTSPEC_ID = 'example-simple';
 const AGENT_NAME = 'simple';
 const AgentRuntimeChatExample = () => {
     const baseUrl = useExampleAgentRuntimesUrl();
-    const [agentId, setAgentId] = useState(null);
-    const [error, setError] = useState(null);
-    const [isCreating, setIsCreating] = useState(true);
-    // Create the agent on mount — always create a fresh instance with a random
-    // slug so that each run starts with clean OTEL data.
-    useEffect(() => {
-        let cancelled = false;
-        const name = uniqueAgentId(AGENT_NAME);
-        const createAgent = async () => {
-            try {
-                const response = await fetch(`${baseUrl}/api/v1/agents`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        name,
-                        agent_spec_id: AGENT_SPEC_ID,
-                        transport: 'ag-ui',
-                    }),
-                });
-                if (!response.ok) {
-                    const data = await response
-                        .json()
-                        .catch(() => ({ detail: 'Unknown error' }));
-                    throw new Error(data.detail || `Failed to create agent: ${response.status}`);
-                }
-                const data = await response.json();
-                if (!cancelled) {
-                    setAgentId(data.id);
-                    setIsCreating(false);
-                }
-            }
-            catch (err) {
-                if (!cancelled) {
-                    setError(err instanceof Error ? err.message : 'Failed to create agent');
-                    setIsCreating(false);
-                }
-            }
-        };
-        createAgent();
-        return () => {
-            cancelled = true;
-        };
-    }, [baseUrl]);
+    const agentName = useMemo(() => uniqueAgentId(AGENT_NAME), []);
+    const { agentId, error, status, isReady } = useExampleAgentRuntime({
+        exampleId: 'ChatExample',
+        agentName,
+        specId: AGENTSPEC_ID,
+        agentConfig: {
+            protocol: 'ag-ui',
+            agentSpecId: AGENTSPEC_ID,
+        },
+    });
+    const isCreating = !isReady && status !== 'error';
     // Loading state while agent is being created
     if (isCreating) {
         return (_jsx(ThemedProvider, { children: _jsxs(Box, { sx: {
@@ -81,7 +50,7 @@ const AgentRuntimeChatExample = () => {
                     height: '100vh',
                     gap: 3,
                     bg: 'canvas.default',
-                }, children: [_jsx(Spinner, { size: "large" }), _jsxs(Text, { sx: { color: 'fg.muted' }, children: ["Creating agent from ", AGENT_SPEC_ID, "..."] })] }) }));
+                }, children: [_jsx(Spinner, { size: "large" }), _jsxs(Text, { sx: { color: 'fg.muted' }, children: ["Creating agent from ", AGENTSPEC_ID, "..."] })] }) }));
     }
     // Error state
     if (error || !agentId) {

package/lib/examples/LexicalAgentExample.js

@@ -42,16 +42,14 @@ import { ChatInlinePlugin } from '../lexical/ChatInlinePlugin';
 import { useChatInlineToolbarItems } from '../lexical/useChatInlineToolbarItems';
 import { useLexicalTools } from '../tools/adapters/agent-runtimes/lexicalHooks';
 import { editorConfig } from './lexical/editorConfig';
+import { useExampleAgentRuntimesUrl } from './utils/useExampleAgentRuntimesUrl';
+import { useExampleAgentRuntime } from './hooks/useExampleAgentRuntime';
 import { DEFAULT_MODEL } from '../specs';
 import '@datalayer/jupyter-lexical/style/index.css';
 import './lexical/lexical-theme.css';
 // Fixed lexical document ID
 const LEXICAL_ID = 'agui-lexical-example';
-// Base URL for agent-runtimes server
-const BASE_URL = 'http://localhost:8765';
 const AGENT_ID = 'lexical-agent-runtime-example';
-// Vercel AI endpoint for lexical operations
-const VERCEL_AI_ENDPOINT = `${BASE_URL}/api/v1/vercel-ai/${AGENT_ID}`;
 function getJupyterSandboxUrl(serviceManager) {
     const envUrl = import.meta.env.VITE_JUPYTER_SANDBOX_URL;
     if (envUrl) {
@@ -75,87 +73,6 @@ function getJupyterSandboxUrl(serviceManager) {
  * Hook to ensure the example-agent exists on the server.
  * Creates it if it doesn't exist.
  */
-function useEnsureAgent(agentId, baseUrl, jupyterSandboxUrl) {
-    const [isReady, setIsReady] = useState(false);
-    const [error, setError] = useState(null);
-    useEffect(() => {
-        let mounted = true;
-        async function ensureAgent() {
-            try {
-                if (!jupyterSandboxUrl) {
-                    if (mounted) {
-                        setError('Could not detect Jupyter server URL from Lexical service manager.');
-                        setIsReady(false);
-                    }
-                    return;
-                }
-                // Try to create the agent (will fail if already exists, which is fine)
-                const response = await fetch(`${baseUrl}/api/v1/agents`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify({
-                        name: agentId,
-                        description: 'Demo agent for lexical example',
-                        agent_library: 'pydantic-ai',
-                        transport: 'vercel-ai',
-                        model: DEFAULT_MODEL,
-                        system_prompt: 'You are a helpful AI assistant that helps users work with documents. You can help with writing, editing, and formatting content.',
-                        enable_codemode: false,
-                        sandbox_variant: 'jupyter',
-                        jupyter_sandbox: jupyterSandboxUrl,
-                    }),
-                });
-                if (mounted) {
-                    if (response.ok) {
-                        console.log(`[AgentRuntimeLexicalAgentExample] Created agent: ${agentId}`);
-                        setError(null);
-                        setIsReady(true);
-                    }
-                    else {
-                        const rawBody = await response.text().catch(() => '');
-                        let detail = rawBody;
-                        try {
-                            const parsed = rawBody ? JSON.parse(rawBody) : {};
-                            if (typeof parsed.detail === 'string' &&
-                                parsed.detail.length > 0) {
-                                detail = parsed.detail;
-                            }
-                        }
-                        catch {
-                            // Keep raw body as fallback detail.
-                        }
-                        const alreadyExists = response.status === 409 ||
-                            response.status === 400 ||
-                            /already exists/i.test(detail || '');
-                        if (alreadyExists) {
-                            console.log(`[AgentRuntimeLexicalAgentExample] Reusing existing agent: ${agentId}`);
-                            setError(null);
-                            setIsReady(true);
-                        }
-                        else {
-                            setError(detail || `Failed to create agent: ${response.status}`);
-                            setIsReady(false);
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                if (mounted) {
-                    console.error('[AgentRuntimeLexicalAgentExample] Error creating agent:', err);
-                    setError(err instanceof Error ? err.message : 'Failed to connect to server');
-                    setIsReady(false);
-                }
-            }
-        }
-        ensureAgent();
-        return () => {
-            mounted = false;
-        };
-    }, [agentId, baseUrl, jupyterSandboxUrl]);
-    return { isReady, error };
-}
 // import contentLexical from './lexicals/vscode.lexical';
 // const INITIAL_CONTENT = JSON.stringify(contentLexical);
 const INITIAL_CONTENT = undefined; // Use default empty document
@@ -228,7 +145,7 @@ function LexicalToolsPlugin({ onToolsReady, }) {
     }, [tools, onToolsReady]);
     return null;
 }
-const LexicalUI = React.memo(function LexicalUI({ content = INITIAL_CONTENT, serviceManager, onToolsReady, }) {
+const LexicalUI = React.memo(function LexicalUI({ content = INITIAL_CONTENT, serviceManager, endpoint, onToolsReady, }) {
     const [floatingAnchorElem, setFloatingAnchorElem] = useState(null);
     const [_isLinkEditMode, setIsLinkEditMode] = useState(false);
     // AI actions registered as toolbar items via the primer-addons toolbar extensibility
@@ -261,13 +178,48 @@ const LexicalUI = React.memo(function LexicalUI({ content = INITIAL_CONTENT, ser
                     minHeight: '600px',
                 }, children: _jsxs(LexicalConfigProvider, { lexicalId: LEXICAL_ID, serviceManager: serviceManager, children: [_jsx(LexicalToolsPlugin, { onToolsReady: onToolsReady }), _jsx(LexicalComposer, { initialConfig: editorConfig, children: _jsxs("div", { className: "lexical-editor-inner", ref: onRef, children: [_jsx(LexicalStatePlugin, {}), _jsx(RichTextPlugin, { contentEditable: _jsx(ContentEditable, { className: "lexical-editor-content", "aria-label": "Lexical Editor" }), ErrorBoundary: LexicalErrorBoundary }), _jsx(OnChangePlugin, { onChange: handleChange }), _jsx(HistoryPlugin, {}), _jsx(AutoFocusPlugin, {}), _jsx(ListPlugin, {}), _jsx(CheckListPlugin, {}), _jsx(LinkPlugin, {}), _jsx(AutoLinkPlugin, {}), _jsx(ListMaxIndentLevelPlugin, { maxDepth: 7 }), _jsx(MarkdownShortcutPlugin, { transformers: TRANSFORMERS }), _jsx(LoadContentPlugin, { content: content }), _jsx(CodeHighlightPlugin, {}), _jsx(ImagesPlugin, { captionsEnabled: false }), _jsx(HorizontalRulePlugin, {}), _jsx(EquationsPlugin, {}), _jsx(YouTubePlugin, {}), _jsx(ExcalidrawPlugin, {}), _jsx(CollapsiblePlugin, {}), _jsx(AutoEmbedPlugin, {}), _jsx(TablePlugin, {}), _jsx(TableCellResizerPlugin, {}), _jsx(JupyterCellPlugin, {}), _jsx(ThemedJupyterProvider, { children: _jsx(SimpleKernelPluginsInner, { serviceManager: serviceManager }) }), floatingAnchorElem && (_jsxs(_Fragment, { children: [_jsx(DraggableBlockPlugin, { anchorElem: floatingAnchorElem }), _jsx(FloatingTextFormatToolbarPlugin, { anchorElem: floatingAnchorElem, setIsLinkEditMode: setIsLinkEditMode, extraItems: toolbarItems }), _jsx(CodeActionMenuPlugin, { anchorElem: floatingAnchorElem })] })), _jsx(ChatInlinePlugin, { protocol: {
                                             type: 'vercel-ai',
-                                            endpoint: VERCEL_AI_ENDPOINT,
+                                            endpoint,
                                         }, isOpen: isAiOpen, onClose: closeAi, pendingPrompt: pendingPrompt, onPendingPromptConsumed: clearPendingPrompt })] }) })] }) })] }));
 });
 function LexicalWithChat({ content, serviceManager, }) {
+    const baseUrl = useExampleAgentRuntimesUrl();
+    const vercelAiEndpoint = `${baseUrl}/api/v1/vercel-ai/${AGENT_ID}`;
+    const [createRequested, setCreateRequested] = useState(false);
     const jupyterSandboxUrl = useMemo(() => getJupyterSandboxUrl(serviceManager), [serviceManager]);
-    // Ensure the agent exists before rendering chat
-    const { isReady, error } = useEnsureAgent(AGENT_ID, BASE_URL, jupyterSandboxUrl);
+    const { agentId, isReady, status, error, createAgent } = useExampleAgentRuntime({
+        exampleId: 'LexicalAgentExample',
+        agentName: AGENT_ID,
+        autoCreateAgent: false,
+        agentConfig: {
+            name: AGENT_ID,
+            description: 'Demo agent for lexical example',
+            protocol: 'vercel-ai',
+            model: DEFAULT_MODEL,
+            systemPrompt: 'You are a helpful AI assistant that helps users work with documents. You can help with writing, editing, and formatting content.',
+            enableCodemode: false,
+            sandboxVariant: 'jupyter',
+            jupyterSandbox: jupyterSandboxUrl,
+        },
+    });
+    useEffect(() => {
+        if (!jupyterSandboxUrl || createRequested || agentId) {
+            return;
+        }
+        setCreateRequested(true);
+        void createAgent({
+            name: AGENT_ID,
+            description: 'Demo agent for lexical example',
+            protocol: 'vercel-ai',
+            model: DEFAULT_MODEL,
+            systemPrompt: 'You are a helpful AI assistant that helps users work with documents. You can help with writing, editing, and formatting content.',
+            enableCodemode: false,
+            sandboxVariant: 'jupyter',
+            jupyterSandbox: jupyterSandboxUrl,
+        }).catch(() => {
+            setCreateRequested(false);
+        });
+    }, [jupyterSandboxUrl, createRequested, agentId, createAgent]);
+    const effectiveReady = isReady || status === 'ready';
     // State to hold tools - populated by LexicalToolsPlugin inside the context
     const [tools, setTools] = useState([]);
     // Stable callback for receiving tools from LexicalToolsPlugin
@@ -284,7 +236,7 @@ function LexicalWithChat({ content, serviceManager, }) {
             width: '100vw',
             display: 'flex',
             overflow: 'hidden',
-        }, children: [_jsx(LexicalUI, { content: content, serviceManager: serviceManager, onToolsReady: handleToolsReady }), error && (_jsxs(Box, { sx: {
+        }, children: [_jsx(LexicalUI, { content: content, serviceManager: serviceManager, endpoint: vercelAiEndpoint, onToolsReady: handleToolsReady }), error && (_jsxs(Box, { sx: {
                     position: 'fixed',
                     bottom: 20,
                     right: 20,
@@ -293,7 +245,7 @@ function LexicalWithChat({ content, serviceManager, }) {
                     color: 'danger.fg',
                     borderRadius: 2,
                     maxWidth: 300,
-                }, children: [_jsx("strong", { children: "Error:" }), " ", error] })), isReady && (_jsx(ChatFloating, { protocol: "vercel-ai", endpoint: VERCEL_AI_ENDPOINT, title: "Lexical AI Agent Runtime", description: "Hi! I can help you edit documents. Try: 'Insert a heading', 'Add a code block', or 'Create a list'", defaultOpen: true, defaultViewMode: "panel", position: "bottom-right", frontendTools: tools, useStore: false, showModelSelector: true, showToolsMenu: true, showSkillsMenu: true, suggestions: [
+                }, children: [_jsx("strong", { children: "Error:" }), " ", error] })), effectiveReady && (_jsx(ChatFloating, { protocol: "vercel-ai", endpoint: vercelAiEndpoint, title: "Lexical AI Agent Runtime", description: "Hi! I can help you edit documents. Try: 'Insert a heading', 'Add a code block', or 'Create a list'", defaultOpen: true, defaultViewMode: "panel", position: "bottom-right", frontendTools: tools, useStore: false, showModelSelector: true, showToolsMenu: true, showSkillsMenu: true, suggestions: [
                     {
                         title: 'Insert heading',
                         message: 'Insert a heading that says "Welcome"',