@frontmcp/testing 0.12.2 → 1.0.0-beta.1

package/esm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontmcp/testing",
-  "version": "0.12.2",
+  "version": "1.0.0-beta.1",
   "description": "E2E testing framework for FrontMCP servers - MCP client, auth mocks, Playwright integration",
   "author": "AgentFront <info@agentfront.dev>",
   "homepage": "https://docs.agentfront.dev",
@@ -87,8 +87,8 @@
     "./esm": null
   },
   "peerDependencies": {
-    "@frontmcp/sdk": "0.12.2",
-    "@frontmcp/ui": "0.12.2",
+    "@frontmcp/sdk": "1.0.0-beta.1",
+    "@frontmcp/ui": "1.0.0-beta.1",
     "@playwright/test": "^1.40.0",
     "jest": "^29.0.0",
     "@jest/globals": "^29.0.0"
@@ -111,8 +111,8 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@frontmcp/utils": "0.12.2",
-    "@modelcontextprotocol/sdk": "1.26.0",
+    "@frontmcp/utils": "1.0.0-beta.1",
+    "@frontmcp/protocol": "1.0.0-beta.1",
     "jose": "^6.0.11",
     "tslib": "^2.3.0"
   },

package/esm/perf/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // libs/testing/src/perf/metrics-collector.ts
 function isGcAvailable() {
   return typeof global.gc === "function";
@@ -829,7 +836,7 @@ function getPlatformCapabilities(platform) {
       ...baseCapabilities,
       experimental: {
         [MCP_APPS_EXTENSION_KEY]: {
-          mimeTypes: ["text/html+mcp"]
+          mimeTypes: ["text/html;profile=mcp-app"]
         }
       }
     };
@@ -950,7 +957,7 @@ var McpTestClientBuilder = class {
    *   .withCapabilities({
    *     sampling: {},
    *     experimental: {
-   *       'io.modelcontextprotocol/ui': { mimeTypes: ['text/html+mcp'] }
+   *       'io.modelcontextprotocol/ui': { mimeTypes: ['text/html;profile=mcp-app'] }
    *     }
    *   })
    *   .buildAndConnect();
@@ -1932,11 +1939,24 @@ var McpTestClient = class {
     this.log("debug", `Connecting to ${this.config.baseUrl}...`);
     this.transport = this.createTransport();
     await this.transport.connect();
-    const initResponse = await this.initialize();
-    if (!initResponse.success || !initResponse.data) {
-      throw new Error(`Failed to initialize MCP connection: ${initResponse.error?.message ?? "Unknown error"}`);
+    const maxRetries = 3;
+    const retryDelayMs = 500;
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const initResponse = await this.initialize();
+      if (initResponse.success && initResponse.data) {
+        this.initResult = initResponse.data;
+        break;
+      }
+      lastError = initResponse.error?.message ?? "Unknown error";
+      if (attempt < maxRetries) {
+        this.log("debug", `MCP init attempt ${attempt} failed (${lastError}), retrying in ${retryDelayMs}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      }
+    }
+    if (!this.initResult) {
+      throw new Error(`Failed to initialize MCP connection after ${maxRetries} attempts: ${lastError}`);
     }
-    this.initResult = initResponse.data;
     this._sessionId = this.transport.getSessionId();
     this._sessionInfo = {
       id: this._sessionId ?? `session-${Date.now()}`,
@@ -2627,7 +2647,7 @@ var McpTestClient = class {
     const raw = response.data ?? { content: [] };
     const isError = !response.success || raw.isError === true;
     const meta = raw._meta;
-    const hasUI = meta?.["ui/html"] !== void 0 || meta?.["ui/component"] !== void 0 || meta?.["openai/html"] !== void 0 || meta?.["frontmcp/html"] !== void 0;
+    const hasUI = meta?.["ui/html"] !== void 0 || meta?.["ui/component"] !== void 0;
     const structuredContent = raw["structuredContent"];
     return {
       raw,
@@ -2979,6 +2999,7 @@ var TestTokenFactory = class {
 
 // libs/testing/src/server/test-server.ts
 import { spawn } from "child_process";
+import { sha256Hex } from "@frontmcp/utils";
 
 // libs/testing/src/errors/index.ts
 var TestClientError = class extends Error {
@@ -3026,9 +3047,16 @@ var E2E_PORT_RANGES = {
   "demo-e2e-agents": { start: 50270, size: 10 },
   "demo-e2e-transport-recreation": { start: 50280, size: 10 },
   "demo-e2e-jobs": { start: 50290, size: 10 },
-  // Infrastructure E2E tests (50300-50399)
+  // Infrastructure E2E tests (50300-50409)
   "demo-e2e-redis": { start: 50300, size: 10 },
   "demo-e2e-serverless": { start: 50310, size: 10 },
+  "demo-e2e-uipack": { start: 50320, size: 10 },
+  "demo-e2e-agent-adapters": { start: 50330, size: 10 },
+  "demo-e2e-guard": { start: 50340, size: 10 },
+  // ESM E2E tests (50400-50449)
+  "esm-package-server": { start: 50400, size: 10 },
+  "esm-package-server-hot-reload": { start: 50410, size: 10 },
+  "esm-package-server-cli": { start: 50420, size: 10 },
   // Mock servers and utilities (50900-50999)
   "mock-oauth": { start: 50900, size: 10 },
   "mock-api": { start: 50910, size: 10 },
@@ -3100,7 +3128,7 @@ async function tryReservePort(port, project) {
     server.once("error", () => {
       resolve(false);
     });
-    server.listen(port, "::", () => {
+    server.listen(port, () => {
       reservedPorts.set(port, {
         port,
         project,
@@ -3141,7 +3169,7 @@ async function isPortAvailable(port) {
     server.once("error", () => {
       resolve(false);
     });
-    server.listen(port, "::", () => {
+    server.listen(port, () => {
       server.close(() => {
         resolve(true);
       });
@@ -3179,15 +3207,37 @@ var TestServer = class _TestServer {
    */
   static async start(options) {
     const project = options.project ?? "default";
-    const { port, release } = await reservePort(project, options.port);
-    const server = new _TestServer(options, port, release);
-    try {
-      await server.startProcess();
-    } catch (error) {
-      await server.stop();
-      throw error;
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const { port, release } = await reservePort(project, options.port);
+      const server = new _TestServer(options, port, release);
+      try {
+        await server.startProcess();
+        return server;
+      } catch (error) {
+        try {
+          await server.stop();
+        } catch (cleanupError) {
+          if (options.debug || DEBUG_SERVER) {
+            const msg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+            console.warn(`[TestServer] Cleanup failed after startup error: ${msg}`);
+          }
+        }
+        const isEADDRINUSE = error instanceof Error && (error.message.includes("EADDRINUSE") || server.getLogs().some((l) => l.includes("EADDRINUSE")));
+        if (isEADDRINUSE && attempt < maxAttempts) {
+          const delayMs = attempt * 500;
+          if (options.debug || DEBUG_SERVER) {
+            console.warn(
+              `[TestServer] EADDRINUSE on port ${port}, retrying in ${delayMs}ms (attempt ${attempt}/${maxAttempts})`
+            );
+          }
+          await sleep4(delayMs);
+          continue;
+        }
+        throw error;
+      }
     }
-    return server;
+    throw new Error(`[TestServer] Failed to start after ${maxAttempts} attempts`);
   }
   /**
    * Start an Nx project as test server
@@ -3198,22 +3248,44 @@ var TestServer = class _TestServer {
         `Invalid project name: ${project}. Must contain only alphanumeric, underscore, and hyphen characters.`
       );
     }
-    const { port, release } = await reservePort(project, options.port);
-    const serverOptions = {
-      ...options,
-      port,
-      project,
-      command: `npx nx serve ${project} --port ${port}`,
-      cwd: options.cwd ?? process.cwd()
-    };
-    const server = new _TestServer(serverOptions, port, release);
-    try {
-      await server.startProcess();
-    } catch (error) {
-      await server.stop();
-      throw error;
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const { port, release } = await reservePort(project, options.port);
+      const serverOptions = {
+        ...options,
+        port,
+        project,
+        command: `npx nx serve ${project} --port ${port}`,
+        cwd: options.cwd ?? process.cwd()
+      };
+      const server = new _TestServer(serverOptions, port, release);
+      try {
+        await server.startProcess();
+        return server;
+      } catch (error) {
+        try {
+          await server.stop();
+        } catch (cleanupError) {
+          if (options.debug || DEBUG_SERVER) {
+            const msg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+            console.warn(`[TestServer] Cleanup failed after startup error: ${msg}`);
+          }
+        }
+        const isEADDRINUSE = error instanceof Error && (error.message.includes("EADDRINUSE") || server.getLogs().some((l) => l.includes("EADDRINUSE")));
+        if (isEADDRINUSE && attempt < maxAttempts) {
+          const delayMs = attempt * 500;
+          if (options.debug || DEBUG_SERVER) {
+            console.warn(
+              `[TestServer] EADDRINUSE on port ${port}, retrying in ${delayMs}ms (attempt ${attempt}/${maxAttempts})`
+            );
+          }
+          await sleep4(delayMs);
+          continue;
+        }
+        throw error;
+      }
     }
-    return server;
+    throw new Error(`[TestServer] Failed to start after ${maxAttempts} attempts`);
   }
   /**
    * Create a test server connected to an already running server
@@ -3250,7 +3322,21 @@ var TestServer = class _TestServer {
     }
     if (this.process) {
       this.log("Stopping server...");
-      this.process.kill("SIGTERM");
+      if (this.process.exitCode !== null || this.process.signalCode !== null) {
+        this.log(`Server already exited (code: ${this.process.exitCode}, signal: ${this.process.signalCode})`);
+        this.process = null;
+        return;
+      }
+      const pid = this.process.pid;
+      try {
+        if (pid !== void 0) {
+          process.kill(-pid, "SIGTERM");
+        } else {
+          this.process.kill("SIGTERM");
+        }
+      } catch {
+        this.process.kill("SIGTERM");
+      }
       const exitPromise = new Promise((resolve) => {
         if (this.process) {
           this.process.once("exit", () => resolve());
@@ -3261,7 +3347,16 @@ var TestServer = class _TestServer {
       const killTimeout = setTimeout(() => {
         if (this.process) {
           this.log("Force killing server after timeout...");
-          this.process.kill("SIGKILL");
+          const killPid = this.process.pid;
+          try {
+            if (killPid !== void 0) {
+              process.kill(-killPid, "SIGKILL");
+            } else {
+              this.process.kill("SIGKILL");
+            }
+          } catch {
+            this.process.kill("SIGKILL");
+          }
         }
       }, 5e3);
       await exitPromise;
@@ -3326,14 +3421,17 @@ var TestServer = class _TestServer {
       ...this.options.env,
       PORT: String(this.options.port)
     };
+    const runtimeEnv = withWorkspaceProtocolFallback(env, this.options.cwd);
     if (this.portRelease) {
       await this.portRelease();
       this.portRelease = null;
+      await sleep4(300);
     }
     this.process = spawn(this.options.command, [], {
       cwd: this.options.cwd,
-      env,
+      env: runtimeEnv,
       shell: true,
+      detached: true,
       stdio: ["pipe", "pipe", "pipe"]
     });
     if (this.process.pid !== void 0) {
@@ -3485,6 +3583,111 @@ TIP: Set DEBUG_SERVER=1 or DEBUG=1 environment variable for verbose output`
 function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function withWorkspaceProtocolFallback(env, cwd) {
+  if (findInstalledProtocolPackageDir(cwd)) {
+    return env;
+  }
+  try {
+    const workspacePackageDir = findWorkspaceProtocolDir(cwd);
+    if (!workspacePackageDir) {
+      return env;
+    }
+    ensureWorkspaceProtocolLink(cwd, workspacePackageDir);
+    if (findInstalledProtocolPackageDir(cwd)) {
+      return env;
+    }
+    return withProtocolNodePathAlias(env, cwd, workspacePackageDir);
+  } catch (err) {
+    if (DEBUG_SERVER) {
+      console.error(
+        `[TestServer] Workspace protocol fallback failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return env;
+  }
+}
+function ensureWorkspaceProtocolLink(cwd, workspacePackageDir) {
+  const fs = __require("node:fs");
+  const path = __require("node:path");
+  const nodeModulesDir = findWorkspaceNodeModulesDir(cwd);
+  if (!nodeModulesDir) {
+    return;
+  }
+  const scopeDir = path.join(nodeModulesDir, "@frontmcp");
+  const aliasPackageDir = path.join(scopeDir, "protocol");
+  if (fs.existsSync(aliasPackageDir)) {
+    return;
+  }
+  fs.mkdirSync(scopeDir, { recursive: true });
+  try {
+    fs.symlinkSync(workspacePackageDir, aliasPackageDir, process.platform === "win32" ? "junction" : "dir");
+  } catch (error) {
+    const err = error;
+    if (err.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function withProtocolNodePathAlias(env, cwd, workspacePackageDir) {
+  const fs = __require("node:fs");
+  const os = __require("node:os");
+  const path = __require("node:path");
+  const aliasRoot = path.join(os.tmpdir(), "frontmcp-test-node-path", sha256Hex(cwd).slice(0, 12));
+  const scopeDir = path.join(aliasRoot, "@frontmcp");
+  const aliasPackageDir = path.join(scopeDir, "protocol");
+  fs.mkdirSync(scopeDir, { recursive: true });
+  try {
+    if (!fs.existsSync(aliasPackageDir)) {
+      fs.symlinkSync(workspacePackageDir, aliasPackageDir, process.platform === "win32" ? "junction" : "dir");
+    }
+  } catch (error) {
+    const err = error;
+    if (err.code !== "EEXIST") throw error;
+  }
+  const existingNodePath = env["NODE_PATH"];
+  const nodePathEntries = [aliasRoot, ...existingNodePath ? existingNodePath.split(path.delimiter) : []].filter(
+    Boolean
+  );
+  return {
+    ...env,
+    NODE_PATH: [...new Set(nodePathEntries)].join(path.delimiter)
+  };
+}
+function findUp(startDir, testFn) {
+  const path = __require("node:path");
+  let currentDir = startDir;
+  while (true) {
+    const result = testFn(currentDir);
+    if (result !== void 0) return result;
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) return void 0;
+    currentDir = parentDir;
+  }
+}
+function findWorkspaceProtocolDir(startDir) {
+  const fs = __require("node:fs");
+  const path = __require("node:path");
+  return findUp(startDir, (dir) => {
+    const candidate = path.join(dir, "libs", "protocol");
+    return fs.existsSync(path.join(candidate, "dist", "index.js")) ? candidate : void 0;
+  });
+}
+function findInstalledProtocolPackageDir(startDir) {
+  const fs = __require("node:fs");
+  const path = __require("node:path");
+  return findUp(startDir, (dir) => {
+    const candidate = path.join(dir, "node_modules", "@frontmcp", "protocol");
+    return fs.existsSync(path.join(candidate, "package.json")) ? candidate : void 0;
+  });
+}
+function findWorkspaceNodeModulesDir(startDir) {
+  const fs = __require("node:fs");
+  const path = __require("node:path");
+  return findUp(startDir, (dir) => {
+    const candidate = path.join(dir, "node_modules");
+    return fs.existsSync(candidate) ? candidate : void 0;
+  });
+}
 
 // libs/testing/src/perf/perf-test.ts
 var currentConfig = {};

package/esm/setup.mjs

@@ -8,23 +8,13 @@ var __commonJS = (cb, mod) => function __require() {
 
 // libs/testing/src/platform/platform-types.ts
 function getPlatformMimeType(platform) {
-  return platform === "openai" ? "text/html+skybridge" : "text/html+mcp";
+  return "text/html;profile=mcp-app";
 }
 function getToolCallMetaPrefixes(platform) {
-  switch (platform) {
-    case "openai":
-      return ["openai/"];
-    default:
-      return ["ui/"];
-  }
+  return ["ui/"];
 }
 function getForbiddenMetaPrefixes(platform) {
-  switch (platform) {
-    case "openai":
-      return ["ui/", "frontmcp/"];
-    default:
-      return ["openai/", "frontmcp/"];
-  }
+  return ["openai/", "frontmcp/"];
 }
 var init_platform_types = __esm({
   "libs/testing/src/platform/platform-types.ts"() {
@@ -141,12 +131,12 @@ var init_ui_matchers = __esm({
         };
       }
       const hasUiHtml = Boolean(meta["ui/html"]);
-      const hasOutputTemplate = Boolean(meta["openai/outputTemplate"]);
       const hasMimeType = Boolean(meta["ui/mimeType"]);
-      const pass = hasUiHtml || hasOutputTemplate || hasMimeType;
+      const hasUiObject = Boolean(meta["ui"] && typeof meta["ui"] === "object");
+      const pass = hasUiHtml || hasMimeType || hasUiObject;
       return {
         pass,
-        message: () => pass ? "Expected result not to have widget metadata" : "Expected _meta to have widget metadata (ui/html, openai/outputTemplate, or ui/mimeType)"
+        message: () => pass ? "Expected result not to have widget metadata" : "Expected _meta to have widget metadata (ui/html, ui/mimeType, or ui object)"
       };
     };
     toHaveCssClass = function(received, className) {
@@ -309,14 +299,7 @@ var init_ui_matchers = __esm({
           message: () => `Expected _meta to have MIME type "${expectedMimeType}" for platform "${platform}", but no _meta found`
         };
       }
-      let mimeTypeKey;
-      switch (platform) {
-        case "openai":
-          mimeTypeKey = "openai/mimeType";
-          break;
-        default:
-          mimeTypeKey = "ui/mimeType";
-      }
+      const mimeTypeKey = "ui/mimeType";
       const actualMimeType = meta[mimeTypeKey];
       const pass = actualMimeType === expectedMimeType;
       return {
@@ -332,14 +315,7 @@ var init_ui_matchers = __esm({
           message: () => `Expected _meta to have platform HTML for "${platform}", but no _meta found`
         };
       }
-      let htmlKey;
-      switch (platform) {
-        case "openai":
-          htmlKey = "openai/html";
-          break;
-        default:
-          htmlKey = "ui/html";
-      }
+      const htmlKey = "ui/html";
       const html = meta[htmlKey];
       const pass = typeof html === "string" && html.length > 0;
       return {

package/example-tools/index.d.ts

@@ -16,5 +16,5 @@
  */
 export { BASIC_UI_TOOL_CONFIG, FULL_UI_TOOL_CONFIG, basicUIToolInputSchema, basicUIToolOutputSchema, fullUIToolInputSchema, fullUIToolOutputSchema, } from './tool-configs';
 export { generateBasicUIToolOutput, generateFullUIToolOutput } from './tool-configs';
-export { EXPECTED_OPENAI_TOOLS_LIST_META_KEYS, EXPECTED_OPENAI_TOOL_CALL_META_KEYS, EXPECTED_EXTAPPS_TOOLS_LIST_META_KEYS, EXPECTED_EXTAPPS_TOOL_CALL_META_KEYS, EXPECTED_FRONTMCP_TOOLS_LIST_META_KEYS, EXPECTED_FRONTMCP_TOOL_CALL_META_KEYS, } from './tool-configs';
+export { EXPECTED_OPENAI_TOOLS_LIST_META_KEYS, EXPECTED_OPENAI_TOOL_CALL_META_KEYS, EXPECTED_EXTAPPS_TOOLS_LIST_META_KEYS, EXPECTED_EXTAPPS_TOOL_CALL_META_KEYS, EXPECTED_GENERIC_TOOLS_LIST_META_KEYS, EXPECTED_GENERIC_TOOL_CALL_META_KEYS, } from './tool-configs';
 //# sourceMappingURL=index.d.ts.map

package/example-tools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/example-tools/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAGrF,OAAO,EACL,oCAAoC,EACpC,mCAAmC,EACnC,qCAAqC,EACrC,oCAAoC,EACpC,sCAAsC,EACtC,qCAAqC,GACtC,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/example-tools/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAGrF,OAAO,EACL,oCAAoC,EACpC,mCAAmC,EACnC,qCAAqC,EACrC,oCAAoC,EACpC,qCAAqC,EACrC,oCAAoC,GACrC,MAAM,gBAAgB,CAAC"}

package/example-tools/tool-configs.d.ts

@@ -146,12 +146,14 @@ export declare function generateFullUIToolOutput(input: z.infer<typeof fullUIToo
 };
 /**
  * Expected meta keys for OpenAI platform in tools/list response.
+ * OpenAI now uses the standard ui/* namespace like all other platforms.
  */
-export declare const EXPECTED_OPENAI_TOOLS_LIST_META_KEYS: readonly ["openai/outputTemplate", "openai/resultCanProduceWidget", "openai/widgetAccessible"];
+export declare const EXPECTED_OPENAI_TOOLS_LIST_META_KEYS: readonly ["ui/resourceUri", "ui/mimeType", "ui/cdn", "ui/type"];
 /**
  * Expected meta keys for OpenAI platform in tools/call response.
+ * OpenAI now uses the standard ui/* namespace like all other platforms.
  */
-export declare const EXPECTED_OPENAI_TOOL_CALL_META_KEYS: readonly ["openai/html", "openai/mimeType", "openai/type"];
+export declare const EXPECTED_OPENAI_TOOL_CALL_META_KEYS: readonly ["ui/html", "ui/mimeType", "ui/type"];
 /**
  * Expected meta keys for ext-apps platform in tools/list response (SEP-1865).
  */
@@ -170,12 +172,4 @@ export declare const EXPECTED_GENERIC_TOOLS_LIST_META_KEYS: readonly ["ui/resour
  * Uses ui/* namespace only.
  */
 export declare const EXPECTED_GENERIC_TOOL_CALL_META_KEYS: readonly ["ui/html", "ui/mimeType", "ui/type"];
-/**
- * @deprecated Use EXPECTED_GENERIC_TOOLS_LIST_META_KEYS instead
- */
-export declare const EXPECTED_FRONTMCP_TOOLS_LIST_META_KEYS: readonly ["ui/resourceUri", "ui/mimeType", "ui/cdn", "ui/type"];
-/**
- * @deprecated Use EXPECTED_GENERIC_TOOL_CALL_META_KEYS instead
- */
-export declare const EXPECTED_FRONTMCP_TOOL_CALL_META_KEYS: readonly ["ui/html", "ui/mimeType", "ui/type"];
 //# sourceMappingURL=tool-configs.d.ts.map

package/example-tools/tool-configs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-configs.d.ts","sourceRoot":"","sources":["../../src/example-tools/tool-configs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,sBAAsB;;iBAEjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;QAM7B;;;WAGG;;;CASG,CAAC;AAMX;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;iBAGhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;QAM5B;;WAEG;;QAqBH;;WAEG;;QAEH;;WAEG;;;;;QAKH;;WAEG;;;;;QAKH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;;CAGG,CAAC;AAMX;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC;;;EAKtF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC;;;;;EAWpF;AAMD;;GAEG;AACH,eAAO,MAAM,oCAAoC,gGAIvC,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mCAAmC,4DAA6D,CAAC;AAE9G;;GAEG;AACH,eAAO,MAAM,qCAAqC,iEAAkE,CAAC;AAErH;;GAEG;AACH,eAAO,MAAM,oCAAoC,gDAAiD,CAAC;AAEnG;;;GAGG;AACH,eAAO,MAAM,qCAAqC,iEAAkE,CAAC;AAErH;;;GAGG;AACH,eAAO,MAAM,oCAAoC,gDAAiD,CAAC;AAEnG;;GAEG;AACH,eAAO,MAAM,sCAAsC,iEAAwC,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,qCAAqC,gDAAuC,CAAC"}
+{"version":3,"file":"tool-configs.d.ts","sourceRoot":"","sources":["../../src/example-tools/tool-configs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,sBAAsB;;iBAEjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;QAM7B;;;WAGG;;;CASG,CAAC;AAMX;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;iBAGhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;QAM5B;;WAEG;;QAqBH;;WAEG;;QAEH;;WAEG;;;;;QAKH;;WAEG;;;;;QAKH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;;CAGG,CAAC;AAMX;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC;;;EAKtF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC;;;;;EAWpF;AAMD;;;GAGG;AACH,eAAO,MAAM,oCAAoC,iEAAkE,CAAC;AAEpH;;;GAGG;AACH,eAAO,MAAM,mCAAmC,gDAAiD,CAAC;AAElG;;GAEG;AACH,eAAO,MAAM,qCAAqC,iEAAkE,CAAC;AAErH;;GAEG;AACH,eAAO,MAAM,oCAAoC,gDAAiD,CAAC;AAEnG;;;GAGG;AACH,eAAO,MAAM,qCAAqC,iEAAkE,CAAC;AAErH;;;GAGG;AACH,eAAO,MAAM,oCAAoC,gDAAiD,CAAC"}