@jupyterlite/ai 0.9.1 → 0.11.0

package/src/mcp/browser.ts

@@ -1,220 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Browser-compatible MCP Server implementation
- *
- * This is a custom implementation that works around the limitation in
- * @openai/agents where MCPServerStreamableHttp doesn't work in browsers
- */
-
-// Type definitions matching openai/agents MCPServer interface
-interface MCPServer {
-  cacheToolsList: boolean;
-  toolFilter?: any;
-  connect(): Promise<void>;
-  readonly name: string;
-  close(): Promise<void>;
-  listTools(): Promise<MCPTool[]>;
-  callTool(
-    toolName: string,
-    args: Record<string, unknown> | null
-  ): Promise<CallToolResultContent>;
-  invalidateToolsCache(): Promise<void>;
-}
-
-interface MCPTool {
-  name: string;
-  description?: string;
-  inputSchema: {
-    type: 'object';
-    properties: Record<string, any>;
-    required: string[];
-    additionalProperties: boolean;
-  };
-}
-
-// CallToolResultContent is an array of content items
-type CallToolResultContent = Array<{ type: string; text: string }>;
-
-interface MCPServerStreamableHttpOptions {
-  url: string;
-  cacheToolsList?: boolean;
-  clientSessionTimeoutSeconds?: number;
-  name?: string;
-  logger?: any;
-  toolFilter?: any;
-  timeout?: number;
-  authProvider?: any;
-  requestInit?: any;
-  fetch?: any;
-  reconnectionOptions?: any;
-  sessionId?: string;
-}
-
-/**
- * Browser-compatible MCP Server implementation that works around limitations
- * in @openai/agents where MCPServerStreamableHttp doesn't work in browsers.
- *
- * This class provides a streamable HTTP client transport for MCP (Model Context Protocol)
- * servers that can be used in browser environments.
- */
-export class BrowserMCPServerStreamableHttp implements MCPServer {
-  readonly name: string;
-  readonly cacheToolsList: boolean;
-  readonly toolFilter: any = undefined;
-
-  constructor(options: MCPServerStreamableHttpOptions) {
-    this._options = options;
-    this.name = options.name || `browser-mcp-server: ${options.url}`;
-    this.cacheToolsList = options.cacheToolsList ?? false;
-  }
-
-  async connect(): Promise<void> {
-    try {
-      // Dynamic import to handle cases where MCP SDK isn't available
-      const { StreamableHTTPClientTransport } = await import(
-        '@modelcontextprotocol/sdk/client/streamableHttp.js'
-      );
-      const { Client } = await import(
-        '@modelcontextprotocol/sdk/client/index.js'
-      );
-
-      // Merge CORS-enabled requestInit with user options
-      const corsRequestInit = {
-        mode: 'cors' as RequestMode,
-        credentials: 'omit' as RequestCredentials,
-        ...this._options.requestInit
-      };
-
-      this._transport = new StreamableHTTPClientTransport(
-        new URL(this._options.url),
-        {
-          authProvider: this._options.authProvider,
-          requestInit: corsRequestInit,
-          fetch: this._options.fetch || fetch,
-          reconnectionOptions: this._options.reconnectionOptions,
-          sessionId: this._options.sessionId
-        }
-      );
-
-      this._session = new Client({
-        name: this.name,
-        version: '1.0.0'
-      });
-
-      await this._session.connect(this._transport);
-    } catch (error) {
-      console.error('Error initializing MCP server:', error);
-      await this.close();
-      throw error;
-    }
-  }
-
-  async close(): Promise<void> {
-    if (this._session) {
-      try {
-        await this._session.close();
-      } catch (error) {
-        console.error('Error closing MCP server session:', error);
-      }
-      this._session = null;
-    }
-    if (this._transport) {
-      try {
-        await this._transport.close();
-      } catch (error) {
-        console.error('Error closing MCP server transport:', error);
-      }
-      this._transport = null;
-    }
-  }
-
-  async listTools(): Promise<MCPTool[]> {
-    if (!this._session) {
-      throw new Error('Server not initialized. Call connect() first.');
-    }
-
-    if (
-      this.cacheToolsList &&
-      !this._cacheDirty &&
-      this._toolsList.length > 0
-    ) {
-      return this._toolsList;
-    }
-
-    try {
-      const { ListToolsResultSchema } = await import(
-        '@modelcontextprotocol/sdk/types.js'
-      );
-
-      const response = await this._session.listTools();
-
-      const parsedResponse = ListToolsResultSchema.parse(response);
-
-      // Map to openai/agents MCPTool type
-      this._toolsList = parsedResponse.tools.map((tool: any) => ({
-        name: tool.name,
-        description: tool.description,
-        inputSchema: {
-          type: 'object' as const,
-          properties: tool.inputSchema?.properties || {},
-          required: tool.inputSchema?.required || [],
-          additionalProperties: tool.inputSchema?.additionalProperties ?? false
-        }
-      }));
-
-      this._cacheDirty = false;
-
-      return this._toolsList;
-    } catch (error) {
-      console.error(`Error listing tools from ${this.name}:`, error);
-      throw error;
-    }
-  }
-
-  async callTool(
-    toolName: string,
-    args: Record<string, unknown> | null
-  ): Promise<CallToolResultContent> {
-    if (!this._session) {
-      throw new Error('Server not initialized. Call connect() first.');
-    }
-
-    try {
-      const { CallToolResultSchema } = await import(
-        '@modelcontextprotocol/sdk/types.js'
-      );
-
-      const response = await this._session.callTool(
-        {
-          name: toolName,
-          arguments: args ?? {}
-        },
-        undefined,
-        {
-          timeout: this._options.timeout ?? 30000
-        }
-      );
-
-      // Parse and validate using MCP SDK schema
-      const parsed = CallToolResultSchema.parse(response);
-      const result = parsed.content;
-
-      // Return the content array as expected by openai/agents
-      // CallToolResultContent is { type: string; text: string }[]
-      return result as CallToolResultContent;
-    } catch (error) {
-      console.error(`Error calling tool ${toolName}:`, error);
-      throw error;
-    }
-  }
-
-  async invalidateToolsCache(): Promise<void> {
-    this._cacheDirty = true;
-  }
-
-  private _session: any | null = null;
-  private _toolsList: MCPTool[] = [];
-  private _cacheDirty = true;
-  private _transport: any = null;
-  private _options: MCPServerStreamableHttpOptions;
-}

package/src/tools/file.ts

@@ -1,438 +0,0 @@
-import { PathExt } from '@jupyterlab/coreutils';
-import { CommandRegistry } from '@lumino/commands';
-import { IDocumentManager } from '@jupyterlab/docmanager';
-import { IDocumentWidget } from '@jupyterlab/docregistry';
-import { IEditorTracker } from '@jupyterlab/fileeditor';
-
-import { tool } from '@openai/agents';
-
-import { z } from 'zod';
-
-import { IDiffManager, ITool } from '../tokens';
-
-/**
- * Create a tool for creating new files of various types
- */
-export function createNewFileTool(docManager: IDocumentManager): ITool {
-  return tool({
-    name: 'create_file',
-    description:
-      'Create a new file of specified type (text, python, markdown, json, etc.)',
-    parameters: z.object({
-      fileName: z.string().describe('Name of the file to create'),
-      fileType: z
-        .string()
-        .default('text')
-        .describe(
-          'Type of file to create. Common examples: text, python, markdown, json, javascript, typescript, yaml, julia, r, csv'
-        ),
-      content: z
-        .string()
-        .optional()
-        .nullable()
-        .describe('Initial content for the file (optional)'),
-      cwd: z
-        .string()
-        .optional()
-        .nullable()
-        .describe('Directory where to create the file (optional)')
-    }),
-    errorFunction: (context, error) => {
-      return JSON.stringify({
-        success: false,
-        error: `Failed to create file: ${error instanceof Error ? error.message : String(error)}`
-      });
-    },
-    execute: async (input: {
-      fileName: string;
-      fileType?: string;
-      content?: string | null;
-      cwd?: string | null;
-    }) => {
-      const { fileName, content = '', cwd, fileType = 'text' } = input;
-
-      const registeredFileType = docManager.registry.getFileType(fileType);
-      const ext = registeredFileType?.extensions[0] || '.txt';
-
-      const existingExt = PathExt.extname(fileName);
-      const fullFileName = existingExt ? fileName : `${fileName}${ext}`;
-
-      const fullPath = cwd ? `${cwd}/${fullFileName}` : fullFileName;
-
-      const model = await docManager.services.contents.newUntitled({
-        path: cwd || '',
-        type: 'file',
-        ext
-      });
-
-      let finalPath = model.path;
-      if (model.name !== fullFileName) {
-        const renamed = await docManager.services.contents.rename(
-          model.path,
-          fullPath
-        );
-        finalPath = renamed.path;
-      }
-
-      if (content) {
-        await docManager.services.contents.save(finalPath, {
-          type: 'file',
-          format: 'text',
-          content
-        });
-      }
-
-      let opened = false;
-      if (!docManager.findWidget(finalPath)) {
-        docManager.openOrReveal(finalPath);
-        opened = true;
-      }
-
-      return {
-        success: true,
-        message: `${fileType} file '${fullFileName}' created and opened successfully`,
-        fileName: fullFileName,
-        filePath: finalPath,
-        fileType,
-        hasContent: !!content,
-        opened
-      };
-    }
-  });
-}
-
-/**
- * Create a tool for opening files
- */
-export function createOpenFileTool(docManager: IDocumentManager): ITool {
-  return tool({
-    name: 'open_file',
-    description: 'Open a file in the editor',
-    parameters: z.object({
-      filePath: z.string().describe('Path to the file to open')
-    }),
-    errorFunction: (context, error) => {
-      return JSON.stringify({
-        success: false,
-        error: `Failed to open file: ${error instanceof Error ? error.message : String(error)}`
-      });
-    },
-    execute: async (input: { filePath: string }) => {
-      const { filePath } = input;
-
-      const widget = docManager.openOrReveal(filePath);
-
-      if (!widget) {
-        throw new Error(`Could not open file: ${filePath}`);
-      }
-
-      return {
-        success: true,
-        message: `File '${filePath}' opened successfully`,
-        filePath,
-        widgetId: widget.id
-      };
-    }
-  });
-}
-
-/**
- * Create a tool for deleting files
- */
-export function createDeleteFileTool(docManager: IDocumentManager): ITool {
-  return tool({
-    name: 'delete_file',
-    description: 'Delete a file from the file system',
-    parameters: z.object({
-      filePath: z.string().describe('Path to the file to delete')
-    }),
-    errorFunction: (context, error) => {
-      return JSON.stringify({
-        success: false,
-        error: `Failed to delete file: ${error instanceof Error ? error.message : String(error)}`
-      });
-    },
-    execute: async (input: { filePath: string }) => {
-      const { filePath } = input;
-
-      await docManager.services.contents.delete(filePath);
-
-      return {
-        success: true,
-        message: `File '${filePath}' deleted successfully`,
-        filePath
-      };
-    }
-  });
-}
-
-/**
- * Create a tool for renaming files
- */
-export function createRenameFileTool(docManager: IDocumentManager): ITool {
-  return tool({
-    name: 'rename_file',
-    description: 'Rename a file or move it to a different location',
-    parameters: z.object({
-      oldPath: z.string().describe('Current path of the file'),
-      newPath: z.string().describe('New path/name for the file')
-    }),
-    errorFunction: (context, error) => {
-      return JSON.stringify({
-        success: false,
-        error: `Failed to rename file: ${error instanceof Error ? error.message : String(error)}`
-      });
-    },
-    execute: async (input: { oldPath: string; newPath: string }) => {
-      const { oldPath, newPath } = input;
-
-      await docManager.services.contents.rename(oldPath, newPath);
-
-      return {
-        success: true,
-        message: `File renamed from '${oldPath}' to '${newPath}' successfully`,
-        oldPath,
-        newPath
-      };
-    }
-  });
-}
-
-/**
- * Create a tool for copying files
- */
-export function createCopyFileTool(docManager: IDocumentManager): ITool {
-  return tool({
-    name: 'copy_file',
-    description: 'Copy a file to a new location',
-    parameters: z.object({
-      sourcePath: z.string().describe('Path of the file to copy'),
-      destinationPath: z
-        .string()
-        .describe('Destination path for the copied file')
-    }),
-    errorFunction: (context, error) => {
-      return JSON.stringify({
-        success: false,
-        error: `Failed to copy file: ${error instanceof Error ? error.message : String(error)}`
-      });
-    },
-    execute: async (input: { sourcePath: string; destinationPath: string }) => {
-      const { sourcePath, destinationPath } = input;
-
-      await docManager.services.contents.copy(sourcePath, destinationPath);
-
-      return {
-        success: true,
-        message: `File copied from '${sourcePath}' to '${destinationPath}' successfully`,
-        sourcePath,
-        destinationPath
-      };
-    }
-  });
-}
-
-/**
- * Create a tool for navigating to directories in the file browser
- */
-export function createNavigateToDirectoryTool(
-  commands: CommandRegistry
-): ITool {
-  return tool({
-    name: 'navigate_to_directory',
-    description: 'Navigate to a specific directory in the file browser',
-    parameters: z.object({
-      directoryPath: z.string().describe('Path to the directory to navigate to')
-    }),
-    errorFunction: (context, error) => {
-      return JSON.stringify({
-        success: false,
-        error: `Failed to navigate to directory: ${error instanceof Error ? error.message : String(error)}`
-      });
-    },
-    execute: async (input: { directoryPath: string }) => {
-      const { directoryPath } = input;
-
-      await commands.execute('filebrowser:go-to-path', {
-        path: directoryPath
-      });
-
-      return {
-        success: true,
-        message: `Navigated to directory '${directoryPath}' successfully`,
-        directoryPath
-      };
-    }
-  });
-}
-
-/**
- * Create a tool for getting file information and content
- */
-export function createGetFileInfoTool(
-  docManager: IDocumentManager,
-  editorTracker?: IEditorTracker
-): ITool {
-  return tool({
-    name: 'get_file_info',
-    description:
-      'Get information about a file including its path, name, extension, and content. Works with text-based files like Python files, markdown, JSON, etc. For Jupyter notebooks, use dedicated notebook tools instead. If no file path is provided, returns information about the currently active file in the editor.',
-    parameters: z.object({
-      filePath: z
-        .string()
-        .optional()
-        .nullable()
-        .describe(
-          'Path to the file to read (e.g., "script.py", "README.md", "config.json"). If not provided, uses the currently active file in the editor.'
-        )
-    }),
-    errorFunction: (context, error) => {
-      return JSON.stringify({
-        success: false,
-        error: `Failed to get file info: ${error instanceof Error ? error.message : String(error)}`
-      });
-    },
-    execute: async (input: { filePath?: string | null }) => {
-      const { filePath } = input;
-
-      let widget: IDocumentWidget | null = null;
-
-      if (filePath) {
-        widget =
-          docManager.findWidget(filePath) ??
-          docManager.openOrReveal(filePath) ??
-          null;
-
-        if (!widget) {
-          throw new Error(`Failed to open file at path: ${filePath}`);
-        }
-      } else {
-        widget = editorTracker?.currentWidget ?? null;
-
-        if (!widget) {
-          throw new Error(
-            'No active file in the editor and no file path provided'
-          );
-        }
-      }
-
-      if (!widget.context) {
-        throw new Error('Widget is not a document');
-      }
-
-      await widget.context.ready;
-
-      const model = widget.context.model;
-
-      if (!model) {
-        throw new Error('File model not available');
-      }
-
-      const sharedModel = model.sharedModel;
-      const content = sharedModel.getSource();
-      const resolvedFilePath = widget.context.path;
-      const fileName = widget.title.label;
-      const fileExtension = PathExt.extname(resolvedFilePath) || 'unknown';
-
-      return JSON.stringify({
-        success: true,
-        filePath: resolvedFilePath,
-        fileName,
-        fileExtension,
-        content,
-        isDirty: model.dirty,
-        readOnly: model.readOnly,
-        widgetType: widget.constructor.name
-      });
-    }
-  });
-}
-
-/**
- * Create a tool for setting the content of a file
- */
-export function createSetFileContentTool(
-  docManager: IDocumentManager,
-  diffManager?: IDiffManager
-): ITool {
-  return tool({
-    name: 'set_file_content',
-    description:
-      'Set or update the content of an existing file. This will replace the entire content of the file. For Jupyter notebooks, use dedicated notebook tools instead.',
-    parameters: z.object({
-      filePath: z
-        .string()
-        .describe(
-          'Path to the file to update (e.g., "script.py", "README.md", "config.json")'
-        ),
-      content: z.string().describe('The new content to set for the file'),
-      save: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe('Whether to save the file after updating (default: true)')
-    }),
-    errorFunction: (context, error) => {
-      return JSON.stringify({
-        success: false,
-        error: `Failed to set file content: ${error instanceof Error ? error.message : String(error)}`
-      });
-    },
-    execute: async (input: {
-      filePath: string;
-      content: string;
-      save?: boolean;
-    }) => {
-      const { filePath, content, save = true } = input;
-
-      let widget = docManager.findWidget(filePath);
-
-      if (!widget) {
-        widget = docManager.openOrReveal(filePath);
-      }
-
-      if (!widget) {
-        throw new Error(`Failed to open file at path: ${filePath}`);
-      }
-
-      await widget.context.ready;
-
-      const model = widget.context.model;
-
-      if (!model) {
-        throw new Error('File model not available');
-      }
-
-      if (model.readOnly) {
-        throw new Error('File is read-only and cannot be modified');
-      }
-
-      const sharedModel = model.sharedModel;
-      const originalContent = sharedModel.getSource();
-
-      sharedModel.setSource(content);
-
-      // Show the file diff using the diff manager if available
-      if (diffManager) {
-        await diffManager.showFileDiff({
-          original: String(originalContent),
-          modified: content,
-          filePath
-        });
-      }
-
-      if (save) {
-        await widget.context.save();
-      }
-
-      return JSON.stringify({
-        success: true,
-        filePath,
-        fileName: widget.title.label,
-        contentLength: content.length,
-        saved: save,
-        isDirty: model.dirty
-      });
-    }
-  });
-}