@codebolt/codeboltjs 1.1.95 → 1.1.96

package/modules/toolBox.d.ts

@@ -9,9 +9,15 @@ import { StrictEventEmitter } from "strict-event-emitter-types";
 import { EventEmitter } from "events";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import http from "http";
+/**
+ * Type definition for SSE Server that can be closed.
+ */
 export type SSEServer = {
     close: () => Promise<void>;
 };
+/**
+ * Event types for the FastMCP event emitter.
+ */
 type FastMCPEvents<T extends FastMCPSessionAuth> = {
     connect: (event: {
         session: FastMCPSession<T>;
@@ -20,6 +26,9 @@ type FastMCPEvents<T extends FastMCPSessionAuth> = {
         session: FastMCPSession<T>;
     }) => void;
 };
+/**
+ * Event types for FastMCPSession event emitter.
+ */
 type FastMCPSessionEvents = {
     rootsChanged: (event: {
         roots: Root[];
@@ -30,6 +39,9 @@ type FastMCPSessionEvents = {
 };
 /**
  * Generates an image content object from a URL, file path, or buffer.
+ *
+ * @param input - The input source for the image (URL, file path, or buffer)
+ * @returns Promise with the image content object
  */
 export declare const imageContent: (input: {
     url: string;
@@ -38,25 +50,56 @@ export declare const imageContent: (input: {
 } | {
     buffer: Buffer;
 }) => Promise<ImageContent>;
+/**
+ * Base class for FastMCP errors.
+ */
 declare abstract class FastMCPError extends Error {
     constructor(message?: string);
 }
+/**
+ * Type for extra data in errors.
+ */
 type Extra = unknown;
+/**
+ * Type for a record of extra data.
+ */
 type Extras = Record<string, Extra>;
+/**
+ * Error class for unexpected state conditions.
+ */
 export declare class UnexpectedStateError extends FastMCPError {
+    /** Additional context for the error */
     extras?: Extras;
+    /**
+     * Creates a new UnexpectedStateError.
+     *
+     * @param message - Error message
+     * @param extras - Additional context for the error
+     */
     constructor(message: string, extras?: Extras);
 }
 /**
- * An error that is meant to be surfaced to the user.
+ * Error that is meant to be surfaced to the user.
  */
 export declare class UserError extends UnexpectedStateError {
 }
+/**
+ * Type for tool parameters schema.
+ */
 type ToolParameters = z.ZodTypeAny;
+/**
+ * Type for literal values.
+ */
 type Literal = boolean | null | number | string | undefined;
+/**
+ * Type for serializable values that can be passed around.
+ */
 type SerializableValue = Literal | SerializableValue[] | {
     [key: string]: SerializableValue;
 };
+/**
+ * Type for reporting progress of operations.
+ */
 type Progress = {
     /**
      * The progress thus far. This should increase every time progress is made, even if the total is unknown.
@@ -67,9 +110,15 @@ type Progress = {
      */
     total?: number;
 };
+/**
+ * Context object passed to tool execution functions.
+ */
 type Context<T extends FastMCPSessionAuth> = {
+    /** The session authentication context */
     session: T | undefined;
+    /** Function to report progress of operations */
     reportProgress: (progress: Progress) => Promise<void>;
+    /** Logging functions */
     log: {
         debug: (message: string, data?: SerializableValue) => void;
         error: (message: string, data?: SerializableValue) => void;
@@ -77,75 +126,151 @@ type Context<T extends FastMCPSessionAuth> = {
         warn: (message: string, data?: SerializableValue) => void;
     };
 };
+/**
+ * Type for text content in messages.
+ */
 type TextContent = {
+    /** Always "text" for text content */
     type: "text";
+    /** The text content */
     text: string;
 };
+/**
+ * Type for image content in messages.
+ */
 type ImageContent = {
+    /** Always "image" for image content */
     type: "image";
+    /** Base64-encoded image data */
     data: string;
+    /** The MIME type of the image */
     mimeType: string;
 };
+/**
+ * Union type for content in messages.
+ */
 type Content = TextContent | ImageContent;
+/**
+ * Type for content results from tool executions.
+ */
 type ContentResult = {
+    /** Array of content blocks */
     content: Content[];
+    /** Whether this result represents an error */
     isError?: boolean;
 };
+/**
+ * Type for completion results.
+ */
 type Completion = {
+    /** Array of completion values */
     values: string[];
+    /** The total number of completions available */
     total?: number;
+    /** Whether there are more completions available */
     hasMore?: boolean;
 };
+/**
+ * Type for a tool that can be executed.
+ */
 type Tool<T extends FastMCPSessionAuth, Params extends ToolParameters = ToolParameters> = {
+    /** Name of the tool */
     name: string;
+    /** Optional description of the tool's functionality */
     description?: string;
+    /** Optional parameters schema for the tool */
     parameters?: Params;
+    /** Function to execute the tool */
     execute: (args: z.infer<Params>, context: Context<T>) => Promise<string | ContentResult | TextContent | ImageContent>;
 };
+/**
+ * Type for resource results.
+ */
 type ResourceResult = {
     text: string;
 } | {
     blob: string;
 };
+/**
+ * Type for input resource template arguments.
+ */
 type InputResourceTemplateArgument = Readonly<{
     name: string;
     description?: string;
     complete?: ArgumentValueCompleter;
 }>;
+/**
+ * Type for resource template arguments.
+ */
 type ResourceTemplateArgument = Readonly<{
     name: string;
     description?: string;
     complete?: ArgumentValueCompleter;
 }>;
+/**
+ * Type transformation from argument array to object.
+ */
 type ResourceTemplateArgumentsToObject<T extends {
     name: string;
 }[]> = {
     [K in T[number]["name"]]: string;
 };
+/**
+ * Type for input resource templates.
+ */
 type InputResourceTemplate<Arguments extends ResourceTemplateArgument[] = ResourceTemplateArgument[]> = {
+    /** URI template for the resource */
     uriTemplate: string;
+    /** Name of the template */
     name: string;
+    /** Optional description */
     description?: string;
+    /** Optional MIME type */
     mimeType?: string;
+    /** Arguments for the template */
     arguments: Arguments;
+    /** Function to load the resource */
     load: (args: ResourceTemplateArgumentsToObject<Arguments>) => Promise<ResourceResult>;
 };
+/**
+ * Type for a resource.
+ */
 type Resource = {
+    /** URI of the resource */
     uri: string;
+    /** Name of the resource */
     name: string;
+    /** Optional description */
     description?: string;
+    /** Optional MIME type */
     mimeType?: string;
+    /** Function to load the resource */
     load: () => Promise<ResourceResult | ResourceResult[]>;
+    /** Optional completion function */
     complete?: (name: string, value: string) => Promise<Completion>;
 };
+/**
+ * Type for argument value completion.
+ */
 type ArgumentValueCompleter = (value: string) => Promise<Completion>;
+/**
+ * Type for input prompt arguments.
+ */
 type InputPromptArgument = Readonly<{
+    /** Name of the argument */
     name: string;
+    /** Optional description */
     description?: string;
+    /** Whether the argument is required */
     required?: boolean;
+    /** Optional completion function */
     complete?: ArgumentValueCompleter;
+    /** Optional enum of possible values */
     enum?: string[];
 }>;
+/**
+ * Type transformation from prompt arguments to object.
+ */
 type PromptArgumentsToObject<T extends {
     name: string;
     required?: boolean;
@@ -154,46 +279,97 @@ type PromptArgumentsToObject<T extends {
         name: K;
     }>["required"] extends true ? string : string | undefined;
 };
+/**
+ * Type for input prompts.
+ */
 type InputPrompt<Arguments extends InputPromptArgument[] = InputPromptArgument[], Args = PromptArgumentsToObject<Arguments>> = {
+    /** Name of the prompt */
     name: string;
+    /** Optional description */
     description?: string;
+    /** Optional arguments */
     arguments?: InputPromptArgument[];
+    /** Function to load the prompt */
     load: (args: Args) => Promise<string>;
 };
+/**
+ * Type for prompt arguments.
+ */
 type PromptArgument = Readonly<{
+    /** Name of the argument */
     name: string;
+    /** Optional description */
     description?: string;
+    /** Whether the argument is required */
     required?: boolean;
+    /** Optional completion function */
     complete?: ArgumentValueCompleter;
+    /** Optional enum of possible values */
     enum?: string[];
 }>;
+/**
+ * Type for prompts.
+ */
 type Prompt<Arguments extends PromptArgument[] = PromptArgument[], Args = PromptArgumentsToObject<Arguments>> = {
+    /** Optional arguments */
     arguments?: PromptArgument[];
+    /** Optional completion function */
     complete?: (name: string, value: string) => Promise<Completion>;
+    /** Optional description */
     description?: string;
+    /** Function to load the prompt */
     load: (args: Args) => Promise<string>;
+    /** Name of the prompt */
     name: string;
 };
+/**
+ * Type for server options.
+ */
 type ServerOptions<T extends FastMCPSessionAuth> = {
+    /** Name of the server */
     name: string;
+    /** Version of the server */
     version: `${number}.${number}.${number}`;
+    /** Optional authentication function */
     authenticate?: Authenticate<T>;
 };
+/**
+ * Type for logging levels.
+ */
 type LoggingLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
 declare const FastMCPSessionEventEmitterBase: {
     new (): StrictEventEmitter<EventEmitter, FastMCPSessionEvents>;
 };
 declare class FastMCPSessionEventEmitter extends FastMCPSessionEventEmitterBase {
 }
+/**
+ * Type for sampling responses.
+ */
 type SamplingResponse = {
+    /** The model used */
     model: string;
+    /** Optional reason for stopping */
     stopReason?: "endTurn" | "stopSequence" | "maxTokens" | string;
+    /** Role of the message */
     role: "user" | "assistant";
+    /** Content of the message */
     content: TextContent | ImageContent;
 };
+/**
+ * Type for session authentication.
+ */
 type FastMCPSessionAuth = Record<string, unknown> | undefined;
+/**
+ * Class representing a FastMCP session.
+ * Manages communication between the client and server.
+ */
 export declare class FastMCPSession<T extends FastMCPSessionAuth = FastMCPSessionAuth> extends FastMCPSessionEventEmitter {
     #private;
+    /**
+     * Creates a new FastMCPSession.
+     *
+     * @param options - Configuration options for the session
+     */
     constructor({ auth, name, version, tools, resources, resourcesTemplates, prompts, }: {
         auth?: T;
         name: string;
@@ -228,29 +404,51 @@ declare const FastMCPEventEmitterBase: {
 declare class FastMCPEventEmitter extends FastMCPEventEmitterBase {
 }
 type Authenticate<T> = (request: http.IncomingMessage) => Promise<T>;
+/**
+ * Class representing a toolbox for FastMCP.
+ * Manages tools, resources, and prompts for a Model Context Protocol server.
+ */
 export declare class ToolBox<T extends Record<string, unknown> | undefined = undefined> extends FastMCPEventEmitter {
     #private;
     options: ServerOptions<T>;
+    /**
+     * Creates a new ToolBox instance.
+     *
+     * @param options - Configuration options for the toolbox
+     */
     constructor(options: ServerOptions<T>);
+    /**
+     * Gets all active sessions.
+     */
     get sessions(): FastMCPSession<T>[];
     /**
      * Adds a tool to the server.
+     *
+     * @param tool - The tool to add
      */
     addTool<Params extends ToolParameters>(tool: Tool<T, Params>): void;
     /**
      * Adds a resource to the server.
+     *
+     * @param resource - The resource to add
      */
     addResource(resource: Resource): void;
     /**
      * Adds a resource template to the server.
+     *
+     * @param resource - The resource template to add
      */
     addResourceTemplate<const Args extends InputResourceTemplateArgument[]>(resource: InputResourceTemplate<Args>): void;
     /**
      * Adds a prompt to the server.
+     *
+     * @param prompt - The prompt to add
      */
     addPrompt<const Args extends InputPromptArgument[]>(prompt: InputPrompt<Args>): void;
     /**
      * Starts the server.
+     *
+     * @param options - Options for the server transport
      */
     start(options?: {
         transportType: "stdio";
@@ -266,7 +464,9 @@ export declare class ToolBox<T extends Record<string, unknown> | undefined = und
      */
     stop(): Promise<void>;
     /**
-     * Starts the server.
+     * Activates the server.
+     *
+     * @param options - Options for the server transport
      */
     activate(options?: {
         transportType: "stdio";

package/modules/toolBox.js

@@ -30,6 +30,9 @@ const undici_1 = require("undici");
 const load_esm_1 = require("load-esm");
 /**
  * Generates an image content object from a URL, file path, or buffer.
+ *
+ * @param input - The input source for the image (URL, file path, or buffer)
+ * @returns Promise with the image content object
  */
 const imageContent = async (input) => {
     var _a;
@@ -52,7 +55,6 @@ const imageContent = async (input) => {
     }
     const { fileTypeFromBuffer } = await (0, load_esm_1.loadEsm)('file-type');
     const mimeType = await fileTypeFromBuffer(rawData);
-    console.log(mimeType);
     const base64Data = rawData.toString("base64");
     return {
         type: "image",
@@ -61,13 +63,25 @@ const imageContent = async (input) => {
     };
 };
 exports.imageContent = imageContent;
+/**
+ * Base class for FastMCP errors.
+ */
 class FastMCPError extends Error {
     constructor(message) {
         super(message);
         this.name = new.target.name;
     }
 }
+/**
+ * Error class for unexpected state conditions.
+ */
 class UnexpectedStateError extends FastMCPError {
+    /**
+     * Creates a new UnexpectedStateError.
+     *
+     * @param message - Error message
+     * @param extras - Additional context for the error
+     */
     constructor(message, extras) {
         super(message);
         this.name = new.target.name;
@@ -76,7 +90,7 @@ class UnexpectedStateError extends FastMCPError {
 }
 exports.UnexpectedStateError = UnexpectedStateError;
 /**
- * An error that is meant to be surfaced to the user.
+ * Error that is meant to be surfaced to the user.
  */
 class UserError extends UnexpectedStateError {
 }
@@ -114,6 +128,7 @@ const ContentResultZodSchema = zod_1.z
 })
     .strict();
 /**
+ * Schema for completion results.
  * https://github.com/modelcontextprotocol/typescript-sdk/blob/3164da64d085ec4e022ae881329eee7b72f208d4/src/types.ts#L983-L1003
  */
 const CompletionZodSchema = zod_1.z.object({
@@ -133,7 +148,16 @@ const CompletionZodSchema = zod_1.z.object({
 const FastMCPSessionEventEmitterBase = events_1.EventEmitter;
 class FastMCPSessionEventEmitter extends FastMCPSessionEventEmitterBase {
 }
+/**
+ * Class representing a FastMCP session.
+ * Manages communication between the client and server.
+ */
 class FastMCPSession extends FastMCPSessionEventEmitter {
+    /**
+     * Creates a new FastMCPSession.
+     *
+     * @param options - Configuration options for the session
+     */
     constructor({ auth, name, version, tools, resources, resourcesTemplates, prompts, }) {
         super();
         _FastMCPSession_capabilities.set(this, {});
@@ -262,7 +286,6 @@ class FastMCPSession extends FastMCPSessionEventEmitter {
         let attempt = 0;
         while (attempt++ < 10) {
             const capabilities = await __classPrivateFieldGet(this, _FastMCPSession_server, "f").getClientCapabilities();
-            console.log("capabilities", capabilities);
             if (capabilities) {
                 __classPrivateFieldSet(this, _FastMCPSession_clientCapabilities, capabilities, "f");
                 break;
@@ -270,7 +293,7 @@ class FastMCPSession extends FastMCPSessionEventEmitter {
             await (0, promises_1.setTimeout)(100);
         }
         if (!__classPrivateFieldGet(this, _FastMCPSession_clientCapabilities, "f")) {
-            console.warn('[warning] toolBox could not infer client capabilities');
+            // console.warn('[warning] toolBox could not infer client capabilities')
         }
         if ((_a = __classPrivateFieldGet(this, _FastMCPSession_clientCapabilities, "f")) === null || _a === void 0 ? void 0 : _a.roots) {
             const roots = await __classPrivateFieldGet(this, _FastMCPSession_server, "f").listRoots();
@@ -619,7 +642,16 @@ _FastMCPSession_capabilities = new WeakMap(), _FastMCPSession_clientCapabilities
 const FastMCPEventEmitterBase = events_1.EventEmitter;
 class FastMCPEventEmitter extends FastMCPEventEmitterBase {
 }
+/**
+ * Class representing a toolbox for FastMCP.
+ * Manages tools, resources, and prompts for a Model Context Protocol server.
+ */
 class ToolBox extends FastMCPEventEmitter {
+    /**
+     * Creates a new ToolBox instance.
+     *
+     * @param options - Configuration options for the toolbox
+     */
     constructor(options) {
         super();
         this.options = options;
@@ -634,35 +666,48 @@ class ToolBox extends FastMCPEventEmitter {
         __classPrivateFieldSet(this, _ToolBox_options, options, "f");
         __classPrivateFieldSet(this, _ToolBox_authenticate, options.authenticate, "f");
     }
+    /**
+     * Gets all active sessions.
+     */
     get sessions() {
         return __classPrivateFieldGet(this, _ToolBox_sessions, "f");
     }
     /**
      * Adds a tool to the server.
+     *
+     * @param tool - The tool to add
      */
     addTool(tool) {
         __classPrivateFieldGet(this, _ToolBox_tools, "f").push(tool);
     }
     /**
      * Adds a resource to the server.
+     *
+     * @param resource - The resource to add
      */
     addResource(resource) {
         __classPrivateFieldGet(this, _ToolBox_resources, "f").push(resource);
     }
     /**
      * Adds a resource template to the server.
+     *
+     * @param resource - The resource template to add
      */
     addResourceTemplate(resource) {
         __classPrivateFieldGet(this, _ToolBox_resourcesTemplates, "f").push(resource);
     }
     /**
      * Adds a prompt to the server.
+     *
+     * @param prompt - The prompt to add
      */
     addPrompt(prompt) {
         __classPrivateFieldGet(this, _ToolBox_prompts, "f").push(prompt);
     }
     /**
      * Starts the server.
+     *
+     * @param options - Options for the server transport
      */
     async start(options = {
         transportType: "stdio",
@@ -698,14 +743,15 @@ class ToolBox extends FastMCPEventEmitter {
         }
     }
     /**
-     * Starts the server.
+     * Activates the server.
+     *
+     * @param options - Options for the server transport
      */
     async activate(options = {
         transportType: "stdio",
     }) {
         if (options.transportType === "stdio") {
             const transport = new stdio_js_1.StdioServerTransport();
-            // console.log("tools", this.#tools);
             const session = new FastMCPSession({
                 name: __classPrivateFieldGet(this, _ToolBox_options, "f").name,
                 version: __classPrivateFieldGet(this, _ToolBox_options, "f").version,
@@ -714,7 +760,6 @@ class ToolBox extends FastMCPEventEmitter {
                 resourcesTemplates: __classPrivateFieldGet(this, _ToolBox_resourcesTemplates, "f"),
                 prompts: __classPrivateFieldGet(this, _ToolBox_prompts, "f"),
             });
-            // console.log("session", session);
             await session.connect(transport);
             __classPrivateFieldGet(this, _ToolBox_sessions, "f").push(session);
             this.emit("connect", {
@@ -723,34 +768,7 @@ class ToolBox extends FastMCPEventEmitter {
             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}`,
-            // );
+            // Implementation for SSE transport
         }
         else {
             throw new Error("Invalid transport type");