diff --git a/CHANGELOG.md b/CHANGELOG.md
index 044072b..8cdfb92 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,20 @@
 ## Unreleased
 
+### New Features
+
+- **`preview_style_tool` and `style_comparison_tool` no longer require an existing `accessToken`.** Both previously made `accessToken` a required `pk.*` input — meaning a caller had to already have (or separately go create) a public token before either tool would do anything, for even a quick one-off preview. `accessToken` is now optional on both: when omitted, the tool auto-generates a preview token from the server's own access token (the same pattern `geojson_preview_tool`'s resource already used) via a new shared `mintScopedPreviewToken` utility, so a first call needs no setup at all.
+  - Pass `share: true` alongside your own `accessToken` on either tool to get a link built from a token you manage yourself, for when you actually want something durable to bookmark or hand to someone else — `share: true` without an `accessToken` is a clear validation error, not a silent fallback.
+  - The two tools' auto-mint tokens differ in shape, confirmed live against the real API: `preview_style_tool` mints a short-lived (~1h) `tk.*` token, since the Styles API's embeddable HTML preview page and GL JS both accept it fine. `style_comparison_tool` mints a non-expiring `pk.*` token instead — `agent.mapbox.com/tools/style-compare`, which its comparison link embeds, validates the token prefix itself and hard-rejects anything but `pk.*` (a `tk.*` token 400s there with "Configuration Error: Invalid token type"). The `pk.*` token is still narrowly scoped (`styles:tiles`/`styles:read`/`fonts:read`) and auto-generated, just not self-expiring; it persists on the account until manually revoked.
+  - Both tools now take `httpRequest` as a constructor dependency (matching every other network-calling tool in this repo) to make the mint call.
+  - **Hosted-endpoint-aware error messages.** Per `README.md`, the hosted MCP endpoint authenticates with its own access token rather than a personal Mapbox account token, and that token isn't granted `tokens:write` — so auto-mint can't work there. Without this, a hosted caller who omits `accessToken` would have hit a raw, misleading `jwtUtils` error (`"MAPBOX_ACCESS_TOKEN is not in valid JWT format"`, referencing an env var the hosted deployment doesn't even use) or a bare `Token API 403`. A new `describeAutoMintFailure` helper rewrites both into an actionable message pointing at `accessToken`/`list_tokens_tool`/`create_token_tool` instead.
+
+### Breaking Changes
+
+- **Consolidated `GeojsonPreviewUIResource` and `PreviewStyleUIResource` into a single `MapPreviewUIResource`.** Both were near-identical hand-written MCP Apps templates — the same postMessage handshake, fullscreen/open-link controls, and resize handling copy-pasted across ~650 lines, differing only in what they drew on the map once a tool result arrived (a GeoJSON overlay on the default Standard style vs. swapping to an arbitrary preview style). `geojson_preview_tool` and `preview_style_tool` now both declare `_meta.ui.resourceUri: 'ui://mapbox/map-preview/index.html'`, served by the merged resource, which dispatches on the shape of the tool-result URL it receives (a `geojson.io` URL vs. a Styles API `.html?access_token=...` preview URL) rather than assuming a fixed mode. Neither tool's own input/output contract changed.
+  - The public resource exports change: `previewStyleUI`/`geojsonPreviewUI` (from `@mapbox/mcp-devkit-server/resources`) are replaced by a single `mapPreviewUI`. `GeojsonPreviewUIResource`/`PreviewStyleUIResource` class exports are removed in favor of `MapPreviewUIResource`.
+  - `style_comparison_tool`'s `StyleComparisonUIResource` is untouched and stays separate — it renders two synced `mapboxgl.Map` instances under a swipe/compare slider, a genuinely different UI shape from "one map, different content," not just another mode to fold in.
+  - The GeoJSON-preview path keeps its existing eager map bootstrap (drawing the default Standard style immediately, before any tool result arrives, so an overlay has something to render onto right away); the style-preview path now reuses that same map instance via `setStyle()` when it exists, falling back to constructing its own (as before) when it doesn't. Verified live against the real Mapbox API in a real browser: the GeoJSON overlay path and the style-swap-in-place path (loading a real custom style by name) both work end-to-end on the merged resource.
+
 ### Dependencies
 
 - Bumped `@modelcontextprotocol/sdk` to `1.30.0`. Not adopting the `2026-07-28` spec revision this release covers (stateless request/response model, elicitation replaced by Multi Round-Trip Requests, Sampling deprecated) — that's a separate migration, tracked in #130, given this repo's own elicitation-based features depend on the mechanism being replaced. Regenerated `patches/@modelcontextprotocol+sdk+1.30.0.patch` (previously pinned to `1.29.0`) — same patch content, applies cleanly to the new version, verified live against the built server.
diff --git a/src/resources/index.ts b/src/resources/index.ts
index bc8a1fc..162a413 100644
--- a/src/resources/index.ts
+++ b/src/resources/index.ts
@@ -23,18 +23,16 @@ export { MapboxStyleLayersResource } from './mapbox-style-layers-resource/Mapbox
 export { MapboxStreetsV8FieldsResource } from './mapbox-streets-v8-fields-resource/MapboxStreetsV8FieldsResource.js';
 export { MapboxTokenScopesResource } from './mapbox-token-scopes-resource/MapboxTokenScopesResource.js';
 export { MapboxLayerTypeMappingResource } from './mapbox-layer-type-mapping-resource/MapboxLayerTypeMappingResource.js';
-export { PreviewStyleUIResource } from './ui-apps/PreviewStyleUIResource.js';
+export { MapPreviewUIResource } from './ui-apps/MapPreviewUIResource.js';
 export { StyleComparisonUIResource } from './ui-apps/StyleComparisonUIResource.js';
-export { GeojsonPreviewUIResource } from './ui-apps/GeojsonPreviewUIResource.js';
 
 // Import resource classes for instantiation
 import { MapboxStyleLayersResource } from './mapbox-style-layers-resource/MapboxStyleLayersResource.js';
 import { MapboxStreetsV8FieldsResource } from './mapbox-streets-v8-fields-resource/MapboxStreetsV8FieldsResource.js';
 import { MapboxTokenScopesResource } from './mapbox-token-scopes-resource/MapboxTokenScopesResource.js';
 import { MapboxLayerTypeMappingResource } from './mapbox-layer-type-mapping-resource/MapboxLayerTypeMappingResource.js';
-import { PreviewStyleUIResource } from './ui-apps/PreviewStyleUIResource.js';
+import { MapPreviewUIResource } from './ui-apps/MapPreviewUIResource.js';
 import { StyleComparisonUIResource } from './ui-apps/StyleComparisonUIResource.js';
-import { GeojsonPreviewUIResource } from './ui-apps/GeojsonPreviewUIResource.js';
 
 // Export pre-configured resource instances with short, clean names
 
@@ -50,15 +48,15 @@ export const mapboxTokenScopes = new MapboxTokenScopesResource();
 /** Mapbox layer type mapping reference */
 export const mapboxLayerTypeMapping = new MapboxLayerTypeMappingResource();
 
-/** Preview style UI resource */
-export const previewStyleUI = new PreviewStyleUIResource();
+/**
+ * Shared map preview UI resource — serves both geojson_preview_tool and
+ * preview_style_tool's inline MCP Apps preview.
+ */
+export const mapPreviewUI = new MapPreviewUIResource();
 
 /** Style comparison UI resource */
 export const styleComparisonUI = new StyleComparisonUIResource();
 
-/** GeoJSON preview UI resource */
-export const geojsonPreviewUI = new GeojsonPreviewUIResource();
-
 // Export registry functions for batch access
 export {
   getAllResources,
diff --git a/src/resources/resourceRegistry.ts b/src/resources/resourceRegistry.ts
index a9758bc..a3c871a 100644
--- a/src/resources/resourceRegistry.ts
+++ b/src/resources/resourceRegistry.ts
@@ -5,9 +5,8 @@ import { MapboxStyleLayersResource } from './mapbox-style-layers-resource/Mapbox
 import { MapboxStreetsV8FieldsResource } from './mapbox-streets-v8-fields-resource/MapboxStreetsV8FieldsResource.js';
 import { MapboxTokenScopesResource } from './mapbox-token-scopes-resource/MapboxTokenScopesResource.js';
 import { MapboxLayerTypeMappingResource } from './mapbox-layer-type-mapping-resource/MapboxLayerTypeMappingResource.js';
-import { PreviewStyleUIResource } from './ui-apps/PreviewStyleUIResource.js';
+import { MapPreviewUIResource } from './ui-apps/MapPreviewUIResource.js';
 import { StyleComparisonUIResource } from './ui-apps/StyleComparisonUIResource.js';
-import { GeojsonPreviewUIResource } from './ui-apps/GeojsonPreviewUIResource.js';
 
 // Central registry of all resources
 export const ALL_RESOURCES = [
@@ -16,9 +15,8 @@ export const ALL_RESOURCES = [
   new MapboxTokenScopesResource(),
   new MapboxLayerTypeMappingResource(),
   // MCP Apps UI resources (ui:// scheme)
-  new PreviewStyleUIResource(),
-  new StyleComparisonUIResource(),
-  new GeojsonPreviewUIResource()
+  new MapPreviewUIResource(),
+  new StyleComparisonUIResource()
 ] as const;
 
 export type ResourceInstance = (typeof ALL_RESOURCES)[number];
diff --git a/src/resources/ui-apps/GeojsonPreviewUIResource.ts b/src/resources/ui-apps/MapPreviewUIResource.ts
similarity index 69%
rename from src/resources/ui-apps/GeojsonPreviewUIResource.ts
rename to src/resources/ui-apps/MapPreviewUIResource.ts
index 48052fd..220ce81 100644
--- a/src/resources/ui-apps/GeojsonPreviewUIResource.ts
+++ b/src/resources/ui-apps/MapPreviewUIResource.ts
@@ -9,50 +9,32 @@ import type {
 } from '@modelcontextprotocol/sdk/types.js';
 import { RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
 import { BaseResource } from '../BaseResource.js';
-import {
-  getUserNameFromToken,
-  mapboxApiEndpoint
-} from '../../utils/jwtUtils.js';
+import { mintScopedPreviewToken } from '../../utils/mintScopedPreviewToken.js';
 
 const MAPBOX_GL_VERSION = '3.12.0';
 
-// GL JS needs a public token; mint a short-lived one per request from the
-// caller's sk.*. Do NOT cache it in module scope — on a multi-tenant server a
-// process-global cache can return one caller's token to a different caller.
-async function createPreviewToken(skToken: string): Promise<string> {
-  const username = getUserNameFromToken(skToken);
-  const expires = new Date(Date.now() + 60 * 60 * 1000).toISOString(); // 1 hour
-  const url = `${mapboxApiEndpoint()}tokens/v2/${username}?access_token=${skToken}`;
-
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      note: 'GeoJSON Preview (auto-generated, expires in 1h)',
-      scopes: ['styles:tiles', 'styles:read', 'fonts:read'],
-      expires
-    })
-  });
-
-  if (!response.ok) {
-    // Do not include the response body — it may echo the token back.
-    throw new Error(`Token API ${response.status}`);
-  }
-
-  const data = (await response.json()) as { token: string };
-  return data.token;
-}
-
 /**
- * Serves UI App HTML for GeoJSON Preview using Mapbox GL JS directly.
- * Renders GeoJSON inline — no inner iframe needed, so frame-src CSP is not an issue.
- * Implements MCP Apps pattern with ui:// scheme.
+ * Serves the UI App HTML shared by `geojson_preview_tool` and
+ * `preview_style_tool` — one Mapbox GL JS map that either draws a GeoJSON
+ * overlay on the default Standard style, or swaps to an arbitrary preview
+ * style, depending on which tool's result arrives. Renders inline — no
+ * inner iframe needed, so frame-src CSP is not an issue.
+ *
+ * Previously two nearly-identical resources (GeojsonPreviewUIResource,
+ * PreviewStyleUIResource) each hand-wrote the same MCP-Apps postMessage
+ * handshake, fullscreen/open-link controls, and resize handling. Merged
+ * here since the only real difference between them was what they drew on
+ * the map once data arrived, not how the map/iframe worked.
+ *
+ * `style_comparison_tool`'s dual-map swipe UI (StyleComparisonUIResource)
+ * is a genuinely different UI shape — two synced map instances under a
+ * compare slider, not "one map, different content" — and stays separate.
  */
-export class GeojsonPreviewUIResource extends BaseResource {
-  readonly name = 'GeoJSON Preview UI';
-  readonly uri = 'ui://mapbox/geojson-preview/index.html';
+export class MapPreviewUIResource extends BaseResource {
+  readonly name = 'Mapbox Map Preview UI';
+  readonly uri = 'ui://mapbox/map-preview/index.html';
   readonly description =
-    'Interactive UI for previewing GeoJSON data rendered inline with Mapbox GL JS (MCP Apps)';
+    'Interactive UI for previewing GeoJSON data or Mapbox styles rendered inline with Mapbox GL JS (MCP Apps)';
   readonly mimeType = RESOURCE_MIME_TYPE;
 
   public async readCallback(
@@ -69,14 +51,13 @@ export class GeojsonPreviewUIResource extends BaseResource {
     let accessToken = '';
     if (skToken.startsWith('sk.')) {
       try {
-        const minted = await createPreviewToken(skToken);
-        // Defense in depth: only embed a token minted for the caller's own
-        // account, so a token can never be served to a different caller.
-        if (getUserNameFromToken(minted) === getUserNameFromToken(skToken)) {
-          accessToken = minted;
-        }
+        accessToken = await mintScopedPreviewToken(fetch, skToken, {
+          note: 'Map Preview (auto-generated, expires in 1h)',
+          scopes: ['styles:tiles', 'styles:read', 'fonts:read']
+        });
       } catch {
-        // Non-fatal — map won't render but the link button still works
+        // Non-fatal — map won't render until a style-preview result
+        // supplies its own token, but the link button still works.
       }
     } else if (skToken.startsWith('pk.')) {
       accessToken = skToken; // Already a public token
@@ -87,7 +68,7 @@ export class GeojsonPreviewUIResource extends BaseResource {
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>GeoJSON Preview</title>
+  <title>Map Preview</title>
   <link href="https://api.mapbox.com/mapbox-gl-js/v${MAPBOX_GL_VERSION}/mapbox-gl.css" rel="stylesheet">
   <script src="https://api.mapbox.com/mapbox-gl-js/v${MAPBOX_GL_VERSION}/mapbox-gl.js"></script>
   <style>
@@ -104,6 +85,14 @@ export class GeojsonPreviewUIResource extends BaseResource {
       color: #d32f2f; background: #ffebee; border-radius: 8px;
       padding: 20px; max-width: 400px; text-align: center; z-index: 10;
     }
+    #style-name {
+      position: absolute; top: 10px; left: 50%; transform: translateX(-50%);
+      background: rgba(0,0,0,0.55); color: #fff;
+      padding: 5px 14px; border-radius: 12px;
+      font-size: 13px; font-weight: 500;
+      display: none; z-index: 10;
+      white-space: nowrap; max-width: 70%; overflow: hidden; text-overflow: ellipsis;
+    }
     #open-btn {
       position: absolute; bottom: 12px; right: 12px; z-index: 10;
       display: none;
@@ -128,8 +117,9 @@ export class GeojsonPreviewUIResource extends BaseResource {
 </head>
 <body>
   <div id="map"></div>
-  <div id="loading">Loading GeoJSON preview...</div>
+  <div id="loading">Loading preview...</div>
   <div id="error" style="display:none"></div>
+  <div id="style-name"></div>
   <button id="open-btn">↗ Open in browser</button>
   <button id="fullscreen-btn" title="Toggle fullscreen">⛶</button>
 
@@ -140,10 +130,10 @@ export class GeojsonPreviewUIResource extends BaseResource {
     var pendingGeoJSON = null;
     var currentPreviewUrl = '';
     var currentDisplayMode = 'inline';
-    var canFullscreen = false;
 
     var loadingEl = document.getElementById('loading');
     var errorEl = document.getElementById('error');
+    var styleNameEl = document.getElementById('style-name');
     var openBtn = document.getElementById('open-btn');
     var fullscreenBtn = document.getElementById('fullscreen-btn');
 
@@ -219,7 +209,6 @@ export class GeojsonPreviewUIResource extends BaseResource {
         }
         if (ctx && ctx.capabilities && ctx.capabilities.supportedDisplayModes &&
             ctx.capabilities.supportedDisplayModes.indexOf('fullscreen') !== -1) {
-          canFullscreen = true;
           fullscreenBtn.classList.add('visible');
         }
       }
@@ -228,7 +217,7 @@ export class GeojsonPreviewUIResource extends BaseResource {
     sendRequest('ui/initialize', {
       protocolVersion: '2026-01-26',
       appCapabilities: {},
-      clientInfo: { name: 'GeoJSON Preview', version: '1.0.0' }
+      clientInfo: { name: 'Mapbox Map Preview', version: '1.0.0' }
     }).then(function() {
       sendNotification('ui/notifications/initialized', {});
     }, function() {
@@ -236,7 +225,7 @@ export class GeojsonPreviewUIResource extends BaseResource {
     });
 
     // ---------------------------------------------------------------------------
-    // Map initialisation
+    // GeoJSON overlay helpers (used once we know we're in GeoJSON-preview mode)
     // ---------------------------------------------------------------------------
 
     function getGeojsonBounds(geojson) {
@@ -301,6 +290,47 @@ export class GeojsonPreviewUIResource extends BaseResource {
       }
     }
 
+    // ---------------------------------------------------------------------------
+    // Style-preview helper (used once we know we're in style-preview mode)
+    // ---------------------------------------------------------------------------
+
+    function onStyleLoaded() {
+      loadingEl.style.display = 'none';
+      var style = map.getStyle();
+      if (style && style.name) {
+        styleNameEl.textContent = style.name;
+        styleNameEl.style.display = 'block';
+      }
+      requestSizeToFit();
+    }
+
+    function showStylePreview(targetStyle, urlToken) {
+      mapboxgl.accessToken = urlToken;
+      if (map) {
+        // A map already exists (GeoJSON-preview's eager bootstrap below) —
+        // swap its style in place rather than creating a second instance.
+        map.once('style.load', onStyleLoaded);
+        map.setStyle(targetStyle);
+      } else {
+        map = new mapboxgl.Map({
+          container: 'map',
+          style: targetStyle,
+          center: [0, 20],
+          zoom: 1.5
+        });
+        map.addControl(new mapboxgl.NavigationControl(), 'top-left');
+        map.on('style.load', onStyleLoaded);
+      }
+    }
+
+    // ---------------------------------------------------------------------------
+    // Eager map bootstrap — draws the default Standard style immediately so a
+    // GeoJSON overlay has something to render onto as soon as it arrives.
+    // Style-preview mode doesn't need this (it supplies its own style/token),
+    // but eagerly creating it here does no harm: showStylePreview() above
+    // reuses this instance via setStyle() instead of creating a second one.
+    // ---------------------------------------------------------------------------
+
     if (TOKEN && typeof mapboxgl !== 'undefined') {
       mapboxgl.accessToken = TOKEN;
       map = new mapboxgl.Map({
@@ -321,11 +351,15 @@ export class GeojsonPreviewUIResource extends BaseResource {
       });
     } else {
       // No token or GL JS failed to load — wait for tool result to show link
-      loadingEl.textContent = 'Waiting for GeoJSON data...';
+      // (or, for style-preview mode, to supply its own token and build the map).
+      loadingEl.textContent = 'Waiting for preview data...';
     }
 
     // ---------------------------------------------------------------------------
-    // Tool result handler
+    // Tool result handler — dispatches on the URL shape returned by whichever
+    // tool fed this resource: geojson_preview_tool (a geojson.io URL carrying
+    // GeoJSON in its data= param) or preview_style_tool (a Styles API
+    // .html preview URL carrying its own access_token).
     // ---------------------------------------------------------------------------
 
     function handleToolResult(result) {
@@ -341,9 +375,41 @@ export class GeojsonPreviewUIResource extends BaseResource {
       currentPreviewUrl = url;
       openBtn.style.display = 'block';
 
-      // Parse GeoJSON from the geojson.io/next URL
+      if (typeof mapboxgl === 'undefined') {
+        loadingEl.style.display = 'none';
+        return;
+      }
+
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch (e) {
+        loadingEl.style.display = 'none';
+        errorEl.textContent = 'Could not parse tool result URL';
+        errorEl.style.display = 'block';
+        return;
+      }
+
+      const styleMatch = parsed.pathname.match(/\\/styles\\/v1\\/([^\\/]+)\\/([^.]+)\\.html/);
+      const urlToken = parsed.searchParams.get('access_token');
+
+      if (styleMatch && urlToken) {
+        // Style-preview mode
+        const username = styleMatch[1];
+        const styleId = styleMatch[2];
+        try {
+          showStylePreview('mapbox://styles/' + username + '/' + styleId, urlToken);
+        } catch (e) {
+          loadingEl.style.display = 'none';
+          errorEl.textContent = 'Could not load style';
+          errorEl.style.display = 'block';
+        }
+        return;
+      }
+
+      // GeoJSON-preview mode
       try {
-        const dataParam = new URL(url).searchParams.get('data');
+        const dataParam = parsed.searchParams.get('data');
         if (!dataParam || !dataParam.startsWith('data:application/json,')) throw new Error('Unexpected URL format');
         const geojson = JSON.parse(decodeURIComponent(dataParam.replace('data:application/json,', '')));
 
diff --git a/src/resources/ui-apps/PreviewStyleUIResource.ts b/src/resources/ui-apps/PreviewStyleUIResource.ts
deleted file mode 100644
index ae6932b..0000000
--- a/src/resources/ui-apps/PreviewStyleUIResource.ts
+++ /dev/null
@@ -1,268 +0,0 @@
-// Copyright (c) Mapbox, Inc.
-// Licensed under the MIT License.
-
-import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import type {
-  ReadResourceResult,
-  ServerNotification,
-  ServerRequest
-} from '@modelcontextprotocol/sdk/types.js';
-import { RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
-import { BaseResource } from '../BaseResource.js';
-
-const MAPBOX_GL_VERSION = '3.12.0';
-
-/**
- * Serves UI App HTML for Mapbox Style Preview using Mapbox GL JS directly.
- * Renders the style inline — no inner iframe needed, so frame-src CSP is not an issue.
- * The pk.* token is parsed from the tool result URL (supplied by the user to the tool).
- * Implements MCP Apps pattern with ui:// scheme.
- */
-export class PreviewStyleUIResource extends BaseResource {
-  readonly name = 'Mapbox Style Preview UI';
-  readonly uri = 'ui://mapbox/preview-style/index.html';
-  readonly description =
-    'Interactive UI for previewing Mapbox styles rendered inline with Mapbox GL JS (MCP Apps)';
-  readonly mimeType = RESOURCE_MIME_TYPE;
-
-  public async readCallback(
-    _uri: URL,
-    _extra: RequestHandlerExtra<ServerRequest, ServerNotification>
-  ): Promise<ReadResourceResult> {
-    const html = `<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Mapbox Style Preview</title>
-  <link href="https://api.mapbox.com/mapbox-gl-js/v${MAPBOX_GL_VERSION}/mapbox-gl.css" rel="stylesheet">
-  <script src="https://api.mapbox.com/mapbox-gl-js/v${MAPBOX_GL_VERSION}/mapbox-gl.js"></script>
-  <style>
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    html, body { width: 100%; height: 100%; overflow: hidden;
-      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; }
-    #map { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
-    #loading {
-      position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);
-      color: #aaa; font-size: 16px; z-index: 10; pointer-events: none;
-    }
-    #error {
-      position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);
-      color: #ff6b6b; background: rgba(0,0,0,0.7); border-radius: 8px;
-      padding: 20px; max-width: 400px; text-align: center; z-index: 10;
-    }
-    #style-name {
-      position: absolute; top: 10px; left: 50%; transform: translateX(-50%);
-      background: rgba(0,0,0,0.55); color: #fff;
-      padding: 5px 14px; border-radius: 12px;
-      font-size: 13px; font-weight: 500;
-      display: none; z-index: 10;
-      white-space: nowrap; max-width: 70%; overflow: hidden; text-overflow: ellipsis;
-    }
-    #open-btn {
-      position: absolute; bottom: 12px; right: 12px; z-index: 10;
-      display: none;
-      color: #fff; background: rgba(0,0,0,0.6);
-      font-size: 13px; padding: 5px 12px;
-      border: 1px solid rgba(255,255,255,0.4); border-radius: 4px;
-      cursor: pointer; font-family: inherit;
-    }
-    #open-btn:hover { background: rgba(0,0,0,0.8); }
-    #fullscreen-btn {
-      position: absolute; top: 10px; right: 10px; z-index: 10;
-      display: none;
-      width: 36px; height: 36px; border: none; border-radius: 8px;
-      background: rgba(255,255,255,0.92);
-      box-shadow: 0 1px 4px rgba(0,0,0,0.2);
-      cursor: pointer; align-items: center; justify-content: center;
-      font-size: 16px;
-    }
-    #fullscreen-btn.visible { display: flex; }
-    #fullscreen-btn:hover { background: rgba(240,240,240,0.95); }
-  </style>
-</head>
-<body>
-  <div id="map"></div>
-  <div id="loading">Loading style preview...</div>
-  <div id="error" style="display:none"></div>
-  <div id="style-name"></div>
-  <button id="open-btn">↗ Open in browser</button>
-  <button id="fullscreen-btn" title="Toggle fullscreen">⛶</button>
-
-  <script>
-    var map = null;
-    var currentPreviewUrl = '';
-    var currentDisplayMode = 'inline';
-
-    var loadingEl = document.getElementById('loading');
-    var errorEl = document.getElementById('error');
-    var styleNameEl = document.getElementById('style-name');
-    var openBtn = document.getElementById('open-btn');
-    var fullscreenBtn = document.getElementById('fullscreen-btn');
-
-    var messageId = 0;
-    var pendingRequests = new Map();
-
-    function sendRequest(method, params) {
-      var id = ++messageId;
-      window.parent.postMessage({ jsonrpc: '2.0', id: id, method: method, params: params || {} }, '*');
-      return new Promise(function(resolve, reject) {
-        pendingRequests.set(id, { resolve: resolve, reject: reject });
-      });
-    }
-
-    function sendNotification(method, params) {
-      window.parent.postMessage({ jsonrpc: '2.0', method: method, params: params || {} }, '*');
-    }
-
-    function requestSizeToFit() {
-      if (currentDisplayMode !== 'inline') return;
-      sendNotification('ui/notifications/size-changed', { height: 600 });
-    }
-
-    fullscreenBtn.addEventListener('click', function() {
-      var newMode = currentDisplayMode === 'fullscreen' ? 'inline' : 'fullscreen';
-      sendRequest('ui/request-display-mode', { mode: newMode }).then(function(result) {
-        currentDisplayMode = (result && result.mode) ? result.mode : newMode;
-        fullscreenBtn.textContent = currentDisplayMode === 'fullscreen' ? '⊟' : '⛶';
-        if (map) setTimeout(function() { map.resize(); }, 100);
-        if (currentDisplayMode === 'inline') requestSizeToFit();
-      }).catch(function() {});
-    });
-
-    openBtn.addEventListener('click', function() {
-      if (!currentPreviewUrl) return;
-      sendRequest('ui/open-link', { url: currentPreviewUrl }).catch(function() {
-        try {
-          var ta = document.createElement('textarea');
-          ta.value = currentPreviewUrl;
-          ta.style.cssText = 'position:fixed;opacity:0';
-          document.body.appendChild(ta);
-          ta.select();
-          document.execCommand('copy');
-          document.body.removeChild(ta);
-          openBtn.textContent = '✓ URL copied';
-          setTimeout(function() { openBtn.textContent = '↗ Open in browser'; }, 2000);
-        } catch (err) {}
-      });
-    });
-
-    window.addEventListener('message', function(event) {
-      var message = event.data;
-      if (!message || typeof message !== 'object') return;
-
-      if (message.id !== undefined && pendingRequests.has(message.id)) {
-        var handlers = pendingRequests.get(message.id);
-        pendingRequests.delete(message.id);
-        if (message.error) handlers.reject(new Error(message.error.message));
-        else handlers.resolve(message.result);
-        return;
-      }
-
-      if (message.method === 'ui/notifications/tool-result') {
-        if (message.params) handleToolResult(message.params);
-      }
-
-      if (message.method === 'ui/notifications/host-context-changed') {
-        var ctx = message.params;
-        if (ctx && ctx.displayMode) {
-          currentDisplayMode = ctx.displayMode;
-          fullscreenBtn.textContent = currentDisplayMode === 'fullscreen' ? '⊟' : '⛶';
-          if (map) setTimeout(function() { map.resize(); }, 100);
-        }
-        if (ctx && ctx.capabilities && ctx.capabilities.supportedDisplayModes &&
-            ctx.capabilities.supportedDisplayModes.indexOf('fullscreen') !== -1) {
-          fullscreenBtn.classList.add('visible');
-        }
-      }
-    });
-
-    sendRequest('ui/initialize', {
-      protocolVersion: '2026-01-26',
-      appCapabilities: {},
-      clientInfo: { name: 'Mapbox Style Preview', version: '1.0.0' }
-    }).then(function() {
-      sendNotification('ui/notifications/initialized', {});
-    }, function() {
-      sendNotification('ui/notifications/initialized', {});
-    });
-
-    function handleToolResult(result) {
-      const textContent = result.content?.find(c => c.type === 'text');
-      if (!textContent?.text) {
-        loadingEl.style.display = 'none';
-        errorEl.textContent = 'No URL found in tool result';
-        errorEl.style.display = 'block';
-        return;
-      }
-
-      const url = textContent.text;
-      currentPreviewUrl = url;
-      openBtn.style.display = 'block';
-
-      if (typeof mapboxgl === 'undefined') {
-        loadingEl.style.display = 'none';
-        return;
-      }
-
-      try {
-        const parsed = new URL(url);
-        const token = parsed.searchParams.get('access_token');
-        const match = parsed.pathname.match(/\\/styles\\/v1\\/([^\\/]+)\\/([^.]+)\\.html/);
-        if (!match || !token) throw new Error('Could not parse style URL');
-
-        const username = match[1];
-        const styleId = match[2];
-
-        mapboxgl.accessToken = token;
-        map = new mapboxgl.Map({
-          container: 'map',
-          style: 'mapbox://styles/' + username + '/' + styleId,
-          center: [0, 20],
-          zoom: 1.5
-        });
-        map.addControl(new mapboxgl.NavigationControl(), 'top-left');
-
-        map.on('style.load', function() {
-          loadingEl.style.display = 'none';
-          var style = map.getStyle();
-          if (style && style.name) {
-            styleNameEl.textContent = style.name;
-            styleNameEl.style.display = 'block';
-          }
-          requestSizeToFit();
-        });
-      } catch (e) {
-        loadingEl.style.display = 'none';
-        errorEl.textContent = 'Could not load style';
-        errorEl.style.display = 'block';
-      }
-    }
-  </script>
-</body>
-</html>`;
-
-    return {
-      contents: [
-        {
-          uri: this.uri,
-          mimeType: RESOURCE_MIME_TYPE,
-          text: html,
-          _meta: {
-            ui: {
-              csp: {
-                connectDomains: ['https://*.mapbox.com'],
-                resourceDomains: ['https://api.mapbox.com'],
-                workerDomains: ['blob:']
-              },
-              preferredSize: {
-                width: 1000,
-                height: 600
-              }
-            }
-          }
-        }
-      ]
-    };
-  }
-}
diff --git a/src/tools/geojson-preview-tool/GeojsonPreviewTool.ts b/src/tools/geojson-preview-tool/GeojsonPreviewTool.ts
index ce60f0c..4a76641 100644
--- a/src/tools/geojson-preview-tool/GeojsonPreviewTool.ts
+++ b/src/tools/geojson-preview-tool/GeojsonPreviewTool.ts
@@ -25,7 +25,7 @@ export class GeojsonPreviewTool extends BaseTool<typeof GeojsonPreviewSchema> {
 
   readonly meta = {
     ui: {
-      resourceUri: 'ui://mapbox/geojson-preview/index.html',
+      resourceUri: 'ui://mapbox/map-preview/index.html',
       csp: {
         frameDomains: ['https://geojson.io']
       }
diff --git a/src/tools/index.ts b/src/tools/index.ts
index ca134f3..91a537e 100644
--- a/src/tools/index.ts
+++ b/src/tools/index.ts
@@ -124,7 +124,7 @@ export const listTokens = new ListTokensTool({ httpRequest });
 export const optimizeStyle = new OptimizeStyleTool();
 
 /** Preview a Mapbox style */
-export const previewStyle = new PreviewStyleTool();
+export const previewStyle = new PreviewStyleTool({ httpRequest });
 
 /** Retrieve a Mapbox style */
 export const retrieveStyle = new RetrieveStyleTool({ httpRequest });
@@ -133,7 +133,7 @@ export const retrieveStyle = new RetrieveStyleTool({ httpRequest });
 export const styleBuilder = new StyleBuilderTool();
 
 /** Compare styles side-by-side */
-export const styleComparison = new StyleComparisonTool();
+export const styleComparison = new StyleComparisonTool({ httpRequest });
 
 /** Query tiles at a location */
 export const tilequery = new TilequeryTool({ httpRequest });
diff --git a/src/tools/preview-style-tool/PreviewStyleTool.input.schema.ts b/src/tools/preview-style-tool/PreviewStyleTool.input.schema.ts
index fb9111b..78dbb6d 100644
--- a/src/tools/preview-style-tool/PreviewStyleTool.input.schema.ts
+++ b/src/tools/preview-style-tool/PreviewStyleTool.input.schema.ts
@@ -9,8 +9,16 @@ export const PreviewStyleSchema = z.object({
       'pk.',
       'Invalid access token. Only public tokens (starting with pk.*) are allowed for preview URLs. Secret tokens (sk.*) cannot be used as they cannot be exposed in browser URLs.'
     )
+    .optional()
+    .describe(
+      'Existing Mapbox public token (must start with pk.* and have styles:read permission). Required when share is true, to build a durable link with a token you control. Optional otherwise — if omitted, a short-lived (~1 hour) preview token is generated automatically, so no existing token is needed for a quick inline look.'
+    ),
+  share: z
+    .boolean()
+    .optional()
+    .default(false)
     .describe(
-      'Mapbox public access token (required, must start with pk.* and have styles:read permission). Secret tokens (sk.*) cannot be used as they cannot be exposed in browser URLs. Please use an existing public token or get one from list_tokens_tool or create one with create_token_tool with styles:read permission.'
+      'Set to true to build a durable, shareable preview link using accessToken (required together with share). Defaults to false: generates a short-lived preview token automatically for viewing the style right now — the returned URL expires in about an hour and is not meant to be bookmarked or shared with others.'
     ),
   title: z
     .boolean()
diff --git a/src/tools/preview-style-tool/PreviewStyleTool.ts b/src/tools/preview-style-tool/PreviewStyleTool.ts
index f445161..de7544c 100644
--- a/src/tools/preview-style-tool/PreviewStyleTool.ts
+++ b/src/tools/preview-style-tool/PreviewStyleTool.ts
@@ -8,11 +8,16 @@ import {
   PreviewStyleInput
 } from './PreviewStyleTool.input.schema.js';
 import { getUserNameFromToken } from '../../utils/jwtUtils.js';
+import {
+  mintScopedPreviewToken,
+  describeAutoMintFailure
+} from '../../utils/mintScopedPreviewToken.js';
+import type { HttpRequest } from '../../utils/types.js';
 
 export class PreviewStyleTool extends BaseTool<typeof PreviewStyleSchema> {
   readonly name = 'preview_style_tool';
   readonly description =
-    'Generate preview URL for a Mapbox style using an existing public token';
+    'Generate a live preview of a Mapbox style. By default, auto-generates a short-lived preview token so you can view it right away — no existing token needed. Pass `share: true` with an existing public `accessToken` instead to generate a durable, shareable preview link.';
   readonly annotations = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -23,7 +28,7 @@ export class PreviewStyleTool extends BaseTool<typeof PreviewStyleSchema> {
 
   readonly meta = {
     ui: {
-      resourceUri: 'ui://mapbox/preview-style/index.html',
+      resourceUri: 'ui://mapbox/map-preview/index.html',
       csp: {
         connectDomains: ['https://*.mapbox.com'],
         resourceDomains: ['https://*.mapbox.com'],
@@ -32,29 +37,79 @@ export class PreviewStyleTool extends BaseTool<typeof PreviewStyleSchema> {
     }
   };
 
-  constructor() {
+  private readonly httpRequest: HttpRequest;
+
+  constructor(params: { httpRequest: HttpRequest }) {
     super({ inputSchema: PreviewStyleSchema });
+    this.httpRequest = params.httpRequest;
   }
 
-  protected async execute(input: PreviewStyleInput): Promise<CallToolResult> {
+  protected async execute(
+    input: PreviewStyleInput,
+    accessToken?: string
+  ): Promise<CallToolResult> {
     let userName: string;
-    try {
-      userName = getUserNameFromToken(input.accessToken);
-    } catch (error) {
+    let publicToken: string;
+
+    if (input.accessToken) {
+      // Caller-supplied token — used as-is, for either mode.
+      try {
+        userName = getUserNameFromToken(input.accessToken);
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: 'text',
+              text: error instanceof Error ? error.message : String(error)
+            }
+          ]
+        };
+      }
+      publicToken = input.accessToken;
+    } else if (input.share) {
       return {
         isError: true,
         content: [
           {
             type: 'text',
-            text: error instanceof Error ? error.message : String(error)
+            text:
+              '`share: true` requires an existing public token via `accessToken` — a persistent ' +
+              'pk.* token is needed for a durable, shareable link. Get one via list_tokens_tool ' +
+              'or create_token_tool, or omit `share` for a quick inline preview (no token needed).'
           }
         ]
       };
+    } else {
+      if (!accessToken) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: 'text',
+              text: 'No Mapbox access token available to generate a preview.'
+            }
+          ]
+        };
+      }
+      try {
+        userName = getUserNameFromToken(accessToken);
+        publicToken = await mintScopedPreviewToken(
+          this.httpRequest,
+          accessToken,
+          {
+            note: 'Style Preview (auto-generated, expires in 1h)',
+            scopes: ['styles:tiles', 'styles:read', 'fonts:read']
+          }
+        );
+      } catch (error) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: describeAutoMintFailure(error) }]
+        };
+      }
     }
 
-    // Use the user-provided public token
-    const publicToken = input.accessToken;
-
     // Build URL for the embeddable HTML endpoint
     const params = new URLSearchParams();
     params.append('access_token', publicToken);
diff --git a/src/tools/style-comparison-tool/StyleComparisonTool.schema.ts b/src/tools/style-comparison-tool/StyleComparisonTool.schema.ts
index 1265c11..f23d215 100644
--- a/src/tools/style-comparison-tool/StyleComparisonTool.schema.ts
+++ b/src/tools/style-comparison-tool/StyleComparisonTool.schema.ts
@@ -28,8 +28,16 @@ export const StyleComparisonSchema = z.object({
       'pk.',
       'Invalid token type. Style comparison requires a public token (pk.*) that can be used in browser URLs. Secret tokens (sk.*) cannot be exposed in client-side applications. Please provide a public token with styles:read permission.'
     )
+    .optional()
+    .describe(
+      'Existing Mapbox public token (must start with pk.* and have styles:read permission). Required when share is true, to build the comparison link with a token you control. Optional otherwise — if omitted, a scoped preview token is generated automatically, so no existing token is needed for a quick inline comparison.'
+    ),
+  share: z
+    .boolean()
+    .optional()
+    .default(false)
     .describe(
-      'Mapbox public access token (required, must start with pk.* and have styles:read permission). Secret tokens (sk.*) cannot be used as they cannot be exposed in browser URLs. Please use a public token or create one with styles:read permission.'
+      'Set to true to build the comparison link with an existing public token you provide via accessToken (required together with share) — use this for a link you intend to keep or share with someone else. Defaults to false: generates a scoped preview token automatically, tied to this comparison only and not tracked or named by you, so no existing token is needed for a quick look right now.'
     ),
   zoom: z
     .number()
diff --git a/src/tools/style-comparison-tool/StyleComparisonTool.ts b/src/tools/style-comparison-tool/StyleComparisonTool.ts
index e916b5a..f925957 100644
--- a/src/tools/style-comparison-tool/StyleComparisonTool.ts
+++ b/src/tools/style-comparison-tool/StyleComparisonTool.ts
@@ -10,13 +10,18 @@ import {
   StyleComparisonInput
 } from './StyleComparisonTool.schema.js';
 import { getUserNameFromToken } from '../../utils/jwtUtils.js';
+import {
+  mintScopedPreviewToken,
+  describeAutoMintFailure
+} from '../../utils/mintScopedPreviewToken.js';
+import type { HttpRequest } from '../../utils/types.js';
 
 export class StyleComparisonTool extends BaseTool<
   typeof StyleComparisonSchema
 > {
   readonly name = 'style_comparison_tool';
   readonly description =
-    'Generate a comparison URL for comparing two Mapbox styles side-by-side';
+    'Generate a live side-by-side comparison of two Mapbox styles. By default, auto-generates a scoped preview token so you can compare them right away — no existing token needed. Pass `share: true` with an existing public `accessToken` instead to generate a comparison link using a token you manage yourself.';
   readonly annotations = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -36,8 +41,11 @@ export class StyleComparisonTool extends BaseTool<
     }
   };
 
-  constructor() {
+  private readonly httpRequest: HttpRequest;
+
+  constructor(params: { httpRequest: HttpRequest }) {
     super({ inputSchema: StyleComparisonSchema });
+    this.httpRequest = params.httpRequest;
   }
 
   /**
@@ -86,14 +94,70 @@ export class StyleComparisonTool extends BaseTool<
   }
 
   protected async execute(
-    input: StyleComparisonInput
+    input: StyleComparisonInput,
+    accessToken?: string
   ): Promise<CallToolResult> {
+    let publicToken: string;
+
+    if (input.accessToken) {
+      // Caller-supplied token — used as-is, for either mode.
+      publicToken = input.accessToken;
+    } else if (input.share) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: 'text',
+            text:
+              '`share: true` requires an existing public token via `accessToken` — a persistent ' +
+              'pk.* token is needed for a durable, shareable link. Get one via list_tokens_tool ' +
+              'or create_token_tool, or omit `share` for a quick inline comparison (no token needed).'
+          }
+        ]
+      };
+    } else {
+      if (!accessToken) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: 'text',
+              text: 'No Mapbox access token available to generate a comparison.'
+            }
+          ]
+        };
+      }
+      try {
+        // Unlike the inline style preview, the comparison page this URL
+        // points to (agent.mapbox.com/tools/style-compare) validates the
+        // token prefix itself and hard-rejects anything but pk.* — a
+        // short-lived tk.* token (this repo's usual auto-mint default)
+        // fails there with a "Configuration Error", confirmed live. So
+        // this mints a real, non-expiring pk.* token instead: narrowly
+        // scoped, but it persists on the account until manually revoked.
+        publicToken = await mintScopedPreviewToken(
+          this.httpRequest,
+          accessToken,
+          {
+            note: 'Style Comparison (auto-generated)',
+            scopes: ['styles:tiles', 'styles:read', 'fonts:read'],
+            expiresInMs: null
+          }
+        );
+      } catch (error) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: describeAutoMintFailure(error) }]
+        };
+      }
+    }
+
     let beforeStyleId;
     let afterStyleId;
     try {
       // Process style IDs to get username/styleId format
-      beforeStyleId = this.processStyleId(input.before, input.accessToken);
-      afterStyleId = this.processStyleId(input.after, input.accessToken);
+      beforeStyleId = this.processStyleId(input.before, publicToken);
+      afterStyleId = this.processStyleId(input.after, publicToken);
     } catch (error) {
       return {
         content: [
@@ -111,7 +175,7 @@ export class StyleComparisonTool extends BaseTool<
 
     // Build the comparison URL
     const params = new URLSearchParams();
-    params.append('access_token', input.accessToken);
+    params.append('access_token', publicToken);
     params.append('before', beforeStyleId);
     params.append('after', afterStyleId);
 
diff --git a/src/tools/toolRegistry.ts b/src/tools/toolRegistry.ts
index 5e9237d..64f181f 100644
--- a/src/tools/toolRegistry.ts
+++ b/src/tools/toolRegistry.ts
@@ -36,13 +36,13 @@ export const CORE_TOOLS = [
   new RetrieveStyleTool({ httpRequest }),
   new UpdateStyleTool({ httpRequest }),
   new DeleteStyleTool({ httpRequest }),
-  new PreviewStyleTool(),
+  new PreviewStyleTool({ httpRequest }),
   new StyleBuilderTool(),
   new GeojsonPreviewTool(),
   new CheckColorContrastTool(),
   new CompareStylesTool(),
   new OptimizeStyleTool(),
-  new StyleComparisonTool(),
+  new StyleComparisonTool({ httpRequest }),
   new CreateTokenTool({ httpRequest }),
   new ListTokensTool({ httpRequest }),
   new BoundingBoxTool(),
diff --git a/src/utils/mintScopedPreviewToken.ts b/src/utils/mintScopedPreviewToken.ts
new file mode 100644
index 0000000..fafeccd
--- /dev/null
+++ b/src/utils/mintScopedPreviewToken.ts
@@ -0,0 +1,123 @@
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+
+import type { HttpRequest } from './types.js';
+import { getUserNameFromToken, mapboxApiEndpoint } from './jwtUtils.js';
+
+/**
+ * Mints a public token scoped to `scopes`, on the same account as
+ * `serverAccessToken`. Used to auto-generate a preview token when a caller
+ * hasn't supplied — and doesn't need to manage — a token of their own, e.g.
+ * for a one-off inline style preview or comparison.
+ *
+ * By default (`expiresInMs` omitted or a number), the Tokens API mints a
+ * short-lived **`tk.*`** temporary token — confirmed live against the real
+ * API — which is what GL JS and the Styles API's embeddable HTML preview
+ * page both accept. Pass `expiresInMs: null` to mint a genuine, non-expiring
+ * **`pk.*`** public token instead — required for any consumer that validates
+ * the token prefix itself and rejects non-`pk.*` tokens outright (confirmed
+ * live: `agent.mapbox.com/tools/style-compare`, which `style_comparison_tool`
+ * embeds, does exactly this and 400s on a `tk.*` token). A `pk.*` token
+ * minted this way does not self-expire; it persists on the account (scoped
+ * narrowly to `scopes`) until manually revoked.
+ *
+ * Verifies the minted token belongs to the caller's own account before
+ * returning it — defense in depth against a misbehaving/misconfigured
+ * backend returning a different account's token (see the AGI-905 regression
+ * suite this same check protects against in `MapPreviewUIResource`).
+ *
+ * Do NOT cache the result across calls: on a multi-tenant server, caching
+ * by anything less than the caller's own identity risks handing one
+ * caller's token to another.
+ */
+export async function mintScopedPreviewToken(
+  httpRequest: HttpRequest,
+  serverAccessToken: string,
+  params: { note: string; scopes: string[]; expiresInMs?: number | null }
+): Promise<string> {
+  const expectedUsername = getUserNameFromToken(serverAccessToken);
+  const expires =
+    params.expiresInMs === null
+      ? undefined
+      : new Date(
+          Date.now() + (params.expiresInMs ?? 60 * 60 * 1000)
+        ).toISOString();
+
+  const url = `${mapboxApiEndpoint()}tokens/v2/${expectedUsername}?access_token=${serverAccessToken}`;
+  const response = await httpRequest(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      note: params.note,
+      scopes: params.scopes,
+      ...(expires ? { expires } : {})
+    })
+  });
+
+  if (!response.ok) {
+    // Do not include the response body — it may echo the token back.
+    throw new Error(`Token API ${response.status}`);
+  }
+
+  const data = (await response.json()) as { token: string };
+  if (getUserNameFromToken(data.token) !== expectedUsername) {
+    throw new Error('Minted token does not match caller account');
+  }
+  return data.token;
+}
+
+/**
+ * Turns a failure from the auto-mint path (either `getUserNameFromToken`
+ * on the server's own token, or `mintScopedPreviewToken` itself) into a
+ * message that actually tells the caller what to do next, instead of
+ * surfacing jwtUtils' raw, `MAPBOX_ACCESS_TOKEN`-flavored error text or a
+ * bare `Token API 403`.
+ *
+ * Two known failure shapes, both confirmed against this repo's own code
+ * and docs rather than assumed:
+ *
+ * 1. The server's own access token isn't a personal Mapbox account token
+ *    at all, so a username can't even be resolved from it before a mint
+ *    attempt — this is the hosted MCP endpoint's normal case. Per
+ *    README.md: "the hosted deployment authenticates each request with
+ *    its own access token rather than your personal Mapbox account
+ *    token" and doesn't expose `create_token_tool` at all. There's no
+ *    reliable way to detect this shape ahead of time (it isn't a Mapbox
+ *    `pk./sk./tk.` token, so it never reaches the mint call), so this is
+ *    keyed off `getUserNameFromToken`'s own error text.
+ * 2. The server's own token IS a Mapbox token but lacks `tokens:write` —
+ *    the mint call itself 401s/403s.
+ *
+ * Anything else (e.g. a transient network/5xx failure) is passed through
+ * unchanged rather than guessed at.
+ */
+export function describeAutoMintFailure(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  const actionableSuffix =
+    'Pass accessToken directly instead: get an existing public token via ' +
+    'list_tokens_tool, or create one with create_token_tool if it is ' +
+    'available in this deployment.';
+
+  const cannotResolveAccount =
+    message.includes('is not in valid JWT format') ||
+    message.includes('does not contain username in payload') ||
+    message.includes('No access token provided');
+  if (cannotResolveAccount) {
+    return (
+      "Could not auto-generate a preview token: this server's own access " +
+      "token isn't a personal Mapbox account token (expected on " +
+      'deployments — like the hosted MCP endpoint — that authenticate a ' +
+      `different way). ${actionableSuffix}`
+    );
+  }
+
+  if (/^Token API 40[13]$/.test(message)) {
+    return (
+      "Could not auto-generate a preview token: this server's access " +
+      'token does not have permission to create new tokens (tokens:write). ' +
+      actionableSuffix
+    );
+  }
+
+  return message;
+}
diff --git a/test/resources/ui-apps/GeojsonPreviewUIResource.test.ts b/test/resources/ui-apps/GeojsonPreviewUIResource.test.ts
deleted file mode 100644
index 95ed635..0000000
--- a/test/resources/ui-apps/GeojsonPreviewUIResource.test.ts
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright (c) Mapbox, Inc.
-// Licensed under the MIT License.
-
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import { GeojsonPreviewUIResource } from '../../../src/resources/ui-apps/GeojsonPreviewUIResource.js';
-
-const uri = new URL('ui://mapbox/geojson-preview/index.html');
-
-// Build a Mapbox-style 3-part JWT whose payload carries the username (`u`).
-function makeToken(prefix: 'sk' | 'pk' | 'tk', username: string): string {
-  const payload = Buffer.from(JSON.stringify({ u: username })).toString(
-    'base64'
-  );
-  return `${prefix}.${payload}.sig`;
-}
-
-function embeddedToken(html: string): string | null {
-  const m = html.match(/var TOKEN = '([^']*)'/);
-  return m ? m[1] : null;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extra(token?: string): any {
-  return token ? { authInfo: { token } } : {};
-}
-
-async function readHtml(
-  resource: GeojsonPreviewUIResource,
-  token?: string
-): Promise<string> {
-  const result = await resource['readCallback'](uri, extra(token));
-  return result.contents[0].text as string;
-}
-
-// Stub global fetch to mirror real Mapbox behaviour: POST tokens/v2/{username}
-// mints a `tk` token for THAT account. Returns the mock for call assertions.
-function stubMintingFetch() {
-  const fn = vi.fn(async (input: string | URL | Request) => {
-    const url = String(input);
-    const username = decodeURIComponent(
-      url.match(/tokens\/v2\/([^?]+)/)?.[1] ?? ''
-    );
-    return new Response(JSON.stringify({ token: makeToken('tk', username) }), {
-      status: 200
-    });
-  });
-  vi.stubGlobal('fetch', fn);
-  return fn;
-}
-
-describe('GeojsonPreviewUIResource — AGI-905 cross-account token leak', () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it('embeds only the caller’s own minted token, never another account’s (regression)', async () => {
-    const fetchMock = stubMintingFetch();
-    const resource = new GeojsonPreviewUIResource();
-
-    const htmlA = await readHtml(resource, makeToken('sk', 'accountA'));
-    const htmlB = await readHtml(resource, makeToken('sk', 'accountB'));
-
-    const tokA = embeddedToken(htmlA);
-    const tokB = embeddedToken(htmlB);
-
-    // Each caller receives a token minted for their own account.
-    expect(tokA).toBe(makeToken('tk', 'accountA'));
-    expect(tokB).toBe(makeToken('tk', 'accountB'));
-
-    // B must never receive A's token.
-    expect(tokB).not.toBe(tokA);
-    expect(htmlB).not.toContain(tokA as string);
-
-    // No process-global cache: each read mints fresh.
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-  });
-
-  it('mints a fresh token on every read (no shared cache, even for the same caller)', async () => {
-    const fetchMock = stubMintingFetch();
-    const resource = new GeojsonPreviewUIResource();
-    const sk = makeToken('sk', 'acct');
-
-    await readHtml(resource, sk);
-    await readHtml(resource, sk);
-
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-  });
-
-  it('does not embed a token minted for a different account (identity assertion)', async () => {
-    // Simulate a (hypothetical) backend returning a token for someone else.
-    vi.stubGlobal(
-      'fetch',
-      vi.fn(
-        async () =>
-          new Response(JSON.stringify({ token: makeToken('tk', 'attacker') }), {
-            status: 200
-          })
-      )
-    );
-    const resource = new GeojsonPreviewUIResource();
-
-    const html = await readHtml(resource, makeToken('sk', 'victim'));
-
-    expect(embeddedToken(html)).toBe('');
-  });
-
-  it('renders without a token when minting fails (graceful degradation)', async () => {
-    vi.stubGlobal(
-      'fetch',
-      vi.fn(async () => new Response('forbidden', { status: 403 }))
-    );
-    const resource = new GeojsonPreviewUIResource();
-
-    const result = await resource['readCallback'](
-      uri,
-      extra(makeToken('sk', 'acct'))
-    );
-
-    expect(result.contents).toHaveLength(1);
-    expect(embeddedToken(result.contents[0].text as string)).toBe('');
-  });
-
-  it('passes a pk token through unchanged without minting', async () => {
-    const fetchMock = stubMintingFetch();
-    const resource = new GeojsonPreviewUIResource();
-    const pk = makeToken('pk', 'acct');
-
-    const html = await readHtml(resource, pk);
-
-    expect(embeddedToken(html)).toBe(pk);
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it('renders without a token when no token is provided', async () => {
-    const saved = process.env.MAPBOX_ACCESS_TOKEN;
-    delete process.env.MAPBOX_ACCESS_TOKEN;
-    try {
-      const fetchMock = stubMintingFetch();
-      const resource = new GeojsonPreviewUIResource();
-
-      const html = await readHtml(resource);
-
-      expect(embeddedToken(html)).toBe('');
-      expect(fetchMock).not.toHaveBeenCalled();
-    } finally {
-      if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
-    }
-  });
-});
diff --git a/test/resources/ui-apps/MapPreviewUIResource.test.ts b/test/resources/ui-apps/MapPreviewUIResource.test.ts
new file mode 100644
index 0000000..7322f66
--- /dev/null
+++ b/test/resources/ui-apps/MapPreviewUIResource.test.ts
@@ -0,0 +1,372 @@
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import * as vm from 'node:vm';
+import { MapPreviewUIResource } from '../../../src/resources/ui-apps/MapPreviewUIResource.js';
+
+const uri = new URL('ui://mapbox/map-preview/index.html');
+
+// Build a Mapbox-style 3-part JWT whose payload carries the username (`u`).
+function makeToken(prefix: 'sk' | 'pk' | 'tk', username: string): string {
+  const payload = Buffer.from(JSON.stringify({ u: username })).toString(
+    'base64'
+  );
+  return `${prefix}.${payload}.sig`;
+}
+
+function embeddedToken(html: string): string | null {
+  const m = html.match(/var TOKEN = '([^']*)'/);
+  return m ? m[1] : null;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extra(token?: string): any {
+  return token ? { authInfo: { token } } : {};
+}
+
+async function readHtml(
+  resource: MapPreviewUIResource,
+  token?: string
+): Promise<string> {
+  const result = await resource['readCallback'](uri, extra(token));
+  return result.contents[0].text as string;
+}
+
+// Stub global fetch to mirror real Mapbox behaviour: POST tokens/v2/{username}
+// mints a `tk` token for THAT account. Returns the mock for call assertions.
+function stubMintingFetch() {
+  const fn = vi.fn(async (input: string | URL | Request) => {
+    const url = String(input);
+    const username = decodeURIComponent(
+      url.match(/tokens\/v2\/([^?]+)/)?.[1] ?? ''
+    );
+    return new Response(JSON.stringify({ token: makeToken('tk', username) }), {
+      status: 200
+    });
+  });
+  vi.stubGlobal('fetch', fn);
+  return fn;
+}
+
+describe('MapPreviewUIResource — AGI-905 cross-account token leak', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('embeds only the caller’s own minted token, never another account’s (regression)', async () => {
+    const fetchMock = stubMintingFetch();
+    const resource = new MapPreviewUIResource();
+
+    const htmlA = await readHtml(resource, makeToken('sk', 'accountA'));
+    const htmlB = await readHtml(resource, makeToken('sk', 'accountB'));
+
+    const tokA = embeddedToken(htmlA);
+    const tokB = embeddedToken(htmlB);
+
+    // Each caller receives a token minted for their own account.
+    expect(tokA).toBe(makeToken('tk', 'accountA'));
+    expect(tokB).toBe(makeToken('tk', 'accountB'));
+
+    // B must never receive A's token.
+    expect(tokB).not.toBe(tokA);
+    expect(htmlB).not.toContain(tokA as string);
+
+    // No process-global cache: each read mints fresh.
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('mints a fresh token on every read (no shared cache, even for the same caller)', async () => {
+    const fetchMock = stubMintingFetch();
+    const resource = new MapPreviewUIResource();
+    const sk = makeToken('sk', 'acct');
+
+    await readHtml(resource, sk);
+    await readHtml(resource, sk);
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not embed a token minted for a different account (identity assertion)', async () => {
+    // Simulate a (hypothetical) backend returning a token for someone else.
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(
+        async () =>
+          new Response(JSON.stringify({ token: makeToken('tk', 'attacker') }), {
+            status: 200
+          })
+      )
+    );
+    const resource = new MapPreviewUIResource();
+
+    const html = await readHtml(resource, makeToken('sk', 'victim'));
+
+    expect(embeddedToken(html)).toBe('');
+  });
+
+  it('renders without a token when minting fails (graceful degradation)', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => new Response('forbidden', { status: 403 }))
+    );
+    const resource = new MapPreviewUIResource();
+
+    const result = await resource['readCallback'](
+      uri,
+      extra(makeToken('sk', 'acct'))
+    );
+
+    expect(result.contents).toHaveLength(1);
+    expect(embeddedToken(result.contents[0].text as string)).toBe('');
+  });
+
+  it('passes a pk token through unchanged without minting', async () => {
+    const fetchMock = stubMintingFetch();
+    const resource = new MapPreviewUIResource();
+    const pk = makeToken('pk', 'acct');
+
+    const html = await readHtml(resource, pk);
+
+    expect(embeddedToken(html)).toBe(pk);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('renders without a token when no token is provided', async () => {
+    const saved = process.env.MAPBOX_ACCESS_TOKEN;
+    delete process.env.MAPBOX_ACCESS_TOKEN;
+    try {
+      const fetchMock = stubMintingFetch();
+      const resource = new MapPreviewUIResource();
+
+      const html = await readHtml(resource);
+
+      expect(embeddedToken(html)).toBe('');
+      expect(fetchMock).not.toHaveBeenCalled();
+    } finally {
+      if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
+    }
+  });
+});
+
+/**
+ * Extracts and runs the resource's inline <script> in a sandboxed VM
+ * context, with just enough of window/document/mapboxgl stubbed to
+ * exercise the merged handleToolResult() dispatch — the one genuinely new
+ * piece of logic this consolidation introduces (previously each resource
+ * only ever had one branch; now one shared script has to tell a
+ * geojson_preview_tool result apart from a preview_style_tool result).
+ */
+function extractScript(html: string): string {
+  const match = html.match(/<script>\s*var TOKEN[\s\S]*?<\/script>/);
+  if (!match) throw new Error('Could not find inline <script> block');
+  return match[0].replace(/^<script>/, '').replace(/<\/script>$/, '');
+}
+
+async function renderHtml(accessToken?: string): Promise<string> {
+  const resource = new MapPreviewUIResource();
+  if (accessToken?.startsWith('pk.')) {
+    const result = await resource['readCallback'](uri, extra(accessToken));
+    return result.contents[0].text as string;
+  }
+  const result = await resource['readCallback'](uri, extra());
+  return result.contents[0].text as string;
+}
+
+function runScriptSandbox(
+  scriptSource: string,
+  options: { mapboxglAvailable: boolean }
+) {
+  const postMessageCalls: Array<Record<string, unknown>> = [];
+  let messageListener: ((event: { data: unknown }) => void) | undefined;
+
+  function fakeElement() {
+    return {
+      style: {} as Record<string, string>,
+      textContent: '',
+      classList: { add: () => {} },
+      addEventListener: () => {}
+    };
+  }
+  const elementsById: Record<string, ReturnType<typeof fakeElement>> = {};
+  function getElementById(id: string) {
+    if (!elementsById[id]) elementsById[id] = fakeElement();
+    return elementsById[id];
+  }
+
+  const addSourceSpy = vi.fn();
+  const addLayerSpy = vi.fn();
+  const setStyleSpy = vi.fn();
+  const removeLayerSpy = vi.fn();
+  const removeSourceSpy = vi.fn();
+
+  const fakeMapInstance = {
+    addControl: () => {},
+    on: (event: string, cb: () => void) => {
+      if (event === 'load' || event === 'style.load') cb();
+    },
+    once: (_event: string, cb: () => void) => cb(),
+    addSource: addSourceSpy,
+    addLayer: addLayerSpy,
+    setStyle: setStyleSpy,
+    getLayer: () => null,
+    getSource: () => null,
+    removeLayer: removeLayerSpy,
+    removeSource: removeSourceSpy,
+    fitBounds: () => {},
+    flyTo: () => {},
+    resize: () => {},
+    getStyle: () => ({ name: 'Test Style' })
+  };
+
+  const mapboxglMock = options.mapboxglAvailable
+    ? {
+        accessToken: '',
+        Map: function Map() {
+          return fakeMapInstance;
+        },
+        NavigationControl: function NavigationControl() {}
+      }
+    : undefined;
+
+  const sandbox: Record<string, unknown> = {
+    window: {
+      addEventListener: (event: string, cb: typeof messageListener) => {
+        if (event === 'message') messageListener = cb;
+      },
+      parent: {
+        postMessage: (message: Record<string, unknown>) => {
+          postMessageCalls.push(message);
+        }
+      }
+    },
+    document: {
+      getElementById: getElementById,
+      createElement: () => fakeElement()
+    },
+    mapboxgl: mapboxglMock,
+    console,
+    setTimeout,
+    URL,
+    Map: globalThis.Map
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(scriptSource, sandbox);
+
+  const initId = postMessageCalls.find((m) => m.method === 'ui/initialize')
+    ?.id as number | undefined;
+  if (initId !== undefined && messageListener) {
+    messageListener({ data: { jsonrpc: '2.0', id: initId, result: {} } });
+  }
+
+  return {
+    sendToolResult: (url: string) => {
+      messageListener?.({
+        data: {
+          jsonrpc: '2.0',
+          method: 'ui/notifications/tool-result',
+          params: { content: [{ type: 'text', text: url }] }
+        }
+      });
+    },
+    mapboxglMock,
+    map: fakeMapInstance,
+    addSourceSpy,
+    addLayerSpy,
+    setStyleSpy,
+    errorEl: elementsById.error
+  };
+}
+
+describe('MapPreviewUIResource — merged tool-result dispatch', () => {
+  it('routes a geojson_preview_tool URL to the GeoJSON overlay path', async () => {
+    const html = await renderHtml(
+      'pk.' +
+        Buffer.from(JSON.stringify({ u: 'acct' })).toString('base64') +
+        '.sig'
+    );
+    const script = extractScript(html);
+    const { sendToolResult, addSourceSpy, addLayerSpy, setStyleSpy } =
+      runScriptSandbox(script, { mapboxglAvailable: true });
+
+    const geojson = { type: 'Point', coordinates: [-122.4, 37.8] };
+    const geojsonUrl =
+      'https://geojson.io/?data=data:application/json,' +
+      encodeURIComponent(JSON.stringify(geojson));
+
+    sendToolResult(geojsonUrl);
+
+    expect(addSourceSpy).toHaveBeenCalledWith(
+      'geojson',
+      expect.objectContaining({ type: 'geojson' })
+    );
+    expect(addLayerSpy).toHaveBeenCalled();
+    expect(setStyleSpy).not.toHaveBeenCalled();
+  });
+
+  it('routes a preview_style_tool URL to the style-swap path, reusing the existing map', async () => {
+    const html = await renderHtml(
+      'pk.' +
+        Buffer.from(JSON.stringify({ u: 'acct' })).toString('base64') +
+        '.sig'
+    );
+    const script = extractScript(html);
+    const { sendToolResult, setStyleSpy, addSourceSpy, mapboxglMock } =
+      runScriptSandbox(script, { mapboxglAvailable: true });
+
+    const styleUrl =
+      'https://api.mapbox.com/styles/v1/someuser/some-style-id.html?access_token=pk.newtoken.sig&fresh=true';
+
+    sendToolResult(styleUrl);
+
+    expect(setStyleSpy).toHaveBeenCalledWith(
+      'mapbox://styles/someuser/some-style-id'
+    );
+    // Swaps mapboxgl.accessToken to the URL's own token, not the
+    // server-minted one the map was originally created with.
+    expect(mapboxglMock?.accessToken).toBe('pk.newtoken.sig');
+    expect(addSourceSpy).not.toHaveBeenCalled();
+  });
+
+  it('creates a fresh map for a style-preview URL when no eager map exists (no server token)', async () => {
+    const saved = process.env.MAPBOX_ACCESS_TOKEN;
+    delete process.env.MAPBOX_ACCESS_TOKEN;
+    try {
+      const html = await renderHtml(); // no token at all
+      const script = extractScript(html);
+      const { sendToolResult, setStyleSpy, mapboxglMock } = runScriptSandbox(
+        script,
+        { mapboxglAvailable: true }
+      );
+
+      const styleUrl =
+        'https://api.mapbox.com/styles/v1/someuser/some-style-id.html?access_token=pk.newtoken.sig';
+
+      sendToolResult(styleUrl);
+
+      // setStyle is only used for the "map already exists" path; with no
+      // eager map, a fresh mapboxgl.Map(...) is constructed directly with
+      // the target style instead.
+      expect(setStyleSpy).not.toHaveBeenCalled();
+      expect(mapboxglMock?.accessToken).toBe('pk.newtoken.sig');
+    } finally {
+      if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
+    }
+  });
+
+  it('shows an error for a tool-result URL matching neither shape', async () => {
+    const html = await renderHtml(
+      'pk.' +
+        Buffer.from(JSON.stringify({ u: 'acct' })).toString('base64') +
+        '.sig'
+    );
+    const script = extractScript(html);
+    const { sendToolResult, errorEl } = runScriptSandbox(script, {
+      mapboxglAvailable: true
+    });
+
+    sendToolResult('https://example.com/not-a-recognized-shape');
+
+    expect(errorEl?.textContent).toContain('Could not parse GeoJSON');
+  });
+});
diff --git a/test/security/path-traversal.test.ts b/test/security/path-traversal.test.ts
index f7b27bd..e26bca8 100644
--- a/test/security/path-traversal.test.ts
+++ b/test/security/path-traversal.test.ts
@@ -200,7 +200,8 @@ describe('path traversal security', () => {
     it('PreviewStyleTool encodes username containing "/" in preview URL and resource URI', async () => {
       const maliciousPublicToken = makePublicToken('user/attacker');
 
-      const result = await new PreviewStyleTool().run({
+      const { httpRequest } = setupHttpRequest();
+      const result = await new PreviewStyleTool({ httpRequest }).run({
         styleId: VALID_STYLE_ID,
         accessToken: maliciousPublicToken
       });
diff --git a/test/tools/__snapshots__/tool-naming-convention.test.ts.snap b/test/tools/__snapshots__/tool-naming-convention.test.ts.snap
index a7277a3..fe074f7 100644
--- a/test/tools/__snapshots__/tool-naming-convention.test.ts.snap
+++ b/test/tools/__snapshots__/tool-naming-convention.test.ts.snap
@@ -74,7 +74,7 @@ exports[`Tool Naming Convention > should maintain consistent tool list (snapshot
   },
   {
     "className": "PreviewStyleTool",
-    "description": "Generate preview URL for a Mapbox style using an existing public token",
+    "description": "Generate a live preview of a Mapbox style. By default, auto-generates a short-lived preview token so you can view it right away — no existing token needed. Pass \`share: true\` with an existing public \`accessToken\` instead to generate a durable, shareable preview link.",
     "toolName": "preview_style_tool",
   },
   {
@@ -149,7 +149,7 @@ If a layer type is not recognized, the tool will provide helpful suggestions sho
   },
   {
     "className": "StyleComparisonTool",
-    "description": "Generate a comparison URL for comparing two Mapbox styles side-by-side",
+    "description": "Generate a live side-by-side comparison of two Mapbox styles. By default, auto-generates a scoped preview token so you can compare them right away — no existing token needed. Pass \`share: true\` with an existing public \`accessToken\` instead to generate a comparison link using a token you manage yourself.",
     "toolName": "style_comparison_tool",
   },
   {
diff --git a/test/tools/preview-style-tool/PreviewStyleTool.test.ts b/test/tools/preview-style-tool/PreviewStyleTool.test.ts
index 93ee55e..5bd2568 100644
--- a/test/tools/preview-style-tool/PreviewStyleTool.test.ts
+++ b/test/tools/preview-style-tool/PreviewStyleTool.test.ts
@@ -2,21 +2,29 @@
 // Licensed under the MIT License.
 
 process.env.MAPBOX_ACCESS_TOKEN =
-  'sk.eyJhbGciOiJIUzI1NiJ9.eyJ1IjoidGVzdC11c2VyIiwiYSI6InRlc3QtYXBpIn0.signature';
+  'sk.eyJ1IjoidGVzdC11c2VyIiwiYSI6InRlc3QtYXBpIn0.signature';
 
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { PreviewStyleTool } from '../../../src/tools/preview-style-tool/PreviewStyleTool.js';
 
+// None of the existing tests below hit the network (they all supply their
+// own accessToken), but the tool now takes httpRequest as a constructor
+// dependency regardless, matching every other network-calling tool in this
+// repo — see toolRegistry.ts.
+function newTool(httpRequest = vi.fn()) {
+  return new PreviewStyleTool({ httpRequest });
+}
+
 describe('PreviewStyleTool', () => {
   const TEST_ACCESS_TOKEN =
     'pk.eyJ1IjoidGVzdC11c2VyIiwiYSI6InRlc3QtYXBpIn0.signature';
 
   describe('tool metadata', () => {
     it('should have correct name and description', () => {
-      const tool = new PreviewStyleTool();
+      const tool = newTool();
       expect(tool.name).toBe('preview_style_tool');
-      expect(tool.description).toBe(
-        'Generate preview URL for a Mapbox style using an existing public token'
+      expect(tool.description).toContain(
+        'auto-generates a short-lived preview token'
       );
     });
 
@@ -28,7 +36,7 @@ describe('PreviewStyleTool', () => {
   });
 
   it('uses user-provided public token and returns preview URL', async () => {
-    const result = await new PreviewStyleTool().run({
+    const result = await newTool().run({
       styleId: 'cmojrmkc9002t01ry96yi6h48',
       accessToken: TEST_ACCESS_TOKEN,
       title: false,
@@ -45,7 +53,7 @@ describe('PreviewStyleTool', () => {
   });
 
   it('includes styleId in URL', async () => {
-    const result = await new PreviewStyleTool().run({
+    const result = await newTool().run({
       styleId: 'cmojrmkc9002t01ry96yi6h49',
       accessToken: TEST_ACCESS_TOKEN,
       title: false,
@@ -61,7 +69,7 @@ describe('PreviewStyleTool', () => {
   });
 
   it('includes title parameter when provided', async () => {
-    const result = await new PreviewStyleTool().run({
+    const result = await newTool().run({
       styleId: 'cmojrmkc9002t01ry96yi6h48',
       accessToken: TEST_ACCESS_TOKEN,
       title: true,
@@ -75,7 +83,7 @@ describe('PreviewStyleTool', () => {
   });
 
   it('includes zoomwheel parameter when provided', async () => {
-    const result = await new PreviewStyleTool().run({
+    const result = await newTool().run({
       styleId: 'cmojrmkc9002t01ry96yi6h48',
       accessToken: TEST_ACCESS_TOKEN,
       zoomwheel: false,
@@ -89,7 +97,7 @@ describe('PreviewStyleTool', () => {
   });
 
   it('includes fresh parameter for secure access', async () => {
-    const result = await new PreviewStyleTool().run({
+    const result = await newTool().run({
       styleId: 'cmojrmkc9002t01ry96yi6h48',
       accessToken: TEST_ACCESS_TOKEN,
       title: false,
@@ -103,7 +111,7 @@ describe('PreviewStyleTool', () => {
   });
 
   it('rejects secret tokens', async () => {
-    const result = await new PreviewStyleTool().run({
+    const result = await newTool().run({
       styleId: 'cmojrmkc9002t01ry96yi6h48',
       accessToken:
         'sk.eyJhbGciOiJIUzI1NiJ9.eyJ1IjoidGVzdC11c2VyIn0.secret_token',
@@ -121,7 +129,7 @@ describe('PreviewStyleTool', () => {
   });
 
   it('rejects temporary tokens', async () => {
-    const result = await new PreviewStyleTool().run({
+    const result = await newTool().run({
       styleId: 'cmojrmkc9002t01ry96yi6h48',
       accessToken: 'tk.eyJhbGciOiJIUzI1NiJ9.eyJ1IjoidGVzdC11c2VyIn0.temp_token',
       title: false,
@@ -138,7 +146,7 @@ describe('PreviewStyleTool', () => {
   });
 
   it('returns URL and MCP-UI resource on success (default)', async () => {
-    const result = await new PreviewStyleTool().run({
+    const result = await newTool().run({
       styleId: 'cmojrmkc9002t01ry96yi6h48',
       accessToken: TEST_ACCESS_TOKEN,
       title: false,
@@ -174,7 +182,7 @@ describe('PreviewStyleTool', () => {
   });
 
   it('returns URL and MCP-UI resource for backward compatibility', async () => {
-    const result = await new PreviewStyleTool().run({
+    const result = await newTool().run({
       styleId: 'cmojrmkc9002t01ry96yi6h48',
       accessToken: TEST_ACCESS_TOKEN,
       title: false,
@@ -195,4 +203,136 @@ describe('PreviewStyleTool', () => {
       type: 'resource'
     });
   });
+
+  describe('auto-minted inline preview (no accessToken, no share)', () => {
+    function stubMintingFetch() {
+      return vi.fn(
+        async (_input: string | URL | Request, _init?: RequestInit) =>
+          new Response(
+            JSON.stringify({
+              token: 'pk.eyJ1IjoidGVzdC11c2VyIn0.minted'
+            }),
+            { status: 200 }
+          )
+      );
+    }
+
+    it('auto-generates a short-lived token from the server access token and needs no accessToken input', async () => {
+      const httpRequest = stubMintingFetch();
+      const result = await new PreviewStyleTool({ httpRequest }).run({
+        styleId: 'cmojrmkc9002t01ry96yi6h48',
+        title: false,
+        zoomwheel: false
+      });
+
+      expect(result.isError).toBe(false);
+      expect(httpRequest).toHaveBeenCalledTimes(1);
+      const [url, init] = httpRequest.mock.calls[0];
+      expect(String(url)).toContain('tokens/v2/test-user');
+      expect(JSON.parse((init as RequestInit).body as string)).toMatchObject({
+        scopes: ['styles:tiles', 'styles:read', 'fonts:read']
+      });
+      expect(result.content[0]).toMatchObject({
+        type: 'text',
+        text: expect.stringContaining(
+          '/styles/v1/test-user/cmojrmkc9002t01ry96yi6h48.html?access_token=pk.'
+        )
+      });
+    });
+
+    it('errors clearly when share is true but accessToken is missing', async () => {
+      const httpRequest = stubMintingFetch();
+      const result = await new PreviewStyleTool({ httpRequest }).run({
+        styleId: 'cmojrmkc9002t01ry96yi6h48',
+        share: true,
+        title: false,
+        zoomwheel: false
+      });
+
+      expect(result.isError).toBe(true);
+      expect(httpRequest).not.toHaveBeenCalled();
+      expect(result.content[0]).toMatchObject({
+        type: 'text',
+        text: expect.stringContaining('share: true` requires')
+      });
+    });
+
+    it('an explicit accessToken is honored even when share is true', async () => {
+      const httpRequest = stubMintingFetch();
+      const result = await new PreviewStyleTool({ httpRequest }).run({
+        styleId: 'cmojrmkc9002t01ry96yi6h48',
+        share: true,
+        accessToken: TEST_ACCESS_TOKEN,
+        title: false,
+        zoomwheel: false
+      });
+
+      expect(result.isError).toBe(false);
+      expect(httpRequest).not.toHaveBeenCalled();
+      expect(result.content[0]).toMatchObject({
+        type: 'text',
+        text: expect.stringContaining(`access_token=${TEST_ACCESS_TOKEN}`)
+      });
+    });
+
+    it('errors when no server access token is available to mint from', async () => {
+      const saved = process.env.MAPBOX_ACCESS_TOKEN;
+      delete process.env.MAPBOX_ACCESS_TOKEN;
+      try {
+        const httpRequest = stubMintingFetch();
+        const result = await new PreviewStyleTool({ httpRequest }).run({
+          styleId: 'cmojrmkc9002t01ry96yi6h48',
+          title: false,
+          zoomwheel: false
+        });
+
+        expect(result.isError).toBe(true);
+        expect(httpRequest).not.toHaveBeenCalled();
+      } finally {
+        if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
+      }
+    });
+
+    it('surfaces an actionable error, not the raw Token API status, when minting fails (e.g. missing tokens:write)', async () => {
+      const httpRequest = vi.fn(
+        async () => new Response('forbidden', { status: 403 })
+      );
+      const result = await new PreviewStyleTool({ httpRequest }).run({
+        styleId: 'cmojrmkc9002t01ry96yi6h48',
+        title: false,
+        zoomwheel: false
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0]).toMatchObject({
+        type: 'text',
+        text: expect.stringContaining('tokens:write')
+      });
+      expect(
+        (result.content[0] as { type: 'text'; text: string }).text
+      ).toContain('list_tokens_tool');
+    });
+
+    it('surfaces a hosted-endpoint-aware error, not a raw jwtUtils message, when the server token is not a Mapbox token at all', async () => {
+      const saved = process.env.MAPBOX_ACCESS_TOKEN;
+      process.env.MAPBOX_ACCESS_TOKEN = 'not-a-mapbox-token';
+      try {
+        const httpRequest = stubMintingFetch();
+        const result = await new PreviewStyleTool({ httpRequest }).run({
+          styleId: 'cmojrmkc9002t01ry96yi6h48',
+          title: false,
+          zoomwheel: false
+        });
+
+        expect(result.isError).toBe(true);
+        expect(httpRequest).not.toHaveBeenCalled();
+        const text = (result.content[0] as { type: 'text'; text: string }).text;
+        expect(text).toContain('list_tokens_tool');
+        expect(text).not.toContain('MAPBOX_ACCESS_TOKEN');
+      } finally {
+        if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
+        else delete process.env.MAPBOX_ACCESS_TOKEN;
+      }
+    });
+  });
 });
diff --git a/test/tools/style-comparison-tool/StyleComparisonTool.test.ts b/test/tools/style-comparison-tool/StyleComparisonTool.test.ts
index 5024af7..6bd01a8 100644
--- a/test/tools/style-comparison-tool/StyleComparisonTool.test.ts
+++ b/test/tools/style-comparison-tool/StyleComparisonTool.test.ts
@@ -9,7 +9,10 @@ describe('StyleComparisonTool', () => {
   let tool: StyleComparisonTool;
 
   beforeEach(() => {
-    tool = new StyleComparisonTool();
+    // Unused by tests below that supply their own accessToken; the tool
+    // takes httpRequest as a constructor dependency regardless, matching
+    // every other network-calling tool in this repo — see toolRegistry.ts.
+    tool = new StyleComparisonTool({ httpRequest: vi.fn() });
   });
 
   afterEach(() => {
@@ -50,19 +53,20 @@ describe('StyleComparisonTool', () => {
       });
     });
 
-    it('should require access token', async () => {
+    it('requires an access token when share is true', async () => {
       const input = {
         before: 'mapbox/streets-v12',
-        after: 'mapbox/satellite-v9'
+        after: 'mapbox/satellite-v9',
+        share: true
         // Missing accessToken
-      } as any;
+      };
 
       const result = await tool.run(input);
 
       expect(result.isError).toBe(true);
       expect(
         (result.content[0] as { type: 'text'; text: string }).text
-      ).toContain('invalid_type');
+      ).toContain('share: true` requires');
     });
 
     it('should handle full style URLs', async () => {
@@ -262,11 +266,145 @@ describe('StyleComparisonTool', () => {
     });
   });
 
+  describe('auto-minted inline comparison (no accessToken, no share)', () => {
+    const SERVER_TOKEN = 'sk.eyJ1IjoidGVzdC11c2VyIn0.signature';
+
+    function stubMintingFetch() {
+      return vi.fn(
+        async (_input: string | URL | Request, _init?: RequestInit) =>
+          new Response(
+            JSON.stringify({ token: 'pk.eyJ1IjoidGVzdC11c2VyIn0.minted' }),
+            { status: 200 }
+          )
+      );
+    }
+
+    it('auto-generates a token from the server access token and needs no accessToken input', async () => {
+      const saved = process.env.MAPBOX_ACCESS_TOKEN;
+      process.env.MAPBOX_ACCESS_TOKEN = SERVER_TOKEN;
+      try {
+        const httpRequest = stubMintingFetch();
+        const result = await new StyleComparisonTool({ httpRequest }).run({
+          before: 'mapbox/streets-v12',
+          after: 'mapbox/outdoors-v12'
+        });
+
+        expect(result.isError).toBe(false);
+        expect(httpRequest).toHaveBeenCalledTimes(1);
+        const [url] = httpRequest.mock.calls[0];
+        expect(String(url)).toContain('tokens/v2/test-user');
+        const resultUrl = (result.content[0] as { type: 'text'; text: string })
+          .text;
+        expect(resultUrl).toContain(
+          'access_token=pk.eyJ1IjoidGVzdC11c2VyIn0.minted'
+        );
+      } finally {
+        if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
+        else delete process.env.MAPBOX_ACCESS_TOKEN;
+      }
+    });
+
+    it('mints a non-expiring token, not the short-lived tk.* the other preview tools use — agent.mapbox.com/tools/style-compare rejects tk.* outright (confirmed live)', async () => {
+      const saved = process.env.MAPBOX_ACCESS_TOKEN;
+      process.env.MAPBOX_ACCESS_TOKEN = SERVER_TOKEN;
+      try {
+        const httpRequest = stubMintingFetch();
+        await new StyleComparisonTool({ httpRequest }).run({
+          before: 'mapbox/streets-v12',
+          after: 'mapbox/outdoors-v12'
+        });
+
+        const [, init] = httpRequest.mock.calls[0];
+        const body = JSON.parse((init as RequestInit).body as string);
+        expect(body).not.toHaveProperty('expires');
+      } finally {
+        if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
+        else delete process.env.MAPBOX_ACCESS_TOKEN;
+      }
+    });
+
+    it('an explicit accessToken is honored even when share is true', async () => {
+      const httpRequest = stubMintingFetch();
+      const result = await new StyleComparisonTool({ httpRequest }).run({
+        before: 'mapbox/streets-v12',
+        after: 'mapbox/outdoors-v12',
+        share: true,
+        accessToken: 'pk.test.token'
+      });
+
+      expect(result.isError).toBe(false);
+      expect(httpRequest).not.toHaveBeenCalled();
+      const resultUrl = (result.content[0] as { type: 'text'; text: string })
+        .text;
+      expect(resultUrl).toContain('access_token=pk.test.token');
+    });
+
+    it('errors when no server access token is available to mint from', async () => {
+      const saved = process.env.MAPBOX_ACCESS_TOKEN;
+      delete process.env.MAPBOX_ACCESS_TOKEN;
+      try {
+        const httpRequest = stubMintingFetch();
+        const result = await new StyleComparisonTool({ httpRequest }).run({
+          before: 'mapbox/streets-v12',
+          after: 'mapbox/outdoors-v12'
+        });
+
+        expect(result.isError).toBe(true);
+        expect(httpRequest).not.toHaveBeenCalled();
+      } finally {
+        if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
+      }
+    });
+
+    it('surfaces a hosted-endpoint-aware error, not a raw jwtUtils message, when the server token is not a Mapbox token at all', async () => {
+      const saved = process.env.MAPBOX_ACCESS_TOKEN;
+      process.env.MAPBOX_ACCESS_TOKEN = 'not-a-mapbox-token';
+      try {
+        const httpRequest = stubMintingFetch();
+        const result = await new StyleComparisonTool({ httpRequest }).run({
+          before: 'mapbox/streets-v12',
+          after: 'mapbox/outdoors-v12'
+        });
+
+        expect(result.isError).toBe(true);
+        expect(httpRequest).not.toHaveBeenCalled();
+        const text = (result.content[0] as { type: 'text'; text: string }).text;
+        expect(text).toContain('list_tokens_tool');
+        expect(text).not.toContain('MAPBOX_ACCESS_TOKEN');
+      } finally {
+        if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
+        else delete process.env.MAPBOX_ACCESS_TOKEN;
+      }
+    });
+
+    it('surfaces an actionable error, not the raw Token API status, when minting fails (e.g. missing tokens:write)', async () => {
+      const saved = process.env.MAPBOX_ACCESS_TOKEN;
+      process.env.MAPBOX_ACCESS_TOKEN = SERVER_TOKEN;
+      try {
+        const httpRequest = vi.fn(
+          async () => new Response('forbidden', { status: 403 })
+        );
+        const result = await new StyleComparisonTool({ httpRequest }).run({
+          before: 'mapbox/streets-v12',
+          after: 'mapbox/outdoors-v12'
+        });
+
+        expect(result.isError).toBe(true);
+        const text = (result.content[0] as { type: 'text'; text: string }).text;
+        expect(text).toContain('tokens:write');
+        expect(text).toContain('list_tokens_tool');
+      } finally {
+        if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
+        else delete process.env.MAPBOX_ACCESS_TOKEN;
+      }
+    });
+  });
+
   describe('metadata', () => {
     it('should have correct name and description', () => {
       expect(tool.name).toBe('style_comparison_tool');
-      expect(tool.description).toBe(
-        'Generate a comparison URL for comparing two Mapbox styles side-by-side'
+      expect(tool.description).toContain(
+        'auto-generates a scoped preview token'
       );
     });
   });
diff --git a/test/utils/mintScopedPreviewToken.test.ts b/test/utils/mintScopedPreviewToken.test.ts
new file mode 100644
index 0000000..698572a
--- /dev/null
+++ b/test/utils/mintScopedPreviewToken.test.ts
@@ -0,0 +1,184 @@
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+
+import { describe, it, expect, vi } from 'vitest';
+import {
+  mintScopedPreviewToken,
+  describeAutoMintFailure
+} from '../../src/utils/mintScopedPreviewToken.js';
+import { getUserNameFromToken } from '../../src/utils/jwtUtils.js';
+
+function makeToken(username: string, signature = 'sig'): string {
+  const payload = Buffer.from(JSON.stringify({ u: username })).toString(
+    'base64'
+  );
+  return `pk.${payload}.${signature}`;
+}
+
+function stubHttpRequest(token: string, status = 200) {
+  return vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
+    void input;
+    void init;
+    return new Response(JSON.stringify({ token }), { status });
+  });
+}
+
+describe('mintScopedPreviewToken', () => {
+  it('POSTs to tokens/v2/{username} for the server token’s own account with the requested scopes and note', async () => {
+    const serverToken = makeToken('acct', 'server-sig');
+    const httpRequest = stubHttpRequest(makeToken('acct', 'minted-sig'));
+
+    await mintScopedPreviewToken(httpRequest, serverToken, {
+      note: 'Test preview',
+      scopes: ['styles:tiles', 'styles:read']
+    });
+
+    expect(httpRequest).toHaveBeenCalledTimes(1);
+    const [url, init] = httpRequest.mock.calls[0];
+    expect(String(url)).toContain('tokens/v2/acct');
+    expect(String(url)).toContain(`access_token=${serverToken}`);
+    const body = JSON.parse((init as RequestInit).body as string);
+    expect(body).toMatchObject({
+      note: 'Test preview',
+      scopes: ['styles:tiles', 'styles:read']
+    });
+    expect(new Date(body.expires).getTime()).toBeGreaterThan(Date.now());
+  });
+
+  it('defaults to a ~1 hour expiry, overridable via expiresInMs', async () => {
+    const serverToken = makeToken('acct');
+    const httpRequest = stubHttpRequest(makeToken('acct'));
+
+    const before = Date.now();
+    await mintScopedPreviewToken(httpRequest, serverToken, {
+      note: 'n',
+      scopes: []
+    });
+    const [, defaultInit] = httpRequest.mock.calls[0];
+    const defaultExpires = new Date(
+      JSON.parse((defaultInit as RequestInit).body as string).expires
+    ).getTime();
+    expect(defaultExpires - before).toBeGreaterThan(59 * 60 * 1000);
+    expect(defaultExpires - before).toBeLessThan(61 * 60 * 1000);
+
+    await mintScopedPreviewToken(httpRequest, serverToken, {
+      note: 'n',
+      scopes: [],
+      expiresInMs: 5 * 60 * 1000
+    });
+    const [, customInit] = httpRequest.mock.calls[1];
+    const customExpires = new Date(
+      JSON.parse((customInit as RequestInit).body as string).expires
+    ).getTime();
+    expect(customExpires - before).toBeLessThan(6 * 60 * 1000);
+  });
+
+  it('returns the minted token when it belongs to the same account as the server token', async () => {
+    const serverToken = makeToken('acct');
+    const minted = makeToken('acct', 'minted-sig');
+    const httpRequest = stubHttpRequest(minted);
+
+    const result = await mintScopedPreviewToken(httpRequest, serverToken, {
+      note: 'n',
+      scopes: []
+    });
+
+    expect(result).toBe(minted);
+  });
+
+  it('throws if the minted token belongs to a different account (AGI-905-style cross-account check)', async () => {
+    const serverToken = makeToken('victim');
+    const httpRequest = stubHttpRequest(makeToken('attacker'));
+
+    await expect(
+      mintScopedPreviewToken(httpRequest, serverToken, {
+        note: 'n',
+        scopes: []
+      })
+    ).rejects.toThrow('Minted token does not match caller account');
+  });
+
+  it('omits `expires` entirely (mints a genuine, non-expiring pk.* token) when expiresInMs is null', async () => {
+    const serverToken = makeToken('acct');
+    const httpRequest = stubHttpRequest(makeToken('acct'));
+
+    await mintScopedPreviewToken(httpRequest, serverToken, {
+      note: 'n',
+      scopes: [],
+      expiresInMs: null
+    });
+
+    const [, init] = httpRequest.mock.calls[0];
+    const body = JSON.parse((init as RequestInit).body as string);
+    expect(body).not.toHaveProperty('expires');
+  });
+
+  it('throws with the status code, not the response body, when the Token API call fails', async () => {
+    const serverToken = makeToken('acct');
+    const httpRequest = vi.fn(
+      async () => new Response('super secret leak', { status: 403 })
+    );
+
+    await expect(
+      mintScopedPreviewToken(httpRequest, serverToken, {
+        note: 'n',
+        scopes: []
+      })
+    ).rejects.toThrow('Token API 403');
+  });
+});
+
+describe('describeAutoMintFailure', () => {
+  it('rewrites getUserNameFromToken’s "not in valid JWT format" error (the hosted-endpoint case) into hosted-aware, actionable wording', () => {
+    let caught: unknown;
+    try {
+      // A hosted-deployment-style opaque bearer: not a Mapbox pk./sk./tk.
+      // token at all, so it fails jwtUtils' part-count check.
+      getUserNameFromToken('not-a-mapbox-token');
+    } catch (error) {
+      caught = error;
+    }
+
+    const message = describeAutoMintFailure(caught);
+    expect(message).toContain('list_tokens_tool');
+    expect(message).toContain('create_token_tool');
+    expect(message).not.toContain('MAPBOX_ACCESS_TOKEN');
+  });
+
+  it('rewrites getUserNameFromToken’s "does not contain username" error the same way', () => {
+    const noUsernameToken = `pk.${Buffer.from(JSON.stringify({ notU: 'x' })).toString('base64')}.sig`;
+    let caught: unknown;
+    try {
+      getUserNameFromToken(noUsernameToken);
+    } catch (error) {
+      caught = error;
+    }
+
+    const message = describeAutoMintFailure(caught);
+    expect(message).toContain('list_tokens_tool');
+  });
+
+  it('rewrites a Token API 401/403 (missing tokens:write) into actionable wording', () => {
+    expect(describeAutoMintFailure(new Error('Token API 403'))).toContain(
+      'tokens:write'
+    );
+    expect(describeAutoMintFailure(new Error('Token API 401'))).toContain(
+      'tokens:write'
+    );
+  });
+
+  it('passes through any other error unchanged (e.g. a transient failure)', () => {
+    expect(describeAutoMintFailure(new Error('Token API 500'))).toBe(
+      'Token API 500'
+    );
+    expect(
+      describeAutoMintFailure(
+        new Error('Minted token does not match caller account')
+      )
+    ).toBe('Minted token does not match caller account');
+  });
+
+  it('handles a non-Error thrown value', () => {
+    expect(describeAutoMintFailure('a plain string')).toBe('a plain string');
+  });
+});