tautau-mcp 0.1.0

package/README.md

@@ -0,0 +1,141 @@
+# tautau-mcp
+
+An MCP (Model Context Protocol) stdio server that gives LLM clients — Claude Code, Claude Desktop, Codex, anything that speaks MCP — access to [tautau](https://tautau.xyz) transcription:
+
+- **YouTube links** → transcript (captions-first, returns in seconds)
+- **Podcast / direct-audio URLs** → transcript (server-side speech-to-text, long jobs poll automatically)
+- **Local audio files** (mp3/wav/m4a/ogg/webm/mp4, up to 25MB) → transcript
+
+No API key, no account: usage is anonymous and quota-tracked per IP by the tautau service (5 lifetime URL transcripts, 5 lifetime dictations). When you hit the wall the tools say so and point at [signup](https://tautau.xyz/login) / [pricing](https://tautau.xyz/pricing) — a free account gets a daily allowance.
+
+## 30-second install
+
+Node.js >= 18 required. The server runs via `npx` — there is nothing to install globally.
+
+**One-shot installer** (detects Claude Code / Codex / Claude Desktop and wires them up, prompting per client):
+
+```bash
+curl -fsSL https://tautau.xyz/mcp/install.sh | bash
+# or from this repo:
+bash mcp/install.sh --yes
+```
+
+Or configure your client by hand:
+
+**Claude Code**
+
+```bash
+claude mcp add tautau -- npx -y tautau-mcp
+```
+
+**Claude Desktop** — edit `claude_desktop_config.json`
+(macOS: `~/Library/Application Support/Claude/`, Linux: `~/.config/Claude/`):
+
+```json
+{
+  "mcpServers": {
+    "tautau": {
+      "command": "npx",
+      "args": ["-y", "tautau-mcp"]
+    }
+  }
+}
+```
+
+**Codex** — append to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.tautau]
+command = "npx"
+args = ["-y", "tautau-mcp"]
+```
+
+Restart the client after editing config. Verify with `get_quota` (see below).
+
+### Environment
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `TAUTAU_API_BASE` | `https://tautau.xyz` | API base URL — only override for self-hosted/dev deployments |
+
+## Tools
+
+### `transcribe_url`
+
+Transcribe a YouTube video, podcast episode, or direct audio URL.
+
+| Argument | Type | Required | Notes |
+| --- | --- | --- | --- |
+| `url` | string | yes | Full `https://` link |
+| `language` | string | no | BCP-47 hint, e.g. `"en"` |
+| `cleanup` | boolean | no | AI polish: punctuation, filler removal |
+
+YouTube resolves from captions inline; audio/podcast links return `pending` and the server polls every 3s for up to 6 minutes. Long transcripts are returned in full.
+
+Example: *"Transcribe https://www.youtube.com/watch?v=UF8uR6Z6KLc"* →
+
+```
+Title: Steve Jobs' 2005 Stanford Commencement Address
+Duration: 15:04
+Source: youtube-captions
+Quota: 1/5 transcripts used on the anonymous plan
+
+[full transcript text…]
+```
+
+### `transcribe_audio`
+
+Transcribe a local audio file.
+
+| Argument | Type | Required | Notes |
+| --- | --- | --- | --- |
+| `filePath` | string | yes | Absolute path; mp3/wav/m4a/ogg/webm/mp4, max 25MB |
+| `language` | string | no | BCP-47 hint |
+| `cleanup` | boolean | no | AI polish |
+
+Example: *"Transcribe the voice memo at /Users/me/recordings/idea.m4a"*
+
+### `get_quota`
+
+No arguments. Returns the current quota snapshot for your IP: plan, used/limit, remaining, and reset time.
+
+## Quotas & anonymity
+
+- The server sends no credentials; tautau tracks anonymous usage by client IP.
+- Anonymous: 5 lifetime YouTube/URL transcripts + 5 lifetime audio dictations.
+- Free account: 5 URL transcripts/day + 15 min of audio per month — [sign up](https://tautau.xyz/login).
+- Paid plans raise the audio-minute pool — [pricing](https://tautau.xyz/pricing).
+- On HTTP 429 the tools return a readable message with used/limit/reset time and the relevant link. On 403 `sign_up_required` (anonymous audio-link jobs) they explain that a free account is needed.
+- Anonymous transcripts are never persisted server-side; nothing is saved to a history.
+
+## Development
+
+```bash
+cd mcp
+npm install
+npm run smoke   # boots the server over stdio, lists tools, calls get_quota (read-only)
+```
+
+From the repo root: `task mcp:smoke`.
+
+Plain ESM JavaScript, zero build step, one runtime dependency (`@modelcontextprotocol/sdk`). The smoke test never burns transcribe quota — only `get_quota` and tool-listing run.
+
+## Marketplace listings
+
+### Smithery
+
+1. `smithery.yaml` ships in this package (stdio, no required config).
+2. Push the repo, then at [smithery.ai](https://smithery.ai) choose **Publish server → GitHub**, point it at this repo and set the server root to `mcp/`.
+3. Smithery builds from `smithery.yaml`; the optional `tautauApiBase` config field maps to `TAUTAU_API_BASE`.
+4. Verify the deployment's tool list shows `transcribe_url`, `transcribe_audio`, `get_quota`, then publish.
+
+### Official MCP servers registry
+
+1. Fork [modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers).
+2. Add a row to the **Third-Party Servers** section of the README: `tautau` — YouTube, podcast, and local-audio transcription ([tautau.xyz](https://tautau.xyz)), linking `https://github.com/castlemilk/tautau/tree/main/mcp`.
+3. Keep the list alphabetized and match the existing row format (name, one-line description, link).
+4. Open the PR against `main`; CI checks formatting only.
+
+## License
+
+MIT

package/install.sh

@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+# tautau-mcp installer — configures MCP clients to use the tautau server.
+# Usage: curl -fsSL https://tautau.xyz/mcp/install.sh | bash
+#        ./install.sh --yes   # auto-accept every prompt
+set -euo pipefail
+
+YES=0
+for arg in "$@"; do
+  case "$arg" in
+    --yes|-y) YES=1 ;;
+    --help|-h) echo "Usage: install.sh [--yes]"; exit 0 ;;
+  esac
+done
+
+bold() { printf '\033[1m%s\033[0m\n' "$1"; }
+info() { printf '  %s\n' "$1"; }
+skip() { printf '  → skipped: %s\n' "$1"; }
+
+confirm() {
+  [ "$YES" = "1" ] && return 0
+  local reply
+  read -r -p "$1 [y/N] " reply </dev/tty || return 1
+  [[ "$reply" =~ ^[Yy]$ ]]
+}
+
+command -v node >/dev/null || { echo "node is required (>=18). Install Node.js first."; exit 1; }
+
+bold "tautau-mcp installer"
+info "The server itself runs via 'npx -y tautau-mcp' — nothing to install globally."
+info "This script wires it into the MCP clients it finds on this machine."
+echo
+
+# ── Claude Code ──────────────────────────────────────────────────────────────
+if command -v claude >/dev/null; then
+  bold "Claude Code detected"
+  info "Will run: claude mcp add tautau -- npx -y tautau-mcp"
+  if confirm "Configure Claude Code?"; then
+    if claude mcp add tautau -- npx -y tautau-mcp; then
+      info "Added 'tautau' to Claude Code MCP servers."
+    else
+      skip "claude mcp add failed (already registered? check 'claude mcp list')"
+    fi
+  else
+    skip "Claude Code"
+  fi
+  echo
+fi
+
+# ── Codex ────────────────────────────────────────────────────────────────────
+CODEX_DIR="$HOME/.codex"
+CODEX_CFG="$CODEX_DIR/config.toml"
+bold "Codex"
+info "Will append to $CODEX_CFG:"
+info '  [mcp_servers.tautau]'
+info '  command = "npx"'
+info '  args = ["-y", "tautau-mcp"]'
+if [ -f "$CODEX_CFG" ] && grep -q '^\[mcp_servers\.tautau\]' "$CODEX_CFG"; then
+  skip "a [mcp_servers.tautau] block already exists in $CODEX_CFG — leaving it untouched"
+elif confirm "Configure Codex?"; then
+  mkdir -p "$CODEX_DIR"
+  [ -f "$CODEX_CFG" ] && cp "$CODEX_CFG" "$CODEX_CFG.bak-$(date +%Y%m%d%H%M%S)"
+  {
+    echo ''
+    echo '[mcp_servers.tautau]'
+    echo 'command = "npx"'
+    echo 'args = ["-y", "tautau-mcp"]'
+  } >> "$CODEX_CFG"
+  info "Appended [mcp_servers.tautau] to $CODEX_CFG"
+else
+  skip "Codex"
+fi
+echo
+
+# ── Claude Desktop ───────────────────────────────────────────────────────────
+case "$(uname -s)" in
+  Darwin) CLAUDE_DESKTOP_CFG="$HOME/Library/Application Support/Claude/claude_desktop_config.json" ;;
+  Linux)  CLAUDE_DESKTOP_CFG="$HOME/.config/Claude/claude_desktop_config.json" ;;
+  *)      CLAUDE_DESKTOP_CFG="" ;;
+esac
+
+if [ -n "$CLAUDE_DESKTOP_CFG" ]; then
+  bold "Claude Desktop"
+  info "Will merge mcpServers.tautau into $CLAUDE_DESKTOP_CFG"
+  if confirm "Configure Claude Desktop?"; then
+    mkdir -p "$(dirname "$CLAUDE_DESKTOP_CFG")"
+    if [ -f "$CLAUDE_DESKTOP_CFG" ]; then
+      cp "$CLAUDE_DESKTOP_CFG" "$CLAUDE_DESKTOP_CFG.bak-$(date +%Y%m%d%H%M%S)"
+      info "Backed up existing config next to the original (*.bak-*)"
+    fi
+    result=$(node -e '
+      const fs = require("fs");
+      const p = process.argv[1];
+      let cfg = {};
+      try { cfg = JSON.parse(fs.readFileSync(p, "utf8")); } catch {}
+      cfg.mcpServers = cfg.mcpServers || {};
+      if (cfg.mcpServers.tautau) { console.log("EXISTS"); process.exit(0); }
+      cfg.mcpServers.tautau = { command: "npx", args: ["-y", "tautau-mcp"] };
+      fs.writeFileSync(p, JSON.stringify(cfg, null, 2) + "\n");
+      console.log("ADDED");
+    ' "$CLAUDE_DESKTOP_CFG")
+    if [ "$result" = "ADDED" ]; then
+      info "Added mcpServers.tautau to $CLAUDE_DESKTOP_CFG"
+      info "Restart Claude Desktop to pick it up."
+    else
+      skip "mcpServers.tautau already present in $CLAUDE_DESKTOP_CFG — leaving it untouched"
+    fi
+  else
+    skip "Claude Desktop"
+  fi
+  echo
+fi
+
+bold "Done."
+info "Verify any client with: npx -y tautau-mcp (Ctrl-C to stop; it speaks MCP on stdio)."
+info "Tools: transcribe_url, transcribe_audio, get_quota — anonymous quota is tracked per IP."

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "tautau-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for tautau — transcribe YouTube links, podcast/audio URLs, and local audio files to text from any MCP client",
+  "keywords": ["mcp", "model-context-protocol", "transcription", "speech-to-text", "youtube-transcript", "podcast-transcript", "tautau"],
+  "homepage": "https://tautau.xyz",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/castlemilk/tautau.git",
+    "directory": "mcp"
+  },
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "tautau-mcp": "./src/index.js"
+  },
+  "files": ["src", "install.sh", "smithery.yaml"],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.0"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "smoke": "node scripts/smoke.mjs"
+  }
+}

package/smithery.yaml

@@ -0,0 +1,19 @@
+# Smithery deployment config — https://smithery.ai
+# tautau-mcp is a stdio MCP server; it needs no build step and no secrets.
+startCommand:
+  type: stdio
+  configSchema:
+    type: object
+    properties:
+      tautauApiBase:
+        type: string
+        title: tautau API base URL
+        description: Override the tautau API endpoint (defaults to https://tautau.xyz). Only needed for self-hosted/dev deployments.
+    required: []
+  commandFunction: |-
+    (config) => ({
+      command: 'npx',
+      args: ['-y', 'tautau-mcp'],
+      env: config.tautauApiBase ? { TAUTAU_API_BASE: config.tautauApiBase } : {}
+    })
+  exampleConfig: {}

package/src/index.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+/**
+ * tautau-mcp — MCP stdio server exposing tautau's transcription API.
+ *
+ * Thin wrapper over https://tautau.xyz (override with TAUTAU_API_BASE):
+ *   POST /api/transcribe-url  {url, language?, cleanup?} → completed | pending+jobId
+ *   GET  /api/transcribe-url?id=<jobId>                  → poll a pending job
+ *   POST /api/transcribe      multipart: file, language, cleanup=true
+ *   GET  /api/user/status                                → quota snapshot
+ *
+ * No auth: usage is anonymous and IP-tracked by the tautau service
+ * (5 lifetime URL transcripts / 5 lifetime dictations). Quota walls
+ * come back as HTTP 429 with a {plan, used, limit, unit, resetsAt} body.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { readFile, stat } from 'node:fs/promises';
+import { basename, extname } from 'node:path';
+
+const API_BASE = (process.env.TAUTAU_API_BASE || 'https://tautau.xyz').replace(/\/+$/, '');
+const LOGIN_URL = `${API_BASE}/login`;
+const PRICING_URL = `${API_BASE}/pricing`;
+const MAX_AUDIO_BYTES = 25 * 1024 * 1024; // whisper-style upstream cap
+const POLL_INTERVAL_MS = 3_000;
+const POLL_CEILING_MS = 6 * 60_000; // long podcast jobs need minutes
+
+const MIME_BY_EXT = {
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.m4a': 'audio/mp4',
+  '.ogg': 'audio/ogg',
+  '.webm': 'audio/webm',
+  '.mp4': 'video/mp4',
+};
+
+const ok = (text) => ({ content: [{ type: 'text', text }] });
+const fail = (text) => ({ content: [{ type: 'text', text }], isError: true });
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function fmtDuration(seconds) {
+  if (typeof seconds !== 'number' || !Number.isFinite(seconds)) return null;
+  const m = Math.floor(seconds / 60);
+  const s = Math.round(seconds % 60);
+  return `${m}:${String(s).padStart(2, '0')}`;
+}
+
+function quotaLine(q) {
+  if (!q || typeof q !== 'object') return null;
+  const used = q.used ?? 0;
+  const limit = q.limit ?? 0;
+  const unit = q.unit || 'units';
+  const plan = q.plan || 'unknown';
+  const resets = q.resetsAt ? `, resets ${q.resetsAt}` : '';
+  return `Quota: ${used}/${limit} ${unit} used on the ${plan} plan${resets}`;
+}
+
+/** Some 429s carry the quota JSON as a stringified message (connect envelope). */
+function parseQuotaMessage(msg) {
+  if (typeof msg !== 'string') return null;
+  try {
+    const parsed = JSON.parse(msg);
+    return parsed && typeof parsed === 'object' && 'plan' in parsed ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Turn a non-2xx tautau API response into a readable tool error. */
+async function httpError(res) {
+  const body = await res.json().catch(() => ({}));
+  const quota = body.quota || parseQuotaMessage(body.message);
+  if (res.status === 429) {
+    const detail = quota ? quotaLine(quota) : null;
+    const plan = quota?.plan;
+    const cta =
+      plan === 'anonymous'
+        ? `Create a free account for a daily allowance: ${LOGIN_URL} — or see plans: ${PRICING_URL}`
+        : `Upgrade for more transcription time: ${PRICING_URL}`;
+    return fail(
+      [
+        'tautau quota exhausted.',
+        detail,
+        body.error,
+        cta,
+      ]
+        .filter(Boolean)
+        .join('\n')
+    );
+  }
+  if (res.status === 403 || body.signUpRequired) {
+    return fail(
+      [
+        body.error ||
+          'This transcription needs a free tautau account (anonymous audio-link jobs are not allowed).',
+        `Sign up free: ${LOGIN_URL}`,
+      ].join('\n')
+    );
+  }
+  return fail(body.error || body.message || `tautau API error (HTTP ${res.status})`);
+}
+
+async function postJson(path, payload) {
+  return fetch(`${API_BASE}${path}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(30_000),
+  });
+}
+
+function transcriptResult(data) {
+  const head = [];
+  if (data.title) head.push(`Title: ${data.title}`);
+  const dur = fmtDuration(data.durationSeconds);
+  if (dur) head.push(`Duration: ${dur}`);
+  if (data.source) head.push(`Source: ${data.source}`);
+  const quota = quotaLine(data.quota);
+  if (quota) head.push(quota);
+  const text = (data.text || '').trim();
+  return ok([head.join('\n'), text].filter(Boolean).join('\n\n'));
+}
+
+async function transcribeUrl({ url, language, cleanup }) {
+  const payload = { url };
+  if (language) payload.language = language;
+  if (typeof cleanup === 'boolean') payload.cleanup = cleanup;
+
+  let res;
+  try {
+    res = await postJson('/api/transcribe-url', payload);
+  } catch (err) {
+    return fail(`Could not reach ${API_BASE}: ${err.message}`);
+  }
+  if (!res.ok) return httpError(res);
+
+  let data = await res.json();
+  if (data.status === 'completed') return transcriptResult(data);
+
+  if (data.status !== 'pending' || !data.jobId) {
+    return fail(`Unexpected response from tautau: ${JSON.stringify(data).slice(0, 500)}`);
+  }
+
+  // Audio/podcast job: poll until completed/failed (3s cadence, 6 min ceiling)
+  const deadline = Date.now() + POLL_CEILING_MS;
+  while (Date.now() < deadline) {
+    await sleep(POLL_INTERVAL_MS);
+    let poll;
+    try {
+      poll = await fetch(`${API_BASE}/api/transcribe-url?id=${encodeURIComponent(data.jobId)}`, {
+        signal: AbortSignal.timeout(15_000),
+      });
+    } catch {
+      continue; // transient network blip — keep polling
+    }
+    if (!poll.ok) return httpError(poll);
+    data = await poll.json();
+    if (data.status === 'completed') return transcriptResult(data);
+    if (data.status === 'failed') {
+      return fail(`Transcription job failed: ${data.error || 'unknown error'}`);
+    }
+  }
+  return fail(
+    `Job ${data.jobId} is still pending after 6 minutes. Call transcribe_url again with the same URL to keep waiting on it.`
+  );
+}
+
+async function transcribeAudio({ filePath, language, cleanup }) {
+  const ext = extname(filePath).toLowerCase();
+  const mime = MIME_BY_EXT[ext];
+  if (!mime) {
+    return fail(
+      `Unsupported file type "${ext || '(none)'}". Supported: ${Object.keys(MIME_BY_EXT).join(', ')}`
+    );
+  }
+
+  let info;
+  try {
+    info = await stat(filePath);
+  } catch {
+    return fail(`File not found or unreadable: ${filePath}`);
+  }
+  if (!info.isFile()) return fail(`Not a file: ${filePath}`);
+  if (info.size > MAX_AUDIO_BYTES) {
+    return fail(
+      `File is ${(info.size / 1024 / 1024).toFixed(1)}MB — over the 25MB limit. Trim or compress it, or host it and use transcribe_url instead.`
+    );
+  }
+
+  const buffer = await readFile(filePath);
+  const form = new FormData();
+  form.append('file', new Blob([buffer], { type: mime }), basename(filePath));
+  if (language) form.append('language', language);
+  if (typeof cleanup === 'boolean') form.append('cleanup', String(cleanup));
+
+  let res;
+  try {
+    res = await fetch(`${API_BASE}/api/transcribe`, {
+      method: 'POST',
+      body: form,
+      signal: AbortSignal.timeout(120_000), // audio uploads + STT can take a while
+    });
+  } catch (err) {
+    return fail(`Could not reach ${API_BASE}: ${err.message}`);
+  }
+  if (!res.ok) return httpError(res);
+
+  const data = await res.json();
+  const text = (data.text || '').trim();
+  if (!text) return fail('tautau returned an empty transcript for this audio.');
+  const head = [];
+  const quota = quotaLine(data.quota);
+  if (quota) head.push(quota);
+  return ok([head.join('\n'), text].filter(Boolean).join('\n\n'));
+}
+
+async function getQuota() {
+  let res;
+  try {
+    res = await fetch(`${API_BASE}/api/user/status`, { signal: AbortSignal.timeout(15_000) });
+  } catch (err) {
+    return fail(`Could not reach ${API_BASE}: ${err.message}`);
+  }
+  if (!res.ok) return httpError(res);
+  const s = await res.json().catch(() => ({}));
+  const lines = [
+    `tautau quota snapshot (${API_BASE})`,
+    `Plan: ${s.plan ?? 'unknown'}${s.subscriptionStatus ? ` (subscription: ${s.subscriptionStatus})` : ''}`,
+  ];
+  if (typeof s.used === 'number' || typeof s.limit === 'number') {
+    const remaining =
+      typeof s.remaining === 'number'
+        ? s.remaining
+        : Math.max(0, (s.limit ?? 0) - (s.used ?? 0));
+    lines.push(
+      `Dictations: ${s.used ?? 0}/${s.limit ?? 0} ${s.unit || 'dictations'} used (${remaining} remaining)`
+    );
+  }
+  lines.push(`Resets: ${s.resetsAt || 'never (lifetime allowance for anonymous use)'}`);
+  if (s.plan === 'anonymous') {
+    lines.push(`Free account (daily allowance): ${LOGIN_URL} · Paid plans: ${PRICING_URL}`);
+  }
+  return ok(lines.join('\n'));
+}
+
+const TOOLS = [
+  {
+    name: 'transcribe_url',
+    description:
+      'Transcribe a YouTube video, podcast episode, or direct audio URL to text via tautau. ' +
+      'YouTube links resolve from captions (fast); podcast/audio links run server-side speech-to-text and may take minutes. ' +
+      'Anonymous use is quota-limited per IP.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'Full https:// URL of a YouTube video, podcast episode, or audio file' },
+        language: { type: 'string', description: 'Optional BCP-47 language hint, e.g. "en", "es"' },
+        cleanup: {
+          type: 'boolean',
+          description: 'Optional: run AI cleanup (punctuation, filler removal) on the transcript',
+        },
+      },
+      required: ['url'],
+    },
+  },
+  {
+    name: 'transcribe_audio',
+    description:
+      'Transcribe a local audio file (mp3/wav/m4a/ogg/webm/mp4, up to 25MB) to text via tautau. ' +
+      'Anonymous use is quota-limited per IP.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        filePath: { type: 'string', description: 'Absolute path to a local audio file' },
+        language: { type: 'string', description: 'Optional BCP-47 language hint, e.g. "en", "es"' },
+        cleanup: {
+          type: 'boolean',
+          description: 'Optional: run AI cleanup (punctuation, filler removal) on the transcript',
+        },
+      },
+      required: ['filePath'],
+    },
+  },
+  {
+    name: 'get_quota',
+    description: 'Check the current tautau transcription quota (anonymous usage is tracked per IP).',
+    inputSchema: { type: 'object', properties: {} },
+  },
+];
+
+const server = new Server(
+  { name: 'tautau-mcp', version: '0.1.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: args = {} } = req.params;
+  try {
+    switch (name) {
+      case 'transcribe_url':
+        if (!args.url || typeof args.url !== 'string') return fail('Missing required argument: url');
+        return await transcribeUrl(args);
+      case 'transcribe_audio':
+        if (!args.filePath || typeof args.filePath !== 'string')
+          return fail('Missing required argument: filePath');
+        return await transcribeAudio(args);
+      case 'get_quota':
+        return await getQuota();
+      default:
+        return fail(`Unknown tool: ${name}`);
+    }
+  } catch (err) {
+    return fail(`tautau-mcp error: ${err.message}`);
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(`tautau-mcp running (API base: ${API_BASE})`);