mcp-marmiton 0.1.0

package/dist/index.js

@@ -0,0 +1,1334 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/version.ts
+var PKG_VERSION = "0.1.0";
+var REPO_URL = "https://github.com/smeet666/mcp-marmiton";
+
+// src/config.ts
+var DEFAULT_USER_AGENT = `mcp-marmiton v${PKG_VERSION} (${REPO_URL})`;
+var DEFAULTS = {
+  minIntervalMs: 1e3,
+  timeoutMs: 15e3,
+  maxRetries: 3,
+  cacheTtlMs: 15 * 60 * 1e3,
+  cacheMaxEntries: 200,
+  logLevel: "error"
+};
+var MIN_ALLOWED_INTERVAL_MS = 500;
+var LOG_LEVELS = ["silent", "error", "info", "debug"];
+function readNumber(name, env, range) {
+  const raw = env[name];
+  if (raw === void 0 || raw.trim() === "") return range.fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    warn(`${name}="${raw}" is not a number, using ${range.fallback}`);
+    return range.fallback;
+  }
+  const rounded = Math.round(parsed);
+  if (rounded < range.min || rounded > range.max) {
+    warn(
+      `${name}=${raw} is outside the accepted range ${range.min}-${range.max} and was ignored; using ${range.fallback}`
+    );
+    return range.fallback;
+  }
+  return rounded;
+}
+function warn(message) {
+  process.stderr.write(`[mcp-marmiton] ${message}
+`);
+}
+function readInterval(env) {
+  const raw = env.MARMITON_MIN_INTERVAL_MS;
+  if (raw === void 0 || raw.trim() === "") return DEFAULTS.minIntervalMs;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    warn(`MARMITON_MIN_INTERVAL_MS="${raw}" is not a number, using ${DEFAULTS.minIntervalMs}ms`);
+    return DEFAULTS.minIntervalMs;
+  }
+  const rounded = Math.round(parsed);
+  if (rounded < MIN_ALLOWED_INTERVAL_MS) {
+    warn(
+      `MARMITON_MIN_INTERVAL_MS=${raw} is below the ${MIN_ALLOWED_INTERVAL_MS}ms floor and was ignored; using ${DEFAULTS.minIntervalMs}ms. Marmiton serves these pages for readers, so this client paces itself.`
+    );
+    return DEFAULTS.minIntervalMs;
+  }
+  return Math.min(6e4, rounded);
+}
+function loadConfig(env = process.env) {
+  const rawUserAgent = env.MARMITON_USER_AGENT?.trim();
+  const rawLogLevel = env.MARMITON_LOG_LEVEL?.trim().toLowerCase();
+  let logLevel = DEFAULTS.logLevel;
+  if (rawLogLevel) {
+    if (LOG_LEVELS.includes(rawLogLevel)) {
+      logLevel = rawLogLevel;
+    } else {
+      warn(`MARMITON_LOG_LEVEL="${rawLogLevel}" is unknown, using "${DEFAULTS.logLevel}"`);
+    }
+  }
+  return {
+    userAgent: rawUserAgent || DEFAULT_USER_AGENT,
+    minIntervalMs: readInterval(env),
+    timeoutMs: readNumber("MARMITON_TIMEOUT_MS", env, {
+      min: 1e3,
+      max: 12e4,
+      fallback: DEFAULTS.timeoutMs
+    }),
+    maxRetries: readNumber("MARMITON_MAX_RETRIES", env, {
+      min: 0,
+      max: 10,
+      fallback: DEFAULTS.maxRetries
+    }),
+    cacheTtlMs: readNumber("MARMITON_CACHE_TTL_MS", env, {
+      min: 0,
+      max: 24 * 60 * 60 * 1e3,
+      fallback: DEFAULTS.cacheTtlMs
+    }),
+    cacheMaxEntries: readNumber("MARMITON_CACHE_MAX_ENTRIES", env, {
+      min: 0,
+      max: 1e4,
+      fallback: DEFAULTS.cacheMaxEntries
+    }),
+    logLevel
+  };
+}
+var LEVEL_RANK = { silent: 0, error: 1, info: 2, debug: 3 };
+function createLogger(level) {
+  const emit = (at, message) => {
+    if (LEVEL_RANK[level] >= LEVEL_RANK[at]) {
+      process.stderr.write(`[mcp-marmiton] ${message}
+`);
+    }
+  };
+  return {
+    error: (message) => emit("error", message),
+    info: (message) => emit("info", message),
+    debug: (message) => emit("debug", message)
+  };
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/marmiton/cache.ts
+var TtlLruCache = class {
+  constructor(maxEntries, ttlMs) {
+    this.maxEntries = maxEntries;
+    this.ttlMs = ttlMs;
+  }
+  maxEntries;
+  ttlMs;
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (Date.now() >= entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    this.store.delete(key);
+    this.store.set(key, entry);
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.maxEntries <= 0 || this.ttlMs <= 0) return;
+    this.store.delete(key);
+    this.store.set(key, { value, expiresAt: Date.now() + this.ttlMs });
+    while (this.store.size > this.maxEntries) {
+      const oldest = this.store.keys().next();
+      if (oldest.done) break;
+      this.store.delete(oldest.value);
+    }
+  }
+  get size() {
+    return this.store.size;
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/errors.ts
+var MarmitonError = class extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "MarmitonError";
+  }
+  code;
+  details;
+};
+var ISSUES_URL = "https://github.com/smeet666/mcp-marmiton/issues";
+function notFound(url, what) {
+  return new MarmitonError("not_found", `Marmiton has no recipe at ${what}.`, {
+    url,
+    status: 404,
+    hint: "Use search_recipes to find a recipe and its id, then call this tool with that id."
+  });
+}
+function invalidInput(message, hint) {
+  return new MarmitonError("invalid_input", message, hint ? { hint } : {});
+}
+function rateLimited(url, retryAfterMs) {
+  return new MarmitonError(
+    "rate_limited",
+    "Marmiton is rate limiting this client. This does NOT mean the recipe does not exist.",
+    {
+      url,
+      retryAfterMs,
+      hint: `Wait about ${Math.ceil(retryAfterMs / 1e3)} seconds, then call the same tool again with the same arguments. If it keeps happening, raise MARMITON_MIN_INTERVAL_MS.`
+    }
+  );
+}
+function parseFailure(url, what) {
+  return new MarmitonError(
+    "parse_failure",
+    `The page loaded but the expected structured recipe data was not found (${what}). Marmiton may have changed how it publishes it.`,
+    { url, hint: `Please report this, with the recipe you asked for, at ${ISSUES_URL}` }
+  );
+}
+function upstreamError(url, status) {
+  return new MarmitonError("network_error", `Marmiton returned HTTP ${status}.`, {
+    url,
+    status,
+    ...status >= 500 ? { hint: "This is a problem on Marmiton's side. Try again shortly." } : {}
+  });
+}
+
+// src/marmiton/rateLimiter.ts
+var DEFAULT_MAX_INTERVAL_MS = 1e4;
+var RateLimiter = class {
+  baseIntervalMs;
+  maxIntervalMs;
+  intervalMs;
+  /** Tail of the queue: each task chains onto the previous one. */
+  tail = Promise.resolve();
+  lastStart = 0;
+  constructor(options) {
+    this.baseIntervalMs = Math.max(0, options.minIntervalMs);
+    this.maxIntervalMs = Math.max(
+      this.baseIntervalMs,
+      options.maxIntervalMs ?? DEFAULT_MAX_INTERVAL_MS
+    );
+    this.intervalMs = this.baseIntervalMs;
+  }
+  get currentIntervalMs() {
+    return this.intervalMs;
+  }
+  /** Queue a task. Tasks run in call order, one at a time. */
+  schedule(task) {
+    const run = this.tail.then(async () => {
+      await this.waitForSlot();
+      this.lastStart = Date.now();
+      return task();
+    });
+    this.tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  /** Called after the site signals it is under load. */
+  penalize() {
+    const next = this.intervalMs === 0 ? 250 : this.intervalMs * 2;
+    this.intervalMs = Math.min(this.maxIntervalMs, next);
+  }
+  /** Called after a success, so a single hiccup does not slow things down forever. */
+  relax() {
+    this.intervalMs = Math.max(this.baseIntervalMs, Math.floor(this.intervalMs * 0.75));
+  }
+  async waitForSlot() {
+    if (this.intervalMs === 0 || this.lastStart === 0) return;
+    const elapsed = Date.now() - this.lastStart;
+    const remaining = this.intervalMs - elapsed;
+    if (remaining > 0) await sleep(remaining);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/marmiton/http.ts
+var BACKOFF_BASE_MS = 2e3;
+var BACKOFF_FACTOR = 2;
+var BACKOFF_MAX_MS = 2e4;
+var MIN_PLAUSIBLE_HTML = 2e3;
+function backoffDelay(attempt, random = Math.random) {
+  const capped = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * BACKOFF_FACTOR ** attempt);
+  return Math.round(capped * (0.5 + random() * 0.5));
+}
+async function fetchHtml(url, deps) {
+  const { config, limiter, logger } = deps;
+  const doFetch = deps.fetchImpl ?? fetch;
+  return limiter.schedule(async () => {
+    let lastError;
+    for (let attempt = 0; attempt <= config.maxRetries; attempt += 1) {
+      if (attempt > 0) {
+        const delay = backoffDelay(attempt - 1);
+        logger.info(`retry ${attempt}/${config.maxRetries} in ${delay}ms for ${url}`);
+        await sleep(delay);
+      }
+      let status;
+      let body;
+      try {
+        const response = await doFetch(url, {
+          headers: {
+            "User-Agent": config.userAgent,
+            Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "fr-FR,fr;q=0.9,en;q=0.8"
+          },
+          redirect: "follow",
+          signal: AbortSignal.timeout(config.timeoutMs)
+        });
+        status = response.status;
+        body = await response.text();
+      } catch (error) {
+        lastError = asTransportError(error, url);
+        logger.debug(`${lastError.code} for ${url}: ${lastError.message}`);
+        continue;
+      }
+      if (status === 429 || status === 503) {
+        limiter.penalize();
+        lastError = rateLimited(url, backoffDelay(attempt));
+        logger.info(`rate limited on ${url}, interval now ${limiter.currentIntervalMs}ms`);
+        continue;
+      }
+      if (status === 404) throw notFound(url, "that address");
+      if (status >= 500) {
+        lastError = upstreamError(url, status);
+        continue;
+      }
+      if (status >= 400) throw upstreamError(url, status);
+      const trimmed = body.trim();
+      if (trimmed.length < MIN_PLAUSIBLE_HTML && !/<\/html>/i.test(trimmed)) {
+        limiter.penalize();
+        lastError = rateLimited(url, backoffDelay(attempt));
+        logger.info(`implausibly short body on ${url}, treating as rate limiting`);
+        continue;
+      }
+      limiter.relax();
+      return body;
+    }
+    throw lastError ?? new MarmitonError("network_error", `Could not fetch ${url}.`, { url });
+  });
+}
+function asTransportError(error, url) {
+  if (error instanceof MarmitonError) return error;
+  const name = error instanceof Error ? error.name : "";
+  if (name === "TimeoutError" || name === "AbortError") {
+    return new MarmitonError("timeout", "Marmiton did not answer in time.", {
+      url,
+      hint: "Raise MARMITON_TIMEOUT_MS if this happens often on a slow connection."
+    });
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new MarmitonError("network_error", `Could not reach Marmiton: ${message}`, { url });
+}
+
+// src/recipe/duration.ts
+var ISO_DURATION = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
+function parseIsoDuration(value) {
+  if (typeof value !== "string") return null;
+  const match = ISO_DURATION.exec(value.trim().toUpperCase());
+  if (!match) return null;
+  const [, days, hours, minutes, seconds] = match;
+  const total = Number(days ?? 0) * 1440 + Number(hours ?? 0) * 60 + Number(minutes ?? 0) + Number(seconds ?? 0) / 60;
+  if (total === 0 && !minutes && !hours && !days && !seconds) return null;
+  return Math.round(total);
+}
+function formatMinutes(minutes) {
+  if (minutes === null || !Number.isFinite(minutes) || minutes <= 0) return null;
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  if (hours === 0) return `${rest} min`;
+  if (rest === 0) return `${hours} h`;
+  return `${hours} h ${String(rest).padStart(2, "0")}`;
+}
+function parseYield(value) {
+  const text = typeof value === "number" && Number.isFinite(value) ? String(value) : typeof value === "string" ? value.trim() : Array.isArray(value) ? String(value[0] ?? "").trim() : "";
+  if (!text) return { count: null, unit: null, text: "" };
+  const match = /^(\d+(?:[.,]\d+)?)\s*(.*)$/.exec(text);
+  if (!match) return { count: null, unit: null, text };
+  const count = Number(match[1].replace(",", "."));
+  const unit = (match[2] ?? "").trim() || null;
+  return { count: Number.isFinite(count) ? count : null, unit, text };
+}
+
+// src/marmiton/jsonld.ts
+var LD_JSON_BLOCK = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+function extractJsonLdNodes(html) {
+  const nodes = [];
+  LD_JSON_BLOCK.lastIndex = 0;
+  let match;
+  while ((match = LD_JSON_BLOCK.exec(html)) !== null) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    for (const node of flatten(parsed)) nodes.push(node);
+  }
+  return nodes;
+}
+function flatten(value) {
+  if (Array.isArray(value)) return value.flatMap(flatten);
+  if (typeof value !== "object" || value === null) return [];
+  const node = value;
+  const graph = node["@graph"];
+  if (graph !== void 0) return flatten(graph);
+  return [node];
+}
+function hasType(node, type) {
+  if (typeof node !== "object" || node === null) return false;
+  const declared = node["@type"];
+  if (typeof declared === "string") return declared === type;
+  if (Array.isArray(declared)) return declared.includes(type);
+  return false;
+}
+function findNodeOfType(nodes, type) {
+  const found = nodes.find((node) => hasType(node, type));
+  return found ?? null;
+}
+function asString(value) {
+  if (typeof value === "string") return value.trim() || null;
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const found = asString(entry);
+      if (found) return found;
+    }
+  }
+  if (typeof value === "object" && value !== null) {
+    const url = value.url;
+    if (typeof url === "string") return url.trim() || null;
+    const name = value.name;
+    if (typeof name === "string") return name.trim() || null;
+  }
+  return null;
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Number(value.replace(",", "."));
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+function asStringList(value) {
+  if (typeof value === "string") return [value.trim()].filter(Boolean);
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    if (typeof entry === "string") {
+      const text = entry.trim();
+      if (text) out.push(text);
+      continue;
+    }
+    if (typeof entry === "object" && entry !== null) {
+      const record = entry;
+      const text = asString(record.text) ?? asString(record.name);
+      if (text) out.push(text);
+    }
+  }
+  return out;
+}
+
+// src/marmiton/urls.ts
+var BASE_URL = "https://www.marmiton.org";
+var RECIPE_PATH_RE = /\/recettes\/recette[_-][a-z0-9%\-.]*?_(\d+)\.aspx/i;
+var ALLOWED_HOSTS = /* @__PURE__ */ new Set(["marmiton.org", "www.marmiton.org"]);
+function buildSearchUrl(query) {
+  const url = new URL(`${BASE_URL}/recettes/recherche.aspx`);
+  url.searchParams.set("aqt", query);
+  return url.toString();
+}
+function buildRecipeUrl(id) {
+  return `${BASE_URL}/recettes/recette_r_${id}.aspx`;
+}
+function isMarmitonHost(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return false;
+  return ALLOWED_HOSTS.has(parsed.hostname.toLowerCase());
+}
+function extractRecipeId(hrefOrUrl) {
+  let path = hrefOrUrl;
+  if (/^https?:\/\//i.test(hrefOrUrl)) {
+    if (!isMarmitonHost(hrefOrUrl)) return null;
+    path = new URL(hrefOrUrl).pathname;
+  }
+  const match = RECIPE_PATH_RE.exec(path);
+  return match?.[1] ?? null;
+}
+function resolveRecipeRef(input) {
+  if (input.id) {
+    if (!/^\d+$/.test(input.id)) {
+      throw invalidInput(
+        `"${input.id}" is not a Marmiton recipe id.`,
+        "Ids are digits only, as returned by search_recipes."
+      );
+    }
+    return { id: input.id, url: buildRecipeUrl(input.id) };
+  }
+  if (input.url) {
+    if (!isMarmitonHost(input.url)) {
+      throw invalidInput(
+        "Only marmiton.org URLs are accepted.",
+        "Pass the url returned by search_recipes, or use the numeric id instead."
+      );
+    }
+    const id = extractRecipeId(input.url);
+    if (!id) {
+      throw invalidInput(
+        "That Marmiton URL is not a recipe page.",
+        "Recipe pages look like https://www.marmiton.org/recettes/recette_tarte-aux-pommes_18588.aspx"
+      );
+    }
+    return { id, url: input.url };
+  }
+  throw invalidInput("Either 'id' or 'url' must be provided.");
+}
+function toAbsoluteUrl(href) {
+  return new URL(href, BASE_URL).toString();
+}
+
+// src/marmiton/parseRecipe.ts
+function parseRecipePage(html, options) {
+  const nodes = extractJsonLdNodes(html);
+  const node = findNodeOfType(nodes, "Recipe");
+  if (!node) {
+    throw parseFailure(options.url, "no schema.org Recipe node in the page");
+  }
+  const title = asString(node.name);
+  const ingredients = asStringList(node.recipeIngredient);
+  const steps = asStringList(node.recipeInstructions);
+  if (!title) throw parseFailure(options.url, "the Recipe node has no name");
+  if (ingredients.length === 0) {
+    throw parseFailure(options.url, "the Recipe node carries no ingredient list");
+  }
+  return {
+    id: options.id,
+    title,
+    url: asString(node.mainEntityOfPage) ?? options.url,
+    imageUrl: asString(node.image),
+    ingredients,
+    steps,
+    recipeYield: parseYield(node.recipeYield),
+    prepMinutes: parseIsoDuration(node.prepTime),
+    cookMinutes: parseIsoDuration(node.cookTime),
+    totalMinutes: parseIsoDuration(node.totalTime),
+    category: asString(node.recipeCategory),
+    author: asString(node.author),
+    rating: parseRating(node.aggregateRating),
+    nutrition: parseNutrition(node.nutrition)
+  };
+}
+function parseRating(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const record = value;
+  const ratingValue = asNumber(record.ratingValue);
+  if (ratingValue === null) return null;
+  return {
+    value: ratingValue,
+    count: asNumber(record.ratingCount) ?? asNumber(record.reviewCount),
+    best: asNumber(record.bestRating)
+  };
+}
+function parseNutrition(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const record = value;
+  const nutrition = {
+    calories: asString(record.calories),
+    protein: asString(record.proteinContent),
+    fat: asString(record.fatContent),
+    carbohydrate: asString(record.carbohydrateContent),
+    fiber: asString(record.fiberContent),
+    sodium: asString(record.sodiumContent),
+    servingSize: asString(record.servingSize)
+  };
+  const hasAny = Object.values(nutrition).some((entry) => entry !== null);
+  return hasAny ? nutrition : null;
+}
+function parseSearchPage(html, url) {
+  const nodes = extractJsonLdNodes(html);
+  const list = findNodeOfType(nodes, "ItemList");
+  if (!list) {
+    throw parseFailure(url, "no schema.org ItemList node on the search page");
+  }
+  const elements = list.itemListElement;
+  if (!Array.isArray(elements)) {
+    throw parseFailure(url, "the ItemList node carries no itemListElement array");
+  }
+  const results = [];
+  let skipped = 0;
+  for (const element of elements) {
+    if (typeof element !== "object" || element === null) {
+      skipped += 1;
+      continue;
+    }
+    const record = element;
+    const href = asString(record.url);
+    const title = asString(record.name);
+    const id = href ? extractRecipeId(href) : null;
+    if (!href || !title || !id) {
+      skipped += 1;
+      continue;
+    }
+    results.push({ id, title, url: toAbsoluteUrl(href), imageUrl: asString(record.image) });
+  }
+  if (results.length === 0 && elements.length > 0) {
+    throw parseFailure(url, `${elements.length} list entries but none could be read`);
+  }
+  if (skipped > 0) {
+    process.stderr.write(`[mcp-marmiton] skipped ${skipped} unreadable search entries on ${url}
+`);
+  }
+  return results;
+}
+
+// src/marmiton/client.ts
+var MarmitonClient = class {
+  config;
+  logger;
+  limiter;
+  cache;
+  fetchImpl;
+  constructor(options = {}) {
+    this.config = options.config ?? loadConfig();
+    this.logger = options.logger ?? createLogger(this.config.logLevel);
+    this.limiter = new RateLimiter({ minIntervalMs: this.config.minIntervalMs });
+    this.cache = new TtlLruCache(this.config.cacheMaxEntries, this.config.cacheTtlMs);
+    this.fetchImpl = options.fetchImpl;
+  }
+  /**
+   * Search recipes.
+   *
+   * One page only: Marmiton's robots.txt disallows the paginated form of this
+   * URL, so there is no page parameter to pass.
+   */
+  async search(query) {
+    const url = buildSearchUrl(query);
+    const { html, cached } = await this.fetchPage(url);
+    return { data: parseSearchPage(html, url), cached };
+  }
+  async getRecipe(ref) {
+    const { id, url } = resolveRecipeRef(ref);
+    const { html, cached } = await this.fetchPage(url);
+    return { data: parseRecipePage(html, { id, url }), cached };
+  }
+  async fetchPage(url) {
+    const hit = this.cache.get(url);
+    if (hit !== void 0) {
+      this.logger.debug(`cache hit ${url}`);
+      return { html: hit, cached: true };
+    }
+    const html = await fetchHtml(url, {
+      config: this.config,
+      limiter: this.limiter,
+      logger: this.logger,
+      ...this.fetchImpl ? { fetchImpl: this.fetchImpl } : {}
+    });
+    this.cache.set(url, html);
+    return { html, cached: false };
+  }
+};
+
+// src/tools/getRecipe.ts
+import { z as z2 } from "zod";
+
+// src/recipe/units.ts
+var UNITS = {
+  // Mass
+  g: { canonical: "g", kind: "measured" },
+  gr: { canonical: "g", kind: "measured" },
+  gramme: { canonical: "g", kind: "measured" },
+  grammes: { canonical: "g", kind: "measured" },
+  kg: { canonical: "kg", kind: "measured" },
+  kilo: { canonical: "kg", kind: "measured" },
+  kilos: { canonical: "kg", kind: "measured" },
+  kilogramme: { canonical: "kg", kind: "measured" },
+  mg: { canonical: "mg", kind: "measured" },
+  // Volume
+  ml: { canonical: "ml", kind: "measured" },
+  cl: { canonical: "cl", kind: "measured" },
+  dl: { canonical: "dl", kind: "measured" },
+  l: { canonical: "l", kind: "measured" },
+  litre: { canonical: "l", kind: "measured" },
+  litres: { canonical: "l", kind: "measured" },
+  // Spoons and cups: real measures, but only in sensible fractions.
+  "cuillere a soupe": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "cuilleres a soupe": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "c a soupe": { canonical: "cuill\xE8re \xE0 soupe", kind: "portioned", plural: "cuill\xE8res \xE0 soupe" },
+  "c a s": { canonical: "cuill\xE8re \xE0 soupe", kind: "portioned", plural: "cuill\xE8res \xE0 soupe" },
+  cas: { canonical: "cuill\xE8re \xE0 soupe", kind: "portioned", plural: "cuill\xE8res \xE0 soupe" },
+  "cuillere a cafe": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  "cuilleres a cafe": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  "c a cafe": { canonical: "cuill\xE8re \xE0 caf\xE9", kind: "portioned", plural: "cuill\xE8res \xE0 caf\xE9" },
+  "c a c": { canonical: "cuill\xE8re \xE0 caf\xE9", kind: "portioned", plural: "cuill\xE8res \xE0 caf\xE9" },
+  cac: { canonical: "cuill\xE8re \xE0 caf\xE9", kind: "portioned", plural: "cuill\xE8res \xE0 caf\xE9" },
+  verre: { canonical: "verre", kind: "portioned" },
+  verres: { canonical: "verre", kind: "portioned" },
+  bol: { canonical: "bol", kind: "portioned" },
+  tasse: { canonical: "tasse", kind: "portioned" },
+  tasses: { canonical: "tasse", kind: "portioned" },
+  // Packaging and natural units: countable, so they round to whole things.
+  sachet: { canonical: "sachet", kind: "portioned" },
+  sachets: { canonical: "sachet", kind: "portioned" },
+  gousse: { canonical: "gousse", kind: "portioned" },
+  gousses: { canonical: "gousse", kind: "portioned" },
+  tranche: { canonical: "tranche", kind: "portioned" },
+  tranches: { canonical: "tranche", kind: "portioned" },
+  botte: { canonical: "botte", kind: "portioned" },
+  bottes: { canonical: "botte", kind: "portioned" },
+  boite: { canonical: "bo\xEEte", kind: "portioned" },
+  boites: { canonical: "bo\xEEte", kind: "portioned" },
+  pot: { canonical: "pot", kind: "portioned" },
+  pots: { canonical: "pot", kind: "portioned" },
+  brique: { canonical: "brique", kind: "portioned" },
+  feuille: { canonical: "feuille", kind: "portioned" },
+  feuilles: { canonical: "feuille", kind: "portioned" },
+  branche: { canonical: "branche", kind: "portioned" },
+  branches: { canonical: "branche", kind: "portioned" },
+  // Deliberately imprecise: the number is a figure of speech.
+  pincee: { canonical: "pinc\xE9e", kind: "vague", plural: "pinc\xE9es" },
+  pincees: { canonical: "pinc\xE9e", kind: "vague", plural: "pinc\xE9es" },
+  trait: { canonical: "trait", kind: "vague" },
+  traits: { canonical: "trait", kind: "vague" },
+  filet: { canonical: "filet", kind: "vague" },
+  filets: { canonical: "filet", kind: "vague" },
+  goutte: { canonical: "goutte", kind: "vague", plural: "gouttes" },
+  gouttes: { canonical: "goutte", kind: "vague", plural: "gouttes" },
+  poignee: { canonical: "poign\xE9e", kind: "vague", plural: "poign\xE9es" },
+  poignees: { canonical: "poign\xE9e", kind: "vague", plural: "poign\xE9es" }
+};
+function normalizeUnitKey(text) {
+  return text.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/\./g, " ").replace(/\s+/g, " ").trim();
+}
+var UNIT_KEYS = Object.keys(UNITS).sort((a, b) => b.length - a.length);
+function lookupUnit(text) {
+  return UNITS[normalizeUnitKey(text)] ?? null;
+}
+function formatUnit(unit, amount) {
+  if (amount < 2) return unit.canonical;
+  if (unit.plural) return unit.plural;
+  if (/^[a-z]{1,3}$/.test(unit.canonical)) return unit.canonical;
+  return `${unit.canonical}s`;
+}
+
+// src/recipe/quantity.ts
+var VULGAR_FRACTIONS = {
+  "\xBD": 0.5,
+  "\u2153": 1 / 3,
+  "\u2154": 2 / 3,
+  "\xBC": 0.25,
+  "\xBE": 0.75,
+  "\u2155": 0.2,
+  "\u2159": 1 / 6,
+  "\u215B": 0.125
+};
+function parseLeadingQuantity(text) {
+  const trimmed = text.trimStart();
+  const offset = text.length - trimmed.length;
+  const glyph = trimmed[0];
+  if (glyph && glyph in VULGAR_FRACTIONS) {
+    return { amount: VULGAR_FRACTIONS[glyph], length: offset + 1 };
+  }
+  const mixed = /^(\d+)\s+(\d+)\s*\/\s*(\d+)/.exec(trimmed);
+  if (mixed) {
+    const whole = Number(mixed[1]);
+    const numerator = Number(mixed[2]);
+    const denominator = Number(mixed[3]);
+    if (denominator !== 0) {
+      return { amount: whole + numerator / denominator, length: offset + mixed[0].length };
+    }
+  }
+  const fraction = /^(\d+)\s*\/\s*(\d+)/.exec(trimmed);
+  if (fraction) {
+    const denominator = Number(fraction[2]);
+    if (denominator !== 0) {
+      return { amount: Number(fraction[1]) / denominator, length: offset + fraction[0].length };
+    }
+  }
+  const decimal = /^(\d+(?:[.,]\d+)?)/.exec(trimmed);
+  if (decimal) {
+    const amount = Number(decimal[1].replace(",", "."));
+    if (Number.isFinite(amount)) {
+      return { amount, length: offset + decimal[0].length };
+    }
+  }
+  return null;
+}
+function parseIngredient(line) {
+  const original = line;
+  const text = line.trim();
+  const quantity = parseLeadingQuantity(text);
+  if (!quantity) {
+    return { original, amount: null, unit: null, unitText: null, item: text };
+  }
+  let rest = text.slice(quantity.length).trimStart();
+  let unit = null;
+  let unitText = null;
+  const normalizedRest = normalizeUnitKey(rest);
+  for (const key of UNIT_KEYS) {
+    if (normalizedRest === key || normalizedRest.startsWith(`${key} `)) {
+      unit = lookupUnit(key);
+      const wordCount = key.split(" ").length;
+      const words = rest.split(/\s+/);
+      unitText = words.slice(0, wordCount).join(" ");
+      rest = words.slice(wordCount).join(" ");
+      break;
+    }
+  }
+  const item = rest.replace(/^(?:de\s+la\s+|de\s+l'|d'|de\s+|du\s+|des\s+)/i, "").trim();
+  return { original, amount: quantity.amount, unit, unitText, item };
+}
+function formatAmount(amount) {
+  if (!Number.isFinite(amount)) return "";
+  if (Number.isInteger(amount)) return String(amount);
+  const whole = Math.floor(amount);
+  const rest = amount - whole;
+  const known = [
+    [0.25, "1/4"],
+    [1 / 3, "1/3"],
+    [0.5, "1/2"],
+    [2 / 3, "2/3"],
+    [0.75, "3/4"]
+  ];
+  for (const [value, label] of known) {
+    if (Math.abs(rest - value) < 0.02) {
+      return whole > 0 ? `${whole} ${label}` : label;
+    }
+  }
+  return String(Math.round(amount * 100) / 100).replace(".", ",");
+}
+
+// src/recipe/scale.ts
+function roundTo(value, step) {
+  return Math.round(Math.round(value / step) * step * 100) / 100;
+}
+function roundMeasured(value) {
+  if (value >= 100) return roundTo(value, 5);
+  if (value >= 10) return roundTo(value, 1);
+  if (value >= 1) return roundTo(value, 0.5);
+  return Math.round(value * 100) / 100;
+}
+function roundCountable(value, allowHalves) {
+  if (value <= 0) return 0;
+  if (value < 1) {
+    const USABLE_FRACTIONS = [0.25, 1 / 3, 0.5, 2 / 3, 0.75];
+    let closest = USABLE_FRACTIONS[0];
+    for (const fraction of USABLE_FRACTIONS) {
+      if (Math.abs(value - fraction) < Math.abs(value - closest)) closest = fraction;
+    }
+    return Math.round(closest * 100) / 100;
+  }
+  return allowHalves ? roundTo(value, 0.5) : Math.round(value);
+}
+function singularizeIfNeeded(item, amount) {
+  if (amount >= 2 || !item) return item;
+  const words = item.split(" ");
+  const first = words[0] ?? "";
+  if (first.length > 3 && /s$/i.test(first) && !/[aiou]s$/i.test(first)) {
+    words[0] = first.slice(0, -1);
+  }
+  return words.join(" ");
+}
+function scaleIngredient(line, options) {
+  const { factor } = options;
+  const parsed = parseIngredient(line);
+  if (parsed.amount === null) {
+    return {
+      original: parsed.original,
+      text: parsed.original,
+      amount: null,
+      unit: null,
+      scaling: "unscaled",
+      note: "No quantity given; adjust to taste."
+    };
+  }
+  const kind = parsed.unit?.kind ?? "countable";
+  if (kind === "vague") {
+    return {
+      original: parsed.original,
+      text: parsed.original,
+      amount: parsed.amount,
+      unit: parsed.unit?.canonical ?? null,
+      scaling: "unscaled",
+      note: "Measure is approximate by nature; adjust to taste."
+    };
+  }
+  const raw = parsed.amount * factor;
+  let amount;
+  let scaling;
+  if (kind === "measured") {
+    amount = roundMeasured(raw);
+    scaling = "scaled";
+  } else if (kind === "portioned") {
+    const allowHalves = /cuillère|verre|tasse|bol/.test(parsed.unit?.canonical ?? "");
+    amount = roundCountable(raw, allowHalves);
+    scaling = "rounded";
+  } else {
+    amount = roundCountable(raw, false);
+    scaling = "rounded";
+  }
+  const unitLabel = parsed.unit ? ` ${formatUnit(parsed.unit, amount)}` : "";
+  const separator = parsed.unit ? " de " : " ";
+  const itemText = parsed.unit ? parsed.item : singularizeIfNeeded(parsed.item, amount);
+  const item = itemText ? `${separator}${itemText}` : "";
+  const text = `${formatAmount(amount)}${unitLabel}${item}`.trim();
+  const result = {
+    original: parsed.original,
+    text,
+    amount,
+    unit: parsed.unit?.canonical ?? null,
+    scaling
+  };
+  if (scaling === "rounded" && Math.abs(raw - amount) > 0.01) {
+    result.note = `Rounded from ${formatAmount(Math.round(raw * 100) / 100)}.`;
+  }
+  return result;
+}
+function scaleIngredients(lines, options) {
+  return lines.map((line) => scaleIngredient(line, options));
+}
+function passthroughIngredients(lines) {
+  return lines.map((line) => {
+    const parsed = parseIngredient(line);
+    return {
+      original: parsed.original,
+      text: parsed.original,
+      amount: parsed.amount,
+      unit: parsed.unit?.canonical ?? null,
+      scaling: "unscaled"
+    };
+  });
+}
+
+// src/tools/shared.ts
+import { z } from "zod";
+var MAX_TEXT_MIRROR_CHARS = 2e3;
+var scaledIngredientSchema = z.object({
+  original: z.string().describe("The ingredient line exactly as Marmiton publishes it."),
+  text: z.string().describe("The line after scaling, identical to 'original' when unscaled."),
+  amount: z.number().nullable(),
+  unit: z.string().nullable(),
+  scaling: z.enum(["scaled", "rounded", "unscaled"]).describe(
+    "'scaled' was multiplied cleanly. 'rounded' was multiplied then rounded to something countable. 'unscaled' was left alone, either because it carries no quantity or because the measure is approximate by nature."
+  ),
+  note: z.string().optional().describe("Why the line was rounded or left alone.")
+});
+function ok(structured, text) {
+  return {
+    content: [{ type: "text", text: truncate(text, MAX_TEXT_MIRROR_CHARS) }],
+    structuredContent: structured
+  };
+}
+function toToolError(error) {
+  const known = error instanceof MarmitonError ? error : new MarmitonError("network_error", error instanceof Error ? error.message : String(error));
+  const lines = [`[${known.code}] ${known.message}`];
+  if (known.details.hint) lines.push(`Hint: ${known.details.hint}`);
+  return { content: [{ type: "text", text: lines.join("\n") }], isError: true };
+}
+function truncate(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
+}
+
+// src/tools/getRecipe.ts
+var getRecipeDescription = [
+  "Read one Marmiton recipe: ingredients, steps, times, category, rating and nutrition.",
+  "Give the id returned by search_recipes, or a marmiton.org recipe URL.",
+  "Set 'servings' to rescale the quantities. Each ingredient reports how it was handled: 'scaled' for grams",
+  "and millilitres, 'rounded' for countable things such as eggs or spoons, and 'unscaled' for lines with no",
+  "quantity or with an approximate one such as a pinch of salt. Trust that flag rather than recomputing:",
+  "the point of scaling here is to avoid answers like '2.4 eggs'.",
+  "Recipes yielding pieces rather than servings are rescaled the same way; check 'yield' to see which.",
+  "Always cite 'attribution' when showing a recipe to a user."
+].join(" ");
+var getRecipeInputShape = {
+  id: z2.string().regex(/^\d+$/, "Recipe ids are digits only.").optional().describe("Marmiton recipe id, as returned by search_recipes. Preferred over 'url'."),
+  url: z2.string().url().optional().describe(
+    "Full marmiton.org recipe URL. Only marmiton.org is accepted. Ignored when 'id' is given."
+  ),
+  servings: z2.number().positive().max(500).optional().describe(
+    "Rescale the ingredients to this many servings. Omit to get the recipe exactly as published."
+  )
+};
+var getRecipeOutputShape = {
+  id: z2.string(),
+  title: z2.string(),
+  url: z2.string(),
+  yield: z2.object({
+    original_count: z2.number().nullable(),
+    original_text: z2.string(),
+    requested: z2.number().nullable(),
+    unit: z2.string().nullable().describe("What is being counted: 'personnes', 'pi\xE8ces'."),
+    factor: z2.number().nullable().describe("Multiplier applied to the quantities.")
+  }),
+  ingredients: z2.array(scaledIngredientSchema),
+  steps: z2.array(z2.string()),
+  prep_minutes: z2.number().int().nullable(),
+  cook_minutes: z2.number().int().nullable(),
+  total_minutes: z2.number().int().nullable(),
+  category: z2.string().nullable(),
+  author: z2.string().nullable(),
+  rating: z2.object({ value: z2.number(), count: z2.number().nullable(), best: z2.number().nullable() }).nullable(),
+  nutrition: z2.object({
+    calories: z2.string().nullable(),
+    protein: z2.string().nullable(),
+    fat: z2.string().nullable(),
+    carbohydrate: z2.string().nullable(),
+    fiber: z2.string().nullable(),
+    sodium: z2.string().nullable(),
+    serving_size: z2.string().nullable()
+  }).nullable().describe("Nutrition is given for the recipe as published, not rescaled."),
+  attribution: z2.string(),
+  source: z2.literal("marmiton.org"),
+  notes: z2.array(z2.string())
+};
+async function runGetRecipe(client, args) {
+  try {
+    const ref = {};
+    if (args.id) ref.id = args.id;
+    else if (args.url) ref.url = args.url;
+    const { data, cached } = await client.getRecipe(ref);
+    const notes = [];
+    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    const originalCount = data.recipeYield.count;
+    let factor = null;
+    let ingredients;
+    if (args.servings === void 0) {
+      ingredients = passthroughIngredients(data.ingredients);
+    } else if (originalCount === null || originalCount <= 0) {
+      ingredients = passthroughIngredients(data.ingredients);
+      notes.push(
+        `Marmiton does not state how many servings this recipe makes ("${data.recipeYield.text}"), so the quantities are unchanged.`
+      );
+    } else {
+      factor = args.servings / originalCount;
+      ingredients = scaleIngredients(data.ingredients, { factor });
+      const unit = data.recipeYield.unit ?? "portions";
+      notes.push(
+        `Quantities rescaled from ${originalCount} to ${args.servings} ${unit} (factor ${Math.round(factor * 100) / 100}).`
+      );
+      if (ingredients.some((entry) => entry.scaling === "rounded")) {
+        notes.push("Some quantities were rounded to remain usable; see the 'scaling' field.");
+      }
+      if (ingredients.some((entry) => entry.scaling === "unscaled")) {
+        notes.push("Some ingredients carry no usable quantity and were left as published.");
+      }
+      if (data.nutrition) {
+        notes.push(
+          "Nutrition values are for the recipe as published, not for the rescaled amounts."
+        );
+      }
+    }
+    const attribution = `${data.title} \u2014 recette Marmiton \u2014 ${data.url}`;
+    const structured = {
+      id: data.id,
+      title: data.title,
+      url: data.url,
+      yield: {
+        original_count: originalCount,
+        original_text: data.recipeYield.text,
+        requested: args.servings ?? null,
+        unit: data.recipeYield.unit,
+        factor: factor === null ? null : Math.round(factor * 1e3) / 1e3
+      },
+      ingredients,
+      steps: data.steps,
+      prep_minutes: data.prepMinutes,
+      cook_minutes: data.cookMinutes,
+      total_minutes: data.totalMinutes,
+      category: data.category,
+      author: data.author,
+      rating: data.rating,
+      nutrition: data.nutrition ? {
+        calories: data.nutrition.calories,
+        protein: data.nutrition.protein,
+        fat: data.nutrition.fat,
+        carbohydrate: data.nutrition.carbohydrate,
+        fiber: data.nutrition.fiber,
+        sodium: data.nutrition.sodium,
+        serving_size: data.nutrition.servingSize
+      } : null,
+      attribution,
+      source: "marmiton.org",
+      notes
+    };
+    const times = [
+      data.prepMinutes ? `pr\xE9paration ${formatMinutes(data.prepMinutes)}` : "",
+      data.cookMinutes ? `cuisson ${formatMinutes(data.cookMinutes)}` : ""
+    ].filter(Boolean).join(", ");
+    const header = [
+      attribution,
+      args.servings !== void 0 && factor !== null ? `Pour ${args.servings} ${data.recipeYield.unit ?? "portions"} (recette pr\xE9vue pour ${data.recipeYield.text}).` : `Recette pour ${data.recipeYield.text || "portions non pr\xE9cis\xE9es"}.`,
+      times
+    ].filter(Boolean).join("\n");
+    const ingredientLines = ingredients.map((entry) => {
+      const flag = entry.scaling === "unscaled" ? " (non ajust\xE9)" : "";
+      return `- ${entry.text}${flag}`;
+    }).join("\n");
+    return ok(structured, `${header}
+
+Ingr\xE9dients:
+${ingredientLines}`);
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/tools/scaleIngredients.ts
+import { z as z3 } from "zod";
+var scaleIngredientsDescription = [
+  "Rescale a list of ingredient lines to a different number of servings, without contacting any website.",
+  "Give either 'factor' directly, or 'from_servings' and 'to_servings' and the factor is computed.",
+  "Works on any French ingredient list, whatever its source, so it also serves a recipe the user pasted in.",
+  "Quantities in grams or millilitres are multiplied and rounded to readable values; countable things such as",
+  "eggs or spoons are rounded to whole or half units; lines with no quantity, or with an approximate one such",
+  "as a pinch, are returned untouched and flagged. Prefer this over doing the arithmetic yourself."
+].join(" ");
+var scaleIngredientsInputShape = {
+  ingredients: z3.array(z3.string().max(300)).min(1).max(100).describe("Ingredient lines, for example ['200 g de farine', '3 oeufs', 'sel']."),
+  factor: z3.number().positive().max(100).optional().describe("Multiplier to apply. Use this or the from/to pair."),
+  from_servings: z3.number().positive().max(500).optional().describe("How many servings the list is written for."),
+  to_servings: z3.number().positive().max(500).optional().describe("How many servings are wanted.")
+};
+var scaleIngredientsOutputShape = {
+  factor: z3.number(),
+  ingredients: z3.array(scaledIngredientSchema),
+  scaled_count: z3.number().int(),
+  rounded_count: z3.number().int(),
+  unscaled_count: z3.number().int(),
+  notes: z3.array(z3.string())
+};
+function runScaleIngredients(args) {
+  try {
+    let factor;
+    if (args.factor !== void 0) {
+      factor = args.factor;
+    } else if (args.from_servings !== void 0 && args.to_servings !== void 0) {
+      factor = args.to_servings / args.from_servings;
+    } else {
+      throw invalidInput(
+        "Provide either 'factor', or both 'from_servings' and 'to_servings'.",
+        "For example from_servings=6 and to_servings=4, or factor=0.667."
+      );
+    }
+    const ingredients = scaleIngredients(args.ingredients, { factor });
+    const counts = {
+      scaled: ingredients.filter((entry) => entry.scaling === "scaled").length,
+      rounded: ingredients.filter((entry) => entry.scaling === "rounded").length,
+      unscaled: ingredients.filter((entry) => entry.scaling === "unscaled").length
+    };
+    const notes = [];
+    if (counts.rounded > 0) {
+      notes.push(
+        `${counts.rounded} quantity(ies) were rounded to stay usable, rather than left as fractions.`
+      );
+    }
+    if (counts.unscaled > 0) {
+      notes.push(
+        `${counts.unscaled} line(s) carry no usable quantity and were returned unchanged; adjust to taste.`
+      );
+    }
+    const structured = {
+      factor: Math.round(factor * 1e3) / 1e3,
+      ingredients,
+      scaled_count: counts.scaled,
+      rounded_count: counts.rounded,
+      unscaled_count: counts.unscaled,
+      notes
+    };
+    const lines = ingredients.map((entry) => {
+      const flag = entry.scaling === "unscaled" ? " (non ajust\xE9)" : "";
+      return `- ${entry.text}${flag}`;
+    }).join("\n");
+    return ok(structured, `Facteur ${Math.round(factor * 100) / 100}:
+${lines}`);
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/tools/searchRecipes.ts
+import { z as z4 } from "zod";
+var searchRecipesDescription = [
+  "Search Marmiton for recipes by free text: a dish, an ingredient, or both, for example 'tarte aux pommes'",
+  "or 'poulet curry coco'. Marmiton is a French site, so French terms work best.",
+  "Returns candidate recipes with the id and URL needed to read one with get_recipe.",
+  "One call returns one page of results. Marmiton's robots.txt disallows paginating search results, so this",
+  "server does not, and there is no page parameter: narrow the query instead of asking for more pages."
+].join(" ");
+var searchRecipesInputShape = {
+  // Deliberately no min(1): an empty string would be rejected by the schema with
+  // a protocol-level validation error, while a whitespace-only one would reach
+  // the tool and come back as invalid_input. Letting both through to the same
+  // check gives callers one error code for one problem.
+  query: z4.string().max(200).describe("What to search for, in French, for example 'tarte aux pommes'."),
+  limit: z4.number().int().min(1).max(30).default(10).describe("Maximum recipes to return from this page of results.")
+};
+var searchRecipesOutputShape = {
+  query: z4.string(),
+  results: z4.array(
+    z4.object({
+      id: z4.string().describe("Marmiton recipe id. Pass this to get_recipe."),
+      title: z4.string(),
+      url: z4.string(),
+      image_url: z4.string().nullable()
+    })
+  ),
+  result_count: z4.number().int(),
+  total_available: z4.number().int().describe("Recipes on this page before applying 'limit'."),
+  source: z4.literal("marmiton.org"),
+  notes: z4.array(z4.string())
+};
+async function runSearchRecipes(client, args) {
+  try {
+    const query = args.query.trim();
+    if (!query) {
+      throw invalidInput(
+        "'query' cannot be empty.",
+        'Give a dish or an ingredient, for example query="tarte aux pommes".'
+      );
+    }
+    const { data, cached } = await client.search(query);
+    const notes = [];
+    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    if (data.length > args.limit) {
+      notes.push(`This page holds ${data.length} recipes; showing the first ${args.limit}.`);
+    }
+    if (data.length === 0) {
+      notes.push(
+        "Marmiton found no recipe for this query. Try French terms, or a broader wording. Note that only one page of results is available."
+      );
+    }
+    const results = data.slice(0, args.limit).map((recipe) => ({
+      id: recipe.id,
+      title: recipe.title,
+      url: recipe.url,
+      image_url: recipe.imageUrl
+    }));
+    const structured = {
+      query,
+      results,
+      result_count: results.length,
+      total_available: data.length,
+      source: "marmiton.org",
+      notes
+    };
+    const header = results.length > 0 ? `${results.length} recette(s) pour "${query}":` : `Aucune recette trouv\xE9e pour "${query}".`;
+    const list = results.map((recipe, index) => `${index + 1}. ${recipe.title} \xB7 id: ${recipe.id}`).join("\n");
+    return ok(structured, `${header}
+${list}`);
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/server.ts
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+function createServer(options = {}) {
+  const config = options.config ?? loadConfig();
+  const logger = options.logger ?? createLogger(config.logLevel);
+  const client = new MarmitonClient({
+    config,
+    logger,
+    ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
+  });
+  const server = new McpServer(
+    { name: "mcp-marmiton", version: PKG_VERSION },
+    {
+      instructions: "Tools for looking up French recipes on Marmiton. No API key is needed. Typical flow: search_recipes to find a recipe and its id, then get_recipe with that id, passing 'servings' when the user wants a different number of people. Do not rescale quantities yourself: get_recipe and scale_ingredients already round countable items sensibly and flag what cannot be scaled, which is what stops answers like '2.4 eggs'. Marmiton disallows paginating search results, so narrow the query instead of asking for more pages. When you show a recipe to a user, credit it and link the source URL."
+    }
+  );
+  server.registerTool(
+    "search_recipes",
+    {
+      title: "Search recipes",
+      description: searchRecipesDescription,
+      inputSchema: searchRecipesInputShape,
+      outputSchema: searchRecipesOutputShape,
+      annotations: READ_ONLY
+    },
+    async (args) => runSearchRecipes(client, args)
+  );
+  server.registerTool(
+    "get_recipe",
+    {
+      title: "Get a recipe",
+      description: getRecipeDescription,
+      inputSchema: getRecipeInputShape,
+      outputSchema: getRecipeOutputShape,
+      annotations: READ_ONLY
+    },
+    async (args) => runGetRecipe(client, args)
+  );
+  server.registerTool(
+    "scale_ingredients",
+    {
+      title: "Scale an ingredient list",
+      description: scaleIngredientsDescription,
+      inputSchema: scaleIngredientsInputShape,
+      outputSchema: scaleIngredientsOutputShape,
+      annotations: READ_ONLY
+    },
+    async (args) => runScaleIngredients(args)
+  );
+  logger.info(
+    `ready: user-agent="${config.userAgent}", min interval ${config.minIntervalMs}ms, cache ${config.cacheTtlMs}ms`
+  );
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const config = loadConfig();
+  const logger = createLogger(config.logLevel);
+  const server = createServer({ config, logger });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  const shutdown = () => {
+    void server.close().finally(() => process.exit(0));
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  process.stderr.write(
+    `[mcp-marmiton] fatal: ${error instanceof Error ? error.stack ?? error.message : String(error)}
+`
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map