@mcp-ts/sdk 1.4.0 → 1.5.0

package/src/adapters/langchain-adapter.ts

@@ -2,6 +2,8 @@ import { MCPClient } from '../server/mcp/oauth-client';
 import { MultiSessionClient } from '../server/mcp/multi-session-client';
 import type { DynamicStructuredTool, StructuredTool } from '@langchain/core/tools';
 import type { z } from 'zod';
+import { ToolRouter } from '../shared/tool-router.js';
+import { executeMetaTool, isMetaTool } from '../shared/meta-tools.js';
 
 export interface LangChainAdapterOptions {
     /** 
@@ -16,6 +18,12 @@ export interface LangChainAdapterOptions {
      * @default false
      */
     simplifyErrors?: boolean;
+
+    /**
+     * Optional ToolRouter for intelligent tool selection.
+     * See AIAdapterOptions.toolRouter for details.
+     */
+    toolRouter?: ToolRouter;
 }
 
 /**
@@ -99,6 +107,11 @@ export class LangChainAdapter {
      * Fetches tools from the MCP server and converts them to LangChain StructuredTools.
      */
     async getTools(): Promise<StructuredTool[]> {
+        // If a ToolRouter is provided, use its filtered output
+        if (this.options.toolRouter) {
+            return this.getToolsViaRouter(this.options.toolRouter);
+        }
+
         // Use duck typing instead of instanceof to handle module bundling issues
         const isMultiSession = typeof (this.client as any).getClients === 'function';
         const clients = isMultiSession
@@ -118,6 +131,67 @@ export class LangChainAdapter {
         return results.flat();
     }
 
+    /**
+     * Build StructuredTools from a ToolRouter's filtered output.
+     *
+     * In `search` strategy, only meta-tools are registered with the framework.
+     * Real tool execution is proxied through `mcp_execute_tool` which uses
+     * `router.callTool()` to route to the correct MCP client.
+     */
+    private async getToolsViaRouter(router: ToolRouter): Promise<StructuredTool[]> {
+        await this.ensureDependencies();
+
+        const filteredTools = await router.getFilteredTools();
+
+        return filteredTools.map((tool) => {
+            const routedTool = tool as typeof tool & { sessionId?: string; serverName?: string };
+            const namespace = routedTool.serverName ?? routedTool.sessionId;
+            const schema = this.jsonSchemaToZod(tool.inputSchema);
+
+            return new this.DynamicStructuredTool!({
+                name: isMetaTool(tool.name)
+                    ? tool.name
+                    : this.getRouterToolKey(tool.name, routedTool.sessionId, routedTool.serverName),
+                description: tool.description || `Tool ${tool.name}`,
+                schema: schema,
+                func: async (args: any) => {
+                    try {
+                        // Handle meta-tool calls via the router
+                        if (isMetaTool(tool.name)) {
+                            const result = await executeMetaTool(
+                                tool.name,
+                                args,
+                                router,
+                                (name, toolArgs, namespace) => router.callTool(name, toolArgs, namespace)
+                            );
+                            if (result) {
+                                return result.content.map((c: any) => c.text ?? '').join('\n');
+                            }
+                        }
+
+                        // For non-meta tools in 'all' or 'groups' strategy,
+                        // route directly to the correct MCP client
+                        return await router.callTool(tool.name, args, namespace);
+                    } catch (error: any) {
+                        if (this.options.simplifyErrors) {
+                            return `Error: ${error.message}`;
+                        }
+                        throw error;
+                    }
+                },
+            });
+        });
+    }
+
+    private getRouterToolKey(toolName: string, sessionId?: string, serverName?: string): string {
+        const namespace = sessionId ?? serverName ?? 'mcp';
+        const normalized = namespace
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '_')
+            .replace(/^_+|_+$/g, '') || 'mcp';
+        return `tool_${normalized}_${toolName}`;
+    }
+
     /**
      * Convenience static method to fetch tools in a single line.
      */

package/src/client/react/index.ts

@@ -12,6 +12,8 @@ export { useAppHost } from './use-app-host.js';
 // Simplified MCP Apps Hook - the main API
 export {
   useMcpApps,
+  McpAppRenderer,
+  getMcpAppMetadata,
   type McpAppRendererProps,
   type McpAppRendererHandle,
   type McpAppMetadata,

package/src/client/react/use-mcp-apps.tsx

@@ -15,7 +15,9 @@ import React, {
   useImperativeHandle,
   type MutableRefObject,
 } from 'react';
-import { useAppHost, type UseAppHostOptions } from './use-app-host.js';
+import type { UseAppHostOptions } from './use-app-host.js';
+import { useAppHost } from './use-app-host.js';
+import { resolveMetaToolProxy } from '../../shared/meta-tools.js';
 import type { SSEClient } from '../core/sse-client.js';
 import { APP_HOST_DEFAULTS } from '../core/constants.js';
 import type { SandboxConfig } from '../core/app-host.js';
@@ -56,9 +58,10 @@ export interface McpAppRendererHandle {
 /** Props for {@link useMcpApps}'s `McpAppRenderer` (client is supplied via the hook). */
 export interface McpAppRendererProps extends Pick<UseAppHostOptions, 'sandbox' | 'hostContext' | 'onCallTool' | 'onReadResource' | 'onFallbackRequest' | 'onMessage' | 'onOpenLink' | 'onLoggingMessage' | 'onSizeChanged' | 'onError'> {
   name: string;
+  client?: McpClient | null;
   toolResourceUri?: string;
   html?: string;
-  input?: Record<string, unknown>;
+  input?: Record<string, unknown> | null;
   result?: unknown;
   status?: 'executing' | 'inProgress' | 'complete' | 'idle';
   toolInputPartial?: any;
@@ -102,8 +105,10 @@ const McpAppViewInner = forwardRef<McpAppRendererHandle, McpAppViewProps>(functi
   },
   ref,
 ) {
+  
   const mcpClient = clientRef.current;
-  const metadata = getMcpAppMetadata(mcpClient, name);
+  const { toolName: resolvedToolName, args: resolvedInput } = resolveMetaToolProxy(name, input);
+  const metadata = getMcpAppMetadata(mcpClient, resolvedToolName, resolvedInput);
   const sseClient = mcpClient?.sseClient ?? null;
   const resourceUri = toolResourceUri || metadata?.resourceUri;
   const appSessionId = metadata?.sessionId;
@@ -194,7 +199,7 @@ const McpAppViewInner = forwardRef<McpAppRendererHandle, McpAppViewProps>(functi
 
   const sentInputRef = useRef(false);
   const sentResultRef = useRef(false);
-  const lastInputRef = useRef(input);
+  const lastInputRef = useRef(resolvedInput);
   const lastResultRef = useRef(result);
   const lastStatusRef = useRef(status);
 
@@ -236,15 +241,16 @@ const McpAppViewInner = forwardRef<McpAppRendererHandle, McpAppViewProps>(functi
       .catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
   }, [host, resourceUri, html, appSessionId]);
 
+  // Send tool inputs
   useEffect(() => {
-    if (!host || !isLaunched || !resourceUri || !appSessionId || !input) return;
+    if (!host || !isLaunched || !resourceUri || !appSessionId || !resolvedInput) return;
 
-    if (!sentInputRef.current || JSON.stringify(input) !== JSON.stringify(lastInputRef.current)) {
+    if (!sentInputRef.current || JSON.stringify(resolvedInput) !== JSON.stringify(lastInputRef.current)) {
       sentInputRef.current = true;
-      lastInputRef.current = input;
-      host.sendToolInput(input);
+      lastInputRef.current = resolvedInput;
+      host.sendToolInput(resolvedInput);
     }
-  }, [host, isLaunched, input, resourceUri, appSessionId, name]);
+  }, [host, isLaunched, resolvedInput, resourceUri, appSessionId, resolvedToolName]);
 
   useEffect(() => {
     if (!host || !isLaunched || !resourceUri || !appSessionId || result === undefined) return;
@@ -259,7 +265,7 @@ const McpAppViewInner = forwardRef<McpAppRendererHandle, McpAppViewProps>(functi
           : result;
       host.sendToolResult(formattedResult);
     }
-  }, [host, isLaunched, result, status, resourceUri, appSessionId, name]);
+  }, [host, isLaunched, result, status, resourceUri, appSessionId, resolvedToolName]);
 
   useEffect(() => {
     if (status === 'executing' && lastStatusRef.current !== 'executing') {
@@ -354,34 +360,44 @@ const McpAppViewInner = forwardRef<McpAppRendererHandle, McpAppViewProps>(functi
 const McpAppView = memo(McpAppViewInner);
 McpAppView.displayName = 'McpAppView';
 
+/**
+ * Renders an interactive MCP application inside a sandboxed iframe.
+ */
+export const McpAppRenderer = memo(
+  forwardRef<McpAppRendererHandle, McpAppRendererProps>(function McpAppRenderer(
+    { client, ...props },
+    ref
+  ) {
+    const clientRef = useRef(client || null);
+    clientRef.current = client || null;
+
+    return <McpAppView ref={ref} clientRef={clientRef} {...props} />;
+  })
+);
+
 /**
  * Helpers scoped to one `mcpClient`. Pass the client here once; `McpAppRenderer` only needs per-tool props (`name`, `input`, `result`, `status`).
  *
  * @param mcpClient - From `useMcp()` or context (for example `useMcpContext()`).
+ * @deprecated Use the standalone `<McpAppRenderer>` component and `getMcpAppMetadata` utility directly.
  */
 export function useMcpApps(mcpClient: McpClient | null) {
-  // Stable `McpAppRenderer` type: parent re-renders and `connections` updates must not remount the iframe.
-  const clientRef = useRef(mcpClient);
-  clientRef.current = mcpClient;
-
   const getAppMetadata = useCallback(
-    (toolName: string) => getMcpAppMetadata(clientRef.current, toolName),
-    []
+    (toolName: string) => getMcpAppMetadata(mcpClient, toolName),
+    [mcpClient]
   );
 
-  const McpAppRenderer = useMemo(() => {
-    const Inner = forwardRef<McpAppRendererHandle, McpAppRendererProps>(function McpAppRenderer(
-      props,
-      ref,
-    ) {
-      return <McpAppView ref={ref} clientRef={clientRef} {...props} />;
-    });
-    const Renderer = memo(Inner);
-    Renderer.displayName = 'McpAppRenderer';
-    return Renderer;
-  }, []);
-
-  return { getAppMetadata, McpAppRenderer };
+  const BoundMcpAppRenderer = useMemo(() => {
+    const Renderer = forwardRef<McpAppRendererHandle, Omit<McpAppRendererProps, 'client'>>(
+      function BoundMcpAppRenderer(props, ref) {
+        return <McpAppRenderer ref={ref} client={mcpClient} {...props} />;
+      }
+    );
+    Renderer.displayName = 'BoundMcpAppRenderer';
+    return memo(Renderer);
+  }, [mcpClient]);
+
+  return { getAppMetadata, McpAppRenderer: BoundMcpAppRenderer };
 }
 
 function extractToolName(fullName: string): string {
@@ -389,13 +405,15 @@ function extractToolName(fullName: string): string {
   return match?.[1] || fullName;
 }
 
-function getMcpAppMetadata(
+export function getMcpAppMetadata(
   mcpClient: McpClient | null,
-  toolName: string
+  toolName: string,
+  input?: Record<string, unknown> | null
 ): McpAppMetadata | undefined {
   if (!mcpClient) return undefined;
 
-  const extractedName = extractToolName(toolName);
+  const { toolName: proxyToolName } = resolveMetaToolProxy(toolName, input);
+  const extractedName = extractToolName(proxyToolName);
 
   for (const conn of mcpClient.connections) {
     for (const tool of conn.tools) {

package/src/server/index.ts

@@ -32,6 +32,8 @@ export type {
 } from '../shared/events';
 
 export type {
+  ToolClient,
+  ToolClientProvider,
   ToolInfo,
   McpRpcRequest,
   McpRpcResponse,

package/src/server/mcp/oauth-client.ts

@@ -1108,7 +1108,9 @@ export class MCPClient {
    * @returns Server name or undefined
    */
   getServerName(): string | undefined {
-    return this.serverName;
+    const info = (this.client as any)?.getServerVersion();
+    console.log('server info ->', info);
+    return info?.title ?? info?.name ?? this.serverName;
   }
 
   /**

package/src/shared/index.ts

@@ -22,6 +22,8 @@ export * from './errors';
 
 // Types
 export type {
+  ToolClient,
+  ToolClientProvider,
   ToolInfo,
   McpRpcRequest,
   McpRpcResponse,
@@ -73,3 +75,37 @@ export {
   type ToolUiConfig,
 } from './tool-utils.js';
 
+// Tool Router — Context window optimization
+export {
+  ToolRouter,
+  type ToolRouterOptions,
+  type ToolRouterStrategy,
+  type ToolRouterClientInput,
+  type ToolGroupInfo,
+} from './tool-router.js';
+
+export {
+  ToolIndex,
+  type ToolSummary,
+  type IndexedTool,
+  type ToolIndexOptions,
+  type EmbedFn,
+} from './tool-index.js';
+
+export {
+  SchemaCompressor,
+  type CompactTool,
+  type CompressionStats,
+} from './schema-compressor.js';
+
+export {
+  createSearchToolDefinition,
+  createRegexSearchToolDefinition,
+  createGetSchemaToolDefinition,
+  createExecuteToolDefinition,
+  executeMetaTool,
+  isMetaTool,
+  resolveMetaToolProxy,
+  type CallToolFn,
+} from './meta-tools.js';
+