@datalayer/agent-runtimes 1.0.2 → 1.0.4

package/lib/renderers/a2ui/index.js

@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2025-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/*
- Copyright 2025 Google LLC
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
- */
-export { A2UIProvider, useA2UIContext } from './context/A2UIContext.js';
-export { ThemeProvider, useTheme, defaultTheme, } from './context/ThemeContext.js';
-export { useA2UI } from './hooks/useA2UI.js';
-export { useDataBinding } from './hooks/useDataBinding.js';
-export { A2UIRenderer } from './components/A2UIRenderer.js';
-export * from './components/index.js';
-export * from './types/index.js';
-export { cn, classMapToString } from './lib/utils.js';
-export { Data, Types, Primitives } from '@a2ui/lit/0.8';

package/lib/renderers/a2ui/lib/utils.d.ts

@@ -1,11 +0,0 @@
-import { type ClassValue } from "clsx";
-/**
- * Utility function to merge Tailwind CSS classes.
- * Combines clsx for conditional classes with tailwind-merge to handle conflicts.
- */
-export declare function cn(...inputs: ClassValue[]): string;
-/**
- * Converts a Record<string, boolean> (class map) to a className string.
- * This is used to convert Lit-style class maps to React className strings.
- */
-export declare function classMapToString(classMap: Record<string, boolean>): string;

package/lib/renderers/a2ui/lib/utils.js

@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2025-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/*
- Copyright 2025 Google LLC
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
- */
-import clsx from "clsx";
-import { twMerge } from "tailwind-merge";
-/**
- * Utility function to merge Tailwind CSS classes.
- * Combines clsx for conditional classes with tailwind-merge to handle conflicts.
- */
-export function cn(...inputs) {
-    return twMerge(clsx(inputs));
-}
-/**
- * Converts a Record<string, boolean> (class map) to a className string.
- * This is used to convert Lit-style class maps to React className strings.
- */
-export function classMapToString(classMap) {
-    return Object.entries(classMap)
-        .filter(([, enabled]) => enabled)
-        .map(([className]) => className)
-        .join(" ");
-}

package/lib/renderers/a2ui/types/index.d.ts

@@ -1,17 +0,0 @@
-import { Types } from '@a2ui/lit/0.8';
-export type MessageProcessor = Types.MessageProcessor;
-export type Theme = Types.Theme;
-export type Surface = Types.Surface;
-export type AnyComponentNode = Types.AnyComponentNode;
-export type ServerToClientMessage = Types.ServerToClientMessage;
-export type DataValue = Types.DataValue;
-export interface A2UIComponentProps {
-    node: Types.AnyComponentNode;
-    surfaceId: string;
-}
-export interface A2UIActionEvent {
-    type: 'a2ui.action';
-    actionId: string;
-    context: Record<string, unknown>;
-}
-export type SendActionCallback = (action: A2UIActionEvent) => void;

package/lib/runtime/index.d.ts

@@ -1,38 +0,0 @@
-/**
- * Runtime management module for agent-runtimes.
- *
- * Provides a Zustand store and hooks for launching and managing cloud runtimes
- * with integrated AI agent support.
- *
- * @module runtime
- *
- * @example
- * ```typescript
- * import { useRuntimeStore, useRuntime, useAgent } from '@datalayer/agent-runtimes/lib/runtime';
- *
- * // Launch a new runtime
- * const { launchRuntime, createAgent } = useRuntimeStore();
- * const runtime = await launchRuntime({ environmentName: 'python-simple', creditsLimit: 100 });
- * const agent = await createAgent({ model: 'anthropic:claude-sonnet-4-5' });
- *
- * // Use in ChatFloating
- * <ChatFloating endpoint={agent.endpoint} />
- *
- * // Or connect to an existing runtime
- * const { connectToRuntime } = useRuntimeStore();
- * connectToRuntime({
- *   podName: 'my-pod',
- *   environmentName: 'python-simple',
- *   serviceManager: myServiceManager,
- * });
- * ```
- */
-export { useRuntimeStore, useRuntime, useAgent, useRuntimeStatus, useRuntimeError, useIsLaunching, getRuntimeState, subscribeToRuntime, } from './runtimeStore';
-export type { RuntimeStore, RuntimeStoreState, RuntimeStoreActions, } from './runtimeStore';
-export { useAgentConnection } from './useAgentConnection';
-export type { UseAgentConnectionReturn, UseAgentConnectionOptions, } from './useAgentConnection';
-export { useAgentRuntime } from './useAgentRuntime';
-export type { UseAgentRuntimeReturn, UseAgentRuntimeOptions, } from './useAgentRuntime';
-export type { IRuntimeLocation, IRuntimeType, IRuntimeCapabilities, IRuntimePod, IRuntimeOptions, IRuntimeDesc, } from './types';
-export type { RuntimeConnection, AgentRuntimeStatus as RuntimeStatus, AgentConfig, AgentConnection, AgentRuntimeState, } from './types';
-export { DEFAULT_AGENT_CONFIG } from './types';

package/lib/runtime/index.js

@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2025-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/**
- * Runtime management module for agent-runtimes.
- *
- * Provides a Zustand store and hooks for launching and managing cloud runtimes
- * with integrated AI agent support.
- *
- * @module runtime
- *
- * @example
- * ```typescript
- * import { useRuntimeStore, useRuntime, useAgent } from '@datalayer/agent-runtimes/lib/runtime';
- *
- * // Launch a new runtime
- * const { launchRuntime, createAgent } = useRuntimeStore();
- * const runtime = await launchRuntime({ environmentName: 'python-simple', creditsLimit: 100 });
- * const agent = await createAgent({ model: 'anthropic:claude-sonnet-4-5' });
- *
- * // Use in ChatFloating
- * <ChatFloating endpoint={agent.endpoint} />
- *
- * // Or connect to an existing runtime
- * const { connectToRuntime } = useRuntimeStore();
- * connectToRuntime({
- *   podName: 'my-pod',
- *   environmentName: 'python-simple',
- *   serviceManager: myServiceManager,
- * });
- * ```
- */
-// Zustand store
-export { useRuntimeStore, useRuntime, useAgent, useRuntimeStatus, useRuntimeError, useIsLaunching, getRuntimeState, subscribeToRuntime, } from './runtimeStore';
-// Hooks
-export { useAgentConnection } from './useAgentConnection';
-export { useAgentRuntime } from './useAgentRuntime';
-// Constants
-export { DEFAULT_AGENT_CONFIG } from './types';

package/lib/runtime/runtimeStore.d.ts

@@ -1,76 +0,0 @@
-import type { ServiceManager } from '@jupyterlab/services';
-import type { IRuntimeOptions, RuntimeConnection, AgentRuntimeStatus, AgentConfig, AgentConnection } from './types';
-/**
- * Runtime store state interface.
- */
-export interface RuntimeStoreState {
-    /** Current runtime connection */
-    runtime: RuntimeConnection | null;
-    /** Current agent connection */
-    agent: AgentConnection | null;
-    /** Current status */
-    status: AgentRuntimeStatus;
-    /** Error message if any */
-    error: string | null;
-    /** Whether a launch is in progress */
-    isLaunching: boolean;
-}
-/**
- * Runtime store actions interface.
- */
-export interface RuntimeStoreActions {
-    /** Launch a new runtime */
-    launchRuntime: (options: IRuntimeOptions) => Promise<RuntimeConnection>;
-    /** Connect to an existing runtime */
-    connectToRuntime: (connection: {
-        podName: string;
-        environmentName: string;
-        serviceManager: ServiceManager.IManager;
-        kernelId?: string;
-    }) => void;
-    /** Create an agent on the current runtime */
-    createAgent: (config?: AgentConfig) => Promise<AgentConnection>;
-    /** Disconnect from the current runtime */
-    disconnect: () => void;
-    /** Clear any errors */
-    clearError: () => void;
-    /** Set error */
-    setError: (error: string) => void;
-    /** Reset store to initial state */
-    reset: () => void;
-}
-export type RuntimeStore = RuntimeStoreState & RuntimeStoreActions;
-/**
- * Zustand store for runtime management.
- *
- * @example
- * ```typescript
- * import { useRuntimeStore } from '@datalayer/agent-runtimes/lib/runtime';
- *
- * // In a component
- * const { runtime, launchRuntime, status } = useRuntimeStore();
- *
- * // Launch a runtime
- * await launchRuntime({ environmentName: 'python-simple', creditsLimit: 100 });
- *
- * // Access runtime info
- * console.log(runtime?.agentBaseUrl);
- * ```
- */
-export declare const useRuntimeStore: import("zustand").UseBoundStore<import("zustand").StoreApi<RuntimeStore>>;
-/**
- * Selector hooks for common use cases.
- */
-export declare const useRuntime: () => RuntimeConnection | null;
-export declare const useAgent: () => AgentConnection | null;
-export declare const useRuntimeStatus: () => AgentRuntimeStatus;
-export declare const useRuntimeError: () => string | null;
-export declare const useIsLaunching: () => boolean;
-/**
- * Get runtime store state without React (for use outside components).
- */
-export declare const getRuntimeState: () => RuntimeStore;
-/**
- * Subscribe to runtime store changes (for use outside React).
- */
-export declare const subscribeToRuntime: (listener: (state: RuntimeStore, prevState: RuntimeStore) => void) => () => void;

package/lib/runtime/runtimeStore.js

@@ -1,184 +0,0 @@
-/*
- * Copyright (c) 2025-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/**
- * Zustand store for runtime management.
- *
- * Provides a global store for managing cloud runtimes and agent connections.
- *
- * @module runtime/runtimeStore
- */
-import { create } from 'zustand';
-const initialState = {
-    runtime: null,
-    agent: null,
-    status: 'idle',
-    error: null,
-    isLaunching: false,
-};
-/**
- * Create an agent on a runtime.
- */
-async function createAgentOnRuntime(agentBaseUrl, agentId, config = {}) {
-    const response = await fetch(`${agentBaseUrl}/api/v1/agents`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            name: config.name || agentId,
-            description: config.description || 'AI assistant',
-            agent_library: config.agentLibrary || 'pydantic-ai',
-            transport: config.transport || 'ag-ui',
-            model: config.model || 'anthropic:claude-sonnet-4-5',
-            system_prompt: config.systemPrompt || 'You are a helpful AI assistant.',
-        }),
-    });
-    if (response.ok || response.status === 400) {
-        // 400 means agent already exists, which is fine
-        const endpoint = `${agentBaseUrl}/api/v1/ag-ui/${agentId}/`;
-        return {
-            agentId,
-            endpoint,
-            isReady: true,
-        };
-    }
-    const errorData = await response.json().catch(() => ({}));
-    throw new Error(errorData.detail || `Failed to create agent: ${response.status}`);
-}
-/**
- * Zustand store for runtime management.
- *
- * @example
- * ```typescript
- * import { useRuntimeStore } from '@datalayer/agent-runtimes/lib/runtime';
- *
- * // In a component
- * const { runtime, launchRuntime, status } = useRuntimeStore();
- *
- * // Launch a runtime
- * await launchRuntime({ environmentName: 'python-simple', creditsLimit: 100 });
- *
- * // Access runtime info
- * console.log(runtime?.agentBaseUrl);
- * ```
- */
-export const useRuntimeStore = create((set, get) => ({
-    ...initialState,
-    connectToRuntime: connection => {
-        const baseUrl = connection.serviceManager.serverSettings.baseUrl;
-        const agentBaseUrl = baseUrl.replace('/jupyter/server/', '/agent-runtimes/');
-        const fullConnection = {
-            podName: connection.podName,
-            environmentName: connection.environmentName,
-            jupyterBaseUrl: baseUrl,
-            agentBaseUrl,
-            serviceManager: connection.serviceManager,
-            status: 'ready',
-            kernelId: connection.kernelId,
-        };
-        set({
-            runtime: fullConnection,
-            status: 'ready',
-            error: null,
-        });
-    },
-    launchRuntime: async (config) => {
-        set({ status: 'launching', error: null, isLaunching: true });
-        try {
-            // Import @datalayer/core dynamically to avoid circular dependencies
-            const { createRuntime, makeDatalayerSettings } = await import('@datalayer/core/lib/api');
-            const { ServiceManager } = await import('@jupyterlab/services');
-            // Create the runtime using IRuntimeOptions from @datalayer/core
-            const runtimePod = await createRuntime({
-                environmentName: config.environmentName,
-                creditsLimit: config.creditsLimit,
-                type: config.type || 'notebook',
-                givenName: config.givenName,
-                capabilities: config.capabilities,
-                snapshot: config.snapshot,
-            });
-            set({ status: 'connecting' });
-            // Create service manager for the runtime
-            const serverSettings = makeDatalayerSettings(runtimePod.ingress, runtimePod.token);
-            const serviceManager = new ServiceManager({ serverSettings });
-            // Wait for the service manager to be ready
-            await serviceManager.ready;
-            // Construct URLs
-            const jupyterBaseUrl = serverSettings.baseUrl;
-            const agentBaseUrl = jupyterBaseUrl.replace('/jupyter/server/', '/agent-runtimes/');
-            const connection = {
-                podName: runtimePod.pod_name,
-                environmentName: runtimePod.environment_name,
-                jupyterBaseUrl,
-                agentBaseUrl,
-                serviceManager,
-                status: 'ready',
-            };
-            set({
-                runtime: connection,
-                status: 'ready',
-                isLaunching: false,
-            });
-            return connection;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to launch runtime';
-            set({
-                status: 'error',
-                error: errorMessage,
-                isLaunching: false,
-            });
-            throw err;
-        }
-    },
-    createAgent: async (config = {}) => {
-        const { runtime } = get();
-        if (!runtime) {
-            throw new Error('No runtime connected. Launch or connect to a runtime first.');
-        }
-        try {
-            const agentId = config.name || runtime.podName;
-            const agentConnection = await createAgentOnRuntime(runtime.agentBaseUrl, agentId, config);
-            set({ agent: agentConnection });
-            return agentConnection;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to create agent';
-            set({ error: errorMessage });
-            throw err;
-        }
-    },
-    disconnect: () => {
-        set({
-            runtime: null,
-            agent: null,
-            status: 'disconnected',
-            error: null,
-        });
-    },
-    clearError: () => {
-        set({ error: null });
-    },
-    setError: error => {
-        set({ error, status: 'error' });
-    },
-    reset: () => {
-        set(initialState);
-    },
-}));
-/**
- * Selector hooks for common use cases.
- */
-export const useRuntime = () => useRuntimeStore(state => state.runtime);
-export const useAgent = () => useRuntimeStore(state => state.agent);
-export const useRuntimeStatus = () => useRuntimeStore(state => state.status);
-export const useRuntimeError = () => useRuntimeStore(state => state.error);
-export const useIsLaunching = () => useRuntimeStore(state => state.isLaunching);
-/**
- * Get runtime store state without React (for use outside components).
- */
-export const getRuntimeState = () => useRuntimeStore.getState();
-/**
- * Subscribe to runtime store changes (for use outside React).
- */
-export const subscribeToRuntime = useRuntimeStore.subscribe;

package/lib/runtime/types.d.ts

@@ -1,84 +0,0 @@
-/**
- * Type definitions for runtime management.
- *
- * Re-exports relevant types from @datalayer/core and defines
- * agent-runtimes specific types for AI agent management.
- *
- * @module runtime/types
- */
-import type { ServiceManager } from '@jupyterlab/services';
-export type { IRuntimeLocation, IRuntimeType, IRuntimeCapabilities, IRuntimePod, IRuntimeDesc, } from '@datalayer/core/lib/models';
-export type { IRuntimeOptions } from '@datalayer/core/lib/stateful/runtimes/apis';
-/**
- * Runtime connection status for the agent-runtimes store.
- */
-export type AgentRuntimeStatus = 'idle' | 'launching' | 'connecting' | 'ready' | 'error' | 'disconnected';
-/**
- * Information about a connected runtime with agent-runtimes server.
- * Extends the basic runtime info with URLs for both Jupyter and agent services.
- */
-export interface RuntimeConnection {
-    /** Runtime pod name (unique identifier) */
-    podName: string;
-    /** Environment name */
-    environmentName: string;
-    /** Base URL for the Jupyter server */
-    jupyterBaseUrl: string;
-    /** Base URL for the agent-runtimes server */
-    agentBaseUrl: string;
-    /** JupyterLab ServiceManager for the runtime */
-    serviceManager: ServiceManager.IManager;
-    /** Runtime status */
-    status: AgentRuntimeStatus;
-    /** Kernel ID if connected */
-    kernelId?: string;
-}
-/**
- * Configuration for creating an agent on a runtime.
- */
-export interface AgentConfig {
-    /** Agent name/ID (defaults to runtime pod name) */
-    name?: string;
-    /** Agent description */
-    description?: string;
-    /** AI model to use (e.g., 'anthropic:claude-sonnet-4-5') */
-    model?: string;
-    /** System prompt for the agent */
-    systemPrompt?: string;
-    /** Agent library (defaults to 'pydantic-ai') */
-    agentLibrary?: 'pydantic-ai' | 'langchain' | 'openai';
-    /** Transport protocol (defaults to 'ag-ui') */
-    transport?: 'ag-ui' | 'vercel-ai' | 'acp' | 'a2a';
-}
-/**
- * Information about a connected agent.
- */
-export interface AgentConnection {
-    /** Agent ID */
-    agentId: string;
-    /** Full endpoint URL for the agent */
-    endpoint: string;
-    /** Whether the agent is ready to use */
-    isReady: boolean;
-}
-/**
- * Complete state for an agent runtime in the Zustand store.
- */
-export interface AgentRuntimeState {
-    /** Runtime connection (null if not connected) */
-    runtime: RuntimeConnection | null;
-    /** Agent connection (null if not created) */
-    agent: AgentConnection | null;
-    /** Current status */
-    status: AgentRuntimeStatus;
-    /** Error message if any */
-    error: string | null;
-    /** Whether the runtime is launching */
-    isLaunching: boolean;
-    /** Whether the agent is ready */
-    isReady: boolean;
-}
-/**
- * Default agent configuration values.
- */
-export declare const DEFAULT_AGENT_CONFIG: Required<AgentConfig>;

package/lib/runtime/useAgentConnection.d.ts

@@ -1,45 +0,0 @@
-import type { AgentConfig, AgentConnection } from './types';
-export interface UseAgentConnectionOptions {
-    /** Agent configuration */
-    config?: AgentConfig;
-    /** Auto-create agent when runtime is ready */
-    autoCreate?: boolean;
-}
-export interface UseAgentConnectionReturn {
-    /** Current agent connection */
-    agent: AgentConnection | null;
-    /** Whether the agent is ready */
-    isReady: boolean;
-    /** Whether agent creation is in progress */
-    isCreating: boolean;
-    /** Error message if any */
-    error: string | null;
-    /** Create an agent on the runtime */
-    create: (config?: AgentConfig) => Promise<AgentConnection>;
-}
-/**
- * Hook for creating and managing agent connections.
- * Uses the Zustand store for runtime state.
- *
- * @param options - Configuration options
- * @returns Agent state and control functions
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { runtime } = useRuntimeStore();
- *   const { agent, isReady } = useAgentConnection({
- *     autoCreate: true,
- *     config: {
- *       model: 'anthropic:claude-sonnet-4-5',
- *       systemPrompt: 'You are a helpful assistant.',
- *     },
- *   });
- *
- *   if (!isReady) return <div>Creating agent...</div>;
- *
- *   return <ChatFloating endpoint={agent.endpoint} />;
- * }
- * ```
- */
-export declare function useAgentConnection(options?: UseAgentConnectionOptions): UseAgentConnectionReturn;

package/lib/runtime/useAgentConnection.js

@@ -1,112 +0,0 @@
-/*
- * Copyright (c) 2025-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/**
- * Hook for creating and managing agent connections on a runtime.
- *
- * @module runtime/useAgentConnection
- */
-import { useState, useCallback, useEffect, useRef } from 'react';
-import { useRuntimeStore } from './runtimeStore';
-const DEFAULT_AGENT_CONFIG = {
-    model: 'anthropic:claude-sonnet-4-5',
-    systemPrompt: 'You are a helpful AI assistant.',
-    agentLibrary: 'pydantic-ai',
-    transport: 'ag-ui',
-};
-/**
- * Hook for creating and managing agent connections.
- * Uses the Zustand store for runtime state.
- *
- * @param options - Configuration options
- * @returns Agent state and control functions
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { runtime } = useRuntimeStore();
- *   const { agent, isReady } = useAgentConnection({
- *     autoCreate: true,
- *     config: {
- *       model: 'anthropic:claude-sonnet-4-5',
- *       systemPrompt: 'You are a helpful assistant.',
- *     },
- *   });
- *
- *   if (!isReady) return <div>Creating agent...</div>;
- *
- *   return <ChatFloating endpoint={agent.endpoint} />;
- * }
- * ```
- */
-export function useAgentConnection(options = {}) {
-    const { config, autoCreate = false } = options;
-    const runtime = useRuntimeStore(state => state.runtime);
-    const storeAgent = useRuntimeStore(state => state.agent);
-    const createStoreAgent = useRuntimeStore(state => state.createAgent);
-    const [isCreating, setIsCreating] = useState(false);
-    const [error, setError] = useState(null);
-    const creatingRef = useRef(false);
-    const createdForRuntimeRef = useRef(null);
-    const create = useCallback(async (overrideConfig) => {
-        if (!runtime) {
-            throw new Error('No runtime connected. Launch or connect to a runtime first.');
-        }
-        if (creatingRef.current) {
-            throw new Error('Agent creation already in progress');
-        }
-        creatingRef.current = true;
-        setIsCreating(true);
-        setError(null);
-        try {
-            // Merge configs: defaults < options.config < overrideConfig
-            const mergedConfig = {
-                ...DEFAULT_AGENT_CONFIG,
-                ...config,
-                ...overrideConfig,
-                name: overrideConfig?.name || config?.name || runtime.podName,
-            };
-            const agentConnection = await createStoreAgent(mergedConfig);
-            createdForRuntimeRef.current = runtime.podName;
-            return agentConnection;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to create agent';
-            setError(errorMessage);
-            throw err;
-        }
-        finally {
-            creatingRef.current = false;
-            setIsCreating(false);
-        }
-    }, [runtime, config, createStoreAgent]);
-    // Auto-create agent when runtime is ready (and not already created for this runtime)
-    useEffect(() => {
-        if (autoCreate &&
-            runtime &&
-            runtime.status === 'ready' &&
-            !storeAgent &&
-            !creatingRef.current) {
-            // Only create if we haven't already created for this runtime
-            if (createdForRuntimeRef.current !== runtime.podName) {
-                create().catch(err => {
-                    console.error('[useAgentConnection] Auto-create failed:', err);
-                });
-            }
-        }
-    }, [autoCreate, runtime, storeAgent, create]);
-    // Reset created tracking when runtime changes
-    useEffect(() => {
-        if (!runtime) {
-            createdForRuntimeRef.current = null;
-        }
-    }, [runtime]);
-    return {
-        agent: storeAgent,
-        isReady: !!storeAgent?.isReady,
-        isCreating,
-        error,
-        create,
-    };
-}