@chrischall/gemini-mcp 1.10.0 → 1.11.1

package/dist/usage.js

@@ -0,0 +1,156 @@
+/**
+ * What a generation cost, in tokens.
+ *
+ * Both Gemini APIs already report this and this server used to discard it. The
+ * two disagree on more than casing: `generateContent` returns camelCase
+ * `usageMetadata` with `promptTokenCount` / `candidatesTokenCount`, while the
+ * Interactions API returns snake_case `usage` with `total_input_tokens` /
+ * `total_output_tokens` plus cached- and thought-token counts that
+ * `generateContent` has no equivalent for. This module is the one place that
+ * knows both, so nothing downstream has to.
+ *
+ * Absence is preserved deliberately. A response with no usage block yields
+ * `undefined`, never a zeroed record: "we do not know what this cost" and "this
+ * cost nothing" are different claims, and a caller adding up a workflow has to
+ * be able to tell them apart.
+ */
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+/**
+ * Pull one modality's entry out of either API's by-modality list.
+ *
+ * Modality matters for money, not just curiosity: each is billed at its own
+ * rate, and they differ by more than an order of magnitude (text output vs
+ * image output is 20-40x on the same model). A modality nobody breaks out is
+ * priced as text, which is the cheap end — so missing one understates rather
+ * than inventing spend.
+ */
+function modalityTokens(list, modality) {
+    if (!Array.isArray(list))
+        return undefined;
+    for (const entry of list) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        // generateContent shouts ("IMAGE"); the Interactions API does not ("image").
+        if (typeof e.modality === 'string' && e.modality.toLowerCase() === modality) {
+            return num(e.tokenCount) ?? num(e.tokens);
+        }
+    }
+    return undefined;
+}
+/**
+ * Read whichever usage block a response carries, or `undefined` when it
+ * carries neither — including the case where the block exists but has no
+ * totals in it, which is indistinguishable from absent for our purposes.
+ */
+export function readUsage(body) {
+    if (!body || typeof body !== 'object')
+        return undefined;
+    const b = body;
+    const meta = b.usageMetadata;
+    if (meta) {
+        const input = num(meta.promptTokenCount);
+        const output = num(meta.candidatesTokenCount);
+        const total = num(meta.totalTokenCount);
+        if (input !== undefined || output !== undefined || total !== undefined) {
+            return compact({
+                input_tokens: input ?? 0,
+                output_tokens: output ?? 0,
+                total_tokens: total ?? (input ?? 0) + (output ?? 0),
+                image_tokens: modalityTokens(meta.candidatesTokensDetails, 'image'),
+                video_tokens: modalityTokens(meta.candidatesTokensDetails, 'video'),
+                audio_tokens: modalityTokens(meta.candidatesTokensDetails, 'audio'),
+                cached_tokens: num(meta.cachedContentTokenCount),
+            });
+        }
+    }
+    const usage = b.usage;
+    if (usage) {
+        const input = num(usage.total_input_tokens);
+        const output = num(usage.total_output_tokens);
+        const total = num(usage.total_tokens);
+        if (input !== undefined || output !== undefined || total !== undefined) {
+            return compact({
+                input_tokens: input ?? 0,
+                output_tokens: output ?? 0,
+                total_tokens: total ?? (input ?? 0) + (output ?? 0),
+                image_tokens: modalityTokens(usage.output_tokens_by_modality, 'image'),
+                video_tokens: modalityTokens(usage.output_tokens_by_modality, 'video'),
+                audio_tokens: modalityTokens(usage.output_tokens_by_modality, 'audio'),
+                cached_tokens: num(usage.total_cached_tokens),
+                thought_tokens: num(usage.total_thought_tokens),
+            });
+        }
+    }
+    return undefined;
+}
+/** Drop the optional counts that are absent or zero — a constant 0 is noise. */
+function compact(u) {
+    const out = {
+        input_tokens: u.input_tokens,
+        output_tokens: u.output_tokens,
+        total_tokens: u.total_tokens,
+    };
+    if (u.image_tokens)
+        out.image_tokens = u.image_tokens;
+    if (u.video_tokens)
+        out.video_tokens = u.video_tokens;
+    if (u.audio_tokens)
+        out.audio_tokens = u.audio_tokens;
+    if (u.cached_tokens)
+        out.cached_tokens = u.cached_tokens;
+    if (u.thought_tokens)
+        out.thought_tokens = u.thought_tokens;
+    return out;
+}
+/**
+ * Add up several calls — `count: N` bills N times, so a tool that reports only
+ * the first call understates itself. Gaps are skipped rather than counted as
+ * zero; if nothing at all is known the sum is `undefined`, so silence does not
+ * turn into a confident total.
+ */
+export function sumUsage(parts) {
+    const known = parts.filter((p) => p !== undefined);
+    if (known.length === 0)
+        return undefined;
+    return compact(known.reduce((acc, u) => ({
+        input_tokens: acc.input_tokens + u.input_tokens,
+        output_tokens: acc.output_tokens + u.output_tokens,
+        total_tokens: acc.total_tokens + u.total_tokens,
+        image_tokens: (acc.image_tokens ?? 0) + (u.image_tokens ?? 0),
+        video_tokens: (acc.video_tokens ?? 0) + (u.video_tokens ?? 0),
+        audio_tokens: (acc.audio_tokens ?? 0) + (u.audio_tokens ?? 0),
+        cached_tokens: (acc.cached_tokens ?? 0) + (u.cached_tokens ?? 0),
+        thought_tokens: (acc.thought_tokens ?? 0) + (u.thought_tokens ?? 0),
+    }), { input_tokens: 0, output_tokens: 0, total_tokens: 0 }));
+}
+/**
+ * Mark a replayed result's usage as already billed.
+ *
+ * `JobRegistry.dispatch()` can serve a matching `idempotency_key` from the
+ * registry without calling upstream — that is what makes a host-timeout retry
+ * free. The recorded result still carries the ORIGINAL call's usage, which is
+ * correct as a description of the image you are being handed and wrong as a
+ * measure of what this call cost: nothing.
+ *
+ * So the counts stay and gain `usage_billed: false`, which is what lets a
+ * workflow total exclude them. Dropping them instead would be worse — the
+ * caller could no longer see how the image was produced — and leaving them
+ * unmarked would double-count a generation that was paid for once.
+ *
+ * A result with no usage at all is left untouched: "unknown" must not turn
+ * into the positive claim "not billed".
+ */
+export function annotateReusedUsage(meta) {
+    if (!meta.usage)
+        return meta;
+    meta.usage_billed = false;
+    // The cost estimate needs the same treatment for the same reason, and is
+    // worse if it does not get it: a token count someone forgets to exclude is a
+    // rounding error in a report, a dollar figure is the report. Marked rather
+    // than deleted, so the result still shows what the generation cost when it
+    // was actually made.
+    if (meta.cost_estimate)
+        meta.cost_billed = false;
+    return meta;
+}

package/dist/version.js

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

package/mint.yaml

@@ -44,12 +44,18 @@ egress:
     # solely in a URL this server BUILDS and returns are excluded.
     - generativelanguage.googleapis.com
     #
-    # NOTE — this server also reaches at least one host determined at
-    # RUNTIME, which cannot appear as a literal here:
-    #   - a signed upload URL returned by the API (often storage.googleapis.com / s3)
-    #   - a media/CDN host supplied at runtime
-    # Confirm the concrete host(s) against a live run and add them, or
-    # the isolated tier will block the call.
+    # That one host covers every Gemini call: generateContent, the Files API
+    # upload start, the resumable upload session URL it hands back (same
+    # host — live-verified, docs/GEMINI-API.md) and the media download, which
+    # client.ts refuses to follow to any other host.
+    #
+    # NOTE — this server also reaches ONE host determined at RUNTIME, which
+    # cannot appear as a literal here: the blob store at MCP_BLOB_BASE_URL
+    # (src/blob-store.ts PUTs/GETs generated media there). On mcp-host that
+    # is the gateway's own public hostname, injected at spawn; add that host
+    # for the deployment you register on, or every hosted image save is
+    # blocked. Nothing else is dialled at runtime: no GCS/S3 host is ever
+    # contacted.
     #
     # Also: the images_url argument makes this server fetch an ARBITRARY
     # caller-supplied https host. That cannot be enumerated in advance, so on

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrischall/gemini-mcp",
-  "version": "1.10.0",
+  "version": "1.11.1",
   "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>",
@@ -42,7 +42,7 @@
     "dev": "node dist/index.js",
     "test": "npm run typecheck && vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "npm run typecheck && vitest run --coverage",
     "typecheck": "tsc -p tsconfig.test.json"
   },
   "dependencies": {

package/server.json

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