@tokenlabai/mcp-server 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TokenLab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,75 @@
+# TokenLab MCP Server
+
+Model Context Protocol server for TokenLab public model discovery, pricing, native endpoint guidance, and optional inference helpers.
+
+It exposes public catalog tools for agents that need to choose models, inspect supported request formats, or compare pricing before calling TokenLab APIs. Optional inference tools require `TOKENLAB_API_KEY`.
+
+## Tools
+
+- `list_models` - List public TokenLab models, optionally filtered by `recommended_for`.
+- `get_model` - Fetch public model details for one model ID.
+- `get_model_pricing` - Fetch pricing details for one model ID.
+- `compare_models` - Compare details and pricing for several model IDs.
+- `get_api_overview` - Fetch the agent-readable `llms.txt` overview.
+- `create_response` - Call TokenLab Responses API. Requires `TOKENLAB_API_KEY`.
+- `create_anthropic_message` - Call TokenLab Anthropic Messages API. Requires `TOKENLAB_API_KEY`.
+- `create_gemini_content` - Call TokenLab Gemini generateContent API. Requires `TOKENLAB_API_KEY`.
+
+## Run
+
+```bash
+npm install
+npm start
+```
+
+Install from npm:
+
+```bash
+npx -y @tokenlabai/mcp-server
+```
+
+Claude Desktop style config:
+
+```json
+{
+  "mcpServers": {
+    "tokenlab-model-catalog": {
+      "command": "node",
+      "args": ["/absolute/path/to/tokenlab-mcp-server/src/index.js"],
+      "env": {
+        "TOKENLAB_API_BASE": "https://api.tokenlab.sh"
+      }
+    }
+  }
+}
+```
+
+No TokenLab API key is required for the public catalog tools. Set `TOKENLAB_API_KEY` only when you want the inference helper tools to call paid TokenLab APIs.
+
+## Environment
+
+- `TOKENLAB_API_BASE`: optional, defaults to `https://api.tokenlab.sh`
+- `TOKENLAB_API_KEY`: optional; required only for `create_response`, `create_anthropic_message`, and `create_gemini_content`
+
+## MCP Registry Metadata
+
+This repository includes `server.json` for the official MCP Registry.
+
+The package uses:
+
+- npm package: `@tokenlabai/mcp-server`
+- MCP registry name: `io.github.hedging8563/tokenlab`
+- `package.json.mcpName`: `io.github.hedging8563/tokenlab`
+
+Publish order:
+
+1. Publish `@tokenlabai/mcp-server` to npm.
+2. Authenticate with `mcp-publisher login github`.
+3. Run `mcp-publisher publish`.
+
+## Links
+
+- Docs: https://docs.tokenlab.sh
+- OpenAPI: https://docs.tokenlab.sh/openapi.json
+- Model catalog: https://api.tokenlab.sh/v1/models
+- Skills: https://github.com/hedging8563/tokenlab-skills

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@tokenlabai/mcp-server",
+  "version": "0.2.0",
+  "description": "MCP server for TokenLab model discovery, pricing, native endpoint guidance, and optional inference helpers.",
+  "type": "module",
+  "mcpName": "io.github.hedging8563/tokenlab",
+  "bin": {
+    "tokenlab-mcp-server": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node ./src/index.js",
+    "test": "node --check ./src/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "tokenlab",
+    "ai-api",
+    "llm-gateway",
+    "model-routing"
+  ],
+  "author": "TokenLab",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hedging8563/tokenlab-mcp-server.git"
+  },
+  "homepage": "https://docs.tokenlab.sh"
+}

package/server.json

@@ -0,0 +1,36 @@
+{
+  "$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, native endpoint guidance, and optional inference helpers.",
+  "repository": {
+    "url": "https://github.com/hedging8563/tokenlab-mcp-server",
+    "source": "github"
+  },
+  "version": "0.2.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@tokenlabai/mcp-server",
+      "version": "0.2.0",
+      "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_response, create_anthropic_message, and create_gemini_content.",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": true
+        }
+      ]
+    }
+  ]
+}

package/src/index.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+const VERSION = "0.2.0";
+const API_BASE = (process.env.TOKENLAB_API_BASE || "https://api.tokenlab.sh").replace(/\/$/, "");
+const API_KEY = process.env.TOKENLAB_API_KEY || "";
+
+const scenes = [
+  "image",
+  "video",
+  "music",
+  "3d",
+  "tts",
+  "stt",
+  "embedding",
+  "rerank",
+  "translation"
+];
+
+const server = new McpServer({
+  name: "tokenlab",
+  version: VERSION
+});
+
+async function fetchJson(path, options = {}) {
+  const headers = {
+    Accept: "application/json",
+    "User-Agent": `tokenlab-mcp-server/${VERSION}`
+  };
+  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}`;
+  }
+
+  const response = await fetch(`${API_BASE}${path}`, {
+    method: options.method || "GET",
+    headers,
+    body: options.body ? JSON.stringify(options.body) : undefined
+  });
+
+  const text = await response.text();
+
+  if (!response.ok) {
+    throw new Error(`TokenLab request failed: ${response.status} ${response.statusText}\n${text}`);
+  }
+
+  return JSON.parse(text);
+}
+
+function textResult(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+      }
+    ]
+  };
+}
+
+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(
+  "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
+        }))
+      ]);
+
+      return include_raw ? { model, details, pricing } : compactModelDetails(details, pricing);
+    }));
+
+    return textResult({ compared });
+  }
+);
+
+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 } : {})
+      }
+    }));
+  }
+);
+
+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
+          }
+        ]
+      }
+    }));
+  }
+);
+
+server.tool(
+  "create_gemini_content",
+  "Create a TokenLab Gemini generateContent call. Requires TOKENLAB_API_KEY.",
+  {
+    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.")
+  },
+  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
+          }
+        })
+      }
+    }));
+  }
+);
+
+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}`
+      }
+    });
+
+    if (!response.ok) {
+      throw new Error(`TokenLab overview request failed: ${response.status} ${response.statusText}`);
+    }
+
+    return textResult(await response.text());
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);