@mcp-ts/sdk 1.3.7 → 1.3.10

package/src/client/core/types.ts

@@ -1,31 +1,31 @@
-import { SessionListResult } from '../../shared/types';
-
-/**
- * Abstraction layer for the AppHost's network communication.
- * 
- * This interface decouples the `AppHost` from the concrete networking implementation (like `SSEClient`).
- * Implementation can be:
- * 1. `SSEClient`: Direct connection to MCP Server (Browser -> Server).
- * 2. `ProxyClient`: Connection via an intermediary API (Browser -> Next.js API -> Server).
- */
-export interface AppHostClient {
-    /**
-     * Check if the client is connected
-     */
-    isConnected(): boolean;
-
-    /**
-     * Get list of active sessions
-     */
-    getSessions(): Promise<SessionListResult>;
-
-    /**
-     * Call a tool on a specific session
-     */
-    callTool(sessionId: string, toolName: string, toolArgs: Record<string, unknown>): Promise<unknown>;
-
-    /**
-     * Read a resource from a specific session
-     */
-    readResource(sessionId: string, uri: string): Promise<unknown>;
-}
+import { SessionListResult } from '../../shared/types';
+
+/**
+ * Abstraction layer for the AppHost's network communication.
+ * 
+ * This interface decouples the `AppHost` from the concrete networking implementation (like `SSEClient`).
+ * Implementation can be:
+ * 1. `SSEClient`: Direct connection to MCP Server (Browser -> Server).
+ * 2. `ProxyClient`: Connection via an intermediary API (Browser -> Next.js API -> Server).
+ */
+export interface AppHostClient {
+    /**
+     * Check if the client is connected
+     */
+    isConnected(): boolean;
+
+    /**
+     * Get list of active sessions
+     */
+    getSessions(): Promise<SessionListResult>;
+
+    /**
+     * Call a tool on a specific session
+     */
+    callTool(sessionId: string, toolName: string, toolArgs: Record<string, unknown>): Promise<unknown>;
+
+    /**
+     * Read a resource from a specific session
+     */
+    readResource(sessionId: string, uri: string): Promise<unknown>;
+}

package/src/client/index.ts

@@ -1,27 +1,27 @@
-/**
- * MCP Redis Client Package
- * Browser/React client-side exports for MCP connection management
- */
-
-/** SSE client for real-time connections */
-export { SSEClient, type SSEClientOptions } from './core/sse-client';
-export { AppHost } from './core/app-host';
-
-
-
-/** Re-export shared types */
-export type {
-  McpConnectionEvent,
-  McpConnectionState,
-  McpObservabilityEvent,
-  Emitter,
-  Disposable,
-  Event,
-  DisposableStore,
-} from '../shared/events';
-
-export type {
-  ToolInfo,
-  McpRpcRequest,
-  McpRpcResponse,
-} from '../shared/types';
+/**
+ * MCP Redis Client Package
+ * Browser/React client-side exports for MCP connection management
+ */
+
+/** SSE client for real-time connections */
+export { SSEClient, type SSEClientOptions } from './core/sse-client';
+export { AppHost } from './core/app-host';
+
+
+
+/** Re-export shared types */
+export type {
+  McpConnectionEvent,
+  McpConnectionState,
+  McpObservabilityEvent,
+  Emitter,
+  Disposable,
+  Event,
+  DisposableStore,
+} from '../shared/events';
+
+export type {
+  ToolInfo,
+  McpRpcRequest,
+  McpRpcResponse,
+} from '../shared/types';

package/src/client/react/index.ts

@@ -1,16 +1,20 @@
-/**
- * MCP SDK - React Client
- * Simple React hooks for MCP app rendering
- */
-
-// Core MCP Hook
-export { useMcp, type UseMcpOptions, type McpClient, type McpConnection } from './use-mcp.js';
-
-// App Host (internal use)
-export { useAppHost } from './use-app-host.js';
-
-// Simplified MCP Apps Hook - the main API
-export { useMcpApps } from './use-mcp-apps.js';
-
-// Re-export shared types and client from main entry
-export * from '../index.js';
+/**
+ * MCP SDK - React Client
+ * Simple React hooks for MCP app rendering
+ */
+
+// Core MCP Hook
+export { useMcp, type UseMcpOptions, type McpClient, type McpConnection } from './use-mcp.js';
+
+// App Host (internal use)
+export { useAppHost } from './use-app-host.js';
+
+// Simplified MCP Apps Hook - the main API
+export {
+  useMcpApps,
+  type McpAppRendererProps,
+  type McpAppMetadata,
+} from './use-mcp-apps.js';
+
+// Re-export shared types and client from main entry
+export * from '../index.js';

package/src/client/react/use-app-host.ts

@@ -1,73 +1,74 @@
-import { useEffect, useRef, useState, useCallback } from 'react';
-import type { SSEClient } from '../core/sse-client';
-import { AppHost } from '../core/app-host';
-
-/**
- * Hook to host an MCP App in a React component
- *
- * Optimized for instant loading:
- * - Creates AppHost synchronously
- * - Starts bridge connection immediately
- * - Returns host before connection completes (ready to call launch)
- *
- * @param client - Connected SSEClient instance
- * @param iframeRef - Reference to the iframe element
- * @param options - Optional configuration
- * @returns Object containing the AppHost instance (or null) and error state
- */
-export function useAppHost(
-    client: SSEClient,
-    iframeRef: React.RefObject<HTMLIFrameElement>,
-    options?: {
-        /** Callback when the App sends a message (e.g. to chat) */
-        onMessage?: (params: { role: string; content: unknown }) => void;
-    }
-) {
-    const [host, setHost] = useState<AppHost | null>(null);
-    const [error, setError] = useState<Error | null>(null);
-    const initializingRef = useRef(false);
-
-    // Store latest callback in ref to avoid re-initializing AppHost on callback change
-    const onMessageRef = useRef(options?.onMessage);
-    useEffect(() => {
-        onMessageRef.current = options?.onMessage;
-    }, [options?.onMessage]);
-
-    useEffect(() => {
-        if (!client || !iframeRef.current || initializingRef.current) return;
-
-        // Prevent double initialization in strict mode
-        initializingRef.current = true;
-
-        const initHost = async () => {
-            try {
-                // Initialize AppHost with security enforcement
-                const appHost = new AppHost(client, iframeRef.current!);
-
-                // Register message handler
-                appHost.onAppMessage = (params) => {
-                    onMessageRef.current?.(params);
-                };
-
-                // Set host immediately so launch can be called
-                // (launch will wait for bridge if needed)
-                setHost(appHost);
-
-                // Start bridge connection (this is fast, just sets up PostMessage)
-                await appHost.start();
-            } catch (err) {
-                console.error('[useAppHost] Failed to initialize AppHost:', err);
-                setError(err instanceof Error ? err : new Error(String(err)));
-            }
-        };
-
-        initHost();
-
-        return () => {
-            initializingRef.current = false;
-            setHost(null);
-        };
-    }, [client, iframeRef]);
-
-    return { host, error };
-}
+import { useEffect, useRef, useState, useCallback } from 'react';
+import type { SSEClient } from '../core/sse-client';
+import { AppHost } from '../core/app-host';
+
+/**
+ * Hook to host an MCP App in a React component
+ *
+ * Initialization is async but optimized for instant availability:
+ * - Constructor runs synchronously (sandbox + bridge handler setup)
+ * - Host is set in state immediately so launch() can be called right away
+ * - start() is a lightweight no-op reserved for future async pre-init work
+ * - The real async work (iframe load, bridge connect) happens inside launch()
+ *
+ * @param client - Connected SSEClient instance
+ * @param iframeRef - Reference to the iframe element
+ * @param options - Optional configuration
+ * @returns Object containing the AppHost instance (or null) and error state
+ */
+export function useAppHost(
+    client: SSEClient,
+    iframeRef: React.RefObject<HTMLIFrameElement>,
+    options?: {
+        /** Callback when the App sends a message (e.g. to chat) */
+        onMessage?: (params: { role: string; content: unknown }) => void;
+    }
+) {
+    const [host, setHost] = useState<AppHost | null>(null);
+    const [error, setError] = useState<Error | null>(null);
+    const initializingRef = useRef(false);
+
+    // Store latest callback in ref to avoid re-initializing AppHost on callback change
+    const onMessageRef = useRef(options?.onMessage);
+    useEffect(() => {
+        onMessageRef.current = options?.onMessage;
+    }, [options?.onMessage]);
+
+    useEffect(() => {
+        if (!client || !iframeRef.current || initializingRef.current) return;
+
+        // Prevent double initialization in strict mode
+        initializingRef.current = true;
+
+        const initHost = async () => {
+            try {
+                // Initialize AppHost with security enforcement
+                const appHost = new AppHost(client, iframeRef.current!);
+
+                // Register message handler
+                appHost.onAppMessage = (params) => {
+                    onMessageRef.current?.(params);
+                };
+
+                // Set host immediately so launch can be called
+                // (launch will wait for bridge if needed)
+                setHost(appHost);
+
+                // Start bridge connection (this is fast, just sets up PostMessage)
+                await appHost.start();
+            } catch (err) {
+                console.error('[useAppHost] Failed to initialize AppHost:', err);
+                setError(err instanceof Error ? err : new Error(String(err)));
+            }
+        };
+
+        initHost();
+
+        return () => {
+            initializingRef.current = false;
+            setHost(null);
+        };
+    }, [client, iframeRef]);
+
+    return { host, error };
+}