@chrischall/gemini-mcp 1.6.1 → 1.6.2

package/dist/client.js

@@ -776,7 +776,11 @@ function hostedStorage() {
     const tenant = () => tenantIdFor(readEnvVar('GEMINI_API_KEY') ?? 'local');
     return {
         mediaSink: createR2Sink(blob.bucket, {
-            signedBaseUrl: blob.baseUrl,
+            // The SAME `links` object the minter gets below. Media GETs and upload
+            // PUTs are one store reached two ways; handing each its own base URL is
+            // how the re-host moved the media links to /b/<registrationId>/ and left
+            // the upload links behind. One object, two shapes, no second edit.
+            links: blob.links,
             sign: blob.signRead,
             urlTtlMs: BLOB_URL_TTL_MS,
             // Hard ceiling on any PER-PERSIST override. `gemini_image_set` asks for
@@ -792,7 +796,7 @@ function hostedStorage() {
             tenant,
         }),
         library: createR2Library(blob.bucket, { tenant }),
-        uploadUrls: createUploadUrlMinter({ baseUrl: blob.baseUrl, sign: blob.signWrite, tenant }),
+        uploadUrls: createUploadUrlMinter({ links: blob.links, sign: blob.signWrite, tenant }),
     };
 }
 /**

package/dist/errors.js

@@ -0,0 +1,120 @@
+/**
+ * Making a failure say what actually failed.
+ *
+ * A hosted `gemini_get_upload_url` call came back to the client as
+ * `{"error": "Error occurred during tool execution", "request_id": "req_…"}` —
+ * no message, no failing step, no stack. That outer wrapper is the client's and
+ * not ours to change, but it is only ever reached when what we hand back is
+ * itself uninformative, and two of this repo's habits make that likely:
+ *
+ *  - a thrown non-`McpToolError` surfaces as bare `err.message`, which for a
+ *    runtime fault (`Illegal invocation`, `fetch failed`) names neither the
+ *    tool nor the operation that was in flight; and
+ *  - `cause` is dropped by MCP serialization, so a wrapped error arrives with
+ *    its actual root cause deleted — the trap `ChainedRequest404Error` in
+ *    client.ts already documents for `hint`, which the host drops too.
+ *
+ * So: {@link describeError} flattens the whole chain into the message,
+ * {@link step} labels the operation, and {@link surfaceToolErrors} wraps a
+ * server so EVERY registered handler gets both without each registrar
+ * remembering to. `index.ts` applies it to every registrar in the list.
+ */
+import { McpToolError } from '@chrischall/mcp-utils';
+/** How far down a `cause` chain to walk before assuming it is pathological. */
+const MAX_CAUSE_DEPTH = 5;
+/**
+ * One flat, self-describing line for anything throwable — including the
+ * `cause` chain, which MCP serialization deletes.
+ *
+ * The error's class name is prefixed only when it carries information: a bare
+ * `Error` says nothing a reader does not already know, while `TypeError:
+ * Illegal invocation` is the entire diagnosis of the workerd receiver bug (see
+ * the fetchImpl note in CLAUDE.md).
+ */
+export function describeError(err) {
+    const seen = new Set();
+    const describe = (value, depth) => {
+        if (!(value instanceof Error)) {
+            if (typeof value === 'string')
+                return value;
+            try {
+                return typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value);
+            }
+            catch {
+                return String(value);
+            }
+        }
+        // A generic `Error` name is noise; anything else is the diagnosis.
+        const named = value.name && value.name !== 'Error' && value.name !== 'McpToolError'
+            ? `${value.name}: ${value.message}`
+            : value.message;
+        const hint = value instanceof McpToolError && value.hint && !value.message.includes(value.hint)
+            ? ` ${value.hint}`
+            : '';
+        const cause = value.cause;
+        // Self-referential and over-deep chains are real (a retry wrapper that
+        // re-wraps its own error); walking one forever is not an option.
+        if (cause === undefined || cause === null || depth >= MAX_CAUSE_DEPTH || seen.has(cause)) {
+            return `${named}${hint}`;
+        }
+        seen.add(cause);
+        return `${named}${hint} [caused by: ${describe(cause, depth + 1)}]`;
+    };
+    seen.add(err);
+    return describe(err, 0);
+}
+/**
+ * Run one named operation, and on failure say which one it was.
+ *
+ * Only the INNERMOST step labels: an already-labelled failure passes straight
+ * through, so a nested `step` reports `signing the upload URL: …` rather than
+ * `minting: signing the upload URL: …`. The label is what the caller needs;
+ * the call stack above it is not.
+ */
+export async function step(label, run) {
+    try {
+        return await run();
+    }
+    catch (err) {
+        if (err instanceof StepError)
+            throw err;
+        throw new StepError(`${label}: ${describeError(err)}`, err);
+    }
+}
+/** An `McpToolError` that has already been attributed to a step. */
+class StepError extends McpToolError {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = 'McpToolError';
+    }
+}
+/**
+ * Wrap a server so every tool registered through it reports failures fully.
+ *
+ * A `Proxy` rather than a spread: `McpServer` methods are bound to real private
+ * state, and registrars reach for more than `registerTool` (`server.server`,
+ * `registerResource`). Everything but `registerTool` passes through untouched,
+ * and a successful result is returned byte-identically — this only ever changes
+ * what an exception looks like.
+ */
+export function surfaceToolErrors(server) {
+    return new Proxy(server, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+            if (prop !== 'registerTool' || typeof value !== 'function') {
+                return typeof value === 'function' ? value.bind(target) : value;
+            }
+            return (name, config, handler) => value.call(target, name, config, async (...args) => {
+                try {
+                    return await handler(...args);
+                }
+                catch (err) {
+                    // Named for the tool AND the underlying error. When the client
+                    // still shows its own generic wrapper, this text is what a
+                    // maintainer has to work from — so it carries everything.
+                    throw new McpToolError(`${name} failed: ${describeError(err)}`, { cause: err });
+                }
+            });
+        },
+    });
+}

package/dist/index.js

@@ -2,16 +2,7 @@
 import { runMcp } from '@chrischall/mcp-utils';
 import { loadStdioDotenv } from './dotenv.js';
 import { VERSION } from './version.js';
-import { registerModelTools } from './tools/models.js';
-import { registerGenerateTools } from './tools/generate.js';
-import { registerSetTools } from './tools/set.js';
-import { registerInteractTools } from './tools/interact.js';
-import { registerVideoTools } from './tools/video.js';
-import { registerMusicTools } from './tools/music.js';
-import { registerJobTools } from './tools/jobs.js';
-import { registerFileTools } from './tools/files.js';
-import { registerUploadUrlTools } from './tools/uploads.js';
-import { registerLibraryTools } from './tools/library.js';
+import { TOOL_REGISTRARS } from './registrars.js';
 import { client } from './client.js';
 // Load `.env` here rather than in client.ts: `import.meta.url` + async I/O at
 // module scope is not safe in every runtime this module graph reaches (see
@@ -29,24 +20,14 @@ await loadStdioDotenv();
 // boots and answers the host's install-time tools/list probe even without
 // GEMINI_API_KEY. It also owns this process's session state (job registry,
 // last-interaction memory); stdio is single-user, so one client is one session.
+//
+// The roster itself lives in registrars.ts: this file cannot be imported
+// without booting a server, and a list nothing can import is a list nothing
+// can test (see the note there).
 await runMcp({
     name: 'gemini-mcp',
     version: VERSION,
     banner: '[gemini-mcp] This project was developed and is maintained by AI (Claude). Use at your own discretion.',
-    tools: [
-        registerModelTools,
-        registerGenerateTools,
-        registerSetTools,
-        registerInteractTools,
-        registerVideoTools,
-        registerMusicTools,
-        registerJobTools,
-        registerFileTools,
-        // Both gate on the client having somewhere to put bytes: hosted with a
-        // blob store they register, and on a local install they no-op rather than
-        // advertising a tool that cannot work.
-        registerUploadUrlTools,
-        registerLibraryTools,
-    ],
+    tools: TOOL_REGISTRARS,
     deps: client,
 });

package/dist/media-url.js

@@ -15,6 +15,7 @@
  * Kept free of any Cloudflare import so the whole thing is testable under Node:
  * WebCrypto is the only primitive used, and it exists on both runtimes.
  */
+import { signedLinks } from './signed-url.js';
 /** How long a freshly minted media URL stays valid. Matches Files API retention. */
 export const MEDIA_URL_TTL_MS = 48 * 60 * 60 * 1000;
 /** KV key holding the lazily-generated signing secret (zero-config path). */
@@ -128,8 +129,14 @@ export async function verifyMediaSignature(signingKey, key, exp, sig, nowMs) {
         return { ok: false, reason: 'expired' };
     return { ok: true };
 }
-/** `<base>/<key>?exp=…&sig=…` — the URL handed back to the caller. */
+/**
+ * `<base>/<key>?exp=…&sig=…` — the URL handed back to the caller.
+ *
+ * Delegates to {@link signedLinks} so this and `buildUploadUrl` cannot drift
+ * apart the way they did across the re-host. Prefer taking a {@link SignedLinks}
+ * over a base-URL string in new code; this wrapper exists for callers that
+ * already hold a base.
+ */
 export function buildMediaUrl(baseUrl, key, expiresAtMs, signature) {
-    const path = key.split('/').map(encodeURIComponent).join('/');
-    return `${baseUrl.replace(/\/+$/, '')}/${path}?exp=${expiresAtMs}&sig=${signature}`;
+    return signedLinks(baseUrl).media(key, expiresAtMs, signature);
 }

package/dist/registrars.js

@@ -0,0 +1,50 @@
+/**
+ * The tool roster, and the one place error reporting is attached to it.
+ *
+ * This lives apart from `index.ts` because that file is an ENTRY POINT: it has
+ * top-level `await loadStdioDotenv()` and `await runMcp(…)`, so importing it
+ * starts a server on stdio. Nothing can assert what it wires without booting
+ * it — which is precisely how `.map(reporting)` could be deleted with the
+ * suite still green, leaving hosted failures unattributed again (the exact
+ * regression this repo just spent a debugging round trip on). Here the list is
+ * an ordinary value, and `tests/registrars.test.ts` runs a registrar through it.
+ */
+import { surfaceToolErrors } from './errors.js';
+import { registerModelTools } from './tools/models.js';
+import { registerGenerateTools } from './tools/generate.js';
+import { registerSetTools } from './tools/set.js';
+import { registerInteractTools } from './tools/interact.js';
+import { registerVideoTools } from './tools/video.js';
+import { registerMusicTools } from './tools/music.js';
+import { registerJobTools } from './tools/jobs.js';
+import { registerFileTools } from './tools/files.js';
+import { registerUploadUrlTools } from './tools/uploads.js';
+import { registerLibraryTools } from './tools/library.js';
+/**
+ * Give one registrar a server that reports failures in full.
+ *
+ * A hosted upload-URL failure reached the client as a bare "Error occurred
+ * during tool execution" — no message, no failing step. That wrapper is the
+ * client's, but it is only ever the whole story when our own text is empty, so
+ * every handler's throw is turned into a message naming the tool, the real
+ * error class, and the `cause` chain MCP serialization drops (src/errors.ts).
+ */
+export const reporting = (register) => (server, deps) => register(surfaceToolErrors(server), deps);
+/**
+ * Every registrar, already wrapped. `index.ts` passes this straight to
+ * `runMcp`; the last two self-gate on the client having somewhere to put bytes
+ * (hosted with a blob store they register, on a local install they no-op
+ * rather than advertising a tool that cannot work).
+ */
+export const TOOL_REGISTRARS = [
+    registerModelTools,
+    registerGenerateTools,
+    registerSetTools,
+    registerInteractTools,
+    registerVideoTools,
+    registerMusicTools,
+    registerJobTools,
+    registerFileTools,
+    registerUploadUrlTools,
+    registerLibraryTools,
+].map(reporting);

package/dist/signed-url.js

@@ -0,0 +1,42 @@
+/**
+ * The one place that knows how a link into the object store is SHAPED.
+ *
+ * There are two kinds of signed link — a media GET (`?exp=&sig=`) and an
+ * upload PUT (`?ct=&exp=&sig=`) — and before this module they were two
+ * independent copies of the same string building, in two files, each holding
+ * its own base URL. That is exactly how the re-host from the retired Cloudflare
+ * connector to mcp-host split them: the media builder was moved onto the new
+ * `https://host/b/<registrationId>` base and the upload builder was a separate
+ * edit in a separate file, so nothing structural said the two had to agree.
+ *
+ * Both builders now delegate here, and {@link signedLinks} binds ONE base URL
+ * to both of them at once, so the next re-host either moves both or neither.
+ *
+ * Byte-compatible with what shipped: the path is percent-encoded per segment
+ * (separators survive, everything else is encoded — the gateway decodes per
+ * segment and verifies against the LOGICAL key), and the query parameters keep
+ * their historical order. Every link ever minted still parses.
+ */
+/**
+ * `<base>/<encoded key>?<params>`.
+ *
+ * Parameter order is insertion order and is part of the observable shape —
+ * nothing verifies against it, but the curl commands in `curl_hint` and every
+ * link in a user's history read the same way across a redeploy.
+ */
+export function signedObjectUrl(baseUrl, key, params) {
+    const path = key.split('/').map(encodeURIComponent).join('/');
+    const query = new URLSearchParams();
+    for (const [name, value] of Object.entries(params))
+        query.set(name, String(value));
+    return `${baseUrl.replace(/\/+$/, '')}/${path}?${query}`;
+}
+/** Bind one base URL to both link shapes. */
+export function signedLinks(baseUrl) {
+    const base = baseUrl.replace(/\/+$/, '');
+    return {
+        base,
+        media: (key, expiresAtMs, signature) => signedObjectUrl(base, key, { exp: expiresAtMs, sig: signature }),
+        upload: (key, contentType, expiresAtMs, signature) => signedObjectUrl(base, key, { ct: contentType.toLowerCase(), exp: expiresAtMs, sig: signature }),
+    };
+}

package/dist/storage/media.js

@@ -12,6 +12,7 @@
  * behaviour and must stay byte-for-byte equivalent to it.
  */
 import { base64ToBytes } from '../bytes.js';
+import { signedLinks } from '../signed-url.js';
 /**
  * The stdio sink: `resolveOutputDir(output_dir)` → `writeMedia` per item, in
  * order (so `uniquePath`'s `name`/`name-2`/`name-3` sequencing is preserved).
@@ -65,7 +66,7 @@ export function createR2Sink(bucket, opts) {
     const now = opts.now ?? (() => new Date());
     const randomId = opts.randomId ?? (() => crypto.randomUUID().slice(0, 8));
     const publicBase = opts.publicBaseUrl?.replace(/\/+$/, '');
-    const signedBase = opts.signedBaseUrl?.replace(/\/+$/, '');
+    const signedBase = opts.links?.base ?? opts.signedBaseUrl?.replace(/\/+$/, '');
     const ttlMs = opts.urlTtlMs ?? 0;
     const readPrefixes = [prefix, ...(opts.readPrefixes ?? [])];
     let tenantCache;
@@ -145,9 +146,11 @@ export function createR2Sink(bucket, opts) {
         if (publicBase)
             return { ref: `${publicBase}/${key}`, key };
         if (signedBase && opts.sign) {
-            const { buildMediaUrl } = await import('../media-url.js');
             const signature = await opts.sign(key, expiresAtMs);
-            return { ref: buildMediaUrl(signedBase, key, expiresAtMs, signature), key, expiresAt: new Date(expiresAtMs).toISOString() };
+            // `signedLinks` is the ONE shape-owner shared with the upload-URL minter
+            // (src/signed-url.ts) — never hand-build the query here.
+            const link = (opts.links ?? signedLinks(signedBase)).media(key, expiresAtMs, signature);
+            return { ref: link, key, expiresAt: new Date(expiresAtMs).toISOString() };
         }
         // Neither configured. Unreachable in the Worker (which always passes its
         // own origin), so this is a misconfiguration rather than a mode — say so

package/dist/tools/uploads.js

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import { McpToolError, textResult } from '@chrischall/mcp-utils';
+import { textResult } from '@chrischall/mcp-utils';
 import { UPLOAD_MAX_BYTES, RASTER_IMAGE_TYPE_PATTERN } from '../upload-url.js';
 import { wholeMb } from '../bytes.js';
+import { step } from '../errors.js';
 /**
  * `gemini_get_upload_url` — mint a short-lived signed PUT URL so a shell can
  * upload a reference image with ZERO auth headers:
@@ -15,9 +16,27 @@ import { wholeMb } from '../bytes.js';
  * shell doesn't have. A signed URL is mintable by the session and usable by
  * the shell.
  *
- * Hosted connector only — stdio has no HTTP surface to PUT against (and no
- * need: it reads local paths directly). Gated on `client.uploadUrls`, the same
- * pattern as `gemini_sign_media` / the library tools.
+ * Hosted only — stdio has no HTTP surface to PUT against (and no need: it reads
+ * local paths directly). Gated on `client.uploadUrls`, the same pattern as
+ * `gemini_sign_media` / the library tools.
+ *
+ * ## The PUT response body is NOT the contract any more
+ *
+ * The retired Cloudflare connector served `/put` itself and answered
+ * `201 { r2_key, size_bytes, content_type, hint }`. mcp-host's blob gateway is
+ * a generic object store: it answers a bare 2xx and the body is whatever the
+ * gateway feels like. So the `r2_key` a caller must keep is the one in THIS
+ * result, minted here, known before a byte is sent — and success is "the PUT
+ * returned 2xx", nothing finer. Every hint below says so; don't reintroduce
+ * guidance to read the key out of the PUT response, it isn't there.
+ *
+ * ## Minting writes nothing
+ *
+ * There is no reservation, no pending-upload record, no placeholder object —
+ * a mint is a tenant id, a key string and one HMAC. That is what makes a failed
+ * mint atomic: it cannot leave orphaned state behind because it never had any
+ * to leave. `tests/upload-flow.test.ts` holds that property to a fake gateway
+ * that fails the call if it is touched at all.
  */
 export function registerUploadUrlTools(server, client) {
     const minter = client.uploadUrls;
@@ -26,10 +45,12 @@ export function registerUploadUrlTools(server, client) {
     server.registerTool('gemini_get_upload_url', {
         description: 'Mint a short-lived (~10 min) signed PUT URL for uploading one reference image to this connector with NO auth ' +
             'headers — usable from any shell: curl -sS -X PUT -H "Content-Type: image/jpeg" --data-binary @photo.jpg "<upload_url>". ' +
-            'The response to the PUT returns an `r2_key` to reference the upload: pass it in `images_r2_keys` on generation ' +
-            'tools, save it permanently with gemini_save_character, or convert it to a ~48h Files API reference with ' +
-            'gemini_upload_file({ r2_key }). Prefer this over images_base64 (which costs ~14k tokens per photo) whenever the ' +
-            `caller has a shell. Images only, up to ${wholeMb(UPLOAD_MAX_BYTES)}MB.`,
+            'A 2xx from that PUT means the bytes are stored; the key to reference them is the `r2_key` in THIS result (the PUT ' +
+            'itself returns no useful body). Pass that r2_key in `images_r2_keys` on generation tools, save it permanently with ' +
+            'gemini_save_character, or convert it to a ~48h Files API reference with gemini_upload_file({ r2_key }). Prefer this ' +
+            'over images_base64 (which costs ~14k tokens per photo) whenever the caller has a shell. Images only, up to ' +
+            `${wholeMb(UPLOAD_MAX_BYTES)}MB. The PUT must send exactly the Content-Type this URL was minted for — the signature ` +
+            'covers it, so a mismatched header is rejected.',
         annotations: { readOnlyHint: true, openWorldHint: false },
         inputSchema: {
             filename: z
@@ -45,13 +66,11 @@ export function registerUploadUrlTools(server, client) {
                 .describe('MIME type of the bytes that will be PUT — raster images only (jpeg/png/webp/gif/avif/heic/heif/bmp/tiff; not SVG). The PUT must send exactly this Content-Type.'),
         },
     }, async (args) => {
-        let minted;
-        try {
-            minted = await minter.mint(args.filename, args.content_type);
-        }
-        catch (err) {
-            throw new McpToolError(err instanceof Error ? err.message : String(err));
-        }
+        // `step` names the operation in the message, and `surfaceToolErrors`
+        // (wired in index.ts) prefixes the tool and flattens the cause chain —
+        // between them a mint failure can no longer reach the client as a bare
+        // "Error occurred during tool execution".
+        const minted = await step(`minting a signed upload URL for ${args.filename} (${args.content_type})`, () => minter.mint(args.filename, args.content_type));
         return textResult({
             upload_url: minted.url,
             method: 'PUT',
@@ -60,10 +79,14 @@ export function registerUploadUrlTools(server, client) {
             expires_at: new Date(minted.expiresAtMs).toISOString(),
             max_bytes: UPLOAD_MAX_BYTES,
             curl_hint: `curl -sS -X PUT -H "Content-Type: ${minted.contentType}" --data-binary @${args.filename} "${minted.url}"`,
-            hint: 'PUT the raw bytes within ~10 minutes; no Authorization header is needed (the signature in the URL is the auth). ' +
-                'Then reference the returned r2_key: images_r2_keys on generation tools (master_images_r2_keys on gemini_image_set), ' +
-                'gemini_save_character to keep it with no expiry, or gemini_upload_file({ r2_key }) for a ~48h files/… reference. ' +
-                'Uploads themselves follow the media retention schedule (default 7 days).',
+            // Named for what it is: the PUT's own body is the object store's, not
+            // this connector's, so 2xx is the whole success signal.
+            success_is: 'any 2xx from the PUT; the response body is not part of the contract and carries no r2_key',
+            hint: 'PUT the raw bytes within ~10 minutes with exactly the Content-Type above; no Authorization header is needed ' +
+                '(the signature in the URL is the auth, and it covers the content type). On a 2xx, reference the `r2_key` from ' +
+                'THIS result — not the PUT response: images_r2_keys on generation tools (master_images_r2_keys on ' +
+                'gemini_image_set), gemini_save_character to keep it with no expiry, or gemini_upload_file({ r2_key }) for a ' +
+                '~48h files/… reference. Uploads themselves follow the media retention schedule (default 7 days).',
         });
     });
 }

package/dist/upload-url.js

@@ -32,6 +32,7 @@
  * import so it tests under Node.
  */
 import { base64UrlEncode, base64UrlDecode } from './media-url.js';
+import { signedLinks } from './signed-url.js';
 import { safeKeySegment } from './storage/media.js';
 /** How long a minted upload URL stays usable. Deliberately short — it exists to
  * be curled within the same conversation turn that minted it. */
@@ -86,10 +87,17 @@ export async function verifyUploadSignature(signingKey, key, contentType, exp, s
         return { ok: false, reason: 'expired' };
     return { ok: true };
 }
-/** `<base>/<key>?ct=…&exp=…&sig=…` — the URL handed back by the mint tool. */
+/**
+ * `<base>/<key>?ct=…&exp=…&sig=…` — the URL handed back by the mint tool.
+ *
+ * Delegates to {@link signedLinks}, the single shape-owner it shares with
+ * `buildMediaUrl`. Prefer passing a {@link SignedLinks} into
+ * {@link createUploadUrlMinter} (`links`) over a bare `baseUrl`: a store handed
+ * to the sink and the minter as one object cannot be re-pointed for one and
+ * not the other, which is precisely how the re-host broke this flow.
+ */
 export function buildUploadUrl(baseUrl, key, contentType, expiresAtMs, signature) {
-    const path = key.split('/').map(encodeURIComponent).join('/');
-    return `${baseUrl.replace(/\/+$/, '')}/${path}?ct=${encodeURIComponent(contentType.toLowerCase())}&exp=${expiresAtMs}&sig=${signature}`;
+    return signedLinks(baseUrl).upload(key, contentType, expiresAtMs, signature);
 }
 /**
  * RASTER image types only — an explicit allowlist, not `image/*`.
@@ -117,6 +125,18 @@ export function acceptableUploadType(contentType) {
  * session's own namespace, so a signed PUT cannot write into anyone else's.
  */
 export function createUploadUrlMinter(opts) {
+    // Fail at construction, not at mint. A minter built without somewhere to
+    // point is not a degraded minter, it is a broken one — and the symptom it
+    // used to produce (a URL reading `undefined/up/…`, or one pointing at a host
+    // that no longer exists) is unreadable from the client side. This is the
+    // "mint-with-missing-env fails loudly and atomically" guarantee: it throws
+    // before any key is derived and long before anything could be written, and
+    // the tool simply does not register.
+    const links = opts.links ?? (opts.baseUrl ? signedLinks(opts.baseUrl) : undefined);
+    if (!links) {
+        throw new Error('createUploadUrlMinter requires `links` (preferred) or `baseUrl`: there is nowhere to point a signed upload URL. ' +
+            'Hosted, both come from the blob store — check MCP_BLOB_BASE_URL is set on the deployment.');
+    }
     const now = opts.now ?? (() => new Date());
     const randomId = opts.randomId ?? (() => crypto.randomUUID().slice(0, 8));
     const ttlMs = opts.ttlMs ?? UPLOAD_URL_TTL_MS;
@@ -132,7 +152,7 @@ export function createUploadUrlMinter(opts) {
             const key = `${UPLOAD_KEY_PREFIX}/${tenant}/${day}/${randomId()}-${safeKeySegment(filename)}`;
             const expiresAtMs = now().getTime() + ttlMs;
             const signature = await opts.sign(key, ct, expiresAtMs);
-            return { url: buildUploadUrl(opts.baseUrl, key, ct, expiresAtMs, signature), key, contentType: ct, expiresAtMs };
+            return { url: links.upload(key, ct, expiresAtMs, signature), key, contentType: ct, expiresAtMs };
         },
     };
 }

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Single source of the server version. release-please bumps the literal below. */
-export const VERSION = '1.6.1'; // x-release-please-version
+export const VERSION = '1.6.2'; // x-release-please-version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrischall/gemini-mcp",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "mcpName": "io.github.chrischall/gemini-mcp",
   "description": "Gemini image-generation MCP server for Claude — developed and maintained by AI (Claude Code)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/gemini-mcp",
     "source": "github"
   },
-  "version": "1.6.1",
+  "version": "1.6.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@chrischall/gemini-mcp",
-      "version": "1.6.1",
+      "version": "1.6.2",
       "transport": {
         "type": "stdio"
       },