@codebolt/codeboltjs 2.0.2 → 2.0.4

package/bkp/toolBox.bkp.ts

@@ -1,1162 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ClientCapabilities,
-  CompleteRequestSchema,
-  CreateMessageRequestSchema,
-  ErrorCode,
-  GetPromptRequestSchema,
-  ListPromptsRequestSchema,
-  ListResourcesRequestSchema,
-  ListResourceTemplatesRequestSchema,
-  ListToolsRequestSchema,
-  McpError,
-  ReadResourceRequestSchema,
-  Root,
-  RootsListChangedNotificationSchema,
-  ServerCapabilities,
-  SetLevelRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { z } from "zod";
-import { setTimeout as delay } from "timers/promises";
-import { readFile } from "fs/promises";
-// import { fileTypeFromBuffer } from "file-type";
-// type FileTypeModule =  typeof import('file-type');
-import { StrictEventEmitter } from "strict-event-emitter-types";
-import { EventEmitter } from "events";
-import Fuse from "fuse.js";
-// import { startSSEServer } from "mcp-proxy";
-import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import parseURITemplate from "uri-templates";
-import { loadEsm } from "load-esm";
-
-export type SSEServer = {
-  close: () => Promise<void>;
-};
-
-type FastMCPEvents = {
-  connect: (event: { session: FastMCPSession }) => void;
-  disconnect: (event: { session: FastMCPSession }) => void;
-};
-
-type FastMCPSessionEvents = {
-  rootsChanged: (event: { roots: Root[] }) => void;
-  error: (event: { error: Error }) => void;
-};
-
-/**
- * Generates an image content object from a URL, file path, or buffer.
- */
-export const imageContent = async (
-  input: { url: string } | { path: string } | { buffer: Buffer },
-): Promise<ImageContent> => {
-  let rawData: Buffer;
-
-  if ("url" in input) {
-    const response = await fetch(input.url);
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch image from URL: ${response.statusText}`);
-    }
-
-    rawData = Buffer.from(await response.arrayBuffer());
-  } else if ("path" in input) {
-    rawData = await readFile(input.path);
-  } else if ("buffer" in input) {
-    rawData = input.buffer;
-  } else {
-    throw new Error(
-      "Invalid input: Provide a valid 'url', 'path', or 'buffer'",
-    );
-  }
-  const { fileTypeFromBuffer } = await loadEsm('file-type');
-  const mimeType = await fileTypeFromBuffer(rawData);
-
-  const base64Data = rawData.toString("base64");
-
-  return {
-    type: "image",
-    data: base64Data,
-    mimeType: mimeType?.mime ?? "image/png",
-  } as const;
-};
-
-abstract class FastMCPError extends Error {
-  public constructor(message?: string) {
-    super(message);
-    this.name = new.target.name;
-  }
-}
-
-type Extra = unknown;
-
-type Extras = Record<string, Extra>;
-
-export class UnexpectedStateError extends FastMCPError {
-  public extras?: Extras;
-
-  public constructor(message: string, extras?: Extras) {
-    super(message);
-    this.name = new.target.name;
-    this.extras = extras;
-  }
-}
-
-/**
- * An error that is meant to be surfaced to the user.
- */
-export class UserError extends UnexpectedStateError { }
-
-type ToolParameters = z.ZodTypeAny;
-
-type Literal = boolean | null | number | string | undefined;
-
-type SerializableValue =
-  | Literal
-  | SerializableValue[]
-  | { [key: string]: SerializableValue };
-
-type Progress = {
-  /**
-   * The progress thus far. This should increase every time progress is made, even if the total is unknown.
-   */
-  progress: number;
-  /**
-   * Total number of items to process (or total progress required), if known.
-   */
-  total?: number;
-};
-
-type Context = {
-  reportProgress: (progress: Progress) => Promise<void>;
-  log: {
-    debug: (message: string, data?: SerializableValue) => void;
-    error: (message: string, data?: SerializableValue) => void;
-    info: (message: string, data?: SerializableValue) => void;
-    warn: (message: string, data?: SerializableValue) => void;
-  };
-};
-
-type TextContent = {
-  type: "text";
-  text: string;
-};
-
-const TextContentZodSchema = z
-  .object({
-    type: z.literal("text"),
-    /**
-     * The text content of the message.
-     */
-    text: z.string(),
-  })
-  .strict() satisfies z.ZodType<TextContent>;
-
-type ImageContent = {
-  type: "image";
-  data: string;
-  mimeType: string;
-};
-
-const ImageContentZodSchema = z
-  .object({
-    type: z.literal("image"),
-    /**
-     * The base64-encoded image data.
-     */
-    data: z.string().base64(),
-    /**
-     * The MIME type of the image. Different providers may support different image types.
-     */
-    mimeType: z.string(),
-  })
-  .strict() satisfies z.ZodType<ImageContent>;
-
-type Content = TextContent | ImageContent;
-
-const ContentZodSchema = z.discriminatedUnion("type", [
-  TextContentZodSchema,
-  ImageContentZodSchema,
-]) satisfies z.ZodType<Content>;
-
-type ContentResult = {
-  content: Content[];
-  isError?: boolean;
-};
-
-const ContentResultZodSchema = z
-  .object({
-    content: ContentZodSchema.array(),
-    isError: z.boolean().optional(),
-  })
-  .strict() satisfies z.ZodType<ContentResult>;
-
-type Completion = {
-  values: string[];
-  total?: number;
-  hasMore?: boolean;
-};
-
-/**
- * https://github.com/modelcontextprotocol/typescript-sdk/blob/3164da64d085ec4e022ae881329eee7b72f208d4/src/types.ts#L983-L1003
- */
-const CompletionZodSchema = z.object({
-  /**
-   * An array of completion values. Must not exceed 100 items.
-   */
-  values: z.array(z.string()).max(100),
-  /**
-   * The total number of completion options available. This can exceed the number of values actually sent in the response.
-   */
-  total: z.optional(z.number().int()),
-  /**
-   * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
-   */
-  hasMore: z.optional(z.boolean()),
-}) satisfies z.ZodType<Completion>;
-
-type Tool<Params extends ToolParameters = ToolParameters> = {
-  name: string;
-  description?: string;
-  parameters?: Params;
-  execute: (
-    args: z.infer<Params>,
-    context: Context,
-  ) => Promise<string | ContentResult | TextContent | ImageContent>;
-};
-
-type ResourceResult =
-  | {
-    text: string;
-  }
-  | {
-    blob: string;
-  };
-
-type InputResourceTemplateArgument = Readonly<{
-  name: string;
-  description?: string;
-  complete?: ArgumentValueCompleter;
-}>;
-
-type ResourceTemplateArgument = Readonly<{
-  name: string;
-  description?: string;
-  complete?: ArgumentValueCompleter;
-}>;
-
-type ResourceTemplate<
-  Arguments extends ResourceTemplateArgument[] = ResourceTemplateArgument[],
-> = {
-  uriTemplate: string;
-  name: string;
-  description?: string;
-  mimeType?: string;
-  arguments: Arguments;
-  complete?: (name: string, value: string) => Promise<Completion>;
-  load: (
-    args: ResourceTemplateArgumentsToObject<Arguments>,
-  ) => Promise<ResourceResult>;
-};
-
-type ResourceTemplateArgumentsToObject<T extends { name: string }[]> = {
-  [K in T[number]["name"]]: string;
-};
-
-type InputResourceTemplate<
-  Arguments extends ResourceTemplateArgument[] = ResourceTemplateArgument[],
-> = {
-  uriTemplate: string;
-  name: string;
-  description?: string;
-  mimeType?: string;
-  arguments: Arguments;
-  load: (
-    args: ResourceTemplateArgumentsToObject<Arguments>,
-  ) => Promise<ResourceResult>;
-};
-
-type Resource = {
-  uri: string;
-  name: string;
-  description?: string;
-  mimeType?: string;
-  load: () => Promise<ResourceResult | ResourceResult[]>;
-  complete?: (name: string, value: string) => Promise<Completion>;
-};
-
-type ArgumentValueCompleter = (value: string) => Promise<Completion>;
-
-type InputPromptArgument = Readonly<{
-  name: string;
-  description?: string;
-  required?: boolean;
-  complete?: ArgumentValueCompleter;
-  enum?: string[];
-}>;
-
-type PromptArgumentsToObject<T extends { name: string; required?: boolean }[]> =
-  {
-    [K in T[number]["name"]]: Extract<
-      T[number],
-      { name: K }
-    >["required"] extends true
-    ? string
-    : string | undefined;
-  };
-
-type InputPrompt<
-  Arguments extends InputPromptArgument[] = InputPromptArgument[],
-  Args = PromptArgumentsToObject<Arguments>,
-> = {
-  name: string;
-  description?: string;
-  arguments?: InputPromptArgument[];
-  load: (args: Args) => Promise<string>;
-};
-
-type PromptArgument = Readonly<{
-  name: string;
-  description?: string;
-  required?: boolean;
-  complete?: ArgumentValueCompleter;
-  enum?: string[];
-}>;
-
-type Prompt<
-  Arguments extends PromptArgument[] = PromptArgument[],
-  Args = PromptArgumentsToObject<Arguments>,
-> = {
-  arguments?: PromptArgument[];
-  complete?: (name: string, value: string) => Promise<Completion>;
-  description?: string;
-  load: (args: Args) => Promise<string>;
-  name: string;
-};
-
-type ServerOptions = {
-  name: string;
-  version: `${number}.${number}.${number}`;
-};
-
-type LoggingLevel =
-  | "debug"
-  | "info"
-  | "notice"
-  | "warning"
-  | "error"
-  | "critical"
-  | "alert"
-  | "emergency";
-
-const FastMCPSessionEventEmitterBase: {
-  new(): StrictEventEmitter<EventEmitter, FastMCPSessionEvents>;
-} = EventEmitter;
-
-class FastMCPSessionEventEmitter extends FastMCPSessionEventEmitterBase { }
-
-type SamplingResponse = {
-  model: string;
-  stopReason?: "endTurn" | "stopSequence" | "maxTokens" | string;
-  role: "user" | "assistant";
-  content: TextContent | ImageContent;
-};
-
-export class FastMCPSession extends FastMCPSessionEventEmitter {
-  #capabilities: ServerCapabilities = {};
-  #clientCapabilities?: ClientCapabilities;
-  #loggingLevel: LoggingLevel = "info";
-  #prompts: Prompt[] = [];
-  #resources: Resource[] = [];
-  #resourceTemplates: ResourceTemplate[] = [];
-  #roots: Root[] = [];
-  #server: Server;
-
-  constructor({
-    name,
-    version,
-    tools,
-    resources,
-    resourcesTemplates,
-    prompts,
-  }: {
-    name: string;
-    version: string;
-    tools: Tool[];
-    resources: Resource[];
-    resourcesTemplates: InputResourceTemplate[];
-    prompts: Prompt[];
-  }) {
-    super();
-
-    if (tools.length) {
-      this.#capabilities.tools = {};
-    }
-
-    if (resources.length || resourcesTemplates.length) {
-      this.#capabilities.resources = {};
-    }
-
-    if (prompts.length) {
-      for (const prompt of prompts) {
-        this.addPrompt(prompt);
-      }
-
-      this.#capabilities.prompts = {};
-    }
-
-    this.#capabilities.logging = {};
-
-    this.#server = new Server(
-      { name: name, version: version },
-      { capabilities: this.#capabilities },
-    );
-
-    this.setupErrorHandling();
-    this.setupLoggingHandlers();
-    this.setupRootsHandlers();
-    this.setupCompleteHandlers();
-
-    if (tools.length) {
-      this.setupToolHandlers(tools);
-    }
-
-    if (resources.length || resourcesTemplates.length) {
-      for (const resource of resources) {
-        this.addResource(resource);
-      }
-
-      this.setupResourceHandlers(resources);
-
-      if (resourcesTemplates.length) {
-        for (const resourceTemplate of resourcesTemplates) {
-          this.addResourceTemplate(resourceTemplate);
-        }
-
-        this.setupResourceTemplateHandlers(resourcesTemplates);
-      }
-    }
-
-    if (prompts.length) {
-      this.setupPromptHandlers(prompts);
-    }
-  }
-
-  private addResource(inputResource: Resource) {
-    this.#resources.push(inputResource);
-  }
-
-  private addResourceTemplate(inputResourceTemplate: InputResourceTemplate) {
-    const completers: Record<string, ArgumentValueCompleter> = {};
-
-    for (const argument of inputResourceTemplate.arguments ?? []) {
-      if (argument.complete) {
-        completers[argument.name] = argument.complete;
-      }
-    }
-
-    const resourceTemplate = {
-      ...inputResourceTemplate,
-      complete: async (name: string, value: string) => {
-        if (completers[name]) {
-          return await completers[name](value);
-        }
-
-        return {
-          values: [],
-        };
-      },
-    };
-
-    this.#resourceTemplates.push(resourceTemplate);
-  }
-
-  private addPrompt(inputPrompt: InputPrompt) {
-    const completers: Record<string, ArgumentValueCompleter> = {};
-    const enums: Record<string, string[]> = {};
-
-    for (const argument of inputPrompt.arguments ?? []) {
-      if (argument.complete) {
-        completers[argument.name] = argument.complete;
-      }
-
-      if (argument.enum) {
-        enums[argument.name] = argument.enum;
-      }
-    }
-
-    const prompt = {
-      ...inputPrompt,
-      complete: async (name: string, value: string) => {
-        if (completers[name]) {
-          return await completers[name](value);
-        }
-
-        if (enums[name]) {
-          const fuse = new Fuse(enums[name], {
-            keys: ["value"],
-          });
-
-          const result = fuse.search(value);
-
-          return {
-            values: result.map((item) => item.item),
-            total: result.length,
-          };
-        }
-
-        return {
-          values: [],
-        };
-      },
-    };
-
-    this.#prompts.push(prompt);
-  }
-
-  public get clientCapabilities(): ClientCapabilities | null {
-    return this.#clientCapabilities ?? null;
-  }
-
-  public get server(): Server {
-    return this.#server;
-  }
-
-  #pingInterval: ReturnType<typeof setInterval> | null = null;
-
-  public async requestSampling(
-    message: z.infer<typeof CreateMessageRequestSchema>["params"],
-  ): Promise<SamplingResponse> {
-    return this.#server.createMessage(message);
-  }
-
-  public async connect(transport: Transport) {
-    if (this.#server.transport) {
-      throw new UnexpectedStateError("Server is already connected");
-    }
-
-    await this.#server.connect(transport);
-
-    let attempt = 0;
-
-    while (attempt++ < 10) {
-      const capabilities = await this.#server.getClientCapabilities();
-
-      if (capabilities) {
-        this.#clientCapabilities = capabilities;
-
-        break;
-      }
-
-      await delay(100);
-    }
-
-    if (!this.#clientCapabilities) {
-      throw new UnexpectedStateError("Server did not connect");
-    }
-
-    if (this.#clientCapabilities?.roots) {
-      const roots = await this.#server.listRoots();
-
-      this.#roots = roots.roots;
-    }
-
-    this.#pingInterval = setInterval(async () => {
-      try {
-        await this.#server.ping();
-      } catch (error) {
-        this.emit("error", {
-          error: error as Error,
-        });
-      }
-    }, 1000);
-  }
-
-  public get roots(): Root[] {
-    return this.#roots;
-  }
-
-  public async close() {
-    if (this.#pingInterval) {
-      clearInterval(this.#pingInterval);
-    }
-
-    await this.#server.close();
-  }
-
-  private setupErrorHandling() {
-    this.#server.onerror = (error) => {
-      console.error("[MCP Error]", error);
-    };
-  }
-
-  public get loggingLevel(): LoggingLevel {
-    return this.#loggingLevel;
-  }
-
-  private setupCompleteHandlers() {
-    this.#server.setRequestHandler(CompleteRequestSchema, async (request) => {
-      if (request.params.ref.type === "ref/prompt") {
-        const prompt = this.#prompts.find(
-          (prompt) => prompt.name === request.params.ref.name,
-        );
-
-        if (!prompt) {
-          throw new UnexpectedStateError("Unknown prompt", {
-            request,
-          });
-        }
-
-        if (!prompt.complete) {
-          throw new UnexpectedStateError("Prompt does not support completion", {
-            request,
-          });
-        }
-
-        const completion = CompletionZodSchema.parse(
-          await prompt.complete(
-            request.params.argument.name,
-            request.params.argument.value,
-          ),
-        );
-
-        return {
-          completion,
-        };
-      }
-
-      if (request.params.ref.type === "ref/resource") {
-        const resource = this.#resourceTemplates.find(
-          (resource) => resource.uriTemplate === request.params.ref.uri,
-        );
-
-        if (!resource) {
-          throw new UnexpectedStateError("Unknown resource", {
-            request,
-          });
-        }
-
-        if (!("uriTemplate" in resource)) {
-          throw new UnexpectedStateError("Unexpected resource");
-        }
-
-        if (!resource.complete) {
-          throw new UnexpectedStateError(
-            "Resource does not support completion",
-            {
-              request,
-            },
-          );
-        }
-
-        const completion = CompletionZodSchema.parse(
-          await resource.complete(
-            request.params.argument.name,
-            request.params.argument.value,
-          ),
-        );
-
-        return {
-          completion,
-        };
-      }
-
-      throw new UnexpectedStateError("Unexpected completion request", {
-        request,
-      });
-    });
-  }
-
-  private setupRootsHandlers() {
-    this.#server.setNotificationHandler(
-      RootsListChangedNotificationSchema,
-      () => {
-        this.#server.listRoots().then((roots) => {
-          this.#roots = roots.roots;
-
-          this.emit("rootsChanged", {
-            roots: roots.roots,
-          });
-        });
-      },
-    );
-  }
-
-  private setupLoggingHandlers() {
-    this.#server.setRequestHandler(SetLevelRequestSchema, (request) => {
-      this.#loggingLevel = request.params.level;
-
-      return {};
-    });
-  }
-
-  private setupToolHandlers(tools: Tool[]) {
-    this.#server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: tools.map((tool) => {
-          return {
-            name: tool.name,
-            description: tool.description,
-            inputSchema: tool.parameters
-              ? zodToJsonSchema(tool.parameters)
-              : undefined,
-          };
-        }),
-      };
-    });
-
-    this.#server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const tool = tools.find((tool) => tool.name === request.params.name);
-
-      if (!tool) {
-        throw new McpError(
-          ErrorCode.MethodNotFound,
-          `Unknown tool: ${request.params.name}`,
-        );
-      }
-
-      let args: any = undefined;
-
-      if (tool.parameters) {
-        const parsed = tool.parameters.safeParse(request.params.arguments);
-
-        if (!parsed.success) {
-          throw new McpError(
-            ErrorCode.InvalidParams,
-            `Invalid ${request.params.name} parameters`,
-          );
-        }
-
-        args = parsed.data;
-      }
-
-      const progressToken = request.params?._meta?.progressToken;
-
-      let result: ContentResult;
-
-      try {
-        const reportProgress = async (progress: Progress) => {
-          await this.#server.notification({
-            method: "notifications/progress",
-            params: {
-              ...progress,
-              progressToken,
-            },
-          });
-        };
-
-        const log = {
-          debug: (message: string, context?: SerializableValue) => {
-            this.#server.sendLoggingMessage({
-              level: "debug",
-              data: {
-                message,
-                context,
-              },
-            });
-          },
-          error: (message: string, context?: SerializableValue) => {
-            this.#server.sendLoggingMessage({
-              level: "error",
-              data: {
-                message,
-                context,
-              },
-            });
-          },
-          info: (message: string, context?: SerializableValue) => {
-            this.#server.sendLoggingMessage({
-              level: "info",
-              data: {
-                message,
-                context,
-              },
-            });
-          },
-          warn: (message: string, context?: SerializableValue) => {
-            this.#server.sendLoggingMessage({
-              level: "warning",
-              data: {
-                message,
-                context,
-              },
-            });
-          },
-        };
-
-        const maybeStringResult = await tool.execute(args, {
-          reportProgress,
-          log,
-        });
-
-        if (typeof maybeStringResult === "string") {
-          result = ContentResultZodSchema.parse({
-            content: [{ type: "text", text: maybeStringResult }],
-          });
-        } else if ("type" in maybeStringResult) {
-          result = ContentResultZodSchema.parse({
-            content: [maybeStringResult],
-          });
-        } else {
-          result = ContentResultZodSchema.parse(maybeStringResult);
-        }
-      } catch (error) {
-        if (error instanceof UserError) {
-          return {
-            content: [{ type: "text", text: error.message }],
-            isError: true,
-          };
-        }
-
-        return {
-          content: [{ type: "text", text: `Error: ${error}` }],
-          isError: true,
-        };
-      }
-
-      return result;
-    });
-  }
-
-  private setupResourceHandlers(resources: Resource[]) {
-    this.#server.setRequestHandler(ListResourcesRequestSchema, async () => {
-      return {
-        resources: resources.map((resource) => {
-          return {
-            uri: resource.uri,
-            name: resource.name,
-            mimeType: resource.mimeType,
-          };
-        }),
-      };
-    });
-
-    this.#server.setRequestHandler(
-      ReadResourceRequestSchema,
-      async (request) => {
-        if ("uri" in request.params) {
-          const resource = resources.find(
-            (resource) =>
-              "uri" in resource && resource.uri === request.params.uri,
-          );
-
-          if (!resource) {
-            for (const resourceTemplate of this.#resourceTemplates) {
-              const uriTemplate = parseURITemplate(
-                resourceTemplate.uriTemplate,
-              );
-
-              const match = uriTemplate.fromUri(request.params.uri);
-
-              if (!match) {
-                continue;
-              }
-
-              const uri = uriTemplate.fill(match);
-
-              const result = await resourceTemplate.load(match);
-
-              return {
-                contents: [
-                  {
-                    uri: uri,
-                    mimeType: resourceTemplate.mimeType,
-                    name: resourceTemplate.name,
-                    ...result,
-                  },
-                ],
-              };
-            }
-
-            throw new McpError(
-              ErrorCode.MethodNotFound,
-              `Unknown resource: ${request.params.uri}`,
-            );
-          }
-
-          if (!("uri" in resource)) {
-            throw new UnexpectedStateError("Resource does not support reading");
-          }
-
-          let maybeArrayResult: Awaited<ReturnType<Resource["load"]>>;
-
-          try {
-            maybeArrayResult = await resource.load();
-          } catch (error) {
-            throw new McpError(
-              ErrorCode.InternalError,
-              `Error reading resource: ${error}`,
-              {
-                uri: resource.uri,
-              },
-            );
-          }
-
-          if (Array.isArray(maybeArrayResult)) {
-            return {
-              contents: maybeArrayResult.map((result) => ({
-                uri: resource.uri,
-                mimeType: resource.mimeType,
-                name: resource.name,
-                ...result,
-              })),
-            };
-          } else {
-            return {
-              contents: [
-                {
-                  uri: resource.uri,
-                  mimeType: resource.mimeType,
-                  name: resource.name,
-                  ...maybeArrayResult,
-                },
-              ],
-            };
-          }
-        }
-
-        throw new UnexpectedStateError("Unknown resource request", {
-          request,
-        });
-      },
-    );
-  }
-
-  private setupResourceTemplateHandlers(resourceTemplates: ResourceTemplate[]) {
-    this.#server.setRequestHandler(
-      ListResourceTemplatesRequestSchema,
-      async () => {
-        return {
-          resourceTemplates: resourceTemplates.map((resourceTemplate) => {
-            return {
-              name: resourceTemplate.name,
-              uriTemplate: resourceTemplate.uriTemplate,
-            };
-          }),
-        };
-      },
-    );
-  }
-
-  private setupPromptHandlers(prompts: Prompt[]) {
-    this.#server.setRequestHandler(ListPromptsRequestSchema, async () => {
-      return {
-        prompts: prompts.map((prompt) => {
-          return {
-            name: prompt.name,
-            description: prompt.description,
-            arguments: prompt.arguments,
-            complete: prompt.complete,
-          };
-        }),
-      };
-    });
-
-    this.#server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-      const prompt = prompts.find(
-        (prompt) => prompt.name === request.params.name,
-      );
-
-      if (!prompt) {
-        throw new McpError(
-          ErrorCode.MethodNotFound,
-          `Unknown prompt: ${request.params.name}`,
-        );
-      }
-
-      const args = request.params.arguments;
-
-      for (const arg of prompt.arguments ?? []) {
-        if (arg.required && !(args && arg.name in args)) {
-          throw new McpError(
-            ErrorCode.InvalidRequest,
-            `Missing required argument: ${arg.name}`,
-          );
-        }
-      }
-
-      let result: Awaited<ReturnType<Prompt["load"]>>;
-
-      try {
-        result = await prompt.load(args as Record<string, string | undefined>);
-      } catch (error) {
-        throw new McpError(
-          ErrorCode.InternalError,
-          `Error loading prompt: ${error}`,
-        );
-      }
-
-      return {
-        description: prompt.description,
-        messages: [
-          {
-            role: "user",
-            content: { type: "text", text: result },
-          },
-        ],
-      };
-    });
-  }
-}
-
-const FastMCPEventEmitterBase: {
-  new(): StrictEventEmitter<EventEmitter, FastMCPEvents>;
-} = EventEmitter;
-
-class FastMCPEventEmitter extends FastMCPEventEmitterBase { }
-
-export class ToolBox extends FastMCPEventEmitter {
-  #options: ServerOptions;
-  #prompts: InputPrompt[] = [];
-  #resources: Resource[] = [];
-  #resourcesTemplates: InputResourceTemplate[] = [];
-  #sessions: FastMCPSession[] = [];
-  #sseServer: SSEServer | null = null;
-  #tools: Tool[] = [];
-
-  constructor(public options: ServerOptions) {
-    super();
-
-    this.#options = options;
-  }
-
-  public get sessions(): FastMCPSession[] {
-    return this.#sessions;
-  }
-
-  /**
-   * Adds a tool to the server.
-   */
-  public addTool<Params extends ToolParameters>(tool: Tool<Params>) {
-    this.#tools.push(tool as unknown as Tool);
-  }
-
-  /**
-   * Adds a resource to the server.
-   */
-  public addResource(resource: Resource) {
-    this.#resources.push(resource);
-  }
-
-  /**
-   * Adds a resource template to the server.
-   */
-  public addResourceTemplate<
-    const Args extends InputResourceTemplateArgument[],
-  >(resource: InputResourceTemplate<Args>) {
-    this.#resourcesTemplates.push(resource);
-  }
-
-  /**
-   * Adds a prompt to the server.
-   */
-  public addPrompt<const Args extends InputPromptArgument[]>(
-    prompt: InputPrompt<Args>,
-  ) {
-    this.#prompts.push(prompt);
-  }
-
-  /**
-   * Starts the server.
-   */
-  public async activate(
-    options:
-      | { transportType: "stdio" }
-      | {
-        transportType: "sse";
-        sse: { endpoint: `/${string}`; port: number };
-      } = {
-        transportType: "stdio",
-      },
-  ) {
-    if (options.transportType === "stdio") {
-      const transport = new StdioServerTransport();
-
-      const session = new FastMCPSession({
-        name: this.#options.name,
-        version: this.#options.version,
-        tools: this.#tools,
-        resources: this.#resources,
-        resourcesTemplates: this.#resourcesTemplates,
-        prompts: this.#prompts,
-      });
-      await session.connect(transport);
-
-      this.#sessions.push(session);
-
-      this.emit("connect", {
-        session,
-      });
-
-      console.info(`server is running on stdio`);
-    } else if (options.transportType === "sse") {
-      // this.#sseServer = await startSSEServer<FastMCPSession>({
-      //   endpoint: options.sse.endpoint as `/${string}`,
-      //   port: options.sse.port,
-      //   createServer: async () => {
-      //     return new FastMCPSession({
-      //       name: this.#options.name,
-      //       version: this.#options.version,
-      //       tools: this.#tools,
-      //       resources: this.#resources,
-      //       resourcesTemplates: this.#resourcesTemplates,
-      //       prompts: this.#prompts,
-      //     });
-      //   },
-      //   onClose: (session) => {
-      //     this.emit("disconnect", {
-      //       session,
-      //     });
-      //   },
-      //   onConnect: async (session) => {
-      //     this.#sessions.push(session);
-
-      //     this.emit("connect", {
-      //       session,
-      //     });
-      //   },
-      // });
-
-      // console.error(
-      //   `server is running on SSE at http://localhost:${options.sse.port}${options.sse.endpoint}`,
-      // );
-    } else {
-      throw new Error("Invalid transport type");
-    }
-  }
-
-  /**
-   * Stops the server.
-   */
-  public async stop() {
-    if (this.#sseServer) {
-      this.#sseServer.close();
-    }
-  }
-
-  // public async activate() {
-
-  //   const transport = new StdioServerTransport();
-
-  //   const session = new FastMCPSession({
-  //     name: this.#options.name,
-  //     version: this.#options.version,
-  //     tools: this.#tools,
-  //     resources: this.#resources,
-  //     resourcesTemplates: this.#resourcesTemplates,
-  //     prompts: this.#prompts,
-  //   });
-
-  //   await session.connect(transport);
-
-  //   this.#sessions.push(session);
-
-  //   this.emit("connect", {
-  //     session,
-  //   });
-
-  //   console.info(`server is running on stdio`);
-  // }
-}