altalandi-mcp 0.1.1 → 0.3.0

package/README.md

@@ -1,77 +1,71 @@
-# altalandi-mcp
-
-An [MCP](https://modelcontextprotocol.io) server that exposes
-[Altalandi](https://altalandi.is) — native-Icelandic refinement with a
-meaning-preservation check — as a tool any MCP client (Claude Code, etc.) can
-call. stdio transport.
-
-## Use it in Claude Code
-
-Mint a key at <https://altalandi.is/portal>, store it in your password manager,
-then load it without putting the plaintext in shell history:
-
-```bash
-read -rsp "Altalandi API key: " ALTALANDI_API_KEY; echo
-export ALTALANDI_API_KEY
-```
-
-PowerShell 7: `$env:ALTALANDI_API_KEY = Read-Host "Altalandi API key" -MaskInput`.
-
-Launch Claude Code from that shell, then add this secret-free MCP config
-(`.mcp.json` in the project, or your Claude Code config). The server inherits
-the variable from its parent process:
-
-```json
-{
-  "mcpServers": {
-    "altalandi": {
-      "command": "npx",
-      "args": ["-y", "altalandi-mcp"]
-    }
-  }
-}
-```
-
-For CI, services, or GUI-launched clients, inject the variable with the host's
-secret manager. Never commit the plaintext key in MCP JSON. Then ask Claude to
-use the **`refine_icelandic`** tool.
-
-## The tool
-
-`refine_icelandic({ text, domain?, register?, sourceLang? })` → the native
-Icelandic text, a 0–100 nativeness score, an explicit meaning verdict, and every
-warning returned by the API.
-
-- `domain`: `general` \| `marketing` \| `data-analysis` \| `childrens-fiction`
-- `register`: `formal` \| `neutral` \| `warm`
-- `sourceLang`: `auto` \| `en` \| `is`
-
-**Meaning guarantee:** on Icelandic input where the rewrite can't be verified to
-preserve meaning, the tool returns the **original unchanged** and flags it —
-never a silent change.
-
-Only **meaning preserved** is a verified result. **MEANING UNVERIFIED** means the
-check did not run or could not complete; review that output before use. API
-warnings are included under a clear `Warnings:` section in the tool's text result.
-
-## Config
-
-| env | default | purpose |
-|-----|---------|---------|
-| `ALTALANDI_API_KEY` | — | your key (Bearer). Mint at https://altalandi.is/portal |
-| `ALTALANDI_BASE_URL` | `https://altalandi.is/api` | API base (override for self-hosting) |
-
-Each API request has a fixed 300-second deadline, including response-body
-download, so a stalled provider cannot leave the MCP tool hanging forever.
-
-## Run standalone
-
-```bash
-npx -y altalandi-mcp     # inherits ALTALANDI_API_KEY; speaks MCP over stdio
-```
-
-MIT licensed. Requires Node ≥ 18. Portal keys share a daily account-level
-billable-word budget; operator-issued keys remain per-key. Text and glossary
-fields count; each
-whitespace-delimited token is at least one unit, and an unbroken token uses one
-unit per 20 characters, rounded up.
+# altalandi-mcp
+
+An [MCP](https://modelcontextprotocol.io) server that exposes
+[Altalandi](https://altalandi.is), native-Icelandic refinement with a
+meaning-preservation check, as a tool any MCP client can call. stdio transport.
+
+## Set up (Claude Code or Codex)
+
+Connect this computer once. This opens altalandi.is, you approve, and the key
+is stored locally. You never copy it:
+
+```bash
+npx altalandi login
+```
+
+Then add the server. No key goes into any config file; the server reads the
+one `altalandi login` stored:
+
+```bash
+claude mcp add altalandi -s user -- npx -y altalandi-mcp   # Claude Code
+codex mcp add altalandi -- npx -y altalandi-mcp            # Codex
+```
+
+Ask for Icelandic and mention Altalandi, e.g. *"Write this in proper Icelandic
+with Altalandi."* The agent calls the **`refine_icelandic`** tool.
+
+### Without `altalandi login` (CI, services, other clients)
+
+Set `ALTALANDI_API_KEY` in the server's environment, from your host's secret
+manager. It takes precedence over a stored login. Mint a key at
+<https://altalandi.is/portal>. Never commit a plaintext key in MCP JSON.
+
+```json
+{ "mcpServers": { "altalandi": { "command": "npx", "args": ["-y", "altalandi-mcp"] } } }
+```
+
+## The tool
+
+`refine_icelandic({ text, domain?, register?, sourceLang? })` returns the native
+Icelandic text, a 0–100 nativeness score, an explicit meaning verdict, and every
+warning returned by the API.
+
+- `domain`: `general` \| `marketing` \| `data-analysis` \| `childrens-fiction`
+- `register`: `formal` \| `neutral` \| `warm`
+- `sourceLang`: `auto` \| `en` \| `is`
+
+**Meaning guarantee:** on Icelandic input where the rewrite can't be verified to
+preserve meaning, the tool returns the **original unchanged** and flags it,
+never a silent change.
+
+Only **meaning preserved** is a verified result. **MEANING UNVERIFIED** means the
+check did not run or could not complete; review that output before use. API
+warnings are included under a clear `Warnings:` section in the tool's result.
+
+## Config
+
+| env | default | purpose |
+|-----|---------|---------|
+| `ALTALANDI_API_KEY` | (the key from `altalandi login`) | your key (Bearer) |
+| `ALTALANDI_CONFIG_DIR` | `%APPDATA%\altalandi` / `~/.config/altalandi` | where `altalandi login` stored it |
+| `ALTALANDI_BASE_URL` | `https://altalandi.is/api` | API base (override for self-hosting) |
+
+Each API request has a fixed 300-second deadline, including the response body,
+so a stalled provider cannot leave the tool hanging.
+
+## Cost
+
+Calls are paid from the account's prepaid credit in krónur (a new account
+starts with trial credit). See <https://altalandi.is/verd>.
+
+MIT licensed. Requires Node ≥ 18.

package/format-response.mjs

@@ -1,23 +1,55 @@
-export function formatRefineResponse(data) {
-  const quality = data?.quality || {};
-  const lines = [
-    String(data?.output ?? ""),
-    "",
-    `— nativeness ${quality.nativenessScore ?? "n/a"}/100`,
-  ];
-
-  if (data?.meaningPreserved === true) {
-    lines.push("— meaning preserved");
-  } else if (data?.meaningPreserved === false) {
-    lines.push("— ⚠ MEANING DRIFT — original returned unchanged");
-  } else {
-    lines.push("— ⚠ MEANING UNVERIFIED — check did not run or could not complete; review before use");
-  }
-
-  const warnings = Array.isArray(data?.warnings) ? data.warnings : [];
-  if (warnings.length) {
-    lines.push("", "Warnings:", ...warnings.map((warning) => `- ${String(warning)}`));
-  }
-
-  return lines.join("\n");
-}
+/**
+ * What actually happened to the caller's text. `meaningPreserved` alone cannot
+ * say: when the candidate veto refuses a broken rewrite, the meaning check has
+ * already passed, so `meaningPreserved` is still true while the ORIGINAL comes
+ * back. An agent reading "meaning preserved" would then report a rewrite that
+ * never shipped.
+ *
+ *   rewritten   the output is a verified rewrite
+ *   refused     a rewrite was produced and rejected; the original is returned
+ *   unchanged   the text needed no rewrite
+ *   unverified  meaning could not be established; do not present as verified
+ *
+ * Responses from older API versions have no `rewriteAttempted` or
+ * `rejectionReason`; they fall through to the meaningPreserved verdict, exactly
+ * as before.
+ */
+export function outcomeOf(data) {
+  if (data?.rejectionReason) return "refused";
+  if (data?.meaningPreserved === false) return "refused";
+  if (data?.rewriteAttempted === false) return "unchanged";
+  if (data?.meaningPreserved !== true) return "unverified";
+  return "rewritten";
+}
+
+export function formatRefineResponse(data) {
+  const quality = data?.quality || {};
+  const outcome = outcomeOf(data);
+  const lines = [
+    String(data?.output ?? ""),
+    "",
+    `— nativeness ${quality.nativenessScore ?? "n/a"}/100`,
+  ];
+
+  if (outcome === "refused") {
+    if (data?.meaningPreserved === false) {
+      lines.push("— ⚠ MEANING DRIFT — original returned unchanged");
+    } else {
+      lines.push("— ⚠ REWRITE REFUSED — the original is returned unchanged");
+    }
+    if (data?.rejectionReason) lines.push(`— reason: ${String(data.rejectionReason)}`);
+  } else if (outcome === "unchanged") {
+    lines.push("— no rewrite needed — the text is returned as it was");
+  } else if (outcome === "unverified") {
+    lines.push("— ⚠ MEANING UNVERIFIED — check did not run or could not complete; review before use");
+  } else {
+    lines.push("— meaning preserved");
+  }
+
+  const warnings = Array.isArray(data?.warnings) ? data.warnings : [];
+  if (warnings.length) {
+    lines.push("", "Warnings:", ...warnings.map((warning) => `- ${String(warning)}`));
+  }
+
+  return lines.join("\n");
+}

package/key.mjs

@@ -0,0 +1,30 @@
+// Where the MCP server finds its API key, in order:
+//   1. ALTALANDI_API_KEY (or ALTALANDI_KEY) in its environment;
+//   2. the key `npx altalandi login` stored on this computer.
+// The second makes the MCP server plug-and-play: after one login, adding it
+// to Claude Code or Codex needs no secret in any config file. The location
+// matches the CLI's (tools/cli/auth.mjs); ALTALANDI_CONFIG_DIR overrides it.
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+export function configDir({ env = process.env, home = homedir(), platform = process.platform } = {}) {
+  if (env.ALTALANDI_CONFIG_DIR) return env.ALTALANDI_CONFIG_DIR;
+  if (platform === "win32") return path.join(env.APPDATA || path.join(home, "AppData", "Roaming"), "altalandi");
+  return path.join(env.XDG_CONFIG_HOME || path.join(home, ".config"), "altalandi");
+}
+
+/** { key, source } where source is "env", "login" or "none". Never throws. */
+export function resolveKey(opts = {}) {
+  const env = opts.env ?? process.env;
+  const fromEnv = env.ALTALANDI_API_KEY || env.ALTALANDI_KEY;
+  if (fromEnv) return { key: fromEnv, source: "env" };
+  try {
+    const data = JSON.parse(readFileSync(path.join(configDir({ ...opts, env }), "credentials.json"), "utf8"));
+    if (data && typeof data.apiKey === "string" && data.apiKey) return { key: data.apiKey, source: "login" };
+  } catch {
+    /* no stored login */
+  }
+  return { key: "", source: "none" };
+}

package/package.json

@@ -1,48 +1,51 @@
-{
-  "name": "altalandi-mcp",
-  "version": "0.1.1",
-  "description": "MCP server exposing Altalandi (native-Icelandic refinement) as a tool for Claude Code and any MCP client.",
-  "type": "module",
-  "bin": {
-    "altalandi-mcp": "server.mjs"
-  },
-  "files": [
-    "server.mjs",
-    "api-client.mjs",
-    "format-response.mjs",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "test": "node --test test/*.test.mjs"
-  },
-  "keywords": [
-    "icelandic",
-    "íslenska",
-    "mcp",
-    "model-context-protocol",
-    "claude",
-    "claude-code",
-    "altalandi",
-    "nlp",
-    "translation",
-    "agent"
-  ],
-  "homepage": "https://altalandi.is",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/pbidhjorvar/ritvit.git",
-    "directory": "tools/mcp"
-  },
-  "bugs": {
-    "url": "https://github.com/pbidhjorvar/ritvit/issues"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "zod": "^3.23.8"
-  },
-  "license": "MIT"
-}
+{
+  "name": "altalandi-mcp",
+  "version": "0.3.0",
+  "description": "MCP server exposing Altalandi (native-Icelandic refinement) as a tool for Claude Code and any MCP client.",
+  "type": "module",
+  "bin": {
+    "altalandi-mcp": "server.mjs"
+  },
+  "files": [
+    "server.mjs",
+    "key.mjs",
+    "api-client.mjs",
+    "format-response.mjs",
+    "report.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "keywords": [
+    "icelandic",
+    "íslenska",
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "claude-code",
+    "codex",
+    "altalandi",
+    "nlp",
+    "translation",
+    "agent"
+  ],
+  "homepage": "https://altalandi.is",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pbidhjorvar/ritvit.git",
+    "directory": "tools/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/pbidhjorvar/ritvit/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8"
+  },
+  "license": "MIT"
+}

package/report.mjs

@@ -0,0 +1,114 @@
+// Before/after for people: a terminal view and an optional Markdown report.
+//
+// The website shows each change inline; in a terminal or an editor the
+// before/after got lost. This module renders it the same way everywhere:
+//   beforeAfterText()  plain (or coloured) block for a terminal or a tool result
+//   reportMarkdown()   the report file: input, output, every change with its
+//                      reason, and the verdict
+//   writeReport()      writes it to ./altalandi-reports/ (or ALTALANDI_REPORT_DIR)
+//
+// Reports are opt-in (--report, or ALTALANDI_REPORT=1): they contain the text.
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+const VERDICT = {
+  rewritten: "Endurskrifað og merking staðfest",
+  refused: "Endurskrift hafnað: upprunalega textanum skilað óbreyttum",
+  unchanged: "Engin breyting þurfti",
+  unverified: "Merking ekki staðfest: farðu yfir áður en þú notar textann",
+};
+
+export function outcomeOf(data) {
+  if (data?.rejectionReason) return "refused";
+  if (data?.meaningPreserved === false) return "refused";
+  if (data?.rewriteAttempted === false) return "unchanged";
+  if (data?.meaningPreserved !== true) return "unverified";
+  return "rewritten";
+}
+
+export function reportEnabled(flag) {
+  if (flag !== undefined && flag !== null) return Boolean(flag);
+  return ["1", "true", "yes"].includes(String(process.env.ALTALANDI_REPORT || "").toLowerCase());
+}
+
+const paint = (on) => ({
+  red: (s) => (on ? `\x1b[31m${s}\x1b[0m` : s),
+  green: (s) => (on ? `\x1b[32m${s}\x1b[0m` : s),
+  dim: (s) => (on ? `\x1b[2m${s}\x1b[0m` : s),
+  bold: (s) => (on ? `\x1b[1m${s}\x1b[0m` : s),
+});
+
+/** A before/after block with the list of changes. `color` adds ANSI colours. */
+export function beforeAfterText(input, data, { color = false } = {}) {
+  const c = paint(color);
+  const diffs = Array.isArray(data?.diffs) ? data.diffs : [];
+  const rule = (label) => c.dim(`── ${label} ${"─".repeat(Math.max(4, 40 - label.length))}`);
+  const lines = [
+    rule("Fyrir"), String(input ?? ""), "",
+    rule("Eftir"), String(data?.output ?? ""), "",
+    rule(`Breytingar (${diffs.length})`),
+  ];
+  if (!diffs.length) lines.push(c.dim("Engar breytingar."));
+  diffs.forEach((d, i) => {
+    lines.push(`${i + 1}. ${c.red("− " + String(d.before ?? "").trim())}`);
+    lines.push(`   ${c.green("+ " + String(d.after ?? "").trim())}`);
+    if (d.reason) lines.push(`   ${c.dim("↳ " + String(d.reason))}`);
+  });
+  const q = data?.quality || {};
+  lines.push("", c.bold(VERDICT[outcomeOf(data)]) + (q.nativenessScore != null ? c.dim(` · innfæddni ${q.nativenessScore}/100`) : ""));
+  return lines.join("\n");
+}
+
+const fence = (s) => {
+  const text = String(s ?? "");
+  const ticks = text.includes("```") ? "````" : "```";
+  return `${ticks}text\n${text}\n${ticks}`;
+};
+const cell = (s) => String(s ?? "").replace(/\|/g, "\\|").replace(/\r?\n/g, " ").trim();
+
+export function reportMarkdown(input, data, options = {}) {
+  const q = data?.quality || {};
+  const diffs = Array.isArray(data?.diffs) ? data.diffs : [];
+  const warnings = Array.isArray(data?.warnings) ? data.warnings : [];
+  const tier = data?.billedTier || data?.tier || {};
+  const when = new Date().toISOString().replace("T", " ").slice(0, 19);
+  const out = [
+    `# Altalandi: ${data?.id || "yfirlestur"}`,
+    "",
+    `| | |`, `|---|---|`,
+    `| Tími | ${when} UTC |`,
+    `| Niðurstaða | ${VERDICT[outcomeOf(data)]} |`,
+    `| Frummál | ${data?.sourceLang || "?"} |`,
+    `| Tegund texta | ${options.domain || "general"} |`,
+    `| Málsnið | ${options.register || "neutral"} |`,
+    `| Innfæddni | ${q.nativenessScore ?? "n/a"}/100 |`,
+    `| Ritill | ${tier.writer || "standard"} / ${tier.scoring || "?"} |`,
+    `| Auðkenni | ${data?.id || "?"} |`,
+    "",
+    "## Fyrir", "", fence(input), "",
+    "## Eftir", "", fence(data?.output), "",
+    `## Breytingar (${diffs.length})`, "",
+  ];
+  if (diffs.length) {
+    out.push("| # | Fyrir | Eftir | Ástæða | Lag |", "|---|---|---|---|---|");
+    diffs.forEach((d, i) => out.push(`| ${i + 1} | ${cell(d.before)} | ${cell(d.after)} | ${cell(d.reason)} | ${cell(d.layer)} |`));
+  } else {
+    out.push("Engar breytingar.");
+  }
+  if (data?.rejectionReason) out.push("", "## Af hverju var endurskriftinni hafnað", "", cell(data.rejectionReason));
+  if (warnings.length) out.push("", "## Viðvaranir", "", ...warnings.map((w) => `- ${cell(w)}`));
+  if (data?.meaningNotes) out.push("", "## Athugun á merkingu", "", cell(data.meaningNotes));
+  return out.join("\n") + "\n";
+}
+
+/** Write the report; returns its path. */
+export async function writeReport(input, data, options = {}, dir) {
+  const base = resolve(dir || process.env.ALTALANDI_REPORT_DIR || join(process.cwd(), "altalandi-reports"));
+  await mkdir(base, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
+  const id = String(data?.id || "yfirlestur").replace(/[^A-Za-z0-9_-]/g, "");
+  const path = join(base, `altalandi-${stamp}-${id}.md`);
+  await writeFile(path, reportMarkdown(input, data, options), "utf8");
+  return path;
+}

package/server.mjs

@@ -1,63 +1,75 @@
-#!/usr/bin/env node
-// Altalandi MCP server — exposes native-Icelandic refinement as a tool that
-// Claude Code (and any MCP client) can call. stdio transport.
-//
-// Load ALTALANDI_API_KEY through the parent environment or a secret manager,
-// then run: npx -y altalandi-mcp
-//
-// Claude Code config (.mcp.json or your Claude Code config) — no plaintext
-// secret required; the child process inherits ALTALANDI_API_KEY:
-//   { "mcpServers": { "altalandi": {
-//       "command": "npx",
-//       "args": ["-y", "altalandi-mcp"] } } }
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { requestRefine } from "./api-client.mjs";
-import { formatRefineResponse } from "./format-response.mjs";
-
-const BASE = (process.env.ALTALANDI_BASE_URL || "https://altalandi.is/api").replace(/\/$/, "");
-const KEY = process.env.ALTALANDI_API_KEY || process.env.ALTALANDI_KEY;
-
-const server = new McpServer({ name: "altalandi", version: "0.1.1" });
-
-server.tool(
-  "refine_icelandic",
-  "Rewrite English or stiff/AI-translated Icelandic into native-sounding Icelandic, with a meaning-preservation check. Use whenever you need Icelandic that must read like a native wrote it (marketing copy, UI strings, prose). Returns the refined text, a 0-100 nativeness score, an explicit meaning verdict, and every API warning. Only 'meaning preserved' is verified; 'MEANING UNVERIFIED' requires review. On drift it returns the original unchanged.",
-  {
-    text: z.string().describe("Text to refine (English or Icelandic)."),
-    domain: z.enum(["general", "marketing", "data-analysis", "childrens-fiction"]).optional()
-      .describe("Tunes register/idiom. Default general."),
-    register: z.enum(["formal", "neutral", "warm"]).optional().describe("Tone. Default neutral."),
-    sourceLang: z.enum(["auto", "en", "is"]).optional()
-      .describe("Source-language hint. Default auto."),
-  },
-  async ({ text, domain, register, sourceLang }) => {
-    if (!KEY) {
-      return { content: [{ type: "text", text: "ALTALANDI_API_KEY is not set for the MCP server." }], isError: true };
-    }
-    try {
-      const { response, data } = await requestRefine(BASE, KEY, {
-        text,
-        domain,
-        register,
-        sourceLang,
-      });
-      if (!response.ok) {
-        return { content: [{ type: "text", text: `Altalandi error ${response.status}: ${data.detail || response.statusText}` }], isError: true };
-      }
-      return {
-        content: [{ type: "text", text: formatRefineResponse(data) }],
-        // MCP callers should not treat an original-on-drift or unverified
-        // response as a successfully refined artifact. The full result remains
-        // visible so an agent can explain/review it instead of losing context.
-        isError: data.meaningPreserved !== true,
-      };
-    } catch (e) {
-      return { content: [{ type: "text", text: `Request failed: ${e.message}` }], isError: true };
-    }
-  },
-);
-
-await server.connect(new StdioServerTransport());
+#!/usr/bin/env node
+// Altalandi MCP server — exposes native-Icelandic refinement as a tool that
+// Claude Code (and any MCP client) can call. stdio transport.
+//
+// The key comes from ALTALANDI_API_KEY or, failing that, from the login that
+// `npx altalandi login` stored on this computer, so no config file ever holds
+// a secret:
+//   claude mcp add altalandi -s user -- npx -y altalandi-mcp
+//   codex mcp add altalandi -- npx -y altalandi-mcp
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { requestRefine } from "./api-client.mjs";
+import { formatRefineResponse, outcomeOf } from "./format-response.mjs";
+import { resolveKey } from "./key.mjs";
+import { beforeAfterText, reportEnabled, writeReport } from "./report.mjs";
+
+const BASE = (process.env.ALTALANDI_BASE_URL || "https://altalandi.is/api").replace(/\/$/, "");
+const server = new McpServer({ name: "altalandi", version: "0.3.0" });
+
+server.tool(
+  "refine_icelandic",
+  "Rewrite English or stiff/AI-translated Icelandic into native-sounding Icelandic, with a meaning-preservation check. Use whenever you need Icelandic that must read like a native wrote it (marketing copy, UI strings, prose). Returns the refined text, a 0-100 nativeness score, an explicit meaning verdict, and every API warning. Only 'meaning preserved' is verified; 'MEANING UNVERIFIED' requires review. On drift it returns the original unchanged. After every call, show the user the before/after block from the result (Fyrir / Eftir) and the numbered list of changes with their reasons, then mention the report path if one was written. Never replace the user's text silently.",
+  {
+    text: z.string().describe("Text to refine (English or Icelandic)."),
+    domain: z.enum(["general", "marketing", "data-analysis", "childrens-fiction"]).optional()
+      .describe("Tunes register/idiom. Default general."),
+    register: z.enum(["formal", "neutral", "warm"]).optional().describe("Tone. Default neutral."),
+    sourceLang: z.enum(["auto", "en", "is"]).optional()
+      .describe("Source-language hint. Default auto."),
+    report: z.boolean().optional()
+      .describe("Also write a Markdown report (input, output, every change with its reason, verdict) to ./altalandi-reports/. Default: on when ALTALANDI_REPORT=1."),
+  },
+  async ({ text, domain, register, sourceLang, report }) => {
+    // Resolved per call, so a login made after the server started is picked up.
+    const { key: KEY } = resolveKey();
+    if (!KEY) {
+      return { content: [{ type: "text", text:
+        "No Altalandi key found. Run `npx altalandi login` once on this computer, or set ALTALANDI_API_KEY." }],
+        isError: true };
+    }
+    try {
+      const { response, data } = await requestRefine(BASE, KEY, {
+        text,
+        domain,
+        register,
+        sourceLang,
+      });
+      if (!response.ok) {
+        return { content: [{ type: "text", text: `Altalandi error ${response.status}: ${data.detail || response.statusText}` }], isError: true };
+      }
+      let reportLine = "";
+      if (reportEnabled(report)) {
+        try {
+          reportLine = `\n\nReport: ${await writeReport(text, data, { domain, register })}`;
+        } catch (e) {
+          reportLine = `\n\nReport could not be written: ${e.message}`;
+        }
+      }
+      return {
+        content: [{ type: "text", text: `${formatRefineResponse(data)}\n\n${beforeAfterText(text, data)}${reportLine}` }],
+        // MCP callers should not treat a refused rewrite (drift, a lost
+        // invariant, or a candidate veto) or an unverified response as a
+        // successfully refined artifact. "No rewrite needed" is a success. The
+        // full result remains visible so an agent can explain it.
+        isError: ["refused", "unverified"].includes(outcomeOf(data)),
+      };
+    } catch (e) {
+      return { content: [{ type: "text", text: `Request failed: ${e.message}` }], isError: true };
+    }
+  },
+);
+
+await server.connect(new StdioServerTransport());