@tokenlabai/mcp-server 0.3.0 → 0.4.1

package/src/index.js

@@ -1,389 +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.3.0";
+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 configuredTimeoutMs = Number.parseInt(process.env.TOKENLAB_REQUEST_TIMEOUT_MS || "30000", 10);
-const REQUEST_TIMEOUT_MS = Number.isFinite(configuredTimeoutMs) && configuredTimeoutMs > 0
-  ? configuredTimeoutMs
-  : 30_000;
+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"));
+
+if (!manifest.profiles.includes(TOOL_PROFILE)) {
+  throw new Error(`Unknown TOKENLAB_MCP_TOOL_PROFILE '${TOOL_PROFILE}'. Expected ${manifest.profiles.join(" or ")}.`);
+}
+
+const server = new McpServer({ name: "tokenlab", version: VERSION });
+
+function positiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value || "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function definedValues(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+
+function textResult(value) {
+  return {
+    content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }]
+  };
+}
+
+function requireApiKey(tool) {
+  if (tool.auth === "required" && !API_KEY) {
+    throw new Error(`TOKENLAB_API_KEY is required for ${tool.name}.`);
+  }
+}
 
-const scenes = [
-  "image",
-  "video",
-  "music",
-  "3d",
-  "tts",
-  "stt",
-  "embedding",
-  "rerank",
-  "translation"
-];
+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 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();
+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;
+  }
 
-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();
+  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));
+}
 
-const openObjectSchema = z.object({}).passthrough();
+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 };
+}
 
-const anthropicMessageSchema = z.object({
-  role: z.enum(["user", "assistant"]),
-  content: z.union([
-    z.string(),
-    z.array(openObjectSchema).min(1)
-  ])
-});
+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
+  });
+}
 
-const geminiContentSchema = z.object({
-  role: z.enum(["user", "model"]).optional(),
-  parts: z.array(openObjectSchema).min(1)
-}).passthrough();
+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";
+}
 
-const server = new McpServer({
-  name: "tokenlab",
-  version: VERSION
-});
+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 }] };
+  }
+  if (bytes.byteLength <= INLINE_BYTES && mimeType.startsWith("audio/")) {
+    return { content: [{ type: "audio", data: Buffer.from(bytes).toString("base64"), mimeType }] };
+  }
+
+  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)));
+  }
+
+  const url = new URL(`${API_BASE}${path}`);
+  for (const [name, value] of Object.entries(queryArguments)) appendQuery(url, name, value);
 
-async function fetchJson(path, options = {}) {
   const headers = {
-    Accept: "application/json",
+    Accept: "application/json, audio/*, image/*, video/*, application/octet-stream",
     "User-Agent": `tokenlab-mcp-server/${VERSION}`
   };
-  if (options.body) {
-    headers["Content-Type"] = "application/json";
+  for (const [name, value] of Object.entries(headerArguments)) {
+    if (value !== undefined) headers[name] = String(value);
   }
-  if (options.auth) {
-    if (!API_KEY) {
-      throw new Error("TOKENLAB_API_KEY is required for TokenLab inference tools.");
+  if (API_KEY && tool.auth !== "none") headers.Authorization = `Bearer ${API_KEY}`;
+
+  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));
     }
-    headers.Authorization = `Bearer ${API_KEY}`;
+    body = form;
   }
 
-  const response = await fetch(`${API_BASE}${path}`, {
-    method: options.method || "GET",
+  const response = await fetch(url, {
+    method: tool.method,
     headers,
-    body: options.body ? JSON.stringify(options.body) : undefined,
+    body,
     signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
   });
-
-  const text = await response.text();
+  const mimeType = (response.headers.get("content-type") || "application/octet-stream").split(";")[0].trim();
 
   if (!response.ok) {
-    const detail = text.length > 2_000 ? `${text.slice(0, 2_000)}...` : text;
+    const detail = (await response.text()).slice(0, 4_000);
     throw new Error(`TokenLab request failed: ${response.status} ${response.statusText}\n${detail}`);
   }
 
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error("TokenLab returned a successful response that was not valid JSON.");
+  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);
 }
 
-function textResult(value) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+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)
+  );
 }
 
-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
-  };
-}
-
-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
-    });
-  }
-);
-
-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)}`));
-  }
-);
-
-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`));
-  }
-);
-
-server.tool(
+server.registerTool(
   "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.")
+    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 ({ 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
-        }))
+        executePublicJson(`/v1/models/${encoded}`),
+        executePublicJson(`/v1/models/${encoded}/pricing`).catch((error) => ({ error: error.message }))
       ]);
-
-      return include_raw ? { model, details, pricing } : compactModelDetails(details, pricing);
+      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(
-  "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)
-    );
-
-    return textResult(await fetchJson("/v1/chat/completions", {
-      method: "POST",
-      auth: true,
-      body
-    }));
-  }
-);
-
-server.tool(
-  "create_response",
-  "Create a non-streaming TokenLab Responses API call with text or native structured input. Requires TOKENLAB_API_KEY.",
-  {
-    model: z.string().min(1).describe("Public TokenLab model ID."),
-    input: z.union([
-      z.string().min(1),
-      z.array(openObjectSchema).min(1)
-    ]).describe("Responses API input as text or native structured input items."),
-    instructions: z.string().optional().describe("Optional system/developer instructions."),
-    max_output_tokens: z.number().int().min(1).optional().describe("Optional output token cap."),
-    temperature: z.number().optional().describe("Optional sampling temperature."),
-    tools: z.array(openObjectSchema).optional().describe("Native Responses API tool definitions."),
-    tool_choice: z.union([z.string(), openObjectSchema]).optional().describe("Tool choice policy or explicit tool selection."),
-    reasoning_effort: z.string().optional().describe("Reasoning-effort hint for compatible models."),
-    include: z.array(z.string()).optional().describe("Additional response sections to include."),
-    service_tier: z.string().nullable().optional().describe("Optional service-tier hint."),
-    truncation_strategy: z.string().optional().describe("Optional truncation strategy."),
-    seed: z.number().int().optional().describe("Optional deterministic seed."),
-    user: z.string().optional().describe("Optional end-user identifier."),
-    parallel_tool_calls: z.boolean().optional().describe("Whether the model may issue parallel tool calls."),
-    metadata: openObjectSchema.optional().describe("Optional request metadata."),
-    text: openObjectSchema.optional().describe("Optional native text formatting configuration.")
-  },
-  async (input) => {
-    return textResult(await fetchJson("/v1/responses", {
-      method: "POST",
-      auth: true,
-      body: Object.fromEntries(
-        Object.entries({ ...input, stream: false }).filter(([, value]) => value !== undefined)
-      )
-    }));
-  }
-);
-
-server.tool(
-  "create_anthropic_message",
-  "Create a non-streaming TokenLab Anthropic Messages call with native messages, multimodal blocks, and tools. A prompt shortcut remains available for simple calls. Requires TOKENLAB_API_KEY.",
-  {
-    model: z.string().min(1).describe("Public TokenLab Claude-compatible model ID."),
-    messages: z.array(anthropicMessageSchema).min(1).optional().describe("Native Anthropic conversation messages."),
-    prompt: z.string().min(1).optional().describe("Convenience shortcut for one user text message; do not combine with messages."),
-    system: z.string().optional().describe("Optional system prompt."),
-    max_tokens: z.number().int().min(1).default(512).describe("Maximum output tokens."),
-    temperature: z.number().min(0).max(1).optional().describe("Optional sampling temperature."),
-    top_p: z.number().min(0).max(1).optional().describe("Optional nucleus sampling probability."),
-    top_k: z.number().int().min(1).optional().describe("Optional top-k sampling cutoff."),
-    stop_sequences: z.array(z.string()).optional().describe("Optional stop sequences."),
-    tools: z.array(openObjectSchema).optional().describe("Native Anthropic tool definitions."),
-    tool_choice: z.union([z.string(), openObjectSchema]).optional().describe("Tool choice policy or explicit tool selection."),
-    metadata: openObjectSchema.optional().describe("Optional request metadata."),
-    thinking: openObjectSchema.optional().describe("Thinking configuration for compatible models."),
-    service_tier: z.string().optional().describe("Optional service-tier hint.")
-  },
-  async ({ prompt, messages, ...input }) => {
-    if (prompt && messages) {
-      throw new Error("Provide either prompt or messages, not both.");
-    }
-    if (!prompt && !messages) {
-      throw new Error("Provide prompt or at least one native Anthropic message.");
-    }
-
-    return textResult(await fetchJson("/v1/messages", {
-      method: "POST",
-      auth: true,
-      body: {
-        ...input,
-        messages: messages || [{ role: "user", content: prompt }],
-        stream: false
-      }
-    }));
-  }
-);
-
-server.tool(
-  "create_gemini_content",
-  "Create a TokenLab Gemini generateContent call with native contents, multimodal parts, generation config, and tools. A prompt shortcut remains available for simple calls. Requires TOKENLAB_API_KEY.",
+server.registerTool(
+  "get_api_overview",
   {
-    model: z.string().min(1).describe("Public TokenLab Gemini-compatible model ID."),
-    contents: z.array(geminiContentSchema).min(1).optional().describe("Native Gemini conversation contents."),
-    prompt: z.string().min(1).optional().describe("Convenience shortcut for one user text part; do not combine with contents."),
-    temperature: z.number().min(0).optional().describe("Convenience temperature setting; do not combine with generationConfig.temperature."),
-    systemInstruction: openObjectSchema.optional().describe("Native Gemini system instruction."),
-    generationConfig: openObjectSchema.optional().describe("Native Gemini generation configuration."),
-    safetySettings: z.array(openObjectSchema).optional().describe("Native Gemini safety settings."),
-    tools: z.array(openObjectSchema).optional().describe("Native Gemini tools."),
-    toolConfig: openObjectSchema.optional().describe("Native Gemini tool configuration."),
-    cachedContent: z.string().optional().describe("Optional cached content resource name.")
+    description: "Fetch TokenLab's agent-readable API overview.",
+    inputSchema: z.object({})
   },
-  async ({ model, prompt, contents, temperature, generationConfig, ...input }) => {
-    if (prompt && contents) {
-      throw new Error("Provide either prompt or contents, not both.");
-    }
-    if (!prompt && !contents) {
-      throw new Error("Provide prompt or at least one native Gemini content item.");
-    }
-    if (temperature !== undefined && generationConfig?.temperature !== undefined) {
-      throw new Error("Set temperature either directly or in generationConfig, not both.");
-    }
-
-    return textResult(await fetchJson(`/v1beta/models/${encodeURIComponent(model)}:generateContent`, {
-      method: "POST",
-      auth: true,
-      body: {
-        ...input,
-        contents: contents || [{ role: "user", parts: [{ text: prompt }] }],
-        ...(generationConfig || temperature !== undefined ? {
-          generationConfig: {
-            ...generationConfig,
-            ...(temperature === undefined ? {} : { temperature })
-          }
-        } : {})
-      }
-    }));
-  }
-);
-
-server.tool(
-  "get_api_overview",
-  "Fetch TokenLab's agent-readable API overview.",
-  {},
   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,53 +0,0 @@
-name: Publish npm package and MCP Registry
-
-on:
-  push:
-    tags:
-      - "v*"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  id-token: write
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: actions/setup-node@v6
-        if: github.event_name == 'push'
-        with:
-          node-version: "24"
-          registry-url: "https://registry.npmjs.org"
-          package-manager-cache: false
-
-      - name: Verify tag matches package version
-        if: github.event_name == 'push'
-        run: node --eval 'if (process.env.GITHUB_REF_NAME !== `v${require("./package.json").version}`) process.exit(1)'
-
-      - name: Install dependencies
-        if: github.event_name == 'push'
-        run: npm ci
-
-      - name: Test package
-        if: github.event_name == 'push'
-        run: npm test
-
-      - name: Publish npm package
-        if: github.event_name == 'push'
-        run: npm publish
-
-      - name: Install MCP Registry publisher
-        run: |
-          curl -fsSLo mcp-publisher.tar.gz \
-            https://github.com/modelcontextprotocol/registry/releases/download/v1.7.9/mcp-publisher_linux_amd64.tar.gz
-          echo "ab128162b0616090b47cf245afe0a23f3ef08936fdce19074f5ba0a4469281ac  mcp-publisher.tar.gz" | sha256sum --check
-          tar -xzf mcp-publisher.tar.gz mcp-publisher
-
-      - name: Authenticate to MCP Registry
-        run: ./mcp-publisher login github-oidc
-
-      - name: Publish to MCP Registry
-        run: ./mcp-publisher publish