@tokenlabai/mcp-server 0.2.0 → 0.2.2

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

@@ -0,0 +1,29 @@
+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/README.md

@@ -1,6 +1,6 @@
 # TokenLab MCP Server
 
-Model Context Protocol server for TokenLab public model discovery, pricing, native endpoint guidance, and optional inference helpers.
+Model Context Protocol server for TokenLab public model discovery, pricing, OpenAI-compatible Chat Completions, 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`.
 
@@ -11,6 +11,7 @@ It exposes public catalog tools for agents that need to choose models, inspect s
 - `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_chat_completion` - Call TokenLab's OpenAI-compatible non-streaming Chat Completions API. Requires `TOKENLAB_API_KEY`.
 - `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`.
@@ -44,28 +45,29 @@ Claude Desktop style config:
 }
 ```
 
-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.
+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. `create_chat_completion` supports OpenAI-compatible messages, multimodal content parts, function calling, and common generation controls. MCP tools return a normal JSON result, so streaming is intentionally disabled.
 
 ## 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`
+- `TOKENLAB_API_KEY`: optional; required only for `create_chat_completion`, `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:
+Current publication:
 
-- npm package: `@tokenlabai/mcp-server`
+- npm package: `@tokenlabai/mcp-server@0.2.2`
 - MCP registry name: `io.github.hedging8563/tokenlab`
+- Official MCP Registry status: active
 - `package.json.mcpName`: `io.github.hedging8563/tokenlab`
 
-Publish order:
+For a new release:
 
-1. Publish `@tokenlabai/mcp-server` to npm.
+1. Publish the next `@tokenlabai/mcp-server` version to npm.
 2. Authenticate with `mcp-publisher login github`.
-3. Run `mcp-publisher publish`.
+3. Update `server.json` and run `mcp-publisher publish`.
 
 ## Links
 

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@tokenlabai/mcp-server",
-  "version": "0.2.0",
-  "description": "MCP server for TokenLab model discovery, pricing, native endpoint guidance, and optional inference helpers.",
+  "version": "0.2.2",
+  "description": "MCP server for TokenLab model discovery, pricing, OpenAI-compatible Chat Completions, native endpoint guidance, and optional inference helpers.",
   "type": "module",
   "mcpName": "io.github.hedging8563/tokenlab",
   "bin": {
-    "tokenlab-mcp-server": "./src/index.js"
+    "tokenlab-mcp-server": "src/index.js"
   },
   "scripts": {
     "start": "node ./src/index.js",
-    "test": "node --check ./src/index.js"
+    "test": "node --check ./src/index.js && node --test"
   },
   "keywords": [
     "mcp",
@@ -30,7 +30,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/hedging8563/tokenlab-mcp-server.git"
+    "url": "git+https://github.com/hedging8563/tokenlab-mcp-server.git"
   },
   "homepage": "https://docs.tokenlab.sh"
 }

package/server.json

@@ -2,17 +2,17 @@
   "$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.",
+  "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.0",
+  "version": "0.2.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@tokenlabai/mcp-server",
-      "version": "0.2.0",
+      "version": "0.2.2",
       "transport": {
         "type": "stdio"
       },
@@ -25,7 +25,7 @@
         },
         {
           "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.",
+          "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

package/src/index.js

@@ -4,7 +4,7 @@ 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 VERSION = "0.2.2";
 const API_BASE = (process.env.TOKENLAB_API_BASE || "https://api.tokenlab.sh").replace(/\/$/, "");
 const API_KEY = process.env.TOKENLAB_API_KEY || "";
 
@@ -20,6 +20,28 @@ const scenes = [
   "translation"
 ];
 
+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 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 server = new McpServer({
   name: "tokenlab",
   version: VERSION
@@ -147,6 +169,60 @@ server.tool(
   }
 );
 
+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 TokenLab Responses API call. Requires TOKENLAB_API_KEY.",

package/test/mcp-tools.test.js

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { stat } from "node:fs/promises";
+import test from "node:test";
+
+function startServer() {
+  const child = spawn(process.execPath, ["src/index.js"], {
+    cwd: process.cwd(),
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let nextId = 1;
+  let buffer = "";
+  const pending = new Map();
+
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = lines.pop();
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const message = JSON.parse(line);
+      const resolve = pending.get(message.id);
+      if (resolve) {
+        pending.delete(message.id);
+        resolve(message);
+      }
+    }
+  });
+
+  function request(method, params) {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`Timed out waiting for ${method}`));
+      }, 5_000);
+      pending.set(id, (message) => {
+        clearTimeout(timeout);
+        resolve(message);
+      });
+      child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+    });
+  }
+
+  function notify(method, params) {
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+  }
+
+  return { child, notify, request };
+}
+
+test("advertises an OpenAI-compatible Chat Completions tool", async (t) => {
+  const server = startServer();
+  t.after(() => server.child.kill());
+
+  const initialized = await server.request("initialize", {
+    protocolVersion: "2025-11-25",
+    capabilities: {},
+    clientInfo: { name: "tokenlab-mcp-test", version: "0.0.0" }
+  });
+  assert.equal(initialized.error, undefined);
+
+  server.notify("notifications/initialized");
+  const listed = await server.request("tools/list", {});
+  const tool = listed.result.tools.find(({ name }) => name === "create_chat_completion");
+
+  assert.ok(tool);
+  assert.equal(tool.inputSchema.properties.model.type, "string");
+  assert.equal(tool.inputSchema.properties.messages.type, "array");
+  assert.equal(tool.inputSchema.properties.stream, undefined);
+});
+
+test("ships an executable npm binary", async () => {
+  const { mode } = await stat(new URL("../src/index.js", import.meta.url));
+  assert.notEqual(mode & 0o111, 0);
+});