mcp-use 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -486,7 +486,6 @@ __export(index_exports, {
   MCPAgent: () => MCPAgent,
   MCPClient: () => MCPClient,
   MCPSession: () => MCPSession,
-  McpServer: () => McpServer,
   OAuthHelper: () => OAuthHelper,
   ObservabilityManager: () => ObservabilityManager,
   ReleaseMCPServerConnectionTool: () => ReleaseMCPServerConnectionTool,
@@ -2686,8 +2685,36 @@ var MCPAgent = class {
         `;
       }
       try {
-        const structuredResult = await structuredLlm.invoke(formatPrompt);
+        logger.info(`\u{1F504} Structured output attempt ${attempt} - using streaming approach`);
+        const stream = await structuredLlm.stream(formatPrompt);
+        let structuredResult = null;
+        let chunkCount = 0;
+        for await (const chunk of stream) {
+          chunkCount++;
+          if (typeof chunk === "string") {
+            try {
+              structuredResult = JSON.parse(chunk);
+            } catch (e) {
+              logger.warn(`\u{1F504} Failed to parse string chunk as JSON: ${chunk}`);
+            }
+          } else if (chunk && typeof chunk === "object") {
+            structuredResult = chunk;
+          } else {
+            try {
+              structuredResult = JSON.parse(String(chunk));
+            } catch (e) {
+              logger.warn(`\u{1F504} Failed to parse chunk as JSON: ${chunk}`);
+            }
+          }
+          await new Promise((resolve) => setTimeout(resolve, 0));
+          if (chunkCount % 10 === 0) {
+            logger.info(`\u{1F504} Structured output streaming: ${chunkCount} chunks`);
+          }
+        }
         logger.info(`\u{1F504} Structured result attempt ${attempt}: ${JSON.stringify(structuredResult, null, 2)}`);
+        if (!structuredResult) {
+          throw new Error("No structured result received from stream");
+        }
         const validatedResult = this._validateStructuredResult(structuredResult, outputSchema);
         logger.info(`\u2705 Structured output successful on attempt ${attempt}`);
         return validatedResult;
@@ -3188,13 +3215,52 @@ var BaseConnector = class {
     logger.debug(`Tool '${name}' returned`, res);
     return res;
   }
-  /** List resources from the server. */
-  async listResources(options) {
+  /**
+   * List resources from the server with optional pagination
+   * 
+   * @param cursor - Optional cursor for pagination
+   * @param options - Request options
+   * @returns Resource list with optional nextCursor for pagination
+   */
+  async listResources(cursor, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug("Listing resources", cursor ? `with cursor: ${cursor}` : "");
+    return await this.client.listResources({ cursor }, options);
+  }
+  /**
+   * List all resources from the server, automatically handling pagination
+   * 
+   * @param options - Request options
+   * @returns Complete list of all resources
+   */
+  async listAllResources(options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug("Listing all resources (with auto-pagination)");
+    const allResources = [];
+    let cursor = void 0;
+    do {
+      const result = await this.client.listResources({ cursor }, options);
+      allResources.push(...result.resources || []);
+      cursor = result.nextCursor;
+    } while (cursor);
+    return { resources: allResources };
+  }
+  /**
+   * List resource templates from the server
+   * 
+   * @param options - Request options
+   * @returns List of available resource templates
+   */
+  async listResourceTemplates(options) {
     if (!this.client) {
       throw new Error("MCP client is not connected");
     }
-    logger.debug("Listing resources");
-    return await this.client.listResources(void 0, options);
+    logger.debug("Listing resource templates");
+    return await this.client.listResourceTemplates(void 0, options);
   }
   /** Read a resource by URI. */
   async readResource(uri, options) {
@@ -3205,6 +3271,32 @@ var BaseConnector = class {
     const res = await this.client.readResource({ uri }, options);
     return { content: res.content, mimeType: res.mimeType };
   }
+  /**
+   * Subscribe to resource updates
+   * 
+   * @param uri - URI of the resource to subscribe to
+   * @param options - Request options
+   */
+  async subscribeToResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Subscribing to resource: ${uri}`);
+    return await this.client.subscribeResource({ uri }, options);
+  }
+  /**
+   * Unsubscribe from resource updates
+   * 
+   * @param uri - URI of the resource to unsubscribe from
+   * @param options - Request options
+   */
+  async unsubscribeFromResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Unsubscribing from resource: ${uri}`);
+    return await this.client.unsubscribeResource({ uri }, options);
+  }
   async listPrompts() {
     if (!this.client) {
       throw new Error("MCP client is not connected");
@@ -3301,12 +3393,16 @@ var HttpConnector = class extends BaseConnector {
     }
     logger.debug(`Connecting to MCP implementation via HTTP: ${baseUrl}`);
     try {
-      logger.debug("Attempting streamable HTTP transport...");
+      logger.info("\u{1F504} Attempting streamable HTTP transport...");
       await this.connectWithStreamableHttp(baseUrl);
+      logger.info("\u2705 Successfully connected via streamable HTTP");
     } catch (err) {
       let fallbackReason = "Unknown error";
       if (err instanceof import_streamableHttp2.StreamableHTTPError) {
-        if (err.code === 404 || err.code === 405) {
+        if (err.code === 400 && err.message.includes("Missing session ID")) {
+          fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
+          logger.warn(`\u26A0\uFE0F  ${fallbackReason}`);
+        } else if (err.code === 404 || err.code === 405) {
           fallbackReason = `Server returned ${err.code} - server likely doesn't support streamable HTTP`;
           logger.debug(fallbackReason);
         } else {
@@ -3315,7 +3411,11 @@ var HttpConnector = class extends BaseConnector {
         }
       } else if (err instanceof Error) {
         const errorStr = err.toString();
-        if (errorStr.includes("405 Method Not Allowed") || errorStr.includes("404 Not Found")) {
+        const errorMsg = err.message || "";
+        if (errorStr.includes("Missing session ID") || errorStr.includes("Bad Request: Missing session ID") || errorMsg.includes("FastMCP session ID error")) {
+          fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
+          logger.warn(`\u26A0\uFE0F  ${fallbackReason}`);
+        } else if (errorStr.includes("405 Method Not Allowed") || errorStr.includes("404 Not Found")) {
           fallbackReason = "Server doesn't support streamable HTTP (405/404)";
           logger.debug(fallbackReason);
         } else {
@@ -3323,7 +3423,7 @@ var HttpConnector = class extends BaseConnector {
           logger.debug(fallbackReason);
         }
       }
-      logger.debug("Falling back to SSE transport...");
+      logger.info("\u{1F504} Falling back to SSE transport...");
       try {
         await this.connectWithSse(baseUrl);
       } catch (sseErr) {
@@ -3354,7 +3454,19 @@ var HttpConnector = class extends BaseConnector {
       );
       const transport = await this.connectionManager.start();
       this.client = new import_client.Client(this.clientInfo, this.opts.clientOptions);
-      await this.client.connect(transport);
+      try {
+        await this.client.connect(transport);
+      } catch (connectErr) {
+        if (connectErr instanceof Error) {
+          const errMsg = connectErr.message || connectErr.toString();
+          if (errMsg.includes("Missing session ID") || errMsg.includes("Bad Request: Missing session ID")) {
+            const wrappedError = new Error(`FastMCP session ID error: ${errMsg}`);
+            wrappedError.cause = connectErr;
+            throw wrappedError;
+          }
+        }
+        throw connectErr;
+      }
       this.connected = true;
       this.transportType = "streamable-http";
       logger.debug(`Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`);
@@ -3678,14 +3790,26 @@ var WebSocketConnector = class extends BaseConnector {
         logger.debug("Received unsolicited message", data);
       }
     }, "onMessage");
-    socket.addEventListener ? socket.addEventListener("message", onMessage) : socket.on("message", onMessage);
+    if (socket.addEventListener) {
+      socket.addEventListener("message", onMessage);
+    } else {
+      socket.on("message", onMessage);
+    }
     return new Promise((resolve) => {
       const onClose = /* @__PURE__ */ __name(() => {
-        socket.removeEventListener ? socket.removeEventListener("message", onMessage) : socket.off("message", onMessage);
+        if (socket.removeEventListener) {
+          socket.removeEventListener("message", onMessage);
+        } else {
+          socket.off("message", onMessage);
+        }
         this.rejectAll(new Error("WebSocket closed"));
         resolve();
       }, "onClose");
-      socket.addEventListener ? socket.addEventListener("close", onClose) : socket.on("close", onClose);
+      if (socket.addEventListener) {
+        socket.addEventListener("close", onClose);
+      } else {
+        socket.on("close", onClose);
+      }
     });
   }
   rejectAll(err) {
@@ -3941,6 +4065,7 @@ var McpServer = class {
       version: config2.version
     });
     this.app = (0, import_express.default)();
+    this.app.use(import_express.default.json());
     this.app.use((req, res, next) => {
       res.header("Access-Control-Allow-Origin", "*");
       res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
@@ -3969,7 +4094,10 @@ var McpServer = class {
    * @param resourceDefinition - Configuration object containing resource metadata and handler function
    * @param resourceDefinition.name - Unique identifier for the resource
    * @param resourceDefinition.uri - URI pattern for accessing the resource
-   * @param resourceDefinition.resource - Resource metadata (mime type, description, etc.)
+   * @param resourceDefinition.title - Optional human-readable title for the resource
+   * @param resourceDefinition.description - Optional description of the resource
+   * @param resourceDefinition.mimeType - MIME type of the resource content
+   * @param resourceDefinition.annotations - Optional annotations (audience, priority, lastModified)
    * @param resourceDefinition.fn - Async function that returns the resource content
    * @returns The server instance for method chaining
    * 
@@ -3978,8 +4106,20 @@ var McpServer = class {
    * server.resource({
    *   name: 'config',
    *   uri: 'config://app-settings',
-   *   resource: { mimeType: 'application/json' },
-   *   fn: async () => ({ theme: 'dark', language: 'en' })
+   *   title: 'Application Settings',
+   *   mimeType: 'application/json',
+   *   description: 'Current application configuration',
+   *   annotations: {
+   *     audience: ['user'],
+   *     priority: 0.8
+   *   },
+   *   fn: async () => ({
+   *     contents: [{
+   *       uri: 'config://app-settings',
+   *       mimeType: 'application/json',
+   *       text: JSON.stringify({ theme: 'dark', language: 'en' })
+   *     }]
+   *   })
    * })
    * ```
    */
@@ -3987,7 +4127,13 @@ var McpServer = class {
     this.server.resource(
       resourceDefinition.name,
       resourceDefinition.uri,
-      resourceDefinition.resource,
+      {
+        name: resourceDefinition.name,
+        title: resourceDefinition.title,
+        description: resourceDefinition.description,
+        mimeType: resourceDefinition.mimeType,
+        annotations: resourceDefinition.annotations
+      },
       async () => {
         return await resourceDefinition.fn();
       }
@@ -3996,18 +4142,76 @@ var McpServer = class {
   }
   /**
    * Define a dynamic resource template with parameters
+   * 
+   * Registers a parameterized resource template with the MCP server. Templates use URI
+   * patterns with placeholders that can be filled in at request time, allowing dynamic
+   * resource generation based on parameters.
+   * 
+   * @param resourceTemplateDefinition - Configuration object for the resource template
+   * @param resourceTemplateDefinition.name - Unique identifier for the template
+   * @param resourceTemplateDefinition.resourceTemplate - ResourceTemplate object with uriTemplate and metadata
+   * @param resourceTemplateDefinition.fn - Async function that generates resource content from URI and params
+   * @returns The server instance for method chaining
+   * 
+   * @example
+   * ```typescript
+   * server.resourceTemplate({
+   *   name: 'user-profile',
+   *   resourceTemplate: {
+   *     uriTemplate: 'user://{userId}/profile',
+   *     name: 'User Profile',
+   *     mimeType: 'application/json'
+   *   },
+   *   fn: async (uri, params) => ({
+   *     contents: [{
+   *       uri: uri.toString(),
+   *       mimeType: 'application/json',
+   *       text: JSON.stringify({ userId: params.userId, name: 'John Doe' })
+   *     }]
+   *   })
+   * })
+   * ```
    */
-  // TODO implement, for some freaky reason this give errors
-  // resourceTemplate(resourceTemplateDefinition: ResourceTemplateDefinition): this {
-  //   this.server.resource(
-  //     resourceTemplateDefinition.name,
-  //     resourceTemplateDefinition.resourceTemplate,
-  //     async (uri, params) => {
-  //       return await resourceTemplateDefinition.fn(uri, params)
-  //     },
-  //   )
-  //   return this
-  // }
+  resourceTemplate(resourceTemplateDefinition) {
+    const template = new import_mcp.ResourceTemplate(
+      resourceTemplateDefinition.resourceTemplate.uriTemplate,
+      {
+        list: void 0,
+        // Optional: callback to list all matching resources
+        complete: void 0
+        // Optional: callback for auto-completion
+      }
+    );
+    const metadata = {};
+    if (resourceTemplateDefinition.resourceTemplate.name) {
+      metadata.name = resourceTemplateDefinition.resourceTemplate.name;
+    }
+    if (resourceTemplateDefinition.title) {
+      metadata.title = resourceTemplateDefinition.title;
+    }
+    if (resourceTemplateDefinition.description || resourceTemplateDefinition.resourceTemplate.description) {
+      metadata.description = resourceTemplateDefinition.description || resourceTemplateDefinition.resourceTemplate.description;
+    }
+    if (resourceTemplateDefinition.resourceTemplate.mimeType) {
+      metadata.mimeType = resourceTemplateDefinition.resourceTemplate.mimeType;
+    }
+    if (resourceTemplateDefinition.annotations) {
+      metadata.annotations = resourceTemplateDefinition.annotations;
+    }
+    this.server.resource(
+      resourceTemplateDefinition.name,
+      template,
+      metadata,
+      async (uri) => {
+        const params = this.parseTemplateUri(
+          resourceTemplateDefinition.resourceTemplate.uriTemplate,
+          uri.toString()
+        );
+        return await resourceTemplateDefinition.fn(uri, params);
+      }
+    );
+    return this;
+  }
   /**
    * Define a tool that can be called by clients
    * 
@@ -4389,6 +4593,39 @@ var McpServer = class {
     const matches = uriTemplate.match(/\{([^}]+)\}/g);
     return matches ? matches.map((match) => match.slice(1, -1)) : [];
   }
+  /**
+   * Parse parameter values from a URI based on a template
+   * 
+   * Extracts parameter values from an actual URI by matching it against a URI template.
+   * The template contains placeholders like {param} which are extracted as key-value pairs.
+   * 
+   * @param template - URI template with placeholders (e.g., "user://{userId}/posts/{postId}")
+   * @param uri - Actual URI to parse (e.g., "user://123/posts/456")
+   * @returns Object mapping parameter names to their values
+   * 
+   * @example
+   * ```typescript
+   * const params = this.parseTemplateUri("user://{userId}/posts/{postId}", "user://123/posts/456")
+   * // Returns: { userId: "123", postId: "456" }
+   * ```
+   */
+  parseTemplateUri(template, uri) {
+    const params = {};
+    let regexPattern = template.replace(/[.*+?^$()[\]\\|]/g, "\\$&");
+    const paramNames = [];
+    regexPattern = regexPattern.replace(/\\\{([^}]+)\\\}/g, (_, paramName) => {
+      paramNames.push(paramName);
+      return "([^/]+)";
+    });
+    const regex = new RegExp(`^${regexPattern}$`);
+    const match = uri.match(regex);
+    if (match) {
+      paramNames.forEach((paramName, index) => {
+        params[paramName] = match[index + 1];
+      });
+    }
+    return params;
+  }
 };
 function createMCPServer(name, config2 = {}) {
   const instance = new McpServer({
@@ -4781,7 +5018,7 @@ var BrowserOAuthClientProvider = class {
     this.serverUrl = serverUrl;
     this.storageKeyPrefix = options.storageKeyPrefix || "mcp:auth";
     this.serverUrlHash = this.hashString(serverUrl);
-    this.clientName = options.clientName || "MCP Browser Client";
+    this.clientName = options.clientName || "mcp-use";
     this.clientUri = options.clientUri || (typeof window !== "undefined" ? window.location.origin : "");
     this.callbackUrl = (0, import_strict_url_sanitise.sanitizeUrl)(
       options.callbackUrl || (typeof window !== "undefined" ? new URL("/oauth/callback", window.location.origin).toString() : "/oauth/callback")
@@ -5202,7 +5439,7 @@ function useMcp(options) {
     }
     if (!clientRef.current) {
       clientRef.current = new import_client3.Client(
-        { name: clientConfig.name || "use-mcp-react-client", version: clientConfig.version || "0.1.0" },
+        { name: clientConfig.name || "mcp-use", version: clientConfig.version || "0.1.0" },
         { capabilities: {} }
       );
       addLog("debug", "MCP Client initialized in connect.");
@@ -5738,7 +5975,6 @@ var import_messages3 = require("@langchain/core/messages");
   MCPAgent,
   MCPClient,
   MCPSession,
-  McpServer,
   OAuthHelper,
   ObservabilityManager,
   ReleaseMCPServerConnectionTool,

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export * from './src/agents/utils/index.js';
 export { ServerManager } from './src/managers/server_manager.js';
 export * from './src/managers/tools/index.js';
 export { type ObservabilityConfig, ObservabilityManager } from './src/observability/index.js';
-export { createMCPServer, McpServer } from './src/server/index.js';
+export { createMCPServer } from './src/server/index.js';
 export type { InputDefinition, PromptDefinition, PromptHandler, ResourceDefinition, ResourceHandler, ServerConfig, ToolDefinition, ToolHandler, } from './src/server/types.js';
 export { setTelemetrySource, Telemetry } from './src/telemetry/index.js';
 export { OAuthHelper, LINEAR_OAUTH_CONFIG, createOAuthMCPConfig } from './src/oauth-helper.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAElE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAEvE,cAAc,6BAA6B,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAEhE,cAAc,+BAA+B,CAAA;AAG7C,OAAO,EAAE,KAAK,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAG7F,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAElE,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,WAAW,GACZ,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAGxE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAC9F,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGrH,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACpF,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAGtD,cAAc,sBAAsB,CAAA;AAGpC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAG3G,YAAY,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AAErE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAElE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAEvE,cAAc,6BAA6B,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAEhE,cAAc,+BAA+B,CAAA;AAG7C,OAAO,EAAE,KAAK,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAG7F,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEvD,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,WAAW,GACZ,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAGxE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAC9F,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGrH,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACpF,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAGtD,cAAc,sBAAsB,CAAA;AAGpC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAG3G,YAAY,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AAErE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAA"}