@tokenlabai/mcp-server 0.2.2 → 0.4.0

package/src/index.js

@@ -1,331 +1,285 @@
 #!/usr/bin/env node
 
+import { createHash } from "node:crypto";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 
-const VERSION = "0.2.2";
-const API_BASE = (process.env.TOKENLAB_API_BASE || "https://api.tokenlab.sh").replace(/\/$/, "");
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const packageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+const manifest = JSON.parse(await readFile(join(root, "generated/tools.json"), "utf8"));
+const VERSION = packageJson.version;
+const API_BASE = (process.env.TOKENLAB_API_BASE || "https://api.tokenlab.sh").replace(/\/+$/, "");
 const API_KEY = process.env.TOKENLAB_API_KEY || "";
+const TOOL_PROFILE = process.env.TOKENLAB_MCP_TOOL_PROFILE || manifest.default_profile;
+const REQUEST_TIMEOUT_MS = positiveInteger(process.env.TOKENLAB_REQUEST_TIMEOUT_MS, 120_000);
+const MAX_FILE_BYTES = positiveInteger(process.env.TOKENLAB_MCP_MAX_FILE_BYTES, 100 * 1024 * 1024);
+const INLINE_BYTES = positiveInteger(process.env.TOKENLAB_MCP_INLINE_BYTES, 2 * 1024 * 1024);
+const ARTIFACT_DIR = resolve(process.env.TOKENLAB_ARTIFACT_DIR || join(tmpdir(), "tokenlab-mcp"));
 
-const scenes = [
-  "image",
-  "video",
-  "music",
-  "3d",
-  "tts",
-  "stt",
-  "embedding",
-  "rerank",
-  "translation"
-];
+if (!manifest.profiles.includes(TOOL_PROFILE)) {
+  throw new Error(`Unknown TOKENLAB_MCP_TOOL_PROFILE '${TOOL_PROFILE}'. Expected ${manifest.profiles.join(" or ")}.`);
+}
 
-const chatMessageSchema = z.object({
-  role: z.enum(["system", "user", "assistant", "function", "tool", "developer"])
-    .describe("OpenAI Chat Completions message role."),
-  content: z.union([
-    z.string(),
-    z.array(z.object({}).passthrough()),
-    z.null()
-  ]).optional().describe("Text, OpenAI-compatible multimodal content parts, or null for tool/function messages."),
-  name: z.string().optional().describe("Optional name for a function or tool message."),
-  tool_calls: z.array(z.object({}).passthrough()).optional().describe("Tool calls made by an assistant message."),
-  tool_call_id: z.string().optional().describe("Tool call ID answered by a tool message.")
-}).passthrough();
+const server = new McpServer({ name: "tokenlab", version: VERSION });
 
-const chatCompletionToolSchema = z.object({
-  type: z.literal("function"),
-  function: z.object({
-    name: z.string().min(1),
-    description: z.string().optional(),
-    parameters: z.object({}).passthrough().optional()
-  }).passthrough()
-}).passthrough();
+function positiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value || "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
 
-const server = new McpServer({
-  name: "tokenlab",
-  version: VERSION
-});
+function definedValues(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
 
-async function fetchJson(path, options = {}) {
-  const headers = {
-    Accept: "application/json",
-    "User-Agent": `tokenlab-mcp-server/${VERSION}`
+function textResult(value) {
+  return {
+    content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }]
   };
-  if (options.body) {
-    headers["Content-Type"] = "application/json";
-  }
-  if (options.auth) {
-    if (!API_KEY) {
-      throw new Error("TOKENLAB_API_KEY is required for TokenLab inference tools.");
-    }
-    headers.Authorization = `Bearer ${API_KEY}`;
+}
+
+function requireApiKey(tool) {
+  if (tool.auth === "required" && !API_KEY) {
+    throw new Error(`TOKENLAB_API_KEY is required for ${tool.name}.`);
   }
+}
 
-  const response = await fetch(`${API_BASE}${path}`, {
-    method: options.method || "GET",
-    headers,
-    body: options.body ? JSON.stringify(options.body) : undefined
-  });
+function appendQuery(url, name, value) {
+  if (value === undefined || value === null) return;
+  if (Array.isArray(value)) {
+    for (const entry of value) appendQuery(url, name, entry);
+    return;
+  }
+  url.searchParams.append(name, typeof value === "object" ? JSON.stringify(value) : String(value));
+}
 
-  const text = await response.text();
+async function appendMultipart(form, name, value, isFile) {
+  if (value === undefined || value === null) return;
+  if (Array.isArray(value)) {
+    for (const entry of value) await appendMultipart(form, name, entry, isFile);
+    return;
+  }
+  if (!isFile) {
+    form.append(name, typeof value === "object" ? JSON.stringify(value) : String(value));
+    return;
+  }
 
-  if (!response.ok) {
-    throw new Error(`TokenLab request failed: ${response.status} ${response.statusText}\n${text}`);
+  const path = resolve(String(value));
+  const details = await stat(path);
+  if (!details.isFile()) throw new Error(`${name} must point to a local file.`);
+  if (details.size > MAX_FILE_BYTES) {
+    throw new Error(`${name} exceeds TOKENLAB_MCP_MAX_FILE_BYTES (${MAX_FILE_BYTES}).`);
   }
+  const bytes = await readFile(path);
+  form.append(name, new Blob([bytes]), basename(path));
+}
 
-  return JSON.parse(text);
+function collectArguments(tool, input) {
+  const pathArguments = Object.fromEntries(tool.bindings.path.map((name) => [name, input[name]]));
+  const queryArguments = Object.fromEntries(tool.bindings.query.map((name) => [name, input[name]]));
+  const headerArguments = Object.fromEntries(tool.bindings.header.map((name) => [name, input[name]]));
+  const bodyArguments = tool.bindings.body.includes("body")
+    ? input.body
+    : Object.fromEntries(tool.bindings.body.map((name) => [name, input[name]]));
+  return { pathArguments, queryArguments, headerArguments, bodyArguments };
 }
 
-function textResult(value) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
-      }
-    ]
-  };
+function taskAwareResult(tool, response) {
+  if (!tool.task || !response || typeof response !== "object") return textResult(response);
+
+  const statusValue = response[tool.task.status_field];
+  const status = typeof statusValue === "string" ? statusValue.toLowerCase() : undefined;
+  const taskId = tool.task.id_fields.map((field) => response[field]).find((value) => typeof value === "string" && value);
+  const pollUrlValue = response[tool.task.poll_url_field];
+  const pollUrl = typeof pollUrlValue === "string" && pollUrlValue
+    ? pollUrlValue
+    : taskId ? `/v1/tasks/${encodeURIComponent(taskId)}` : undefined;
+  const terminal = Boolean(status && tool.task.terminal_statuses.includes(status));
+  const asyncDelivery = tool.task.mode !== "hybrid" || Boolean(taskId || pollUrl || status);
+
+  return textResult({
+    delivery: asyncDelivery
+      ? definedValues({
+          mode: "async",
+          task_id: taskId,
+          status,
+          poll_url: pollUrl,
+          terminal,
+          next_tool: terminal ? undefined : "get_task_status"
+        })
+      : { mode: "complete", terminal: true },
+    response
+  });
 }
 
-function compactModelDetails(details, pricing) {
-  return {
-    id: details.id || details.model || details.name,
-    object: details.object,
-    owned_by: details.owned_by,
-    request_endpoint: details.request_endpoint,
-    request_shape_mode: details.request_shape_mode,
-    supported_operations: details.supported_operations,
-    supported_parameters: details.supported_parameters,
-    recommended_request: details.recommended_request,
-    pricing
+function extensionFor(mimeType) {
+  const known = {
+    "audio/mpeg": ".mp3",
+    "audio/wav": ".wav",
+    "audio/ogg": ".ogg",
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/webp": ".webp",
+    "video/mp4": ".mp4",
+    "application/json": ".json"
   };
+  return known[mimeType] || ".bin";
 }
 
-server.tool(
-  "list_models",
-  "List public TokenLab models, optionally filtered by recommended task.",
-  {
-    recommended_for: z.enum(scenes).optional().describe("Optional task filter such as image, video, embedding, or rerank."),
-    limit: z.number().int().min(1).max(100).default(25).describe("Maximum number of models to return.")
-  },
-  async ({ recommended_for, limit }) => {
-    const query = recommended_for ? `?recommended_for=${encodeURIComponent(recommended_for)}` : "";
-    const data = await fetchJson(`/v1/models${query}`);
-    const models = Array.isArray(data.data) ? data.data.slice(0, limit) : [];
-
-    return textResult({
-      object: data.object,
-      count: Array.isArray(data.data) ? data.data.length : 0,
-      returned: models.length,
-      models
-    });
+async function artifactResult(bytes, mimeType, toolName) {
+  if (bytes.byteLength <= INLINE_BYTES && mimeType.startsWith("image/")) {
+    return { content: [{ type: "image", data: Buffer.from(bytes).toString("base64"), mimeType }] };
   }
-);
-
-server.tool(
-  "get_model",
-  "Fetch public TokenLab model details for one model ID.",
-  {
-    model: z.string().min(1).describe("Public TokenLab model ID, for example gpt-5.5 or gemini-3.5-flash.")
-  },
-  async ({ model }) => {
-    return textResult(await fetchJson(`/v1/models/${encodeURIComponent(model)}`));
+  if (bytes.byteLength <= INLINE_BYTES && mimeType.startsWith("audio/")) {
+    return { content: [{ type: "audio", data: Buffer.from(bytes).toString("base64"), mimeType }] };
   }
-);
 
-server.tool(
-  "get_model_pricing",
-  "Fetch public TokenLab pricing details for one model ID.",
-  {
-    model: z.string().min(1).describe("Public TokenLab model ID.")
-  },
-  async ({ model }) => {
-    return textResult(await fetchJson(`/v1/models/${encodeURIComponent(model)}/pricing`));
+  await mkdir(ARTIFACT_DIR, { recursive: true });
+  const digest = createHash("sha256").update(bytes).digest("hex").slice(0, 16);
+  const path = join(ARTIFACT_DIR, `${toolName}-${digest}${extensionFor(mimeType)}`);
+  await writeFile(path, bytes);
+  return textResult({ artifact_path: path, mime_type: mimeType, bytes: bytes.byteLength });
+}
+
+async function executeGeneratedTool(tool, input) {
+  requireApiKey(tool);
+  const { pathArguments, queryArguments, headerArguments, bodyArguments } = collectArguments(tool, input);
+  let path = tool.path;
+  for (const [name, value] of Object.entries(pathArguments)) {
+    path = path.replace(`{${name}}`, encodeURIComponent(String(value)));
   }
-);
 
-server.tool(
-  "compare_models",
-  "Compare public TokenLab model details and pricing for several model IDs.",
-  {
-    models: z.array(z.string().min(1)).min(2).max(8).describe("Public TokenLab model IDs to compare."),
-    include_raw: z.boolean().default(false).describe("Return raw details and pricing payloads instead of compact summaries.")
-  },
-  async ({ models, include_raw }) => {
-    const compared = await Promise.all(models.map(async (model) => {
-      const encoded = encodeURIComponent(model);
-      const [details, pricing] = await Promise.all([
-        fetchJson(`/v1/models/${encoded}`),
-        fetchJson(`/v1/models/${encoded}/pricing`).catch((error) => ({
-          error: error.message
-        }))
-      ]);
+  const url = new URL(`${API_BASE}${path}`);
+  for (const [name, value] of Object.entries(queryArguments)) appendQuery(url, name, value);
 
-      return include_raw ? { model, details, pricing } : compactModelDetails(details, pricing);
-    }));
+  const headers = {
+    Accept: "application/json, audio/*, image/*, video/*, application/octet-stream",
+    "User-Agent": `tokenlab-mcp-server/${VERSION}`
+  };
+  for (const [name, value] of Object.entries(headerArguments)) {
+    if (value !== undefined) headers[name] = String(value);
+  }
+  if (API_KEY && tool.auth !== "none") headers.Authorization = `Bearer ${API_KEY}`;
 
-    return textResult({ compared });
+  let body;
+  if (tool.content_type === "application/json") {
+    headers["Content-Type"] = "application/json";
+    body = JSON.stringify(bodyArguments);
+  } else if (tool.content_type === "multipart/form-data") {
+    const form = new FormData();
+    for (const [name, value] of Object.entries(bodyArguments || {})) {
+      await appendMultipart(form, name, value, tool.bindings.files.includes(name));
+    }
+    body = form;
   }
-);
 
-server.tool(
-  "create_chat_completion",
-  "Create a non-streaming TokenLab OpenAI-compatible Chat Completions call. Requires TOKENLAB_API_KEY.",
-  {
-    model: z.string().min(1).describe("Public TokenLab model ID."),
-    messages: z.array(chatMessageSchema).min(1).describe("OpenAI-compatible conversation messages, including text, image, tool, and function messages."),
-    temperature: z.number().min(0).max(2).optional().describe("Optional sampling temperature."),
-    top_p: z.number().min(0).max(1).optional().describe("Optional nucleus sampling probability."),
-    n: z.number().int().min(1).max(128).optional().describe("Optional number of non-streaming completions."),
-    stop: z.union([z.string(), z.array(z.string()).min(1).max(4)]).optional().describe("Optional stop sequence or up to four stop sequences."),
-    max_tokens: z.number().int().min(1).optional().describe("Optional maximum generated tokens."),
-    max_completion_tokens: z.number().int().min(1).optional().describe("Optional completion-token cap for compatible reasoning models."),
-    presence_penalty: z.number().min(-2).max(2).optional().describe("Optional presence penalty."),
-    frequency_penalty: z.number().min(-2).max(2).optional().describe("Optional frequency penalty."),
-    tools: z.array(chatCompletionToolSchema).optional().describe("Optional OpenAI function tools available to the model."),
-    tool_choice: z.union([
-      z.enum(["none", "auto", "required"]),
-      z.object({
-        type: z.literal("function"),
-        function: z.object({ name: z.string().min(1) })
-      })
-    ]).optional().describe("Optional OpenAI tool-choice setting."),
-    response_format: z.object({
-      type: z.enum(["text", "json_object"])
-    }).optional().describe("Optional response format."),
-    seed: z.number().int().optional().describe("Optional deterministic seed for compatible models."),
-    user: z.string().optional().describe("Optional end-user identifier."),
-    parallel_tool_calls: z.boolean().optional().describe("Whether compatible models may make parallel tool calls."),
-    reasoning_effort: z.string().optional().describe("Optional reasoning-effort hint for compatible models."),
-    logprobs: z.boolean().optional().describe("Whether to return output-token log probabilities."),
-    top_logprobs: z.number().int().min(0).max(20).optional().describe("Optional number of likely tokens to include with log probabilities."),
-    top_k: z.number().int().min(1).optional().describe("Optional top-k sampling cutoff for compatible models."),
-    logit_bias: z.record(z.string(), z.number()).optional().describe("Optional per-token logit-bias map."),
-    modalities: z.array(z.string()).min(1).optional().describe("Optional requested output modalities, such as text or audio."),
-    audio: z.object({}).passthrough().optional().describe("Optional audio output configuration."),
-    prediction: z.object({}).passthrough().optional().describe("Optional prediction hint for compatible models."),
-    service_tier: z.string().nullable().optional().describe("Optional service-tier hint for compatible models.")
-  },
-  async (input) => {
-    const body = Object.fromEntries(
-      Object.entries({
-        ...input,
-        stream: false
-      }).filter(([, value]) => value !== undefined)
-    );
+  const response = await fetch(url, {
+    method: tool.method,
+    headers,
+    body,
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  const mimeType = (response.headers.get("content-type") || "application/octet-stream").split(";")[0].trim();
 
-    return textResult(await fetchJson("/v1/chat/completions", {
-      method: "POST",
-      auth: true,
-      body
-    }));
+  if (!response.ok) {
+    const detail = (await response.text()).slice(0, 4_000);
+    throw new Error(`TokenLab request failed: ${response.status} ${response.statusText}\n${detail}`);
   }
-);
 
-server.tool(
-  "create_response",
-  "Create a TokenLab Responses API call. Requires TOKENLAB_API_KEY.",
-  {
-    model: z.string().min(1).describe("Public TokenLab model ID."),
-    input: z.string().min(1).describe("Responses API input text."),
-    instructions: z.string().optional().describe("Optional system/developer instructions."),
-    max_output_tokens: z.number().int().min(1).max(8192).optional().describe("Optional output token cap.")
-  },
-  async ({ model, input, instructions, max_output_tokens }) => {
-    return textResult(await fetchJson("/v1/responses", {
-      method: "POST",
-      auth: true,
-      body: {
-        model,
-        input,
-        ...(instructions ? { instructions } : {}),
-        ...(max_output_tokens ? { max_output_tokens } : {})
-      }
-    }));
+  if (mimeType === "application/json" || mimeType.endsWith("+json")) {
+    const result = await response.json();
+    const serialized = JSON.stringify(result);
+    if (Buffer.byteLength(serialized) > INLINE_BYTES) {
+      return artifactResult(Buffer.from(serialized), "application/json", tool.name);
+    }
+    return taskAwareResult(tool, result);
   }
-);
+  if (mimeType.startsWith("text/")) return textResult(await response.text());
+  return artifactResult(Buffer.from(await response.arrayBuffer()), mimeType, tool.name);
+}
 
-server.tool(
-  "create_anthropic_message",
-  "Create a TokenLab Anthropic Messages call. Requires TOKENLAB_API_KEY.",
-  {
-    model: z.string().min(1).describe("Public TokenLab Claude-compatible model ID."),
-    prompt: z.string().min(1).describe("User prompt text."),
-    system: z.string().optional().describe("Optional system prompt."),
-    max_tokens: z.number().int().min(1).max(8192).default(512).describe("Maximum output tokens.")
-  },
-  async ({ model, prompt, system, max_tokens }) => {
-    return textResult(await fetchJson("/v1/messages", {
-      method: "POST",
-      auth: true,
-      body: {
-        model,
-        max_tokens,
-        ...(system ? { system } : {}),
-        messages: [
-          {
-            role: "user",
-            content: prompt
-          }
-        ]
+const activeTools = manifest.tools.filter((tool) => tool.profiles.includes(TOOL_PROFILE));
+for (const tool of activeTools) {
+  const inputSchema = z.fromJSONSchema(tool.input_schema);
+  server.registerTool(
+    tool.name,
+    {
+      description: tool.description,
+      inputSchema,
+      annotations: tool.annotations,
+      _meta: {
+        "tokenlab/operationId": tool.operation_id,
+        "tokenlab/method": tool.method,
+        "tokenlab/path": tool.path,
+        "tokenlab/contentType": tool.content_type,
+        "tokenlab/contractSha256": manifest.source.sha256
       }
-    }));
-  }
-);
+    },
+    async (input) => executeGeneratedTool(tool, input)
+  );
+}
 
-server.tool(
-  "create_gemini_content",
-  "Create a TokenLab Gemini generateContent call. Requires TOKENLAB_API_KEY.",
+server.registerTool(
+  "compare_models",
   {
-    model: z.string().min(1).describe("Public TokenLab Gemini-compatible model ID."),
-    prompt: z.string().min(1).describe("User prompt text."),
-    temperature: z.number().min(0).max(2).optional().describe("Optional Gemini generation temperature.")
+    description: "Compare public TokenLab model details and pricing for several model IDs.",
+    inputSchema: z.object({
+      models: z.array(z.string().min(1)).min(2).max(8),
+      include_raw: z.boolean().default(false)
+    })
   },
-  async ({ model, prompt, temperature }) => {
-    return textResult(await fetchJson(`/v1beta/models/${encodeURIComponent(model)}:generateContent`, {
-      method: "POST",
-      auth: true,
-      body: {
-        contents: [
-          {
-            role: "user",
-            parts: [
-              {
-                text: prompt
-              }
-            ]
-          }
-        ],
-        ...(temperature === undefined ? {} : {
-          generationConfig: {
-            temperature
-          }
-        })
-      }
+  async ({ models, include_raw }) => {
+    const compared = await Promise.all(models.map(async (model) => {
+      const encoded = encodeURIComponent(model);
+      const [details, pricing] = await Promise.all([
+        executePublicJson(`/v1/models/${encoded}`),
+        executePublicJson(`/v1/models/${encoded}/pricing`).catch((error) => ({ error: error.message }))
+      ]);
+      if (include_raw) return { model, details, pricing };
+      return {
+        id: details.id || details.model || model,
+        request_endpoint: details.request_endpoint,
+        request_shape_mode: details.request_shape_mode,
+        supported_operations: details.supported_operations,
+        supported_parameters: details.supported_parameters,
+        recommended_request: details.recommended_request,
+        pricing
+      };
     }));
+    return textResult({ compared });
   }
 );
 
-server.tool(
+server.registerTool(
   "get_api_overview",
-  "Fetch TokenLab's agent-readable API overview.",
-  {},
+  {
+    description: "Fetch TokenLab's agent-readable API overview.",
+    inputSchema: z.object({})
+  },
   async () => {
     const response = await fetch(`${API_BASE}/llms.txt`, {
-      headers: {
-        Accept: "text/plain",
-        "User-Agent": `tokenlab-mcp-server/${VERSION}`
-      }
+      headers: { Accept: "text/plain", "User-Agent": `tokenlab-mcp-server/${VERSION}` },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
     });
-
-    if (!response.ok) {
-      throw new Error(`TokenLab overview request failed: ${response.status} ${response.statusText}`);
-    }
-
+    if (!response.ok) throw new Error(`TokenLab overview request failed: ${response.status} ${response.statusText}`);
     return textResult(await response.text());
   }
 );
 
+async function executePublicJson(path) {
+  const response = await fetch(`${API_BASE}${path}`, {
+    headers: { Accept: "application/json", "User-Agent": `tokenlab-mcp-server/${VERSION}` },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`TokenLab request failed: ${response.status} ${response.statusText}\n${text.slice(0, 2_000)}`);
+  return JSON.parse(text);
+}
+
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/.github/workflows/publish-npm.yml

@@ -1,29 +0,0 @@
-name: Publish npm package
-
-on:
-  push:
-    tags:
-      - "v*"
-
-permissions:
-  contents: read
-  id-token: write
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: actions/setup-node@v6
-        with:
-          node-version: "24"
-          registry-url: "https://registry.npmjs.org"
-          package-manager-cache: false
-
-      - name: Verify tag matches package version
-        run: node --eval 'if (process.env.GITHUB_REF_NAME !== `v${require("./package.json").version}`) process.exit(1)'
-
-      - run: npm ci
-      - run: npm test
-      - run: npm publish

package/server.json

@@ -1,36 +0,0 @@
-{
-  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
-  "name": "io.github.hedging8563/tokenlab",
-  "title": "TokenLab",
-  "description": "MCP server for TokenLab model discovery, pricing, OpenAI-compatible Chat Completions, native endpoints, and inference helpers.",
-  "repository": {
-    "url": "https://github.com/hedging8563/tokenlab-mcp-server",
-    "source": "github"
-  },
-  "version": "0.2.2",
-  "packages": [
-    {
-      "registryType": "npm",
-      "identifier": "@tokenlabai/mcp-server",
-      "version": "0.2.2",
-      "transport": {
-        "type": "stdio"
-      },
-      "environmentVariables": [
-        {
-          "name": "TOKENLAB_API_BASE",
-          "description": "Optional TokenLab API base URL. Defaults to https://api.tokenlab.sh.",
-          "isRequired": false,
-          "format": "string"
-        },
-        {
-          "name": "TOKENLAB_API_KEY",
-          "description": "Optional TokenLab API key. Required only for inference tools such as create_chat_completion, create_response, create_anthropic_message, and create_gemini_content.",
-          "isRequired": false,
-          "format": "string",
-          "isSecret": true
-        }
-      ]
-    }
-  ]
-}