@xiawan-play/steam-tools-mcp 0.3.0 → 0.3.2

package/dist/server.js

@@ -19504,8 +19504,8 @@ var require_subresource_integrity = __commonJS({
       if (parsedMetadata.length === 0) {
         return true;
       }
-      const metadata = getStrongestMetadata(parsedMetadata);
-      for (const item of metadata) {
+      const metadata2 = getStrongestMetadata(parsedMetadata);
+      for (const item of metadata2) {
         const algorithm = item.alg;
         const expectedValue = item.val;
         const actualValue = applyAlgorithmToBytes(algorithm, bytes);
@@ -19544,9 +19544,9 @@ var require_subresource_integrity = __commonJS({
       }
       return result;
     }
-    function parseMetadata(metadata) {
+    function parseMetadata(metadata2) {
       const result = [];
-      for (const item of metadata.split(" ")) {
+      for (const item of metadata2.split(" ")) {
         const expressionAndOptions = item.split("?", 1);
         const algorithmExpression = expressionAndOptions[0];
         let base64Value = "";
@@ -19558,11 +19558,11 @@ var require_subresource_integrity = __commonJS({
         if (algorithmAndValue[1]) {
           base64Value = algorithmAndValue[1];
         }
-        const metadata2 = {
+        const metadata3 = {
           alg: algorithm,
           val: base64Value
         };
-        result.push(metadata2);
+        result.push(metadata3);
       }
       return result;
     }
@@ -34612,6 +34612,80 @@ function applyGeneratedToolTitles(spec2) {
   return spec2;
 }
 
+// package.json
+var package_default = {
+  name: "@xiawan-play/steam-tools-mcp",
+  version: "0.3.2",
+  description: "A Steam MCP server with Chinese-friendly high-level tools for profiles, libraries, game snapshots, achievements, and app discovery.",
+  type: "module",
+  license: "MIT",
+  main: "./dist/server.js",
+  types: "./dist/server.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/server.d.ts",
+      default: "./dist/server.js"
+    }
+  },
+  bin: {
+    "steam-tools-mcp": "dist/server.js"
+  },
+  files: [
+    "dist",
+    "docs",
+    "README.md",
+    ".env.example"
+  ],
+  keywords: [
+    "mcp",
+    "model-context-protocol",
+    "steam",
+    "steam-tools",
+    "steam-web-api",
+    "steamworks"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/XiaWan-Play/steam-tools-mcp.git"
+  },
+  homepage: "https://github.com/XiaWan-Play/steam-tools-mcp#readme",
+  bugs: {
+    url: "https://github.com/XiaWan-Play/steam-tools-mcp/issues"
+  },
+  engines: {
+    node: ">=20.0.0"
+  },
+  scripts: {
+    dev: "tsx src/server.ts",
+    build: "tsup src/server.ts --format esm --dts --clean",
+    "check:tool-registry": "tsx scripts/check-tool-registration.ts",
+    start: "node dist/server.js",
+    "sync:steam-spec": "tsx scripts/sync-steam-web-api-spec.ts",
+    prepare: "npm run build"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    cheerio: "^1.2.0",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@types/express": "^5.0.3",
+    "@types/node": "^24.6.1",
+    tsup: "^8.5.1",
+    tsx: "^4.20.6",
+    typescript: "^5.9.3"
+  }
+};
+
+// src/lib/package-meta.ts
+var metadata = package_default;
+var PACKAGE_NAME = metadata.name.includes("/") ? metadata.name.split("/").pop() ?? metadata.name : metadata.name;
+var PACKAGE_VERSION = metadata.version;
+var PACKAGE_USER_AGENT = `${PACKAGE_NAME}/${PACKAGE_VERSION}`;
+
 // src/normalizers/common.ts
 function normalizeScalarInput(value) {
   if (value === void 0 || value === null) {
@@ -35153,11 +35227,11 @@ async function fetchTextResponse(url, timeoutMs) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const response = await fetch(url, {
+    const response = await fetchWithProxy(url, {
       signal: controller.signal,
       headers: {
         "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
-        "user-agent": "steam-tools-mcp/0.2.0"
+        "user-agent": PACKAGE_USER_AGENT
       }
     });
     if (!response.ok) {
@@ -35174,6 +35248,70 @@ async function fetchJsonResponse(url, timeoutMs) {
 }
 
 // src/services/base/apps.ts
+function isChineseLikeLocale(locale) {
+  const normalized = normalizeLocale(locale) ?? "";
+  return normalized.startsWith("zh") || normalized.includes("chinese");
+}
+function normalizeStoreTitleCandidate(value) {
+  const text = value?.replace(/\s+/g, " ").trim();
+  if (!text) {
+    return void 0;
+  }
+  const patterns = [
+    /^在 Steam 上购买\s+(.+?)\s+立省.*$/u,
+    /^Steam 上的\s+(.+)$/u,
+    /^在 Steam 上下载\s+(.+)$/u,
+    /^Buy\s+(.+?)\s+on Steam$/iu,
+    /^Save .* on\s+(.+?)\s+on Steam$/iu,
+    /^(.+?) on Steam$/iu
+  ];
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    const candidate = match?.[1]?.trim();
+    if (candidate) {
+      return candidate;
+    }
+  }
+  return text;
+}
+function pickStorePageAppName(candidates, locale) {
+  const normalizedCandidates = uniqueStrings(
+    candidates.map((candidate) => normalizeStoreTitleCandidate(candidate)).filter((candidate) => Boolean(candidate))
+  );
+  if (normalizedCandidates.length === 0) {
+    return void 0;
+  }
+  if (isChineseLikeLocale(locale)) {
+    return normalizedCandidates.find((candidate) => containsNonAscii(candidate)) ?? normalizedCandidates[0];
+  }
+  return normalizedCandidates[0];
+}
+function shouldFetchStorePageName(existingName, locale) {
+  if (!isChineseLikeLocale(locale)) {
+    return false;
+  }
+  if (!existingName) {
+    return true;
+  }
+  return !containsNonAscii(existingName);
+}
+function shouldPreferStorePageName(existingName, candidateName, locale) {
+  if (!candidateName) {
+    return false;
+  }
+  if (!existingName) {
+    return true;
+  }
+  if (!isChineseLikeLocale(locale)) {
+    return false;
+  }
+  const existingHasLocalizedChars = containsNonAscii(existingName);
+  const candidateHasLocalizedChars = containsNonAscii(candidateName);
+  if (existingHasLocalizedChars !== candidateHasLocalizedChars) {
+    return candidateHasLocalizedChars;
+  }
+  return false;
+}
 function createAppRuntimeHelpers(deps) {
   const { config, safeInvokeKnownMethod, requireSteamApiKey } = deps;
   let appCatalogCache = null;
@@ -35322,6 +35460,38 @@ function createAppRuntimeHelpers(deps) {
       locale: normalizedLocale
     };
   }
+  async function fetchStorePageLocalizedAppName(appid, locale = "schinese") {
+    const normalizedLocale = normalizeLocale(locale) ?? "schinese";
+    const url = new URL(`https://store.steampowered.com/app/${appid}/`);
+    url.searchParams.set("l", normalizedLocale);
+    url.searchParams.set("cc", "cn");
+    const pageText = await fetchTextResponse(url, 3500);
+    const $ = load(pageText);
+    const reviewPropsRaw = $('[data-featuretarget="appreviews"]').first().attr("data-props");
+    let reviewAppName;
+    if (reviewPropsRaw) {
+      try {
+        const reviewProps = asRecord(JSON.parse(reviewPropsRaw));
+        reviewAppName = getStringValue(reviewProps?.appname);
+      } catch {
+        reviewAppName = void 0;
+      }
+    }
+    const localizedName = pickStorePageAppName(
+      [
+        reviewAppName,
+        $("#appHubAppName").first().text(),
+        $(".apphub_AppName").first().text(),
+        $('meta[property="og:title"]').attr("content"),
+        $("title").first().text()
+      ],
+      normalizedLocale
+    );
+    return {
+      localizedName,
+      locale: normalizedLocale
+    };
+  }
   async function fetchLocalizedStoreAppName(appid, locale) {
     const cacheKey = `${appid}:${locale}`;
     const cached = localizedAppNameCache.get(cacheKey);
@@ -35330,10 +35500,25 @@ function createAppRuntimeHelpers(deps) {
       return cached.value;
     }
     const details = await fetchStoreAppDetailsSummary(appid, locale);
-    const localizedName = details?.name;
+    let localizedName = details?.name;
+    let source = localizedName ? "storeAppDetails" : "fallback";
+    if (shouldFetchStorePageName(localizedName, locale)) {
+      try {
+        const pageName = await fetchStorePageLocalizedAppName(appid, locale);
+        if (shouldPreferStorePageName(
+          localizedName,
+          pageName.localizedName,
+          pageName.locale
+        )) {
+          localizedName = pageName.localizedName;
+          source = localizedName ? "storePage" : source;
+        }
+      } catch {
+      }
+    }
     const value = {
       localizedName,
-      source: localizedName ? "storeAppDetails" : "fallback",
+      source,
       locale: details?.locale ?? normalizeLocale(locale) ?? "schinese"
     };
     localizedAppNameCache.set(cacheKey, {
@@ -37007,444 +37192,221 @@ async function buildAppSnapshotData(runtime2, input) {
   };
 }
 
-// src/services/prices.ts
-var AUGMENTED_STEAM_PRICES_ENDPOINT = "https://api.augmentedsteam.com/prices/v2";
-var DEFAULT_SHOP_IDS = [61];
-async function buildPriceOverviewData(runtime2, input) {
-  const target = await resolvePriceTarget(runtime2, input);
-  const country = normalizeCountryCode(input.country);
-  const shopIds = parseShopIds(input.shops);
-  const payload = await fetchAugmentedSteamPrices(runtime2, {
-    country,
-    apps: target.type === "app" ? [parseNumericId(target.id, "appid")] : [],
-    subs: target.type === "sub" ? [parseNumericId(target.id, "subid")] : [],
-    bundles: target.type === "bundle" ? [parseNumericId(target.id, "bundleid")] : [],
-    voucher: input.includeVoucher,
-    shops: shopIds
+// src/services/achievement-guide.ts
+import { load as load2 } from "cheerio";
+var STEAM_GUIDE_KEYWORDS = [
+  "achievement",
+  "100%",
+  "all achievements",
+  "guide",
+  "walkthrough",
+  "missable",
+  "coop",
+  "co-op"
+];
+var RARITY_BANDS = [
+  {
+    key: "veryRare",
+    label: "Very Rare",
+    minPercent: 0,
+    maxPercent: 5
+  },
+  {
+    key: "rare",
+    label: "Rare",
+    minPercent: 5,
+    maxPercent: 20
+  },
+  {
+    key: "uncommon",
+    label: "Uncommon",
+    minPercent: 20,
+    maxPercent: 50
+  },
+  {
+    key: "common",
+    label: "Common",
+    minPercent: 50,
+    maxPercent: Number.POSITIVE_INFINITY
+  }
+];
+function isPresent(value) {
+  return value !== null && value !== void 0;
+}
+async function buildAchievementGuideData(runtime2, input) {
+  const overview = await buildGlobalAchievementOverviewData(runtime2, {
+    toolName: input.toolName,
+    appid: input.appid,
+    query: input.query,
+    key: input.key,
+    language: input.language,
+    includeSchemaDetails: input.includeSchemaDetails,
+    topCount: input.topCount
   });
-  const priceRecord = asRecord(getNestedValue(payload, "prices", `${target.type}/${target.id}`));
-  const warnings = [...target.warnings];
-  if (!priceRecord) {
+  const target = asRecord(overview.target);
+  const app = asRecord(target?.app);
+  const overviewSummary = asRecord(overview.summary);
+  const warnings = Array.isArray(overview.warnings) ? [...overview.warnings] : [];
+  const sourceItems = getRecordItems(overview.items);
+  const achievementMap = buildAchievementMap(sourceItems);
+  const indexUrls = app && getStringValue(app.appid) ? buildSteamGuideIndexUrls(getStringValue(app.appid)) : [];
+  const selectedGuides = await loadGuideCandidates(
+    runtime2,
+    indexUrls,
+    input.maxGuides,
+    warnings
+  );
+  const guideAnalyses = await Promise.all(
+    selectedGuides.map(async (guide) => {
+      try {
+        const html = await fetchSteamCommunityHtml(guide.url, runtime2.config.timeoutMs);
+        return analyzeGuidePage(html, guide, achievementMap);
+      } catch (error) {
+        warnings.push(
+          `Steam Guide fetch failed for ${guide.url}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return null;
+      }
+    })
+  );
+  const validGuides = guideAnalyses.filter(
+    (guide) => Boolean(guide)
+  );
+  const guideFacts = dedupeGuideFacts(
+    validGuides.flatMap((guide) => guide.facts)
+  ).slice(0, input.maxGuideFacts);
+  const achievementEvidence = buildAchievementEvidence(
+    validGuides,
+    input.maxEvidencePerAchievement
+  );
+  const evidenceByAchievement = new Map(
+    achievementEvidence.map((entry) => [entry.achievement, entry])
+  );
+  const checklist = sourceItems.map((achievement, index) => {
+    const displayName = getStringValue(achievement.displayName) ?? getStringValue(achievement.apiName);
+    const evidence = displayName ? evidenceByAchievement.get(displayName) : void 0;
+    const globalPercent = toNumber(achievement.globalPercent);
     return {
-      ok: false,
-      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      target: buildPriceToolTarget(target),
-      summary: {
-        type: target.type,
-        country,
-        source: "augmentedsteam",
-        requestedShopIds: shopIds
-      },
-      items: [],
-      note: `No price data was returned for ${target.type}/${target.id} in country '${country}'.`,
-      warnings
+      checklistIndex: index + 1,
+      apiName: getStringValue(achievement.apiName),
+      displayName,
+      description: getStringValue(achievement.description),
+      hidden: toBoolean(achievement.hidden) ?? false,
+      globalPercent,
+      rarityBand: classifyRarityBand(globalPercent),
+      icon: getStringValue(achievement.icon),
+      iconGray: getStringValue(achievement.iconGray),
+      guideEvidenceCount: evidence?.evidenceCount ?? 0,
+      guideEvidence: evidence?.evidence ?? [],
+      guideSources: evidence?.sources ?? []
     };
-  }
-  const current = normalizePriceNode(asRecord(priceRecord.current));
-  const lowest = normalizePriceNode(asRecord(priceRecord.lowest));
-  const urls = normalizePriceUrls(asRecord(priceRecord.urls));
-  const bundled = toNumber(priceRecord.bundled) ?? 0;
-  const currentAmount = toNumber(getNestedValue(current, "price", "amount"));
-  const lowestAmount = toNumber(getNestedValue(lowest, "price", "amount"));
-  const lowestTimestamp = getStringValue(lowest?.timestamp);
-  const historicalLowDate = lowestTimestamp ? new Date(lowestTimestamp).toISOString().slice(0, 10) : null;
-  const currentMatchesHistoricalLow = currentAmount !== void 0 && lowestAmount !== void 0 && currentAmount <= lowestAmount;
-  const item = {
-    type: target.type,
-    id: target.id,
-    historicalLowPrice: getNestedValue(lowest, "price"),
-    historicalLowDate,
-    currentLowestPrice: getNestedValue(current, "price"),
-    currentIsHistoricalLow: currentMatchesHistoricalLow,
-    current,
-    historicalLow: lowest,
-    bundledCount: bundled,
-    urls,
-    source: {
-      name: "Augmented Steam",
-      endpoint: AUGMENTED_STEAM_PRICES_ENDPOINT
-    }
-  };
+  });
+  const hidden = checklist.filter(
+    (achievement) => toBoolean(achievement.hidden) === true
+  );
+  const withPercent = checklist.filter(
+    (achievement) => toNumber(achievement.globalPercent) !== void 0
+  );
+  const sortedByRarity = [...withPercent].sort(
+    (left, right) => (toNumber(left.globalPercent) ?? Number.POSITIVE_INFINITY) - (toNumber(right.globalPercent) ?? Number.POSITIVE_INFINITY)
+  );
+  const sortedByCommonness = [...sortedByRarity].reverse();
+  const averageUnlockRate = withPercent.length > 0 ? roundTo(
+    withPercent.reduce(
+      (sum, achievement) => sum + (toNumber(achievement.globalPercent) ?? 0),
+      0
+    ) / withPercent.length,
+    2
+  ) : null;
   return {
-    ok: true,
+    ok: overview.ok,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    target: buildPriceToolTarget(target),
+    target: {
+      app
+    },
     summary: {
-      type: target.type,
-      country,
-      source: "augmentedsteam",
-      requestedShopIds: shopIds,
-      hasCurrentPrice: current !== null,
-      hasHistoricalLow: lowest !== null,
-      historicalLowPrice: getNestedValue(lowest, "price"),
-      historicalLowDate,
-      currentLowestPrice: getNestedValue(current, "price"),
-      currentMatchesHistoricalLow,
-      currentIsHistoricalLow: currentMatchesHistoricalLow,
-      currentDiscountPercent: toNumber(current?.cut) ?? null,
-      historicalLowDiscountPercent: toNumber(lowest?.cut) ?? null,
-      bundledCount: bundled
+      source: "official_achievements+steam_guides",
+      totalAchievements: checklist.length,
+      hiddenCount: hidden.length,
+      visibleCount: checklist.length - hidden.length,
+      achievementsWithGuideEvidence: achievementEvidence.length,
+      guideCount: validGuides.length,
+      guideFactCount: guideFacts.length,
+      missableCount: guideFacts.filter((fact) => fact.category === "missable").length,
+      coOpCount: guideFacts.filter((fact) => fact.category === "co_op").length,
+      difficultyCount: guideFacts.filter((fact) => fact.category === "difficulty").length,
+      setupCount: guideFacts.filter((fact) => fact.category === "setup").length,
+      cleanupCount: guideFacts.filter((fact) => fact.category === "cleanup").length,
+      averageUnlockRate,
+      schemaEnriched: toBoolean(overviewSummary?.schemaEnriched) ?? false
     },
-    items: [item],
+    items: checklist,
     sections: {
-      provider: {
-        name: "Augmented Steam",
-        endpoint: AUGMENTED_STEAM_PRICES_ENDPOINT,
-        requestedShopIds: shopIds,
-        steamOnly: shopIds.length === 1 && shopIds[0] === 61
-      },
-      links: urls
+      rarest: sortedByRarity.slice(0, input.topCount),
+      mostCommon: sortedByCommonness.slice(0, input.topCount),
+      hidden,
+      guideFacts,
+      achievementEvidence,
+      guideFactCounts: buildGuideFactCounts(guideFacts),
+      rarityBands: buildRarityBandCounts(checklist),
+      sources: validGuides.map((guide) => ({
+        ...guide.metadata,
+        mentionCount: guide.mentions.length,
+        factCount: guide.facts.length,
+        score: guide.score
+      }))
     },
     warnings
   };
 }
-async function resolvePriceTarget(runtime2, input) {
-  const appid = normalizeScalarInput(input.appid);
-  const subid = normalizeScalarInput(input.subid);
-  const bundleid = normalizeScalarInput(input.bundleid);
-  const query = normalizeScalarInput(input.query);
-  const explicitTargets = [appid, subid, bundleid].filter(Boolean);
-  if (explicitTargets.length > 1) {
-    throw new Error("Provide only one of appid, subid, or bundleid.");
-  }
-  if ((subid || bundleid) && query) {
-    throw new Error("query can only be used with app targets. Use subid or bundleid directly.");
+async function loadGuideCandidates(runtime2, indexUrls, maxGuides, warnings) {
+  const indexPages = await Promise.all(
+    indexUrls.map(async (url) => {
+      try {
+        return {
+          url,
+          html: await fetchSteamCommunityHtml(url, runtime2.config.timeoutMs)
+        };
+      } catch (error) {
+        warnings.push(
+          `Steam Guides index fetch failed for ${url}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return null;
+      }
+    })
+  );
+  const candidateMap = /* @__PURE__ */ new Map();
+  for (const page of indexPages) {
+    if (!page) {
+      continue;
+    }
+    for (const candidate of parseGuideCandidates(page.html)) {
+      const existing = candidateMap.get(candidate.guideId);
+      if (!existing || candidate.score > existing.score) {
+        candidateMap.set(candidate.guideId, candidate);
+      }
+    }
   }
-  if (subid) {
-    return {
-      type: "sub",
-      id: subid,
-      resolvedFrom: "subid",
-      warnings: []
-    };
-  }
-  if (bundleid) {
-    return {
-      type: "bundle",
-      id: bundleid,
-      resolvedFrom: "bundleid",
-      warnings: []
-    };
-  }
-  if (!appid && !query) {
-    throw new Error("steam_get_price_overview requires appid, subid, bundleid, or query.");
-  }
-  const resolved = await runtime2.resolveAppSelection({
-    toolName: input.toolName,
-    appid,
-    query,
-    key: input.key,
-    limit: 5,
-    forceRefresh: false,
-    locale: input.language,
-    preferLocalizedName: Boolean(query) || Boolean(input.language)
-  });
-  return {
-    type: "app",
-    id: resolved.appid,
-    resolvedFrom: query ? "query" : "appid",
-    query,
-    appTarget: resolved.target,
-    warnings: resolved.warnings
-  };
-}
-async function fetchAugmentedSteamPrices(runtime2, body) {
-  const response = await fetchWithProxy(AUGMENTED_STEAM_PRICES_ENDPOINT, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      "content-type": "application/json",
-      "user-agent": "steam-tools-mcp/0.2.0"
-    },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(runtime2.config.timeoutMs)
-  });
-  const text = await response.text();
-  if (!response.ok) {
-    throw new Error(
-      `Augmented Steam prices request failed with ${response.status} ${response.statusText}.`
-    );
-  }
-  try {
-    return JSON.parse(text);
-  } catch (error) {
-    throw new Error(
-      `Augmented Steam prices response was not valid JSON: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-function normalizePriceNode(value) {
-  if (!value) {
-    return null;
-  }
-  return {
-    shop: normalizeShop(asRecord(value.shop)),
-    price: normalizeMoney(asRecord(value.price)),
-    regular: normalizeMoney(asRecord(value.regular)),
-    cut: toNumber(value.cut),
-    voucher: value.voucher ?? null,
-    flag: value.flag ?? null,
-    drm: Array.isArray(value.drm) ? value.drm : [],
-    platforms: Array.isArray(value.platforms) ? value.platforms.map((entry) => normalizePlatform(asRecord(entry))).filter((entry) => Boolean(entry)) : [],
-    timestamp: getStringValue(value.timestamp),
-    expiry: getStringValue(value.expiry),
-    url: getStringValue(value.url)
-  };
-}
-function normalizePriceUrls(value) {
-  if (!value) {
-    return null;
-  }
-  return {
-    info: getStringValue(value.info),
-    history: getStringValue(value.history),
-    bundles: getStringValue(value.bundles)
-  };
-}
-function normalizeShop(value) {
-  if (!value) {
-    return null;
-  }
-  return {
-    id: toNumber(value.id),
-    name: getStringValue(value.name)
-  };
-}
-function normalizePlatform(value) {
-  if (!value) {
-    return null;
-  }
-  return {
-    id: toNumber(value.id),
-    name: getStringValue(value.name)
-  };
-}
-function normalizeMoney(value) {
-  if (!value) {
-    return null;
-  }
-  return {
-    amount: toNumber(value.amount),
-    amountInt: toNumber(value.amountInt),
-    currency: getStringValue(value.currency)
-  };
-}
-function parseShopIds(value) {
-  if (value === void 0) {
-    return DEFAULT_SHOP_IDS;
-  }
-  const values = Array.isArray(value) ? value : [value];
-  const shopIds = [...new Set(
-    values.flatMap(
-      (entry) => typeof entry === "string" ? entry.split(/[,\s]+/) : [String(entry)]
-    ).map((entry) => normalizeScalarInput(entry)).map((entry) => entry ? Number.parseInt(entry, 10) : Number.NaN).filter((entry) => Number.isFinite(entry) && entry > 0)
-  )];
-  return shopIds.length > 0 ? shopIds : DEFAULT_SHOP_IDS;
-}
-function normalizeCountryCode(value) {
-  const normalized = value.trim().toLowerCase();
-  if (!/^[a-z]{2}$/.test(normalized)) {
-    throw new Error("country must be a two-letter ISO 3166-1 country code, such as 'cn' or 'us'.");
-  }
-  return normalized;
-}
-function buildPriceToolTarget(target) {
-  return {
-    subject: {
-      type: target.type,
-      id: target.id,
-      resolvedFrom: target.resolvedFrom,
-      query: target.query
-    },
-    ...target.appTarget ? { app: target.appTarget } : {}
-  };
-}
-function parseNumericId(value, fieldName) {
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new Error(`${fieldName} must be a positive integer.`);
-  }
-  return parsed;
-}
-
-// src/services/roadmap.ts
-import { load as load2 } from "cheerio";
-var STEAM_GUIDE_KEYWORDS = [
-  "achievement",
-  "100%",
-  "all achievements",
-  "roadmap",
-  "walkthrough",
-  "missable",
-  "coop",
-  "co-op"
-];
-var PHASE_ORDER = [
-  "preparation",
-  "main_story",
-  "co_op",
-  "challenge",
-  "cleanup"
-];
-var PHASE_TITLES = {
-  preparation: "Before You Start",
-  main_story: "Main Story Progress",
-  co_op: "Co-op / Multiplayer",
-  challenge: "Harder Or Rarer Targets",
-  cleanup: "Cleanup"
-};
-function isPresent(value) {
-  return value !== null && value !== void 0;
-}
-async function buildAchievementRoadmapData(runtime2, input) {
-  const resolved = await runtime2.resolveAppSelection({
-    toolName: input.toolName,
-    appid: input.appid,
-    query: input.query,
-    key: input.key,
-    limit: 5,
-    forceRefresh: false,
-    locale: input.language,
-    preferLocalizedName: Boolean(input.query) || Boolean(input.language)
-  });
-  const achievementOverview = await buildGlobalAchievementOverviewData(runtime2, {
-    toolName: input.toolName,
-    appid: resolved.appid,
-    key: input.key,
-    language: input.language,
-    includeSchemaDetails: true,
-    topCount: 10
-  });
-  const achievementItems = getRecordItems(getNestedValue(achievementOverview, "items"));
-  const achievementMap = buildAchievementMap(achievementItems);
-  const warnings = [...resolved.warnings, ...getWarnings(achievementOverview)];
-  const indexUrls = buildSteamGuideIndexUrls(resolved.appid);
-  const indexPages = await Promise.all(
-    indexUrls.map(async (url) => {
-      try {
-        return {
-          url,
-          html: await fetchSteamCommunityHtml(url, runtime2.config.timeoutMs)
-        };
-      } catch (error) {
-        warnings.push(
-          `Steam Guides index fetch failed for ${url}: ${error instanceof Error ? error.message : String(error)}`
-        );
-        return null;
-      }
-    })
-  );
-  const candidateMap = /* @__PURE__ */ new Map();
-  for (const page of indexPages) {
-    if (!page) {
-      continue;
-    }
-    for (const candidate of parseGuideCandidates(page.html)) {
-      const existing = candidateMap.get(candidate.guideId);
-      if (!existing || candidate.score > existing.score) {
-        candidateMap.set(candidate.guideId, candidate);
-      }
-    }
-  }
-  const selectedGuides = [...candidateMap.values()].sort((left, right) => right.score - left.score).slice(0, input.maxGuides);
-  if (selectedGuides.length === 0) {
-    return {
-      ok: false,
-      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      target: {
-        app: resolved.target
-      },
-      summary: {
-        source: "steam_guides",
-        guideCount: 0,
-        routePhaseCount: 0,
-        missableCount: 0
-      },
-      items: [],
-      sections: {
-        sources: [],
-        missables: [],
-        achievementNotes: []
-      },
-      note: "No Steam Guides candidates were found for this game.",
-      warnings
-    };
-  }
-  const guideAnalyses = await Promise.all(
-    selectedGuides.map(async (guide) => {
-      try {
-        const html = await fetchSteamCommunityHtml(guide.url, runtime2.config.timeoutMs);
-        return analyzeGuidePage(html, guide, achievementMap);
-      } catch (error) {
-        warnings.push(
-          `Steam Guide fetch failed for ${guide.url}: ${error instanceof Error ? error.message : String(error)}`
-        );
-        return null;
-      }
-    })
-  );
-  const validGuides = guideAnalyses.filter(
-    (guide) => Boolean(guide)
-  );
-  const routePhases = buildRoutePhases(validGuides, achievementMap);
-  const missables = dedupeAttentionItems(
-    validGuides.flatMap(
-      (guide) => guide.attention.filter((item) => item.category === "missable")
-    )
-  );
-  const achievementNotes = buildAchievementNotes(validGuides, input.maxAchievementNotes);
-  const guideSummary = buildGuideSummary(validGuides, routePhases, missables);
-  return {
-    ok: true,
-    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    target: {
-      app: resolved.target
-    },
-    summary: {
-      source: "steam_guides",
-      guideCount: validGuides.length,
-      routePhaseCount: routePhases.length,
-      missableCount: missables.length,
-      achievementNoteCount: achievementNotes.length,
-      supportedByOfficialAchievements: achievementMap.length > 0
-    },
-    items: routePhases,
-    sections: {
-      guideSummary,
-      sources: validGuides.map((guide) => ({
-        ...guide.metadata,
-        mentionCount: guide.mentions.length,
-        attentionCount: guide.attention.length,
-        score: guide.score
-      })),
-      missables,
-      achievementNotes,
-      officialAchievements: {
-        totalCount: achievementMap.length,
-        rarest: getNestedValue(achievementOverview, "sections", "rarest")
-      }
-    },
-    warnings
-  };
-}
-function buildSteamGuideIndexUrls(appid) {
-  return [
-    `https://steamcommunity.com/app/${appid}/guides/?l=english`,
-    `https://steamcommunity.com/app/${appid}/guides/?l=english&searchText=achievement`,
-    `https://steamcommunity.com/app/${appid}/guides/?l=english&searchText=100%25`
-  ];
-}
-async function fetchSteamCommunityHtml(url, timeoutMs) {
-  const response = await fetchWithProxy(url, {
-    headers: {
-      accept: "text/html,application/xhtml+xml",
-      "accept-language": "en-US,en;q=0.9",
-      "user-agent": "steam-tools-mcp/0.2.0"
-    },
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status} ${response.statusText}`);
+  return [...candidateMap.values()].sort((left, right) => right.score - left.score).slice(0, maxGuides);
+}
+function buildSteamGuideIndexUrls(appid) {
+  return [
+    `https://steamcommunity.com/app/${appid}/guides/?l=english`,
+    `https://steamcommunity.com/app/${appid}/guides/?l=english&searchText=achievement`,
+    `https://steamcommunity.com/app/${appid}/guides/?l=english&searchText=100%25`
+  ];
+}
+async function fetchSteamCommunityHtml(url, timeoutMs) {
+  const response = await fetchWithProxy(url, {
+    headers: {
+      accept: "text/html,application/xhtml+xml",
+      "accept-language": "en-US,en;q=0.9",
+      "user-agent": PACKAGE_USER_AGENT
+    },
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText}`);
   }
   return response.text();
 }
@@ -37510,9 +37472,6 @@ function scoreGuideCandidate(title, snippet) {
   if (haystack.includes("definitive")) {
     score += 8;
   }
-  if (haystack.includes("guide")) {
-    score += 6;
-  }
   return score;
 }
 function analyzeGuidePage(html, candidate, achievementMap) {
@@ -37520,54 +37479,46 @@ function analyzeGuidePage(html, candidate, achievementMap) {
   $("script, style, noscript").remove();
   $("br").replaceWith("\n");
   const lines = $.root().text().split(/\n+/).map((line) => cleanText(line)).filter((line) => line.length > 0);
-  const metadata = extractGuideMetadata(lines, candidate);
+  const metadata2 = extractGuideMetadata(lines, candidate);
   const mentions = [];
-  const attention = [];
-  let currentPhase = "preparation";
+  const facts = [];
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index];
-    const phaseFromLine = detectPhaseKey(line);
-    if (phaseFromLine) {
-      currentPhase = phaseFromLine;
-    }
     const matchedAchievements = findAchievementsInLine(line, achievementMap);
     for (const achievement of matchedAchievements) {
       mentions.push({
         achievementName: achievement.name,
         globalPercent: achievement.globalPercent,
         snippet: buildSnippet(lines, index),
-        phaseKey: currentPhase,
         source: {
-          guideId: metadata.guideId,
-          title: metadata.title,
-          url: metadata.url
+          guideId: metadata2.guideId,
+          title: metadata2.title,
+          url: metadata2.url
         }
       });
     }
-    const attentionCategory = classifyAttentionCategory(line);
-    if (!attentionCategory) {
+    const category = classifyGuideFactCategory(line);
+    if (!category) {
       continue;
     }
-    attention.push({
-      category: attentionCategory,
+    facts.push({
+      category,
       text: line,
-      phaseKey: attentionCategory === "cleanup" ? "cleanup" : currentPhase,
       source: {
-        guideId: metadata.guideId,
-        title: metadata.title,
-        url: metadata.url
+        guideId: metadata2.guideId,
+        title: metadata2.title,
+        url: metadata2.url
       },
-      relatedAchievements: matchedAchievements.map((achievement) => achievement.name),
-      confidence: matchedAchievements.length > 0 || attentionCategory === "missable" ? "high" : "medium"
+      relatedAchievements: matchedAchievements.map((achievement) => achievement.name)
     });
   }
   const uniqueMentions = dedupeMentions(mentions);
+  const uniqueFacts = dedupeGuideFacts(facts);
   return {
-    metadata,
+    metadata: metadata2,
     mentions: uniqueMentions,
-    attention: dedupeAttentionItems(attention),
-    lines,
-    score: candidate.score + uniqueMentions.length * 2 + attention.length
+    facts: uniqueFacts,
+    score: candidate.score + uniqueMentions.length * 2 + uniqueFacts.length
   };
 }
 function extractGuideMetadata(lines, candidate) {
@@ -37628,289 +37579,425 @@ function findAchievementsInLine(line, achievementMap) {
     return tokens.length >= 2 && tokens.every((token) => normalizedLine.includes(token));
   });
 }
-function buildRoutePhases(guides, achievementMap) {
-  const assignedAchievements = /* @__PURE__ */ new Set();
-  const phases = /* @__PURE__ */ new Map();
-  for (const phaseKey of PHASE_ORDER) {
-    phases.set(phaseKey, {
-      notes: [],
-      achievements: [],
-      sources: []
-    });
+function classifyGuideFactCategory(line) {
+  const normalized = normalizeSearchText(line);
+  if (!normalized || normalized.length < 12) {
+    return null;
+  }
+  if (/missable|do not miss|dont miss|don't miss|before finishing|before ending|last chance|point of no return|cannot go back/.test(
+    normalized
+  )) {
+    return "missable";
+  }
+  if (/co op|coop|multiplayer|friend|partner|another player|online/.test(normalized)) {
+    return "co_op";
   }
+  if (/hard|hardest|rarest|practice|difficult|challenge/.test(normalized)) {
+    return "difficulty";
+  }
+  if (/cleanup|replay|chapter select|post game|remaining/.test(normalized)) {
+    return "cleanup";
+  }
+  if (/setup|console|bind|command|config|save file|backup/.test(normalized)) {
+    return "setup";
+  }
+  if (/warning|important|note/.test(normalized)) {
+    return "warning";
+  }
+  return null;
+}
+function buildSnippet(lines, index) {
+  return lines.slice(Math.max(0, index - 1), Math.min(lines.length, index + 2)).join(" ").slice(0, 320);
+}
+function buildAchievementMap(items) {
+  return items.map((item) => {
+    const name = getStringValue(item.displayName) ?? getStringValue(item.apiName) ?? void 0;
+    if (!name) {
+      return null;
+    }
+    return {
+      apiName: getStringValue(item.apiName),
+      name,
+      normalizedName: normalizeSearchText(name),
+      globalPercent: toNumber(item.globalPercent)
+    };
+  }).filter(isPresent);
+}
+function buildAchievementEvidence(guides, maxEvidencePerAchievement) {
+  const evidenceByAchievement = /* @__PURE__ */ new Map();
   for (const guide of guides) {
     for (const mention of guide.mentions) {
-      const phase = phases.get(mention.phaseKey);
-      if (!phase || assignedAchievements.has(mention.achievementName)) {
-        continue;
-      }
-      phase.achievements.push({
-        achievement: mention.achievementName,
-        globalPercent: mention.globalPercent ?? null,
-        sourceGuideTitle: mention.source.title,
-        sourceGuideUrl: mention.source.url,
-        evidence: mention.snippet
-      });
-      phase.sources.push(mention.source.title);
-      assignedAchievements.add(mention.achievementName);
+      const existing = evidenceByAchievement.get(mention.achievementName) ?? {
+        globalPercent: mention.globalPercent,
+        snippets: [],
+        sources: []
+      };
+      existing.globalPercent = existing.globalPercent ?? mention.globalPercent;
+      existing.snippets.push(mention.snippet);
+      existing.sources.push(mention.source.title);
+      evidenceByAchievement.set(mention.achievementName, existing);
     }
-    for (const item of guide.attention) {
-      const phase = phases.get(item.phaseKey);
-      if (!phase) {
-        continue;
-      }
-      phase.notes.push(item.text);
-      phase.sources.push(item.source.title);
+  }
+  return [...evidenceByAchievement.entries()].map(([achievement, evidence]) => ({
+    achievement,
+    globalPercent: evidence.globalPercent ?? null,
+    evidenceCount: uniqueStrings(evidence.snippets).length,
+    evidence: uniqueStrings(evidence.snippets).slice(0, maxEvidencePerAchievement),
+    sources: uniqueStrings(evidence.sources)
+  })).sort(
+    (left, right) => (toNumber(left.globalPercent) ?? Number.POSITIVE_INFINITY) - (toNumber(right.globalPercent) ?? Number.POSITIVE_INFINITY)
+  );
+}
+function buildGuideFactCounts(facts) {
+  const categories = [
+    "missable",
+    "co_op",
+    "difficulty",
+    "cleanup",
+    "setup",
+    "warning"
+  ];
+  return categories.map((category) => ({
+    category,
+    count: facts.filter((fact) => fact.category === category).length
+  }));
+}
+function dedupeMentions(mentions) {
+  const seen = /* @__PURE__ */ new Set();
+  return mentions.filter((mention) => {
+    const key = `${mention.achievementName}:${normalizeSearchText(mention.snippet)}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function dedupeGuideFacts(facts) {
+  const seen = /* @__PURE__ */ new Set();
+  return facts.filter((fact) => {
+    const key = `${fact.category}:${normalizeSearchText(fact.text)}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function buildRarityBandCounts(checklist) {
+  return [
+    ...RARITY_BANDS.map((band) => ({
+      key: band.key,
+      label: band.label,
+      minPercent: band.minPercent,
+      maxPercent: Number.isFinite(band.maxPercent) ? band.maxPercent : null,
+      count: checklist.filter(
+        (achievement) => achievement.rarityBand === band.key
+      ).length
+    })),
+    {
+      key: "unknown",
+      label: "Unknown",
+      minPercent: null,
+      maxPercent: null,
+      count: checklist.filter(
+        (achievement) => achievement.rarityBand === "unknown"
+      ).length
+    }
+  ];
+}
+function classifyRarityBand(globalPercent) {
+  if (globalPercent === void 0) {
+    return "unknown";
+  }
+  for (const band of RARITY_BANDS) {
+    if (globalPercent >= band.minPercent && globalPercent < band.maxPercent) {
+      return band.key;
     }
   }
-  const cleanupPhase = phases.get("cleanup");
-  const remainingAchievements = achievementMap.filter(
-    (achievement) => !assignedAchievements.has(achievement.name)
-  );
-  if (cleanupPhase) {
-    for (const achievement of remainingAchievements) {
-      cleanupPhase.achievements.push({
-        achievement: achievement.name,
-        globalPercent: achievement.globalPercent ?? null,
-        sourceGuideTitle: null,
-        sourceGuideUrl: null,
-        evidence: "Not explicitly placed in the selected Steam Guides, so it is left for cleanup."
-      });
-    }
+  return "unknown";
+}
+function parseCount(line) {
+  const match = line.match(/(\d[\d,]*)/);
+  if (!match) {
+    return void 0;
+  }
+  return Number.parseInt(match[1].replace(/,/g, ""), 10);
+}
+function extractGuideId(url) {
+  try {
+    const parsed = new URL(url);
+    const guideId = parsed.searchParams.get("id");
+    return guideId ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getRecordItems(value) {
+  return Array.isArray(value) ? value.map((entry) => asRecord(entry)).filter((entry) => Boolean(entry)) : [];
+}
+function cleanText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+// src/services/prices.ts
+var AUGMENTED_STEAM_PRICES_ENDPOINT = "https://api.augmentedsteam.com/prices/v2";
+var DEFAULT_SHOP_IDS = [61];
+async function buildPriceOverviewData(runtime2, input) {
+  const target = await resolvePriceTarget(runtime2, input);
+  const country = normalizeCountryCode(input.country);
+  const shopIds = parseShopIds(input.shops);
+  const payload = await fetchAugmentedSteamPrices(runtime2, {
+    country,
+    apps: target.type === "app" ? [parseNumericId(target.id, "appid")] : [],
+    subs: target.type === "sub" ? [parseNumericId(target.id, "subid")] : [],
+    bundles: target.type === "bundle" ? [parseNumericId(target.id, "bundleid")] : [],
+    voucher: input.includeVoucher,
+    shops: shopIds
+  });
+  const priceRecord = asRecord(getNestedValue(payload, "prices", `${target.type}/${target.id}`));
+  const warnings = [...target.warnings];
+  if (!priceRecord) {
+    return {
+      ok: false,
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      target: buildPriceToolTarget(target),
+      summary: {
+        type: target.type,
+        country,
+        source: "augmentedsteam",
+        requestedShopIds: shopIds
+      },
+      items: [],
+      note: `No price data was returned for ${target.type}/${target.id} in country '${country}'.`,
+      warnings
+    };
+  }
+  const current = normalizePriceNode(asRecord(priceRecord.current));
+  const lowest = normalizePriceNode(asRecord(priceRecord.lowest));
+  const urls = normalizePriceUrls(asRecord(priceRecord.urls));
+  const bundled = toNumber(priceRecord.bundled) ?? 0;
+  const currentAmount = toNumber(getNestedValue(current, "price", "amount"));
+  const lowestAmount = toNumber(getNestedValue(lowest, "price", "amount"));
+  const lowestTimestamp = getStringValue(lowest?.timestamp);
+  const historicalLowDate = lowestTimestamp ? new Date(lowestTimestamp).toISOString().slice(0, 10) : null;
+  const currentMatchesHistoricalLow = currentAmount !== void 0 && lowestAmount !== void 0 && currentAmount <= lowestAmount;
+  const item = {
+    type: target.type,
+    id: target.id,
+    historicalLowPrice: getNestedValue(lowest, "price"),
+    historicalLowDate,
+    currentLowestPrice: getNestedValue(current, "price"),
+    currentIsHistoricalLow: currentMatchesHistoricalLow,
+    current,
+    historicalLow: lowest,
+    bundledCount: bundled,
+    urls,
+    source: {
+      name: "Augmented Steam",
+      endpoint: AUGMENTED_STEAM_PRICES_ENDPOINT
+    }
+  };
+  return {
+    ok: true,
+    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    target: buildPriceToolTarget(target),
+    summary: {
+      type: target.type,
+      country,
+      source: "augmentedsteam",
+      requestedShopIds: shopIds,
+      hasCurrentPrice: current !== null,
+      hasHistoricalLow: lowest !== null,
+      historicalLowPrice: getNestedValue(lowest, "price"),
+      historicalLowDate,
+      currentLowestPrice: getNestedValue(current, "price"),
+      currentMatchesHistoricalLow,
+      currentIsHistoricalLow: currentMatchesHistoricalLow,
+      currentDiscountPercent: toNumber(current?.cut) ?? null,
+      historicalLowDiscountPercent: toNumber(lowest?.cut) ?? null,
+      bundledCount: bundled
+    },
+    items: [item],
+    sections: {
+      provider: {
+        name: "Augmented Steam",
+        endpoint: AUGMENTED_STEAM_PRICES_ENDPOINT,
+        requestedShopIds: shopIds,
+        steamOnly: shopIds.length === 1 && shopIds[0] === 61
+      },
+      links: urls
+    },
+    warnings
+  };
+}
+async function resolvePriceTarget(runtime2, input) {
+  const appid = normalizeScalarInput(input.appid);
+  const subid = normalizeScalarInput(input.subid);
+  const bundleid = normalizeScalarInput(input.bundleid);
+  const query = normalizeScalarInput(input.query);
+  const explicitTargets = [appid, subid, bundleid].filter(Boolean);
+  if (explicitTargets.length > 1) {
+    throw new Error("Provide only one of appid, subid, or bundleid.");
+  }
+  if ((subid || bundleid) && query) {
+    throw new Error("query can only be used with app targets. Use subid or bundleid directly.");
   }
-  return PHASE_ORDER.map((phaseKey, index) => {
-    const phase = phases.get(phaseKey);
-    if (!phase) {
-      return null;
-    }
-    const notes = uniqueStrings(phase.notes).slice(0, 6);
-    const achievements = phase.achievements;
-    if (notes.length === 0 && achievements.length === 0) {
-      return null;
-    }
+  if (subid) {
     return {
-      phase: index + 1,
-      key: phaseKey,
-      title: PHASE_TITLES[phaseKey],
-      summary: buildPhaseSummary(phaseKey, achievements.length, notes.length),
-      achievements,
-      notes,
-      sources: uniqueStrings(phase.sources)
+      type: "sub",
+      id: subid,
+      resolvedFrom: "subid",
+      warnings: []
     };
-  }).filter(isPresent);
-}
-function buildAchievementNotes(guides, maxAchievementNotes) {
-  const byAchievement = /* @__PURE__ */ new Map();
-  for (const guide of guides) {
-    for (const mention of guide.mentions) {
-      const existing = byAchievement.get(mention.achievementName) ?? {
-        snippets: [],
-        phaseKeys: [],
-        sources: [],
-        globalPercent: mention.globalPercent
-      };
-      existing.snippets.push(mention.snippet);
-      existing.phaseKeys.push(mention.phaseKey);
-      existing.sources.push(mention.source.title);
-      existing.globalPercent = existing.globalPercent ?? mention.globalPercent;
-      byAchievement.set(mention.achievementName, existing);
-    }
-  }
-  return [...byAchievement.entries()].map(([achievement, value]) => ({
-    achievement,
-    suggestedPhase: mostCommon(value.phaseKeys),
-    globalPercent: value.globalPercent ?? null,
-    evidence: uniqueStrings(value.snippets).slice(0, 2),
-    sources: uniqueStrings(value.sources)
-  })).sort((left, right) => {
-    const leftGlobal = toNumber(left.globalPercent) ?? -1;
-    const rightGlobal = toNumber(right.globalPercent) ?? -1;
-    return rightGlobal - leftGlobal;
-  }).slice(0, maxAchievementNotes);
-}
-function buildGuideSummary(guides, routePhases, missables) {
-  const coOpSignals = guides.flatMap(
-    (guide) => guide.attention.filter((item) => item.category === "co_op")
-  );
-  const difficultySignals = guides.flatMap(
-    (guide) => guide.attention.filter((item) => item.category === "difficulty")
-  );
-  const cleanupSignals = guides.flatMap(
-    (guide) => guide.attention.filter((item) => item.category === "cleanup")
-  );
-  const digest = [];
-  if (coOpSignals.length > 0) {
-    digest.push({
-      topic: "co_op",
-      summary: "Selected Steam Guides indicate that some achievements require co-op, multiplayer, or another player.",
-      evidenceCount: coOpSignals.length,
-      sources: uniqueStrings(coOpSignals.map((item) => item.source.title))
-    });
-  }
-  if (difficultySignals.length > 0) {
-    digest.push({
-      topic: "difficulty",
-      summary: "Selected Steam Guides call out harder or rarer targets that may need extra practice, planning, or setup.",
-      evidenceCount: difficultySignals.length,
-      sources: uniqueStrings(difficultySignals.map((item) => item.source.title))
-    });
   }
-  if (cleanupSignals.length > 0 || routePhases.some((phase) => phase.key === "cleanup")) {
-    digest.push({
-      topic: "cleanup",
-      summary: "The roadmap keeps a final cleanup phase for anything not clearly placed into story or co-op progression.",
-      evidenceCount: cleanupSignals.length,
-      sources: uniqueStrings(cleanupSignals.map((item) => item.source.title))
-    });
+  if (bundleid) {
+    return {
+      type: "bundle",
+      id: bundleid,
+      resolvedFrom: "bundleid",
+      warnings: []
+    };
   }
-  if (missables.length > 0) {
-    digest.push({
-      topic: "missables",
-      summary: "The selected Steam Guides contain explicit missable or timing-sensitive warnings.",
-      evidenceCount: missables.length,
-      sources: uniqueStrings(missables.map((item) => item.source.title))
-    });
+  if (!appid && !query) {
+    throw new Error("steam_get_price_overview requires appid, subid, bundleid, or query.");
   }
-  return digest;
-}
-function dedupeMentions(mentions) {
-  const seen = /* @__PURE__ */ new Set();
-  return mentions.filter((mention) => {
-    const key = `${mention.achievementName}:${mention.phaseKey}:${normalizeSearchText(mention.snippet)}`;
-    if (seen.has(key)) {
-      return false;
-    }
-    seen.add(key);
-    return true;
+  const resolved = await runtime2.resolveAppSelection({
+    toolName: input.toolName,
+    appid,
+    query,
+    key: input.key,
+    limit: 5,
+    forceRefresh: false,
+    locale: input.language,
+    preferLocalizedName: Boolean(query) || Boolean(input.language)
   });
+  return {
+    type: "app",
+    id: resolved.appid,
+    resolvedFrom: query ? "query" : "appid",
+    query,
+    appTarget: resolved.target,
+    warnings: resolved.warnings
+  };
 }
-function dedupeAttentionItems(items) {
-  const seen = /* @__PURE__ */ new Set();
-  return items.filter((item) => {
-    const key = `${item.category}:${normalizeSearchText(item.text)}`;
-    if (seen.has(key)) {
-      return false;
-    }
-    seen.add(key);
-    return true;
+async function fetchAugmentedSteamPrices(runtime2, body) {
+  const response = await fetchWithProxy(AUGMENTED_STEAM_PRICES_ENDPOINT, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json",
+      "user-agent": PACKAGE_USER_AGENT
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(runtime2.config.timeoutMs)
   });
-}
-function detectPhaseKey(line) {
-  const normalized = normalizeSearchText(line);
-  if (!normalized) {
-    return null;
-  }
-  if (normalized.includes("before you start") || normalized === "overview" || normalized === "notes" || normalized.includes("setup")) {
-    return "preparation";
-  }
-  if (normalized.includes("singleplayer") || normalized.includes("campaign") || normalized.includes("main story") || normalized.includes("story")) {
-    return "main_story";
-  }
-  if (normalized.includes("co op") || normalized.includes("coop") || normalized.includes("multiplayer")) {
-    return "co_op";
-  }
-  if (normalized.includes("challenge") || normalized.includes("hard") || normalized.includes("rarest")) {
-    return "challenge";
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(
+      `Augmented Steam prices request failed with ${response.status} ${response.statusText}.`
+    );
   }
-  if (normalized.includes("cleanup") || normalized.includes("remaining") || normalized.includes("post game")) {
-    return "cleanup";
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(
+      `Augmented Steam prices response was not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
-  return null;
 }
-function classifyAttentionCategory(line) {
-  const normalized = normalizeSearchText(line);
-  if (!normalized || normalized.length < 12) {
+function normalizePriceNode(value) {
+  if (!value) {
     return null;
   }
-  if (/missable|do not miss|dont miss|don't miss|before finishing|before ending|last chance|point of no return|cannot go back/.test(
-    normalized
-  )) {
-    return "missable";
-  }
-  if (/co op|coop|multiplayer|friend|partner|another player|online/.test(normalized)) {
-    return "co_op";
-  }
-  if (/hard|hardest|rarest|practice|difficult|challenge/.test(normalized)) {
-    return "difficulty";
-  }
-  if (/cleanup|replay|chapter select|post game|remaining/.test(normalized)) {
-    return "cleanup";
-  }
-  if (/setup|console|bind|command|config|save file|backup/.test(normalized)) {
-    return "setup";
-  }
-  if (/warning|important|note/.test(normalized)) {
-    return "warning";
-  }
-  return null;
-}
-function buildSnippet(lines, index) {
-  return lines.slice(Math.max(0, index - 1), Math.min(lines.length, index + 2)).join(" ").slice(0, 320);
-}
-function buildAchievementMap(items) {
-  return items.map((item) => {
-    const name = getStringValue(item.displayName) ?? getStringValue(item.apiName) ?? void 0;
-    if (!name) {
-      return null;
-    }
-    return {
-      name,
-      normalizedName: normalizeSearchText(name),
-      globalPercent: toNumber(item.globalPercent)
-    };
-  }).filter(isPresent);
+  return {
+    shop: normalizeShop(asRecord(value.shop)),
+    price: normalizeMoney(asRecord(value.price)),
+    regular: normalizeMoney(asRecord(value.regular)),
+    cut: toNumber(value.cut),
+    voucher: value.voucher ?? null,
+    flag: value.flag ?? null,
+    drm: Array.isArray(value.drm) ? value.drm : [],
+    platforms: Array.isArray(value.platforms) ? value.platforms.map((entry) => normalizePlatform(asRecord(entry))).filter((entry) => Boolean(entry)) : [],
+    timestamp: getStringValue(value.timestamp),
+    expiry: getStringValue(value.expiry),
+    url: getStringValue(value.url)
+  };
 }
-function parseCount(line) {
-  const match = line.match(/(\d[\d,]*)/);
-  if (!match) {
-    return void 0;
+function normalizePriceUrls(value) {
+  if (!value) {
+    return null;
   }
-  return Number.parseInt(match[1].replace(/,/g, ""), 10);
+  return {
+    info: getStringValue(value.info),
+    history: getStringValue(value.history),
+    bundles: getStringValue(value.bundles)
+  };
 }
-function extractGuideId(url) {
-  try {
-    const parsed = new URL(url);
-    const guideId = parsed.searchParams.get("id");
-    return guideId ?? void 0;
-  } catch {
-    return void 0;
+function normalizeShop(value) {
+  if (!value) {
+    return null;
   }
+  return {
+    id: toNumber(value.id),
+    name: getStringValue(value.name)
+  };
 }
-function buildPhaseSummary(phaseKey, achievementCount, noteCount) {
-  switch (phaseKey) {
-    case "preparation":
-      return `Use this phase to capture setup notes and pre-run warnings before starting. (${achievementCount} named achievements, ${noteCount} notes)`;
-    case "main_story":
-      return `Prioritize the achievements the selected Steam Guides place alongside normal story or campaign progress. (${achievementCount} named achievements, ${noteCount} notes)`;
-    case "co_op":
-      return `Set aside the achievements the selected Steam Guides associate with co-op, multiplayer, or another player. (${achievementCount} named achievements, ${noteCount} notes)`;
-    case "challenge":
-      return `Leave the rarer or harder targets for a focused pass once the easier progression is done. (${achievementCount} named achievements, ${noteCount} notes)`;
-    case "cleanup":
-      return `Finish anything not clearly placed by the guides in a final cleanup pass. (${achievementCount} named achievements, ${noteCount} notes)`;
-    default:
-      return `${achievementCount} achievements and ${noteCount} notes`;
+function normalizePlatform(value) {
+  if (!value) {
+    return null;
   }
+  return {
+    id: toNumber(value.id),
+    name: getStringValue(value.name)
+  };
 }
-function mostCommon(values) {
-  if (values.length === 0) {
+function normalizeMoney(value) {
+  if (!value) {
     return null;
   }
-  const counts = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    counts.set(value, (counts.get(value) ?? 0) + 1);
+  return {
+    amount: toNumber(value.amount),
+    amountInt: toNumber(value.amountInt),
+    currency: getStringValue(value.currency)
+  };
+}
+function parseShopIds(value) {
+  if (value === void 0) {
+    return DEFAULT_SHOP_IDS;
   }
-  return [...counts.entries()].sort((left, right) => right[1] - left[1])[0]?.[0] ?? null;
+  const values = Array.isArray(value) ? value : [value];
+  const shopIds = [...new Set(
+    values.flatMap(
+      (entry) => typeof entry === "string" ? entry.split(/[,\s]+/) : [String(entry)]
+    ).map((entry) => normalizeScalarInput(entry)).map((entry) => entry ? Number.parseInt(entry, 10) : Number.NaN).filter((entry) => Number.isFinite(entry) && entry > 0)
+  )];
+  return shopIds.length > 0 ? shopIds : DEFAULT_SHOP_IDS;
 }
-function getWarnings(payload) {
-  const warnings = getNestedValue(payload, "warnings");
-  return Array.isArray(warnings) ? warnings : [];
+function normalizeCountryCode(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!/^[a-z]{2}$/.test(normalized)) {
+    throw new Error("country must be a two-letter ISO 3166-1 country code, such as 'cn' or 'us'.");
+  }
+  return normalized;
 }
-function getRecordItems(value) {
-  return Array.isArray(value) ? value.map((entry) => asRecord(entry)).filter((entry) => Boolean(entry)) : [];
+function buildPriceToolTarget(target) {
+  return {
+    subject: {
+      type: target.type,
+      id: target.id,
+      resolvedFrom: target.resolvedFrom,
+      query: target.query
+    },
+    ...target.appTarget ? { app: target.appTarget } : {}
+  };
 }
-function cleanText(value) {
-  return value.replace(/\s+/g, " ").trim();
+function parseNumericId(value, fieldName) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${fieldName} must be a positive integer.`);
+  }
+  return parsed;
 }
 
 // src/tools/register-steam-tool.ts
@@ -38064,7 +38151,7 @@ function registerAppTools(server, runtime2) {
     "steam_get_price_overview",
     {
       title: "\u4EF7\u683C\u4E0E\u53F2\u4F4E",
-      description: "\u67E5\u770B app\u3001sub \u6216 bundle \u7684\u5F53\u524D\u6700\u4F4E\u4EF7\u3001\u5386\u53F2\u6700\u4F4E\u4EF7\u3001\u53F2\u4F4E\u65E5\u671F\uFF0C\u4EE5\u53CA\u5F53\u524D\u662F\u5426\u7B49\u4E8E\u53F2\u4F4E\u3002",
+      description: "\u516C\u5171\u4EF7\u683C\u4E13\u9879\u89C6\u56FE\uFF0C\u67E5\u770B app\u3001sub \u6216 bundle \u7684\u5F53\u524D\u6700\u4F4E\u4EF7\u3001\u5386\u53F2\u6700\u4F4E\u4EF7\u3001\u53F2\u4F4E\u65E5\u671F\uFF0C\u4EE5\u53CA\u5F53\u524D\u662F\u5426\u7B49\u4E8E\u53F2\u4F4E\u3002",
       inputSchema: {
         appid: z2.union([z2.string(), z2.number()]).optional().describe("Steam AppID\u3002\u4E0E subid\u3001bundleid\u3001query \u56DB\u9009\u4E00\u3002"),
         subid: z2.union([z2.string(), z2.number()]).optional().describe("Steam Package/Sub ID\u3002\u4E0E appid\u3001bundleid\u3001query \u56DB\u9009\u4E00\u3002"),
@@ -38113,15 +38200,18 @@ function registerAppTools(server, runtime2) {
     runtime2,
     "steam_get_achievement_roadmap",
     {
-      title: "\u6210\u5C31\u8DEF\u7EBF\u56FE",
-      description: "\u4EC5\u57FA\u4E8E Steam \u6307\u5357\uFF0C\u4E3A\u67D0\u4E2A\u6E38\u620F\u751F\u6210\u5168\u6210\u5C31\u6CE8\u610F\u4E8B\u9879\u3001\u9636\u6BB5\u8DEF\u7EBF\u56FE\u548C\u6210\u5C31\u5907\u6CE8\u6458\u8981\u3002",
+      title: "\u5168\u6210\u5C31\u653B\u7565",
+      description: "\u516C\u5171\u5355\u6E38\u620F\u653B\u7565\u4E8B\u5B9E\u89C6\u56FE\uFF0C\u6574\u5408\u5B98\u65B9\u6210\u5C31\u6E05\u5355\u548C Steam \u6307\u5357\u4E2D\u7684\u53EF\u8FFD\u6EAF\u4E8B\u5B9E\uFF0C\u4F8B\u5982 missable\u3001co-op \u548C\u6761\u4EF6\u8BF4\u660E\u3002",
       inputSchema: {
         appid: z2.union([z2.string(), z2.number()]).optional().describe("Steam AppID\u3002\u4E0E query \u4E8C\u9009\u4E00\u3002"),
         query: z2.union([z2.string(), z2.number()]).optional().describe("\u6E38\u620F\u540D\u6216 AppID\uFF0C\u652F\u6301\u76F4\u63A5\u8F93\u5165\u4E2D\u6587\u540D\u3002\u4E0E appid \u4E8C\u9009\u4E00\u3002"),
-        key: z2.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\uFF1B\u6309 query \u89E3\u6790 app \u6216\u8865\u5168\u6210\u5C31\u5143\u6570\u636E\u65F6\u53EF\u80FD\u9700\u8981\u3002"),
+        key: z2.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\uFF1B\u8865\u5168\u5B98\u65B9\u6210\u5C31 schema \u65F6\u53EF\u80FD\u9700\u8981\u3002"),
         language: z2.string().optional().describe("\u53EF\u9009\u8BED\u8A00\u4EE3\u7801\uFF0C\u4F8B\u5982 schinese \u6216 english\u3002"),
-        maxGuides: z2.number().int().min(1).max(8).optional().describe("\u6700\u591A\u6293\u53D6\u5E76\u6574\u5408\u591A\u5C11\u7BC7 Steam \u6307\u5357\uFF0C\u9ED8\u8BA4 3\u3002"),
-        maxAchievementNotes: z2.number().int().min(1).max(30).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u6761\u6210\u5C31\u7EA7\u522B\u5907\u6CE8\uFF0C\u9ED8\u8BA4 12\u3002")
+        includeSchemaDetails: z2.boolean().optional().describe("\u662F\u5426\u8865\u5145\u5B98\u65B9\u6210\u5C31 schema \u7EC6\u8282\uFF0C\u9ED8\u8BA4 true\u3002"),
+        maxGuides: z2.number().int().min(1).max(8).optional().describe("\u6700\u591A\u6293\u53D6\u591A\u5C11\u7BC7 Steam \u6307\u5357\uFF0C\u9ED8\u8BA4 3\u3002"),
+        maxGuideFacts: z2.number().int().min(1).max(50).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u6761\u6307\u5357\u4E8B\u5B9E\uFF0C\u9ED8\u8BA4 20\u3002"),
+        maxEvidencePerAchievement: z2.number().int().min(1).max(5).optional().describe("\u6BCF\u4E2A\u6210\u5C31\u6700\u591A\u4FDD\u7559\u591A\u5C11\u6761\u6307\u5357\u8BC1\u636E\uFF0C\u9ED8\u8BA4 2\u3002"),
+        topCount: z2.number().int().min(1).max(50).optional().describe("\u6700\u7A00\u6709\u548C\u6700\u5E38\u89C1\u6210\u5C31\u5404\u8FD4\u56DE\u591A\u5C11\u6761\uFF0C\u9ED8\u8BA4 10\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -38133,16 +38223,22 @@ function registerAppTools(server, runtime2) {
       query,
       key,
       language,
+      includeSchemaDetails = true,
       maxGuides = 3,
-      maxAchievementNotes = 12
-    }) => buildAchievementRoadmapData(runtime2, {
+      maxGuideFacts = 20,
+      maxEvidencePerAchievement = 2,
+      topCount = 10
+    }) => buildAchievementGuideData(runtime2, {
       toolName: "steam_get_achievement_roadmap",
       appid,
       query,
       key,
       language,
+      includeSchemaDetails,
       maxGuides,
-      maxAchievementNotes
+      maxGuideFacts,
+      maxEvidencePerAchievement,
+      topCount
     })
   );
   registerSteamTool(
@@ -38151,7 +38247,7 @@ function registerAppTools(server, runtime2) {
     "steam_get_global_achievement_overview",
     {
       title: "\u5168\u5C40\u6210\u5C31\u603B\u89C8",
-      description: "\u67E5\u770B\u67D0\u4E2A\u6E38\u620F\u7684\u5168\u5C40\u6210\u5C31\u5B8C\u6210\u7387\uFF0C\u5E76\u53EF\u9009\u8865\u5145 schema \u7EC6\u8282\u3002",
+      description: "\u516C\u5171\u5355\u6E38\u620F\u4E13\u9879\u89C6\u56FE\uFF0C\u67E5\u770B\u67D0\u4E2A\u6E38\u620F\u7684\u5168\u5C40\u6210\u5C31\u5B8C\u6210\u7387\uFF0C\u5E76\u53EF\u9009\u8865\u5145 schema \u7EC6\u8282\u3002",
       inputSchema: {
         appid: z2.union([z2.string(), z2.number()]).optional().describe("Steam AppID\u3002\u4E0E query \u4E8C\u9009\u4E00\u3002"),
         query: z2.union([z2.string(), z2.number()]).optional().describe("\u6E38\u620F\u540D\u6216 AppID\uFF0C\u652F\u6301\u76F4\u63A5\u8F93\u5165\u4E2D\u6587\u540D\u3002\u4E0E appid \u4E8C\u9009\u4E00\u3002"),
@@ -38250,7 +38346,7 @@ function buildDefaultPlayerTarget(identity) {
     }
   };
 }
-function getWarnings2(payload) {
+function getWarnings(payload) {
   const warnings = getNestedValue(payload, "warnings");
   return Array.isArray(warnings) ? warnings : [];
 }
@@ -38487,7 +38583,7 @@ async function buildFriendActivityData(runtime2, input) {
     sections: {
       profile: getNestedValue(friendsData, "sections", "profile")
     },
-    warnings: getWarnings2(friendsData)
+    warnings: getWarnings(friendsData)
   };
 }
 async function buildFriendNetworkData(runtime2, input) {
@@ -38556,7 +38652,7 @@ async function buildFriendNetworkData(runtime2, input) {
       },
       graph
     },
-    warnings: getWarnings2(friendsData)
+    warnings: getWarnings(friendsData)
   };
 }
 
@@ -38615,8 +38711,8 @@ async function buildGameSnapshotData(runtime2, input) {
   const warnings = [
     ...resolved.warnings,
     ...runtime2.collectWarnings([playerSummaryCall, ownedGamesCall]),
-    ...getWarnings2(achievementOverview),
-    ...getWarnings2(newsOverview)
+    ...getWarnings(achievementOverview),
+    ...getWarnings(newsOverview)
   ];
   return {
     ok: true,
@@ -38747,7 +38843,7 @@ async function buildGameFeedData(runtime2, input) {
         currentPlayers: getNestedValue(newsOverview, "summary", "currentPlayers"),
         ownedContext: ownedContextMap.get(appid) ?? null,
         items: newsItems,
-        warnings: getWarnings2(newsOverview)
+        warnings: getWarnings(newsOverview)
       };
     })
   );
@@ -38886,7 +38982,7 @@ async function buildBacklogCandidatesData(runtime2, input) {
     },
     warnings: [
       ...runtime2.collectWarnings([playerSummaryCall, ownedGamesCall]),
-      ...shortlist.flatMap((candidate) => getWarnings2(candidate))
+      ...shortlist.flatMap((candidate) => getWarnings(candidate))
     ]
   };
 }
@@ -38981,7 +39077,7 @@ async function buildAchievementHuntData(runtime2, input) {
             getNestedValue(overview, "sections", "recentlyUnlocked")
           ),
           easiestRemaining,
-          warnings: getWarnings2(overview)
+          warnings: getWarnings(overview)
         };
       } catch (error) {
         return {
@@ -39203,7 +39299,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_profile",
     {
       title: "\u6211\u7684\u8D44\u6599",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u6211\u7684 Steam \u8D44\u6599\u603B\u89C8\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u4E3B\u5165\u53E3\uFF0C\u67E5\u770B\u6211\u7684 Steam \u8D44\u6599\u603B\u89C8\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         includeRecentlyPlayed: z3.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u6E38\u73A9\uFF0C\u9ED8\u8BA4 true\u3002"),
@@ -39230,7 +39326,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_library",
     {
       title: "\u6211\u7684\u6E38\u620F\u5E93",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u6211\u7684\u6E38\u620F\u5E93\u603B\u89C8\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u4E3B\u5165\u53E3\uFF0C\u67E5\u770B\u6211\u7684\u6E38\u620F\u5E93\u603B\u89C8\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         includeAppInfo: z3.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6E38\u620F\u540D\u79F0\u548C\u56FE\u6807\uFF0C\u9ED8\u8BA4 true\u3002"),
@@ -39270,7 +39366,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_recently_played",
     {
       title: "\u6211\u7684\u6700\u8FD1\u6E38\u73A9",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u6700\u8FD1\u6E38\u73A9\u7684\u6E38\u620F\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u53EA\u770B\u6700\u8FD1\u6E38\u73A9\u7684\u6E38\u620F\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         count: z3.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002")
@@ -39295,7 +39391,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_badges",
     {
       title: "\u6211\u7684\u5FBD\u7AE0",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u6211\u7684\u7B49\u7EA7\u548C\u5FBD\u7AE0\u4FE1\u606F\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u53EA\u770B\u6211\u7684\u7B49\u7EA7\u548C\u5FBD\u7AE0\u4FE1\u606F\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002")
       },
@@ -39318,7 +39414,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_game_achievements",
     {
       title: "\u6211\u7684\u6E38\u620F\u6210\u5C31",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u6211\u5728\u67D0\u4E2A\u6E38\u620F\u91CC\u7684\u6210\u5C31\u548C\u5B8C\u6210\u7387\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u5355\u6E38\u620F\u4E13\u9879\u89C6\u56FE\uFF0C\u67E5\u770B\u6211\u5728\u67D0\u4E2A\u6E38\u620F\u91CC\u7684\u6210\u5C31\u548C\u5B8C\u6210\u7387\u3002",
       inputSchema: {
         appid: z3.union([z3.string(), z3.number()]).optional().describe("Steam AppID\u3002\u4E0E query \u4E8C\u9009\u4E00\u3002"),
         query: z3.union([z3.string(), z3.number()]).optional().describe("\u6E38\u620F\u540D\u6216 AppID\uFF0C\u652F\u6301\u76F4\u63A5\u8F93\u5165\u4E2D\u6587\u540D\u3002\u4E0E appid \u4E8C\u9009\u4E00\u3002"),
@@ -39358,7 +39454,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_friends",
     {
       title: "\u597D\u53CB\u5217\u8868",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u597D\u53CB\u5217\u8868\uFF0C\u53EF\u9009\u8865\u5145\u8D44\u6599\u548C\u5C01\u7981\u4FE1\u606F\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u4E13\u9879\u89C6\u56FE\uFF0C\u67E5\u770B\u597D\u53CB\u5217\u8868\uFF0C\u53EF\u9009\u8865\u5145\u8D44\u6599\u548C\u5C01\u7981\u4FE1\u606F\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         relationship: z3.string().optional().describe("\u597D\u53CB\u5173\u7CFB\u8FC7\u6EE4\u6761\u4EF6\uFF0C\u9ED8\u8BA4 friend\u3002"),
@@ -39395,7 +39491,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_friend_activity",
     {
       title: "\u597D\u53CB\u5728\u7EBF\u52A8\u6001",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u54EA\u4E9B\u597D\u53CB\u5728\u7EBF\u3001\u5728\u73A9\u6E38\u620F\u6216\u6700\u8FD1\u6D3B\u8DC3\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u4E13\u9879\u89C6\u56FE\uFF0C\u67E5\u770B\u54EA\u4E9B\u597D\u53CB\u5728\u7EBF\u3001\u5728\u73A9\u6E38\u620F\u6216\u6700\u8FD1\u6D3B\u8DC3\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         limit: z3.number().int().min(1).max(500).optional().describe("\u6700\u591A\u68C0\u67E5\u591A\u5C11\u4F4D\u597D\u53CB\uFF0C\u9ED8\u8BA4 100\u3002"),
@@ -39424,7 +39520,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_friend_network",
     {
       title: "\u597D\u53CB\u5173\u7CFB\u56FE\u8C31",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u751F\u6210\u597D\u53CB\u5173\u7CFB\u548C\u6D3B\u52A8\u5206\u7EC4\u89C6\u56FE\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u4E13\u9879\u89C6\u56FE\uFF0C\u751F\u6210\u597D\u53CB\u5173\u7CFB\u548C\u6D3B\u52A8\u5206\u7EC4\u89C6\u56FE\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         limit: z3.number().int().min(1).max(500).optional().describe("\u6700\u591A\u68C0\u67E5\u591A\u5C11\u4F4D\u597D\u53CB\uFF0C\u9ED8\u8BA4 150\u3002"),
@@ -39465,7 +39561,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_bans",
     {
       title: "\u6211\u7684\u5C01\u7981\u6458\u8981",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u6211\u7684\u5C01\u7981\u72B6\u6001\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u53EA\u770B\u6211\u7684\u5C01\u7981\u72B6\u6001\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002")
       },
@@ -39488,7 +39584,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_library_compare",
     {
       title: "\u6211\u7684\u5E93\u5BF9\u6BD4",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u628A\u6211\u7684\u5E93\u548C\u53E6\u4E00\u4F4D\u73A9\u5BB6\u505A\u5BF9\u6BD4\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u4E13\u9879\u89C6\u56FE\uFF0C\u628A\u6211\u7684\u5E93\u548C\u53E6\u4E00\u4F4D\u73A9\u5BB6\u505A\u5BF9\u6BD4\u3002",
       inputSchema: {
         steamid: z3.union([z3.string(), z3.number()]).optional().describe("\u5BF9\u65B9\u73A9\u5BB6\u7684 SteamID64\u3002\u4E0E vanityUrl \u4E8C\u9009\u4E00\u3002"),
         vanityUrl: z3.string().optional().describe("\u5BF9\u65B9\u73A9\u5BB6\u7684\u81EA\u5B9A\u4E49\u4E3B\u9875\u6807\u8BC6\u3002\u4E0E steamid \u4E8C\u9009\u4E00\u3002"),
@@ -39528,7 +39624,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_backlog_candidates",
     {
       title: "\u6211\u7684\u79EF\u538B\u5019\u9009",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u4ECE\u6211\u7684\u5E93\u91CC\u6311\u51FA\u503C\u5F97\u5F00\u5751\u7684\u79EF\u538B\u6E38\u620F\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u4E13\u9879\u89C6\u56FE\uFF0C\u4ECE\u6211\u7684\u5E93\u91CC\u6311\u51FA\u503C\u5F97\u5F00\u5751\u7684\u79EF\u538B\u6E38\u620F\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         limit: z3.number().int().min(1).max(30).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u4E2A\u5019\u9009\uFF0C\u9ED8\u8BA4 12\u3002"),
@@ -39571,7 +39667,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_achievement_hunt",
     {
       title: "\u6211\u7684\u6210\u5C31\u8865\u5B8C\u5019\u9009",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u627E\u51FA\u79BB\u5168\u6210\u5C31\u4E0D\u8FDC\u7684\u6E38\u620F\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u4E13\u9879\u89C6\u56FE\uFF0C\u627E\u51FA\u79BB\u5168\u6210\u5C31\u4E0D\u8FDC\u7684\u6E38\u620F\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         language: z3.string().optional().describe("\u8BED\u8A00\u4EE3\u7801\uFF0C\u4F8B\u5982 schinese \u6216 english\u3002"),
@@ -39620,7 +39716,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_game_snapshot",
     {
       title: "\u6211\u7684\u6E38\u620F\u5FEB\u7167",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u6211\u4E0E\u67D0\u4E2A\u6E38\u620F\u7684\u5173\u7CFB\u3001\u65B0\u95FB\u548C\u6210\u5C31\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u5355\u6E38\u620F\u4E3B\u5165\u53E3\uFF0C\u67E5\u770B\u6211\u4E0E\u67D0\u4E2A\u6E38\u620F\u7684\u5173\u7CFB\u3001\u65B0\u95FB\u548C\u6210\u5C31\u3002",
       inputSchema: {
         appid: z3.union([z3.string(), z3.number()]).optional().describe("Steam AppID\u3002\u4E0E query \u4E8C\u9009\u4E00\u3002"),
         query: z3.union([z3.string(), z3.number()]).optional().describe("\u6E38\u620F\u540D\u6216 AppID\uFF0C\u652F\u6301\u76F4\u63A5\u8F93\u5165\u4E2D\u6587\u540D\u3002\u4E0E appid \u4E8C\u9009\u4E00\u3002"),
@@ -39673,7 +39769,7 @@ function registerMyAccountTools(server, runtime2) {
     "steam_me_game_feed",
     {
       title: "\u6211\u7684\u6E38\u620F\u52A8\u6001\u6D41",
-      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u6309\u6700\u8FD1\u6E38\u73A9\u3001\u5E38\u73A9\u6216\u663E\u5F0F App \u751F\u6210\u4E2A\u4EBA\u6E38\u620F\u52A8\u6001\u6D41\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u4E13\u9879\u89C6\u56FE\uFF0C\u6309\u6700\u8FD1\u6E38\u73A9\u3001\u5E38\u73A9\u6216\u663E\u5F0F App \u751F\u6210\u4E2A\u4EBA\u6E38\u620F\u52A8\u6001\u6D41\u3002",
       inputSchema: {
         key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         source: z3.enum(["recent", "topOwned", "mixed", "explicit"]).optional().describe("\u52A8\u6001\u6D41\u7684\u6E38\u620F\u6765\u6E90\uFF0C\u9ED8\u8BA4 recent\u3002"),
@@ -39725,7 +39821,7 @@ function registerOverviewTools(server, runtime2) {
     "steam_get_player_profile_overview",
     {
       title: "\u73A9\u5BB6\u8D44\u6599\u603B\u89C8",
-      description: "\u805A\u5408\u73A9\u5BB6\u8D44\u6599\u3001\u5C01\u7981\u3001\u7B49\u7EA7\u3001\u5FBD\u7AE0\u548C\u6700\u8FD1\u6E38\u73A9\u4FE1\u606F\u3002",
+      description: "\u901A\u7528\u73A9\u5BB6\u4E3B\u5165\u53E3\uFF0C\u805A\u5408\u73A9\u5BB6\u8D44\u6599\u3001\u5C01\u7981\u3001\u7B49\u7EA7\u3001\u5FBD\u7AE0\u548C\u6700\u8FD1\u6E38\u73A9\u4FE1\u606F\u3002",
       inputSchema: {
         steamid: z4.union([z4.string(), z4.number()]).optional().describe("\u73A9\u5BB6\u7684 SteamID64\u3002\u4E0E vanityUrl \u4E8C\u9009\u4E00\u3002"),
         vanityUrl: z4.string().optional().describe("\u73A9\u5BB6\u7684\u81EA\u5B9A\u4E49\u4E3B\u9875\u6807\u8BC6\uFF0C\u4F8B\u5982 gaben\u3002\u4E0E steamid \u4E8C\u9009\u4E00\u3002"),
@@ -39759,7 +39855,7 @@ function registerOverviewTools(server, runtime2) {
     "steam_get_library_overview",
     {
       title: "\u6E38\u620F\u5E93\u603B\u89C8",
-      description: "\u805A\u5408\u73A9\u5BB6\u62E5\u6709\u7684\u6E38\u620F\u3001\u6700\u8FD1\u6E38\u73A9\u548C\u5E38\u73A9\u6E38\u620F\u3002",
+      description: "\u901A\u7528\u73A9\u5BB6\u6E38\u620F\u5E93\u4E3B\u5165\u53E3\uFF0C\u805A\u5408\u73A9\u5BB6\u62E5\u6709\u7684\u6E38\u620F\u3001\u6700\u8FD1\u6E38\u73A9\u548C\u5E38\u73A9\u6E38\u620F\u3002",
       inputSchema: {
         steamid: z4.union([z4.string(), z4.number()]).optional().describe("\u73A9\u5BB6\u7684 SteamID64\u3002\u4E0E vanityUrl \u4E8C\u9009\u4E00\u3002"),
         vanityUrl: z4.string().optional().describe("\u73A9\u5BB6\u7684\u81EA\u5B9A\u4E49\u4E3B\u9875\u6807\u8BC6\uFF0C\u4F8B\u5982 gaben\u3002\u4E0E steamid \u4E8C\u9009\u4E00\u3002"),
@@ -39802,7 +39898,7 @@ function registerOverviewTools(server, runtime2) {
     "steam_get_player_game_achievements",
     {
       title: "\u73A9\u5BB6\u6E38\u620F\u6210\u5C31",
-      description: "\u67E5\u770B\u67D0\u4E2A\u73A9\u5BB6\u5728\u67D0\u4E2A\u6E38\u620F\u91CC\u7684\u6210\u5C31\u3001\u5B8C\u6210\u7387\u548C\u53EF\u9009\u7EDF\u8BA1\u3002",
+      description: "\u901A\u7528\u73A9\u5BB6\u5355\u6E38\u620F\u4E13\u9879\u89C6\u56FE\uFF0C\u67E5\u770B\u67D0\u4E2A\u73A9\u5BB6\u5728\u67D0\u4E2A\u6E38\u620F\u91CC\u7684\u6210\u5C31\u3001\u5B8C\u6210\u7387\u548C\u53EF\u9009\u7EDF\u8BA1\u3002",
       inputSchema: {
         steamid: z4.union([z4.string(), z4.number()]).optional().describe("\u73A9\u5BB6\u7684 SteamID64\u3002\u4E0E vanityUrl \u4E8C\u9009\u4E00\u3002"),
         vanityUrl: z4.string().optional().describe("\u73A9\u5BB6\u7684\u81EA\u5B9A\u4E49\u4E3B\u9875\u6807\u8BC6\uFF0C\u4F8B\u5982 gaben\u3002\u4E0E steamid \u4E8C\u9009\u4E00\u3002"),
@@ -39845,7 +39941,7 @@ function registerOverviewTools(server, runtime2) {
     "steam_get_app_news",
     {
       title: "\u6E38\u620F\u65B0\u95FB",
-      description: "\u67E5\u770B\u67D0\u4E2A\u6E38\u620F\u7684 Steam \u65B0\u95FB\uFF0C\u5E76\u53EF\u9009\u9644\u5E26\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\u3002",
+      description: "\u516C\u5171\u5355\u6E38\u620F\u4E13\u9879\u89C6\u56FE\uFF0C\u67E5\u770B\u67D0\u4E2A\u6E38\u620F\u7684 Steam \u65B0\u95FB\uFF0C\u5E76\u53EF\u9009\u9644\u5E26\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\u3002",
       inputSchema: {
         appid: z4.union([z4.string(), z4.number()]).optional().describe("Steam AppID\u3002\u4E0E query \u4E8C\u9009\u4E00\u3002"),
         query: z4.union([z4.string(), z4.number()]).optional().describe("\u6E38\u620F\u540D\u6216 AppID\uFF0C\u652F\u6301\u76F4\u63A5\u8F93\u5165\u4E2D\u6587\u540D\u3002\u4E0E appid \u4E8C\u9009\u4E00\u3002"),
@@ -39894,8 +39990,8 @@ var runtime = createSteamBaseRuntime(spec, {
 });
 function createServer() {
   const server = new McpServer({
-    name: "steam-tools-mcp",
-    version: "0.2.0",
+    name: PACKAGE_NAME,
+    version: PACKAGE_VERSION,
     websiteUrl: "https://partner.steamgames.com/doc/webapi"
   });
   registerOverviewTools(server, runtime);