@tokenlabai/mcp-server 0.2.1 → 0.3.0

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

@@ -1,9 +1,10 @@
-name: Publish npm package
+name: Publish npm package and MCP Registry
 
 on:
   push:
     tags:
       - "v*"
+  workflow_dispatch:
 
 permissions:
   contents: read
@@ -16,14 +17,37 @@ jobs:
       - 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)'
 
-      - run: npm ci
-      - run: npm test
-      - run: npm publish
+      - 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

package/README.md

@@ -1,6 +1,6 @@
 # TokenLab MCP Server
 
-Model Context Protocol server for TokenLab public model discovery, pricing, OpenAI-compatible Chat Completions, native endpoint guidance, and optional inference helpers.
+Model Context Protocol server for TokenLab public model discovery, pricing, OpenAI-compatible Chat Completions, and native Responses, Anthropic Messages, and Gemini inference.
 
 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`.
 
@@ -35,8 +35,8 @@ Claude Desktop style config:
 {
   "mcpServers": {
     "tokenlab-model-catalog": {
-      "command": "node",
-      "args": ["/absolute/path/to/tokenlab-mcp-server/src/index.js"],
+      "command": "npx",
+      "args": ["-y", "@tokenlabai/mcp-server"],
       "env": {
         "TOKENLAB_API_BASE": "https://api.tokenlab.sh"
       }
@@ -45,12 +45,13 @@ 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. `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.
+No TokenLab API key is required for the public catalog tools. Set `TOKENLAB_API_KEY` only when you want the inference tools to call paid TokenLab APIs. `create_chat_completion` supports OpenAI-compatible messages, multimodal content parts, function calling, and common generation controls. The native tools preserve structured Responses input, Anthropic message blocks and tools, and Gemini contents, multimodal parts, tools, and generation config. The `prompt` shortcuts remain available for simple Anthropic and Gemini calls. 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_chat_completion`, `create_response`, `create_anthropic_message`, and `create_gemini_content`
+- `TOKENLAB_REQUEST_TIMEOUT_MS`: optional request timeout in milliseconds, defaults to `30000`
 
 ## MCP Registry Metadata
 
@@ -58,16 +59,18 @@ This repository includes `server.json` for the official MCP Registry.
 
 Current publication:
 
-- npm package: `@tokenlabai/mcp-server@0.2.1`
+- npm package: `@tokenlabai/mcp-server@0.3.0`
 - MCP registry name: `io.github.hedging8563/tokenlab`
 - Official MCP Registry status: active
 - `package.json.mcpName`: `io.github.hedging8563/tokenlab`
 
 For a new release:
 
-1. Publish the next `@tokenlabai/mcp-server` version to npm.
-2. Authenticate with `mcp-publisher login github`.
-3. Update `server.json` and run `mcp-publisher publish`.
+1. Bump the matching versions in `package.json`, `package-lock.json`, and `server.json`.
+2. Push a matching tag such as `v0.3.0`.
+3. The publish workflow tests and publishes npm through trusted publishing, then publishes the MCP Registry entry through GitHub Actions OIDC.
+
+The same workflow can be run manually from `main` to republish only the current MCP Registry metadata. No npm or MCP Registry token is stored in GitHub.
 
 ## Links
 

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@tokenlabai/mcp-server",
-  "version": "0.2.1",
-  "description": "MCP server for TokenLab model discovery, pricing, OpenAI-compatible Chat Completions, native endpoint guidance, and optional inference helpers.",
+  "version": "0.3.0",
+  "description": "MCP server for TokenLab model discovery, pricing, OpenAI-compatible Chat Completions, and native Responses, Anthropic Messages, and Gemini inference.",
   "type": "module",
+  "engines": {
+    "node": ">=18.17"
+  },
   "mcpName": "io.github.hedging8563/tokenlab",
   "bin": {
     "tokenlab-mcp-server": "src/index.js"

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, OpenAI-compatible Chat Completions, native endpoints, and inference helpers.",
+  "description": "TokenLab MCP server for model discovery, pricing, OpenAI-compatible chat, and native endpoints.",
   "repository": {
     "url": "https://github.com/hedging8563/tokenlab-mcp-server",
     "source": "github"
   },
-  "version": "0.2.1",
+  "version": "0.3.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@tokenlabai/mcp-server",
-      "version": "0.2.1",
+      "version": "0.3.0",
       "transport": {
         "type": "stdio"
       },
@@ -29,6 +29,12 @@
           "isRequired": false,
           "format": "string",
           "isSecret": true
+        },
+        {
+          "name": "TOKENLAB_REQUEST_TIMEOUT_MS",
+          "description": "Optional request timeout in milliseconds. Defaults to 30000.",
+          "isRequired": false,
+          "format": "number"
         }
       ]
     }

package/src/index.js

@@ -4,9 +4,13 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 
-const VERSION = "0.2.1";
-const API_BASE = (process.env.TOKENLAB_API_BASE || "https://api.tokenlab.sh").replace(/\/$/, "");
+const VERSION = "0.3.0";
+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 scenes = [
   "image",
@@ -42,6 +46,21 @@ const chatCompletionToolSchema = z.object({
   }).passthrough()
 }).passthrough();
 
+const openObjectSchema = z.object({}).passthrough();
+
+const anthropicMessageSchema = z.object({
+  role: z.enum(["user", "assistant"]),
+  content: z.union([
+    z.string(),
+    z.array(openObjectSchema).min(1)
+  ])
+});
+
+const geminiContentSchema = z.object({
+  role: z.enum(["user", "model"]).optional(),
+  parts: z.array(openObjectSchema).min(1)
+}).passthrough();
+
 const server = new McpServer({
   name: "tokenlab",
   version: VERSION
@@ -65,16 +84,22 @@ async function fetchJson(path, options = {}) {
   const response = await fetch(`${API_BASE}${path}`, {
     method: options.method || "GET",
     headers,
-    body: options.body ? JSON.stringify(options.body) : undefined
+    body: options.body ? JSON.stringify(options.body) : undefined,
+    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}`);
+    const detail = text.length > 2_000 ? `${text.slice(0, 2_000)}...` : text;
+    throw new Error(`TokenLab request failed: ${response.status} ${response.statusText}\n${detail}`);
   }
 
-  return JSON.parse(text);
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error("TokenLab returned a successful response that was not valid JSON.");
+  }
 }
 
 function textResult(value) {
@@ -225,50 +250,73 @@ server.tool(
 
 server.tool(
   "create_response",
-  "Create a TokenLab Responses API call. Requires TOKENLAB_API_KEY.",
+  "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.string().min(1).describe("Responses API input text."),
+    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).max(8192).optional().describe("Optional output token cap.")
+    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 ({ model, input, instructions, max_output_tokens }) => {
+  async (input) => {
     return textResult(await fetchJson("/v1/responses", {
       method: "POST",
       auth: true,
-      body: {
-        model,
-        input,
-        ...(instructions ? { instructions } : {}),
-        ...(max_output_tokens ? { max_output_tokens } : {})
-      }
+      body: Object.fromEntries(
+        Object.entries({ ...input, stream: false }).filter(([, value]) => value !== undefined)
+      )
     }));
   }
 );
 
 server.tool(
   "create_anthropic_message",
-  "Create a TokenLab Anthropic Messages call. Requires TOKENLAB_API_KEY.",
+  "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."),
-    prompt: z.string().min(1).describe("User prompt text."),
+    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).max(8192).default(512).describe("Maximum output tokens.")
+    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 ({ model, prompt, system, max_tokens }) => {
+  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: {
-        model,
-        max_tokens,
-        ...(system ? { system } : {}),
-        messages: [
-          {
-            role: "user",
-            content: prompt
-          }
-        ]
+        ...input,
+        messages: messages || [{ role: "user", content: prompt }],
+        stream: false
       }
     }));
   }
@@ -276,32 +324,42 @@ server.tool(
 
 server.tool(
   "create_gemini_content",
-  "Create a TokenLab Gemini generateContent call. Requires TOKENLAB_API_KEY.",
+  "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.",
   {
     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.")
+    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.")
   },
-  async ({ model, prompt, temperature }) => {
+  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: {
-        contents: [
-          {
-            role: "user",
-            parts: [
-              {
-                text: prompt
-              }
-            ]
-          }
-        ],
-        ...(temperature === undefined ? {} : {
+        ...input,
+        contents: contents || [{ role: "user", parts: [{ text: prompt }] }],
+        ...(generationConfig || temperature !== undefined ? {
           generationConfig: {
-            temperature
+            ...generationConfig,
+            ...(temperature === undefined ? {} : { temperature })
           }
-        })
+        } : {})
       }
     }));
   }

package/test/mcp-tools.test.js

@@ -1,72 +1,157 @@
 import assert from "node:assert/strict";
-import { spawn } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { createServer } from "node:http";
 import test from "node:test";
 
-function startServer() {
-  const child = spawn(process.execPath, ["src/index.js"], {
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+async function startMockApi(t) {
+  const requests = [];
+  const server = createServer(async (request, response) => {
+    let body = "";
+    for await (const chunk of request) body += chunk;
+
+    requests.push({
+      method: request.method,
+      url: request.url,
+      authorization: request.headers.authorization,
+      body: body ? JSON.parse(body) : undefined
+    });
+
+    response.writeHead(200, { "Content-Type": "application/json" });
+    response.end(JSON.stringify({ ok: true }));
+  });
+
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  t.after(() => new Promise((resolve) => server.close(resolve)));
+
+  const address = server.address();
+  return {
+    baseUrl: `http://127.0.0.1:${address.port}`,
+    requests
+  };
+}
+
+async function startMcpClient(t, env = {}) {
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: ["src/index.js"],
     cwd: process.cwd(),
-    stdio: ["pipe", "pipe", "pipe"]
+    env: { ...process.env, ...env },
+    stderr: "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);
-      }
-    }
+  const client = new Client({ name: "tokenlab-mcp-test", version: "0.0.0" });
+
+  await client.connect(transport);
+  t.after(() => client.close());
+  return client;
+}
+
+test("advertises all catalog, OpenAI-compatible, and native endpoint tools", async (t) => {
+  const client = await startMcpClient(t);
+  const { tools } = await client.listTools();
+  const byName = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
+
+  assert.deepEqual(Object.keys(byName).sort(), [
+    "compare_models",
+    "create_anthropic_message",
+    "create_chat_completion",
+    "create_gemini_content",
+    "create_response",
+    "get_api_overview",
+    "get_model",
+    "get_model_pricing",
+    "list_models"
+  ]);
+  assert.equal(byName.create_chat_completion.inputSchema.properties.messages.type, "array");
+  assert.equal(byName.create_chat_completion.inputSchema.properties.stream, undefined);
+  assert.ok(byName.create_response.inputSchema.properties.input.anyOf);
+  assert.equal(byName.create_anthropic_message.inputSchema.properties.messages.type, "array");
+  assert.equal(byName.create_gemini_content.inputSchema.properties.contents.type, "array");
+});
+
+test("forwards native endpoint payloads without flattening their semantics", async (t) => {
+  const api = await startMockApi(t);
+  const client = await startMcpClient(t, {
+    TOKENLAB_API_BASE: api.baseUrl,
+    TOKENLAB_API_KEY: "test-key"
   });
 
-  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`);
-    });
-  }
+  await client.callTool({
+    name: "create_response",
+    arguments: {
+      model: "gpt-5.5",
+      input: [{ role: "user", content: [{ type: "input_text", text: "Hello" }] }],
+      tools: [{ type: "function", name: "lookup" }]
+    }
+  });
+  await client.callTool({
+    name: "create_anthropic_message",
+    arguments: {
+      model: "claude-sonnet-5",
+      max_tokens: 1024,
+      messages: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
+      tools: [{ name: "lookup", input_schema: { type: "object" } }]
+    }
+  });
+  await client.callTool({
+    name: "create_gemini_content",
+    arguments: {
+      model: "gemini-3.5-flash",
+      contents: [{ role: "user", parts: [{ text: "Hello" }] }],
+      generationConfig: { responseMimeType: "application/json" },
+      tools: [{ functionDeclarations: [{ name: "lookup" }] }]
+    }
+  });
 
-  function notify(method, params) {
-    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+  assert.equal(api.requests.length, 3);
+  for (const request of api.requests) {
+    assert.equal(request.method, "POST");
+    assert.equal(request.authorization, "Bearer test-key");
   }
 
-  return { child, notify, request };
-}
+  assert.equal(api.requests[0].url, "/v1/responses");
+  assert.equal(api.requests[0].body.stream, false);
+  assert.deepEqual(api.requests[0].body.input[0].content[0], { type: "input_text", text: "Hello" });
+  assert.equal(api.requests[1].url, "/v1/messages");
+  assert.equal(api.requests[1].body.stream, false);
+  assert.equal(api.requests[1].body.messages[0].content[0].type, "text");
+  assert.equal(api.requests[2].url, "/v1beta/models/gemini-3.5-flash:generateContent");
+  assert.equal(api.requests[2].body.generationConfig.responseMimeType, "application/json");
+  assert.equal(api.requests[2].body.tools[0].functionDeclarations[0].name, "lookup");
+});
 
-test("advertises an OpenAI-compatible Chat Completions tool", async (t) => {
-  const server = startServer();
-  t.after(() => server.child.kill());
+test("keeps simple prompt shortcuts and requires auth for inference", async (t) => {
+  const api = await startMockApi(t);
+  const authenticated = await startMcpClient(t, {
+    TOKENLAB_API_BASE: api.baseUrl,
+    TOKENLAB_API_KEY: "test-key"
+  });
 
-  const initialized = await server.request("initialize", {
-    protocolVersion: "2025-11-25",
-    capabilities: {},
-    clientInfo: { name: "tokenlab-mcp-test", version: "0.0.0" }
+  await authenticated.callTool({
+    name: "create_anthropic_message",
+    arguments: { model: "claude-sonnet-5", prompt: "Hello", max_tokens: 32 }
+  });
+  await authenticated.callTool({
+    name: "create_gemini_content",
+    arguments: { model: "gemini-3.5-flash", prompt: "Hello", temperature: 0.2 }
   });
-  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.equal(api.requests[0].body.messages[0].content, "Hello");
+  assert.equal(api.requests[1].body.contents[0].parts[0].text, "Hello");
+  assert.equal(api.requests[1].body.generationConfig.temperature, 0.2);
+
+  const unauthenticated = await startMcpClient(t, { TOKENLAB_API_BASE: api.baseUrl });
+  const result = await unauthenticated.callTool({
+    name: "create_response",
+    arguments: { model: "gpt-5.5", input: "Hello" }
+  });
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /TOKENLAB_API_KEY is required/);
+});
 
-  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);
 });